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)
#!/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)