def test_table_stuff():
tf = tempfile.mkdtemp()
tf = Path(tf) / "test.db"
db_tools = DataBase(db_path=tf)
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.create_table(table_name="data", categories=categories)
data_table = db_tools.tables["data"]
sql_data = [{
"money": "2000",
"time": "10"
}, {
"time": "300",
"money": "600"
}]
for data in sql_data:
data_table.write(data)
assert len(data_table.columns) == 3
assert data_table.columns == ["id", "money", "time"]
money_column = data_table / "money"
print(money_column)
assert money_column == [(2000, ), (600, )]
all_columns = data_table / "*"
print(all_columns)
assert all_columns[0] == (1, 2000, 10)
def test_read_and_write_table_column():
tf = tempfile.mkdtemp()
tf = Path(tf) / "test.db"
db_tools = DataBase(db_path=tf)
#TODO: Use enumerator class instead of strings
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.create_table(table_name="data", categories=categories)
# Test write, and order of write features is arbritary
data_table = db_tools.tables["data"]
sql_data = [{
"money": "2000",
"time": "10"
}, {
"time": "300",
"money": "600"
}]
for data in sql_data:
data_table.write(data)
#TODO: Make column data, class attribute
time_res = data_table.select(["time"])
assert time_res[0] == (10, )
assert time_res[1] == (300, )
money_res = data_table.select(["money"])
assert money_res[0] == (2000, )
assert money_res[1] == (600, )
def test_columns():
tf = tempfile.mkdtemp()
tf = Path(tf) / "test.db"
db_tools = DataBase(db_path=tf)
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.create_table(table_name="data", categories=categories)
data_table = db_tools.tables["data"]
sql_data = [{
"money": "2000",
"time": "10"
}, {
"time": "300",
"money": "600"
}]
for data in sql_data:
data_table.write(data)
connection = db_tools.active_db
with pytest.raises(RuntimeError):
col = Column(sql_session=connection,
column_name="data",
data_type="Intege")
col = Column(sql_session=connection,
column_name="data",
data_type="INTEGER")
def multiple_write_of_rows(n_rows, memory: bool = False):
td = tempfile.mkdtemp()
tf = Path(td) / "test_mrows.db"
tf = str(tf)
tf = "squealer.db"
db_tools = DataBase(db_path=tf)
db_tools.set_local_session
categories, sql_data = get_lots_of_data(n_rows=n_rows)
db_tools.create_table(table_name="data", categories=categories)
data_table = db_tools.tables["data"]
data_table.multi_write(sql_data)
def test_truediv_operator():
tf = tempfile.mkdtemp()
tf = Path(tf) / "test.db"
db_tools = DataBase(db_path=tf)
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.create_table(table_name="data", categories=categories)
# Try to find a non-existing table
no_table = db_tools / "hey"
assert no_table is None
a_table = db_tools / "data"
assert a_table == db_tools.tables["data"]
def write_read_memory(n_rows, memory):
td = tempfile.mkdtemp()
tf = Path(td) / "test_mrows.db"
tf = str(tf)
db_tools = DataBase(db_path=tf)
db_tools.set_memory_session
categories, sql_data = get_lots_of_data(n_rows=n_rows)
db_tools.create_table(table_name="data", categories=categories)
data_table = db_tools.tables["data"]
data_table.multi_write(sql_data)
data_table.select("*")
def test_create_table_uniqe_key():
tf = tempfile.mkdtemp()
tf = Path(tf) / "test.db"
db_tools = DataBase(db_path=tf)
categories = {"money": "REAL", "time": "REAL PRIMARY KEY"}
db_tools.create_table(table_name="data",
categories=categories,
primary_key_id=False)
data_table = db_tools.tables["data"]
data_table.write({"money": 2000, "time": 10})
data_table.write({"time": 33, "money": 22})
res = data_table.select(["*"])
assert res[0] == (2000, 10)
with pytest.raises(sqlite3.IntegrityError):
data_table.write({"time": 33, "money": 22})
def test_load_local_db_to_memory():
tf = tempfile.mkdtemp()
tf = Path(tf) / "mytest.db"
db_tools = DataBase(db_path=tf)
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.create_table(table_name="data", categories=categories)
sql_data = [{
"money": "2000",
"time": "10"
}, {
"time": "300",
"money": "600"
}]
# Initiate data to local db
local_table = db_tools.tables["data"]
local_table.multi_write(sql_data)
# Check local db has table named data
assert db_tools.context == "local"
assert list(db_tools.tables.keys()) == ["data"]
# Now set active session as memory db
db_tools.set_memory_session()
assert db_tools.get_active_session().db_path == ":memory:"
#Check memory db doesn't have table data
assert len(db_tools.tables) == 0
assert db_tools._fetch_all_tables() == []
# Load data to memory
db_tools.load_to_memory()
#db_tools.load_to_memory_stringio()
assert len(db_tools.tables) != 0
assert list(db_tools.tables.keys()) == ["data"]
memory_data_table = db_tools.tables["data"]
res = memory_data_table.select(["*"])
assert res[0] == (1, 2000, 10)
assert res[1] == (2, 600, 300)
assert len(res) == 2
def single_write_of_rows(n_rows, memory: bool=False):
td = tempfile.mkdtemp()
tf = Path(td) / "test_rows.db"
tf = str(tf)
db_tools = DataBase(db_path=tf)
if memory:
db_tools.set_memory_session
else:
db_tools.set_local_session
categories, sql_data = get_lots_of_data(n_rows=n_rows)
db_tools.create_table(table_name="data",
categories=categories)
data_table = db_tools.tables["data"]
for data in sql_data:
data_table.write(data)
def load_db_to_memory(n_rows, memory):
td = tempfile.mkdtemp()
tf = Path(td) / f"test_{memory}_rows.db"
tf = str(tf)
db_tools = DataBase(db_path=tf)
categories, sql_data = get_lots_of_data(n_rows=n_rows)
db_tools.create_table(table_name="data", categories=categories)
data_table = db_tools.tables["data"]
data_table.multi_write(sql_data)
if memory == "stringio":
db_tools.load_to_memory_stringio()
else:
db_tools.load_to_memory()
db_tools.memory_db.close()
def test_create_table_sqlite_db():
tf = tempfile.mkdtemp()
tf = Path(tf) / "test.db"
db_tools = DataBase(db_path=tf)
# Check inital registry is empty
assert list(db_tools.tables.keys()) == []
categories = {"money": "REAL", "time": "REAL"}
db_tools.create_table(table_name="data", categories=categories)
assert list(db_tools.tables.keys()) == ["data"]
db_tools.delete_table("data")
assert list(db_tools.tables.keys()) == []
def test_read_and_write_table():
tf = tempfile.mkdtemp()
tf = Path(tf) / "test.db"
db_tools = DataBase(db_path=tf)
not_valid_categories = {"money": "RREAL", "time": "REAL"}
# Checks for unvalid SQL data type
#TODO: Make own test for enumerator, covering valid types
with pytest.raises(TypeError):
db_tools.create_table(table_name="data",
categories=not_valid_categories)
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.create_table(table_name="data", categories=categories)
# Test write, and order of write features is arbritary
data_table = db_tools.tables["data"]
sql_data = [{
"money": "2000",
"time": "10"
}, {
"time": "300",
"money": "600"
}]
for data in sql_data:
data_table.write(data)
res = data_table.select(["*"])
assert res[0] == (1, 2000, 10)
assert res[1] == (2, 600, 300)
sql_data = [{
"money": "2000",
"time": "10"
}, {
"time": "300",
"money": "600"
}]
data_table.multi_write(sql_data)
res = data_table.select(["*"])
# TODO: Multi write should support random order of dict.keys
# only write suppoerts this for now
# Keep separate due to loots of checks for many rows
assert res[2] == (3, 2000, 10)
assert res[3] == (4, 600, 300)
res = data_table.select(["time, money"])
def get_data_table_tool(db_name="test"):
tf = tempfile.TemporaryFile(suffix=".db", prefix=db_name)
tf = str(tf)
db_tools = DataBase(db_path=tf)
return db_tools
def test_memory_read_and_write():
tf = tempfile.mkdtemp()
tf = Path(tf) / "mytest.db"
db_tools = DataBase(db_path=tf)
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.set_memory_session()
assert db_tools.context == "memory"
db_tools.create_table(table_name="data", categories=categories)
sql_data = [{
"money": "2000",
"time": "10"
}, {
"time": "300",
"money": "600"
}]
memory_table = db_tools.tables["data"]
memory_table.multi_write(sql_data)
res = memory_table.select(["*"])
assert res[0] == (1, 2000, 10)
assert res[1] == (2, 600, 300)
assert len(res) == 2
sql_data = [{
"money": "6000",
"time": "60"
}, {
"time": "900",
"money": "900"
}]
# BUG, table is now connected to local db
memory_data_table = db_tools.tables["data"]
memory_data_table.multi_write(sql_data)
assert db_tools.get_active_session().db_path == ":memory:"
# Check that local file db is empty
db_tools.set_local_session()
assert db_tools.get_active_session().db_path != ":memory:"
local_tables = db_tools._fetch_all_tables()
assert local_tables == []
def test_initiate_memory_db():
tf = tempfile.mkdtemp()
tf = Path(tf) / "mytest.db"
db_tools = DataBase(db_path=tf)
assert not db_tools.in_memory()
assert db_tools.context == "local"
categories = {"money": "INTEGER", "time": "INTEGER"}
db_tools.create_table(table_name="data", categories=categories)
# Create local db with values
local_tables = db_tools._fetch_all_tables()
assert "data" in local_tables
# Change context to memory db and check that data table isn't initiated
db_tools.set_memory_session()
assert db_tools.context == "memory"
memory_tables = db_tools._fetch_all_tables()
assert "data" not in memory_tables
# Change context to memory db and check that data table isn't initiated
#db_tools.load_to_memory_stringio()
db_tools.load_to_memory()
memory_tables = db_tools._fetch_all_tables()
assert "data" in memory_tables
