def create(self, table_data, index_list):
con_mem = simplesqlite.connect_sqlite_memdb()
con_mem.create_table_from_tabledata(table_data)
is_rename = self.__require_rename_table(con_mem, table_data.table_name)
src_table_name = con_mem.get_table_name_list()[0]
dst_table_name = src_table_name
if is_rename:
dst_table_name = self.__make_unique_table_name(src_table_name)
self.__logger.debug(u"rename table from '{}' to '{}'".format(
src_table_name, dst_table_name))
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:
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, [
simplesqlite.sqlquery.SqlQuery.sanitize_attr(index)
for index in index_list
])
def test_normal(self):
con = connect_sqlite_memdb()
column_list = ["id", "value", "name"]
dataframe = pandas.DataFrame(
[
[0, 0.1, "a"],
[1, 1.1, "bb"],
[2, 2.2, "ccc"],
],
columns=column_list)
table_name = "tablename"
con.create_table_from_dataframe(dataframe, table_name)
actual_all = con.select_as_dataframe(table_name=table_name)
print("[expected]\n{}\n".format(dataframe))
print("[actual]\n{}\n".format(actual_all))
assert actual_all.equals(dataframe)
select_column_list = ["value", "name"]
actual_part = con.select_as_dataframe(
table_name=table_name, column_list=select_column_list)
assert actual_part.equals(pandas.DataFrame(
[
[0.1, "a"],
[1.1, "bb"],
[2.2, "ccc"],
],
columns=select_column_list))
def __strip_empty_col(self):
from simplesqlite import connect_sqlite_memdb
from simplesqlite.sqlquery import SqlQuery
con = connect_sqlite_memdb()
tmp_table_name = "tmp"
header_list = [
"a{:d}".format(i) for i in range(len(self.__all_values[0]))
]
con.create_table_from_data_matrix(table_name=tmp_table_name,
attr_name_list=header_list,
data_matrix=self.__all_values)
for col_idx, header in enumerate(header_list):
result = con.select(select=SqlQuery.to_attr_str(header),
table_name=tmp_table_name)
if any([
typepy.is_not_null_string(record[0])
for record in result.fetchall()
]):
break
strip_header_list = header_list[col_idx:]
if typepy.is_empty_sequence(strip_header_list):
raise ValueError()
result = con.select(select=",".join(
SqlQuery.to_attr_str_list(strip_header_list)),
table_name=tmp_table_name)
self.__all_values = result.fetchall()
def __require_rename_table(self, tabledata):
con_mem = simplesqlite.connect_sqlite_memdb()
con_mem.create_table_from_tabledata(tabledata=tabledata)
if not self.__dst_con.has_table(tabledata.table_name):
return (False, con_mem)
if self.__dst_con.get_attr_name_list(tabledata.table_name) != tabledata.header_list:
return (True, con_mem)
con_schema_extractor = SqliteSchemaExtractor(
self.__dst_con, verbosity_level=1)
con_mem_schema_extractor = SqliteSchemaExtractor(
con_mem, verbosity_level=1)
if con_schema_extractor.get_database_schema() == con_mem_schema_extractor.get_database_schema():
return (False, con_mem)
return (True, con_mem)
def clear(self):
self.__con = simplesqlite.connect_sqlite_memdb()
self.__filter_parser = TcFilterParser(self.__con, self.__ip_version)
self.__parsed_mappings = {}
def test_normal(self):
con_mem = connect_sqlite_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 json
import simplesqlite
table_name = "sample_table"
con = simplesqlite.connect_sqlite_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_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 -----
def qdisc_parser():
return tcconfig.parser._qdisc.TcQdiscParser(connect_sqlite_memdb())
def filter_parser_ipv6():
return tcconfig.parser._filter.TcFilterParser(connect_sqlite_memdb(),
ip_version=6)
#!/usr/bin/env python
# encoding: utf-8
from __future__ import print_function
import json
import simplesqlite
table_name = "sample_table"
con = simplesqlite.connect_sqlite_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_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))
def test_normal_con(self, mode):
con = SimpleSQLite(connect_sqlite_memdb().connection, mode)
assert con.database_path is None
assert con.connection is not None
def test_normal(self):
con_mem = connect_sqlite_memdb()
assert con_mem is not None
assert con_mem.database_path == ":memory:"
