def test_normal_add_primary_key_column(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = "table1"
con.create_table_from_data_matrix(
table_name=table_name,
attr_names=["AA", "BB"],
data_matrix=[["a", 11], ["bb", 12]],
add_primary_key_column=True,
)
assert con.select_as_tabledata(table_name) == TableData(
table_name=table_name, headers=["id", "AA", "BB"], rows=[[1, "a", 11], [2, "bb", 12]]
)
assert con.schema_extractor.fetch_table_schema(table_name).primary_key == "id"
table_name = "table2"
con.create_table_from_data_matrix(
table_name=table_name,
attr_names=["AA", "BB"],
data_matrix=[["a", 11], ["bb", 12]],
primary_key="pkey",
add_primary_key_column=True,
)
assert con.select_as_tabledata(table_name) == TableData(
table_name=table_name, headers=["pkey", "AA", "BB"], rows=[[1, "a", 11], [2, "bb", 12]]
)
assert con.schema_extractor.fetch_table_schema(table_name).primary_key == "pkey"
def con(tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(TEST_TABLE_NAME, ["attr_a", "attr_b"], [[1, 2], [3, 4]])
return con
def test_normal_empty_header(self, tmpdir, table_name, attr_names, data_matrix, expected):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(table_name, attr_names, data_matrix)
assert con.fetch_attr_names(table_name) == expected
def test_normal_add_primary_key_column(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = "table1"
con.create_table_from_data_matrix(
table_name=table_name,
attr_names=["AA", "BB"],
data_matrix=[["a", 11], ["bb", 12]],
add_primary_key_column=True,
)
assert con.select_as_tabledata(table_name) == TableData(
table_name=table_name,
headers=["id", "AA", "BB"],
rows=[[1, "a", 11], [2, "bb", 12]])
assert con.schema_extractor.fetch_table_schema(
table_name).primary_key == "id"
table_name = "table2"
con.create_table_from_data_matrix(
table_name=table_name,
attr_names=["AA", "BB"],
data_matrix=[["a", 11], ["bb", 12]],
primary_key="pkey",
add_primary_key_column=True,
)
assert con.select_as_tabledata(table_name) == TableData(
table_name=table_name,
headers=["pkey", "AA", "BB"],
rows=[[1, "a", 11], [2, "bb", 12]])
assert con.schema_extractor.fetch_table_schema(
table_name).primary_key == "pkey"
def main():
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix("hoge", ["attr_a", "attr_b"],
[[1, "a"], [2, "b"]])
print(con.has_table("hoge"))
print(con.has_table("not_existing"))
def con(tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(TEST_TABLE_NAME, ["attr_a", "attr_b"],
[[1, 2], [3, 4]])
return con
def test_exception_empty_header(self, tmpdir, table_name, attr_name_list,
data_matrix, index_attr_list, expected):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
with pytest.raises(expected):
con.create_table_from_data_matrix(table_name, attr_name_list,
data_matrix, index_attr_list)
def con_profile(tmpdir):
p = tmpdir.join("tmp_profile.db")
con = SimpleSQLite(str(p), "w", profile=True)
con.create_table_from_data_matrix(TEST_TABLE_NAME, ["attr_a", "attr_b"], [[1, 2], [3, 4]])
con.commit()
return con
def test_normal_empty_header(self, tmpdir, table_name, attr_names,
data_matrix, expected):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(table_name, attr_names, data_matrix)
assert con.fetch_attr_names(table_name) == expected
def con_b0():
con = SimpleSQLite("tmp_b0.sqlite", "w")
con.create_table_from_data_matrix(
table_name=TEST_TABLE_NAME_B,
attr_name_list=["ba", "bb"],
data_matrix=[[101, 102], [103, 104]],
)
return con
def con_mix(tmpdir):
p = tmpdir.join("tmp_mixed_data.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(TEST_TABLE_NAME,
["attr_i", "attr_f", "attr_s"],
[[1, 2.2, "aa"], [3, 4.4, "bb"]])
return con
def con_profile(tmpdir):
p = tmpdir.join("tmp_profile.db")
con = SimpleSQLite(str(p), "w", profile=True)
con.create_table_from_data_matrix(TEST_TABLE_NAME, ["attr_a", "attr_b"],
[[1, 2], [3, 4]])
con.commit()
return con
def con_ro(tmpdir):
p = tmpdir.join("tmp_readonly.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(TEST_TABLE_NAME, ["attr_a", "attr_b"], [[1, 2], [3, 4]])
con.close()
con.connect(str(p), "r")
return con
def con_a1():
con = SimpleSQLite("tmp_a1.sqlite", "w")
con.create_table_from_data_matrix(
table_name=TEST_TABLE_NAME_A,
attr_name_list=["attr_a", "attr_b"],
data_matrix=[[11, 12], [13, 14]],
)
return con
def con_mix(tmpdir):
p = tmpdir.join("tmp_mixed_data.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(
TEST_TABLE_NAME, ["attr_i", "attr_f", "attr_s"], [[1, 2.2, "aa"], [3, 4.4, "bb"]]
)
return con
def con_ro(tmpdir):
p = tmpdir.join("tmp_readonly.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(TEST_TABLE_NAME, ["attr_a", "attr_b"],
[[1, 2], [3, 4]])
con.close()
con.connect(str(p), "r")
return con
def con_a0():
con = SimpleSQLite("tmp_a0.sqlite", "w")
con.create_table_from_data_matrix(table_name=TEST_TABLE_NAME_A,
attr_name_list=["attr_a", "attr_b"],
data_matrix=[
[1, 2],
[3, 4],
])
return con
def test_normal_primary_key(self, tmpdir, table_name, attr_names, data_matrix, expected):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = TEST_TABLE_NAME
con.create_table_from_data_matrix(
table_name, attr_names, data_matrix, primary_key=attr_names[0]
)
assert con.schema_extractor.fetch_table_schema(table_name).primary_key == "AA"
def main():
con = SimpleSQLite("sample.sqlite", "w", profile=True)
con.create_table_from_data_matrix(
"sample_table",
["a", "b", "c", "d", "e"],
[[1, 1.1, "aaa", 1, 1], [2, 2.2, "bbb", 2.2, 2.2], [3, 3.3, "ccc", 3, "ccc"]],
)
print(con.select_as_dataframe(table_name="sample_table"))
def main():
con = SimpleSQLite("sample.sqlite", "w", profile=True)
data_matrix = [[1, 1.1, "aaa", 1, 1], [2, 2.2, "bbb", 2.2, 2.2],
[3, 3.3, "ccc", 3, "ccc"]]
con.create_table_from_data_matrix("sample_table",
["a", "b", "c", "d", "e"],
data_matrix,
index_attrs=["a"])
for profile in con.get_profile():
print(profile)
def con(tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(TEST_TABLE_NAME, ["attr_a", "attr_b"],
[[1, 2], [3, 4]])
con.execute_query(
f"CREATE VIEW view1 AS SELECT attr_a, attr_b FROM {TEST_TABLE_NAME}")
con.commit()
return con
def test_normal_number_header(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = "numbers"
attr_names = [1, 123456789]
data_matrix = [[1, 2], [1, 2]]
expected = ["1", "123456789"]
con.create_table_from_data_matrix(table_name, attr_names, data_matrix)
assert con.fetch_attr_names(table_name) == expected
def test_normal_symbol_header(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = "symbols"
attr_names = ["a!bc#d$e%f&gh(i)j", "k@l[m]n{o}p;q:r_s.t/u"]
data_matrix = [{"ABCD>8.5": "aaa", "ABCD<8.5": 0}, {"ABCD>8.5": "bbb", "ABCD<8.5": 9}]
expected = ["a!bc#d$e%f&gh(i)j", "k@l[m]n{o}p;q:r_s.t/u"]
con.create_table_from_data_matrix(table_name, attr_names, data_matrix)
assert con.fetch_attr_names(table_name) == expected
def test_normal_number_header(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = "numbers"
attr_names = [1, 123456789]
data_matrix = [[1, 2], [1, 2]]
expected = ["1", "123456789"]
con.create_table_from_data_matrix(table_name, attr_names, data_matrix)
assert con.fetch_attr_names(table_name) == expected
def con(tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(table_name=TEST_TABLE_NAME,
attr_name_list=["attr_a", "attr_b"],
data_matrix=[
[1, 2],
[3, 4],
])
return con
def test_except_add_primary_key_column(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
with pytest.raises(ValueError):
con.create_table_from_data_matrix(
table_name="specify existing attr as a primary key",
attr_names=["AA", "BB"],
data_matrix=[["a", 11], ["bb", 12]],
primary_key="AA",
add_primary_key_column=True,
)
def test_except_add_primary_key_column(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
with pytest.raises(ValueError):
con.create_table_from_data_matrix(
table_name="specify existing attr as a primary key",
attr_names=["AA", "BB"],
data_matrix=[["a", 11], ["bb", 12]],
primary_key="AA",
add_primary_key_column=True,
)
def test_normal_primary_key(self, tmpdir, table_name, attr_names,
data_matrix, expected):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = TEST_TABLE_NAME
con.create_table_from_data_matrix(table_name,
attr_names,
data_matrix,
primary_key=attr_names[0])
assert con.schema_extractor.fetch_table_schema(
table_name).primary_key == "AA"
def test_normal_type_hints(self, tmpdir, table_name, attr_names,
data_matrix, type_hints, expected):
p = tmpdir.join("tmp_type_hints.db")
con = SimpleSQLite(str(p), "w")
con.create_table_from_data_matrix(table_name,
attr_names,
data_matrix,
type_hints=type_hints)
assert con.select_as_dict(table_name) == [
OrderedDict([("int", 1), ("text", "001")]),
OrderedDict([("int", 2), ("text", "010")]),
]
def main():
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix(table_name, ["attr_a", "attr_b"], [[1, "a"], [2, "b"]])
con.verify_attr_existence(table_name, "attr_a")
try:
con.verify_attr_existence(table_name, "not_existing")
except AttributeNotFoundError as e:
print(e)
try:
con.verify_attr_existence("not_existing", "attr_a")
except DatabaseError as e:
print(e)
def simpledb():
return_array = []
temp_dict = {}
print("In the simpledb function")
table_name = "sample_table"
con = SimpleSQLite("simple.sqlite", "w")
print("after con")
# create table -----
data_matrix = [[1, 1.1, "aaa", 1, 1], [2, 2.2, "bbb", 2.2, 2.2],
[3, 3.3, "ccc", 3, "ccc"]]
con.create_table_from_data_matrix(
table_name,
["attr_a", "attr_b", "attr_c", "attr_d", "attr_e"],
data_matrix,
)
con.insert(table_name,
record={
"attr_a": 4,
"attr_b": 4.4,
"attr_c": "ddd",
"attr_d": 4.44,
"attr_e": "hoge",
})
# display data type for each column in the table -----
print(con.schema_extractor.fetch_table_schema(table_name).dumps())
# display values in the table -----
print("records:")
key_array = [
"attr_a",
"attr_b",
"attr_c",
"attr_d",
"attr_e",
]
result = con.select(select="*", table_name=table_name)
print(type(result))
for record in result.fetchall():
print(record)
temp_dict = dict(zip(key_array, record))
return_array.append(temp_dict)
temp_dict = []
print("Last line of the simpledb function:")
return json.dumps(return_array)
def test_normal(self, tmpdir, attr_names, data_matrix, index_attrs, expected_attr):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = TEST_TABLE_NAME
con.create_table_from_data_matrix(
table_name, attr_names, data_matrix, primary_key=None, index_attrs=index_attrs
)
# check data ---
result = con.select(select=AttrList(attr_names), table_name=table_name)
result_matrix = result.fetchall()
assert len(result_matrix) == 3
print_test_result(expected=expected_attr, actual=con.fetch_attr_type(table_name))
assert con.fetch_attr_type(table_name) == expected_attr
def test_normal_symbol_header(self, tmpdir):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = "symbols"
attr_names = ["a!bc#d$e%f&gh(i)j", "k@l[m]n{o}p;q:r_s.t/u"]
data_matrix = [{
"ABCD>8.5": "aaa",
"ABCD<8.5": 0
}, {
"ABCD>8.5": "bbb",
"ABCD<8.5": 9
}]
expected = ["a!bc#d$e%f&gh(i)j", "k@l[m]n{o}p;q:r_s.t/u"]
con.create_table_from_data_matrix(table_name, attr_names, data_matrix)
assert con.fetch_attr_names(table_name) == expected
def main():
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
# create table -----
data_matrix = [[1, 1.1, "aaa", 1, 1], [2, 2.2, "bbb", 2.2, 2.2],
[3, 3.3, "ccc", 3, "ccc"]]
con.create_table_from_data_matrix(
table_name, ["attr_a", "attr_b", "attr_c", "attr_d", "attr_e"],
data_matrix)
# display data type for each column in the table -----
print(con.schema_extractor.fetch_table_schema(table_name).dumps())
# display values in the table -----
print("records:")
result = con.select(select="*", table_name=table_name)
for record in result.fetchall():
print(record)
def test_normal(self, tmpdir, attr_names, data_matrix, index_attrs,
expected_attr):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = TEST_TABLE_NAME
con.create_table_from_data_matrix(table_name,
attr_names,
data_matrix,
primary_key=None,
index_attrs=index_attrs)
# check data ---
result = con.select(select=AttrList(attr_names), table_name=table_name)
result_matrix = result.fetchall()
assert len(result_matrix) == 3
print_test_result(expected=expected_attr,
actual=con.fetch_attr_type(table_name))
assert con.fetch_attr_type(table_name) == expected_attr
def main():
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix(
table_name, ["attr_a", "attr_b", "attr_c", "attr_d", "attr_e"], [[1, 1.1, "aaa", 1, 1]]
)
# insert namedtuple
SampleTuple = namedtuple("SampleTuple", "attr_a attr_b attr_c attr_d attr_e")
con.insert(table_name, record=[7, 7.7, "fff", 7.77, "bar"])
con.insert_many(
table_name,
records=[(8, 8.8, "ggg", 8.88, "foobar"), SampleTuple(9, 9.9, "ggg", 9.99, "hogehoge")],
)
# print
result = con.select(select="*", table_name=table_name)
for record in result.fetchall():
print(record)
def main():
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
data_matrix = [[1, "aaa"], [2, "bbb"]]
con.create_table_from_data_matrix(table_name, ["key", "value"],
data_matrix)
print("---- before update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
print()
con.update(table_name,
set_query="value = 'ccc'",
where=Where(key="key", value=1))
print("---- after update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
def test_normal(self, tmpdir, attr_name_list, data_matrix, index_attr_list,
expected_attr):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
table_name = TEST_TABLE_NAME
con.create_table_from_data_matrix(table_name, attr_name_list,
data_matrix, index_attr_list)
con.commit()
# check data ---
result = con.select(select=",".join(
SqlQuery.to_attr_str_list(attr_name_list)),
table_name=table_name)
result_matrix = result.fetchall()
assert len(result_matrix) == 3
print("expected: {}".format(expected_attr))
print("actual: {}".format(con.get_attr_type(table_name)))
assert con.get_attr_type(table_name) == expected_attr
def main():
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix(
table_name, ["attr_a", "attr_b", "attr_c", "attr_d", "attr_e"], [[1, 1.1, "aaa", 1, 1]]
)
con.insert(
table_name,
record={"attr_a": 4, "attr_b": 4.4, "attr_c": "ddd", "attr_d": 4.44, "attr_e": "hoge"},
)
con.insert_many(
table_name,
records=[
{"attr_a": 5, "attr_b": 5.5, "attr_c": "eee", "attr_d": 5.55, "attr_e": "foo"},
{"attr_a": 6, "attr_c": "fff"},
],
)
result = con.select(select="*", table_name=table_name)
for record in result.fetchall():
print(record)
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
con = SimpleSQLite("sample.sqlite", "w", profile=True)
con.create_table_from_data_matrix(
"sample_table",
["a", "b", "c", "d", "e"],
[[1, 1.1, "aaa", 1, 1], [2, 2.2, "bbb", 2.2, 2.2], [3, 3.3, "ccc", 3, "ccc"]],
)
print(con.select_as_dataframe(table_name="sample_table"))
from __future__ import print_function
from simplesqlite import SimpleSQLite
from simplesqlite.sqlquery import SqlQuery
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
data_matrix = [
[1, "aaa"],
[2, "bbb"],
]
con.create_table_from_data_matrix(
table_name,
attr_name_list=["key", "value"],
data_matrix=data_matrix)
print("---- before update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
print()
con.update(
table_name,
set_query="value = 'ccc'",
where=SqlQuery.make_where(key="key", value=1))
print("---- after update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
from simplesqlite.query import Where
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
data_matrix = [[1, "aaa"], [2, "bbb"]]
con.create_table_from_data_matrix(table_name, ["key", "value"], data_matrix)
print("---- before update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
print()
con.update(table_name, set_query="value = 'ccc'", where=Where(key="key", value=1))
print("---- after update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
import json
from simplesqlite import SimpleSQLite
con = SimpleSQLite("sample.sqlite", "w")
data_matrix = [
[1, 1.1, "aaa", 1, 1],
[2, 2.2, "bbb", 2.2, 2.2],
[3, 3.3, "ccc", 3, "ccc"],
]
con.create_table_from_data_matrix(
table_name="sample_table",
attr_name_list=["a", "b", "c", "d", "e"],
data_matrix=data_matrix,
index_attr_list=["a"])
print(json.dumps(con.get_sqlite_master(), indent=4))
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
import json
from simplesqlite import SimpleSQLite
con = SimpleSQLite("sample.sqlite", "w")
data_matrix = [[1, 1.1, "aaa", 1, 1], [2, 2.2, "bbb", 2.2, 2.2], [3, 3.3, "ccc", 3, "ccc"]]
con.create_table_from_data_matrix(
"sample_table", ["a", "b", "c", "d", "e"], data_matrix, index_attrs=["a"]
)
print(json.dumps(con.fetch_sqlite_master(), indent=4))
# encoding: utf-8
from __future__ import print_function
import json
from simplesqlite import SimpleSQLite
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
# create table -----
data_matrix = [
[1, 1.1, "aaa", 1, 1],
[2, 2.2, "bbb", 2.2, 2.2],
[3, 3.3, "ccc", 3, "ccc"],
]
con.create_table_from_data_matrix(
table_name,
attr_name_list=["attr_a", "attr_b", "attr_c", "attr_d", "attr_e"],
data_matrix=data_matrix)
# display values in the table -----
print(con.get_attr_name_list(table_name))
result = con.select(select="*", table_name=table_name)
for record in result.fetchall():
print(record)
# display data type for each column in the table -----
print(json.dumps(con.get_attr_type(table_name), indent=4))
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix(
table_name="hoge",
attr_name_list=["attr_a", "attr_b"],
data_matrix=[[1, "a"], [2, "b"]])
print(con.has_table("hoge"))
print(con.has_table("not_existing"))
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import AttributeNotFoundError, SimpleSQLite, TableNotFoundError
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix(table_name, ["attr_a", "attr_b"], [[1, "a"], [2, "b"]])
con.verify_attr_existence(table_name, "attr_a")
try:
con.verify_attr_existence(table_name, "not_existing")
except AttributeNotFoundError as e:
print(e)
try:
con.verify_attr_existence("not_existing", "attr_a")
except TableNotFoundError as e:
print(e)
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
con = SimpleSQLite("sample.sqlite", "w", profile=True)
con.create_table_from_data_matrix(
table_name="sample_table",
attr_name_list=["a", "b", "c", "d", "e"],
data_matrix=[
[1, 1.1, "aaa", 1, 1],
[2, 2.2, "bbb", 2.2, 2.2],
[3, 3.3, "ccc", 3, "ccc"],
])
print(con.select_as_dataframe(table_name="sample_table"))
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix(
table_name, ["attr_a", "attr_b", "attr_c", "attr_d", "attr_e"], [[1, 1.1, "aaa", 1, 1]]
)
con.insert(
table_name,
record={"attr_a": 4, "attr_b": 4.4, "attr_c": "ddd", "attr_d": 4.44, "attr_e": "hoge"},
)
con.insert_many(
table_name,
records=[
{"attr_a": 5, "attr_b": 5.5, "attr_c": "eee", "attr_d": 5.55, "attr_e": "foo"},
{"attr_a": 6, "attr_c": "fff"},
],
)
result = con.select(select="*", table_name=table_name)
for record in result.fetchall():
print(record)
def main():
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix("hoge", ["attr_a", "attr_b"],
[[1, "a"], [2, "b"]])
print(con.fetch_table_names())
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix(
table_name,
attr_name_list=["attr_a", "attr_b", "attr_c", "attr_d", "attr_e"],
data_matrix=[[1, 1.1, "aaa", 1, 1]])
con.insert(
table_name,
insert_record={
"attr_a": 4,
"attr_b": 4.4,
"attr_c": "ddd",
"attr_d": 4.44,
"attr_e": "hoge",
})
con.insert_many(
table_name,
insert_record_list=[
{
"attr_a": 5,
"attr_b": 5.5,
"attr_c": "eee",
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
from simplesqlite.query import Where
table_name = "sample_table"
con = SimpleSQLite("sample.sqlite", "w")
data_matrix = [[1, "aaa"], [2, "bbb"]]
con.create_table_from_data_matrix(table_name, ["key", "value"], data_matrix)
print("---- before update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
print()
con.update(table_name,
set_query="value = 'ccc'",
where=Where(key="key", value=1))
print("---- after update ----")
for record in con.select(select="*", table_name=table_name).fetchall():
print(record)
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
from simplesqlite import SimpleSQLite
con = SimpleSQLite("sample.sqlite", "w")
con.create_table_from_data_matrix("hoge", ["attr_a", "attr_b"], [[1, "a"], [2, "b"]])
print(con.has_table("hoge"))
print(con.has_table("not_existing"))
