def test_normal(self, tmpdir, value, expected):
p_db = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p_db), "w")
con.create_table_from_tabledata(value)
assert con.select_as_dict(table_name=value.table_name) == expected
def test_normal(self, tmpdir, value, expected):
p_db = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p_db), "w")
con.create_table_from_tabledata(value)
assert con.select_as_dict(table_name=value.table_name) == expected
def test_smoke(self, tmpdir, filename):
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
test_data_file_path = os.path.join(
os.path.dirname(__file__), "data", filename)
loader = ptr.TableFileLoader(test_data_file_path)
success_count = 0
for tabledata in loader.load():
if tabledata.is_empty():
continue
print(ptw.dump_tabledata(tabledata))
try:
con.create_table_from_tabledata(
ptr.SQLiteTableDataSanitizer(tabledata).sanitize())
success_count += 1
except ValueError as e:
print(e)
con.commit()
assert success_count > 0
def test_normal(self, tmpdir, value, type_hints, expected):
p_db = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p_db), "w")
con.create_table_from_tabledata(value)
assert con.fetch_table_names() == [value.table_name]
assert con.fetch_attr_names(value.table_name) == value.headers
actual = con.select_as_tabledata(columns=value.headers,
table_name=value.table_name,
type_hints=type_hints)
assert actual.value_matrix == expected
def test_normal(self, tmpdir, value, type_hints, expected):
p_db = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p_db), "w")
con.create_table_from_tabledata(value)
assert con.fetch_table_names() == [value.table_name]
assert con.fetch_attr_names(value.table_name) == value.headers
actual = con.select_as_tabledata(
columns=value.headers, table_name=value.table_name, type_hints=type_hints
)
assert actual.value_matrix == expected
def test_normal(self, tmpdir, value, expected):
p_db = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p_db), "w")
con.create_table_from_tabledata(value)
assert con.fetch_table_names() == [value.table_name]
assert con.fetch_attr_names(value.table_name) == value.headers
result = con.select(select="*", table_name=value.table_name)
result_matrix = result.fetchall()
assert result_matrix == expected
actual = con.select_as_tabledata(columns=value.headers, table_name=value.table_name)
assert actual.equals(value)
def test_normal(self, tmpdir, value, expected):
p_db = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p_db), "w")
con.create_table_from_tabledata(value)
assert con.fetch_table_names() == [value.table_name]
assert con.fetch_attr_names(value.table_name) == value.headers
result = con.select(select="*", table_name=value.table_name)
result_matrix = result.fetchall()
assert result_matrix == expected
actual = con.select_as_tabledata(columns=value.headers,
table_name=value.table_name)
assert actual.equals(value)
def test_normal(self, tmpdir, test_id, tabledata, filename, headers, expected):
file_path = Path(str(tmpdir.join(filename)))
file_path.parent.makedirs_p()
con = SimpleSQLite(file_path, "w")
con.create_table_from_tabledata(tabledata)
loader = ptr.SqliteFileLoader(file_path)
loader.headers = headers
for tabledata in loader.load():
print("test-id={}".format(test_id))
print(dumps_tabledata(tabledata))
assert tabledata.in_tabledata_list(expected)
def test_smoke(self, tmpdir, filename):
try:
import pytablereader as ptr
except ImportError:
pytest.skip("requires pytablereader")
p = tmpdir.join("tmp.db")
con = SimpleSQLite(str(p), "w")
test_data_file_path = os.path.join(os.path.dirname(__file__), "data",
filename)
loader = ptr.TableFileLoader(test_data_file_path)
success_count = 0
for table_data in loader.load():
if table_data.is_empty():
continue
try:
from pytablewriter import dumps_tabledata
print(dumps_tabledata(table_data))
except ImportError:
pass
try:
con.create_table_from_tabledata(
SQLiteTableDataSanitizer(table_data).normalize())
success_count += 1
except ValueError as e:
print(e)
con.commit()
assert success_count > 0
class SqliteTableWriter(AbstractBinaryTableWriter):
"""
A table writer class for SQLite database.
.. py:method:: write_table()
Write a table to a SQLite database.
:raises pytablewriter.EmptyTableNameError:
If the |table_name| is empty.
:raises pytablewriter.EmptyHeaderError:
If the |header_list| is empty.
:raises pytablewriter.EmptyValueError:
If the |value_matrix| is empty.
:Example:
:ref:`example-sqlite-table-writer`
"""
FORMAT_NAME = "sqlite"
@property
def format_name(self):
return self.FORMAT_NAME
@property
def support_split_write(self):
return True
def __init__(self):
import copy
import dataproperty
super(SqliteTableWriter, self).__init__()
self.stream = None
self.is_padding = False
self.is_formatting_float = False
self._use_default_header = True
self._is_require_table_name = True
self._is_require_header = True
self._quoting_flags = copy.deepcopy(dataproperty.NOT_QUOTING_FLAGS)
def __del__(self):
self.close()
def open(self, file_path):
"""
Open a SQLite database file.
:param str file_path: SQLite database file path to open.
"""
from simplesqlite import SimpleSQLite
self.close()
self.stream = SimpleSQLite(file_path, "w")
def _write_table(self):
self._verify_value_matrix()
self._preprocess()
table_data = tabledata.TableData(
self.table_name,
self.header_list,
[[value_dp.data for value_dp in value_dp_list]
for value_dp_list in self._table_value_dp_matrix],
)
self.stream.create_table_from_tabledata(table_data)
def _write_value_row_separator(self):
pass
class SqliteTableWriter(AbstractBinaryTableWriter):
"""
A table writer class for SQLite database.
.. py:method:: write_table()
Write a table to a SQLite database.
:raises pytablewriter.EmptyTableNameError:
If the |table_name| is empty.
:raises pytablewriter.EmptyHeaderError:
If the |header_list| is empty.
:raises pytablewriter.EmptyValueError:
If the |value_matrix| is empty.
:Example:
:ref:`example-sqlite-table-writer`
"""
FORMAT_NAME = "sqlite"
@property
def format_name(self):
return self.FORMAT_NAME
@property
def support_split_write(self):
return True
def __init__(self):
import copy
import dataproperty
super(SqliteTableWriter, self).__init__()
self.stream = None
self.is_padding = False
self.is_formatting_float = False
self._use_default_header = True
self._is_require_table_name = True
self._is_require_header = True
self._quoting_flags = copy.deepcopy(dataproperty.NOT_QUOTING_FLAGS)
def __del__(self):
self.close()
def is_opened(self):
return self.stream is not None
def open(self, file_path):
"""
Open a SQLite database file.
:param str file_path: SQLite database file path to open.
"""
from simplesqlite import SimpleSQLite
if self.is_opened():
if self.stream.database_path == abspath(file_path):
self._logger.logger.debug(
"database already opened: {}".format(self.stream.database_path)
)
return
self.close()
self.stream = SimpleSQLite(file_path, "w")
def dump(self, output, close_after_write=True):
"""Write data to the SQLite database file.
Args:
output (file descriptor or filepath):
close_after_write (bool, optional):
Close the output after write.
Defaults to True.
"""
self.open(output)
try:
self.write_table()
finally:
if close_after_write:
self.close()
def _write_table(self):
self._verify_value_matrix()
self._preprocess()
table_data = tabledata.TableData(
self.table_name,
self.header_list,
[
[value_dp.data for value_dp in value_dp_list]
for value_dp_list in self._table_value_dp_matrix
],
)
self.stream.create_table_from_tabledata(table_data)
def _write_value_row_separator(self):
pass
