def test_normal_con(self, mode):
con = SimpleSQLite(connect_memdb().connection, mode)
assert con.database_path is None
assert con.connection
con = SimpleSQLite(connect_memdb(), mode)
assert con.database_path
assert con.connection
def test_normal_con(self, mode):
con = SimpleSQLite(connect_memdb().connection, mode)
assert con.database_path is None
assert con.connection
con = SimpleSQLite(connect_memdb(), mode)
assert con.database_path
assert con.connection
def __init__(
self,
device,
ip_version,
logger,
tc_command_output,
export_path=None,
is_parse_filter_id=True,
dump_db_path=None,
):
if dump_db_path is None:
self.__con = connect_memdb()
else:
self.__con = SimpleSQLite(dump_db_path, "w")
Filter.attach(self.__con)
Filter.create()
Qdisc.attach(self.__con)
Qdisc.create()
self.__device = device
self.__ip_version = ip_version
self.__tc_command_output = tc_command_output
self.__logger = logger
self.__export_path = export_path
self.clear()
self.__ifb_device = self.__get_ifb_from_device()
self.__iptables_ctrl = IptablesMangleController(True, ip_version)
self.is_parse_filter_id = is_parse_filter_id
def __strip_empty_col(self):
from simplesqlite import connect_memdb
from simplesqlite.query import Attr, AttrList
con = connect_memdb()
tmp_table_name = "tmp"
headers = ["a{:d}".format(i) for i in range(len(self.__all_values[0]))]
con.create_table_from_data_matrix(tmp_table_name, headers,
self.__all_values)
for col_idx, header in enumerate(headers):
result = con.select(select=Attr(header), table_name=tmp_table_name)
if any([
typepy.is_not_null_string(record[0])
for record in result.fetchall()
]):
break
strip_headers = headers[col_idx:]
if typepy.is_empty_sequence(strip_headers):
raise ValueError()
result = con.select(select=AttrList(strip_headers),
table_name=tmp_table_name)
self.__all_values = result.fetchall()
def test_orm():
con = connect_memdb()
Hoge.attach(con, is_hidden=True)
Hoge.create()
assert Hoge.fetch_num_records() == 0
hoge_inputs = [Hoge(hoge_id=10, name="a"), Hoge(hoge_id=20, name="b")]
for hoge_input in hoge_inputs:
Hoge.insert(hoge_input)
Foo.attach(con)
Foo.create()
foo_inputs = [Foo(foo_id=11, name="aq", value=0.1), Foo(foo_id=22, name="bb", value=1.11)]
for foo_input in foo_inputs:
Foo.insert(foo_input)
assert Hoge.fetch_num_records() == 2
for record, hoge_input in zip(Hoge.select(), hoge_inputs):
assert record == hoge_input
for record, foo_input in zip(Foo.select(), foo_inputs):
assert record == foo_input
result = Hoge.select(where=Where("hoge_id", 999))
assert len(list(result)) == 0
def __init__(self, tc_command_output=TcCommandOutput.NOT_SET):
self.__client = APIClient(version="auto")
self.__host_name = os.uname()[1]
self.__tc_command_output = tc_command_output
self.__con = connect_memdb()
IfIndex.attach(self.__con)
def create(self, table_data, index_list, source_info):
con_mem = simplesqlite.connect_memdb()
con_mem.create_table_from_tabledata(table_data)
need_rename = self.__require_rename_table(con_mem,
table_data.table_name)
src_table_name = con_mem.fetch_table_name_list()[0]
dst_table_name = src_table_name
if need_rename:
dst_table_name = self.__make_unique_table_name(src_table_name)
self.__logger.debug("rename table from '{}' to '{}'".format(
src_table_name, dst_table_name))
is_create_table = True
simplesqlite.copy_table(
src_con=con_mem,
dst_con=self.__dst_con,
src_table_name=src_table_name,
dst_table_name=dst_table_name,
)
else:
is_create_table = not self.__dst_con.has_table(dst_table_name)
simplesqlite.append_table(src_con=con_mem,
dst_con=self.__dst_con,
table_name=dst_table_name)
self.__dst_con.create_index_list(dst_table_name, index_list)
self.__result_logger.logging_success(
source_info.get_name(self.__verbosity_level), dst_table_name,
is_create_table)
def test_normal(self, table_name, headers, records, expected):
new_tabledata = SQLiteTableDataSanitizer(
TableData(table_name, headers, records)
).normalize()
print_test_result(expected=dump_tabledata(expected), actual=dump_tabledata(new_tabledata))
con = connect_memdb()
con.create_table_from_tabledata(new_tabledata)
assert con.select_as_tabledata(new_tabledata.table_name) == expected
assert new_tabledata.equals(expected)
def test_normal_type_hints(
self, table_name, headers, records, type_hints, expecte_col_types, expecte_data
):
new_tabledata = SQLiteTableDataSanitizer(
TableData(table_name, headers, records, type_hints=type_hints)
).normalize()
actual_col_types = [col_dp.typename for col_dp in new_tabledata.column_dp_list]
assert actual_col_types == expecte_col_types
con = connect_memdb()
con.create_table_from_tabledata(new_tabledata)
assert con.select_as_tabledata(new_tabledata.table_name) == expecte_data
def test_normal_type_hints(self, table_name, headers, records, type_hints,
expecte_col_types, expecte_data):
new_tabledata = SQLiteTableDataSanitizer(
TableData(table_name, headers, records,
type_hints=type_hints)).normalize()
actual_col_types = [
col_dp.typename for col_dp in new_tabledata.column_dp_list
]
assert actual_col_types == expecte_col_types
con = connect_memdb()
con.create_table_from_tabledata(new_tabledata)
assert con.select_as_tabledata(
new_tabledata.table_name) == expecte_data
def main():
con = connect_memdb()
Sample.attach(con)
Sample.create()
Sample.insert(Sample(name="abc", value=0.1))
Sample.insert(Sample(name="xyz", value=1.11))
Sample.insert(Sample(name="bar"))
print(Sample.fetch_schema().dumps())
print("records:")
for record in Sample.select():
print(f" {record}")
return 0
def test_normal_include_datetime(self):
con = connect_memdb()
table_name = "table_w_datetime"
dataframe = pd.DataFrame(
[
["2020-03-25 15:24:00-04:00", 0, 0.1, "a"],
["2020-03-25 15:25:00-04:00", 1, 1.1, "bb"],
["2020-03-25 15:30:00-04:00", 2, 2.2, "ccc"],
],
columns=["timestamp", "id", "value", "name"],
)
dataframe["timestamp"] = pd.to_datetime(dataframe["timestamp"])
con.create_table_from_dataframe(dataframe, table_name=table_name)
actual_all = con.select_as_dataframe(table_name=table_name)
print_test_result(expected=dataframe, actual=actual_all)
def test_normal(self, table_name, headers, records, expected):
new_tabledata = SQLiteTableDataSanitizer(
TableData(table_name, headers, records)).normalize()
try:
from pytablewriter import dumps_tabledata
print_test_result(expected=dumps_tabledata(expected),
actual=dumps_tabledata(new_tabledata))
except ImportError:
pass
con = connect_memdb()
con.create_table_from_tabledata(new_tabledata)
assert con.select_as_tabledata(new_tabledata.table_name) == expected
assert new_tabledata.equals(expected)
def main():
table_name = "sample_table"
con = simplesqlite.connect_memdb()
# 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):
con = connect_memdb()
dataframe = pandas.DataFrame(
[[0, 0.1, "a"], [1, 1.1, "bb"], [2, 2.2, "ccc"]], columns=["id", "value", "name"]
)
table_name = "tablename"
con.create_table_from_dataframe(dataframe, table_name)
actual_all = con.select_as_dataframe(table_name=table_name)
print_test_result(expected=dataframe, actual=actual_all)
assert actual_all.equals(dataframe)
select_columns = ["value", "name"]
actual_part = con.select_as_dataframe(table_name=table_name, columns=select_columns)
assert actual_part.equals(
pandas.DataFrame([[0.1, "a"], [1.1, "bb"], [2.2, "ccc"]], columns=select_columns)
)
def test_orm():
con = connect_memdb()
Hoge.attach(con, is_hidden=True)
Hoge.create()
hoge_inputs = [Hoge(hoge_id=10, name="a"), Hoge(hoge_id=20, name="b")]
for hoge_input in hoge_inputs:
Hoge.insert(hoge_input)
Foo.attach(con)
Foo.create()
foo_inputs = [Foo(foo_id=11, name="aq", value=0.1), Foo(foo_id=22, name="bb", value=1.11)]
for foo_input in foo_inputs:
Foo.insert(foo_input)
for record, hoge_input in zip(Hoge.select(), hoge_inputs):
assert record == hoge_input
for record, foo_input in zip(Foo.select(), foo_inputs):
assert record == foo_input
def main():
con = connect_memdb()
Hoge.attach(con, is_hidden=True)
Hoge.create()
Hoge.insert(Hoge(hoge_id=10, name="a"))
Hoge.insert(Hoge(hoge_id=20, name="b"))
Foo.attach(con)
Foo.create()
Foo.insert(Foo(foo_id=11, name="aq", value=0.1))
Foo.insert(Foo(foo_id=22, name="bb", value=1.11))
print(Hoge.fetch_schema().dumps())
for hoge in Hoge.select():
print(hoge.hoge_id, hoge.name)
print("\n--------------------\n")
print(Foo.fetch_schema().dumps())
for foo in Foo.select():
print(foo)
def create(
self, table_data: TableData, index_list: Sequence[str], source_info: "SourceInfo"
) -> None:
con_mem = simplesqlite.connect_memdb()
con_mem.create_table_from_tabledata(
table_data,
primary_key=self.__add_pri_key_name,
add_primary_key_column=String(self.__add_pri_key_name).is_type(),
)
src_table_name = con_mem.fetch_table_names()[0]
dst_table_name = src_table_name
if self.__require_rename_table(con_mem, src_table_name):
dst_table_name = self.__make_unique_table_name(src_table_name)
self.__logger.debug(
"rename table from '{}' to '{}'".format(src_table_name, dst_table_name)
)
is_create_table = True
simplesqlite.copy_table(
src_con=con_mem,
dst_con=self.__dst_con,
src_table_name=src_table_name,
dst_table_name=dst_table_name,
)
else:
is_create_table = not self.__dst_con.has_table(dst_table_name)
simplesqlite.append_table(
src_con=con_mem, dst_con=self.__dst_con, table_name=dst_table_name
)
self.__dst_con.create_index_list(dst_table_name, index_list)
self.__result_logger.logging_success(
source_info.get_name(self.__verbosity_level), dst_table_name, is_create_table
)
def main():
# simplesqlite.set_log_level(logbook.DEBUG)
con = connect_memdb()
Hoge.attach(con, is_hidden=True)
Hoge.create()
Hoge.insert(Hoge(hoge_id=10, name="a"))
Hoge.insert(Hoge(hoge_id=20, name="b"))
Foo.attach(con)
Foo.create()
Foo.insert(Foo(foo_id=11, name="aq", value=0.1))
Foo.insert(Foo(foo_id=22, name="bb", value=1.11))
print(Hoge.fetch_schema().dumps())
for hoge in Hoge.select():
print(hoge.hoge_id, hoge.name)
print("\n--------------------\n")
print(Foo.fetch_schema().dumps())
for foo in Foo.select():
print(foo)
return 0
def create(self, table_data, index_list, source_info):
con_mem = simplesqlite.connect_memdb()
con_mem.create_table_from_tabledata(
table_data,
primary_key=self.__add_pri_key_name,
add_primary_key_column=String(self.__add_pri_key_name).is_type(),
)
src_table_name = con_mem.fetch_table_names()[0]
dst_table_name = src_table_name
if self.__require_rename_table(con_mem, table_data.table_name):
dst_table_name = self.__make_unique_table_name(src_table_name)
self.__logger.debug(
"rename table from '{}' to '{}'".format(src_table_name, dst_table_name)
)
is_create_table = True
simplesqlite.copy_table(
src_con=con_mem,
dst_con=self.__dst_con,
src_table_name=src_table_name,
dst_table_name=dst_table_name,
)
else:
is_create_table = not self.__dst_con.has_table(dst_table_name)
simplesqlite.append_table(
src_con=con_mem, dst_con=self.__dst_con, table_name=dst_table_name
)
self.__dst_con.create_index_list(dst_table_name, index_list)
self.__result_logger.logging_success(
source_info.get_name(self.__verbosity_level), dst_table_name, is_create_table
)
def qdisc_parser():
return tcconfig.parser._qdisc.TcQdiscParser(connect_memdb())
def filter_parser_ipv6():
return tcconfig.parser._filter.TcFilterParser(connect_memdb(),
ip_version=6)
def test_normal(self):
con_mem = connect_memdb()
assert con_mem is not None
assert con_mem.database_path == ":memory:"
def class_parser():
return TcClassParser(connect_memdb())
def clear(self):
self.__con = connect_memdb()
self.__filter_parser = TcFilterParser(self.__con, self.__ip_version)
self.__parsed_mappings = {}
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
import simplesqlite
table_name = "sample_table"
con = simplesqlite.connect_memdb()
# 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):
con_mem = connect_memdb()
assert con_mem is not None
assert con_mem.database_path == ":memory:"
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
import simplesqlite
table_name = "sample_table"
con = simplesqlite.connect_memdb()
# 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)
