diff --git a/tests/test_analyze.py b/tests/test_analyze.py
index a4cd8a2..edd5174 100644
--- a/tests/test_analyze.py
+++ b/tests/test_analyze.py
@@ -3,11 +3,13 @@ import pytest
@pytest.fixture
def db(fresh_db):
- fresh_db["one_index"].insert({"id": 1, "name": "Cleo"}, pk="id")
- fresh_db["one_index"].create_index(["name"])
- fresh_db["two_indexes"].insert({"id": 1, "name": "Cleo", "species": "dog"}, pk="id")
- fresh_db["two_indexes"].create_index(["name"])
- fresh_db["two_indexes"].create_index(["species"])
+ fresh_db.table("one_index").insert({"id": 1, "name": "Cleo"}, pk="id")
+ fresh_db.table("one_index").create_index(["name"])
+ fresh_db.table("two_indexes").insert(
+ {"id": 1, "name": "Cleo", "species": "dog"}, pk="id"
+ )
+ fresh_db.table("two_indexes").create_index(["name"])
+ fresh_db.table("two_indexes").create_index(["species"])
return fresh_db
@@ -17,7 +19,7 @@ def test_analyze_whole_database(db):
assert set(db.table_names()).issuperset(
{"one_index", "two_indexes", "sqlite_stat1"}
)
- assert list(db["sqlite_stat1"].rows) == [
+ assert list(db.table("sqlite_stat1").rows) == [
{"tbl": "two_indexes", "idx": "idx_two_indexes_species", "stat": "1 1"},
{"tbl": "two_indexes", "idx": "idx_two_indexes_name", "stat": "1 1"},
{"tbl": "one_index", "idx": "idx_one_index_name", "stat": "1 1"},
@@ -30,12 +32,12 @@ def test_analyze_one_table(db, method):
if method == "db_method_with_name":
db.analyze("one_index")
elif method == "table_method":
- db["one_index"].analyze()
+ db.table("one_index").analyze()
assert set(db.table_names()).issuperset(
{"one_index", "two_indexes", "sqlite_stat1"}
)
- assert list(db["sqlite_stat1"].rows) == [
+ assert list(db.table("sqlite_stat1").rows) == [
{"tbl": "one_index", "idx": "idx_one_index_name", "stat": "1 1"}
]
@@ -46,6 +48,6 @@ def test_analyze_index_by_name(db):
assert set(db.table_names()).issuperset(
{"one_index", "two_indexes", "sqlite_stat1"}
)
- assert list(db["sqlite_stat1"].rows) == [
+ assert list(db.table("sqlite_stat1").rows) == [
{"tbl": "two_indexes", "idx": "idx_two_indexes_species", "stat": "1 1"},
]
diff --git a/tests/test_analyze_tables.py b/tests/test_analyze_tables.py
index a51bba6..9e4799c 100644
--- a/tests/test_analyze_tables.py
+++ b/tests/test_analyze_tables.py
@@ -9,7 +9,7 @@ from sqlite_utils.db import ColumnDetails, Database
@pytest.fixture
def db_to_analyze(fresh_db):
- stuff = fresh_db["stuff"]
+ stuff = fresh_db.table("stuff")
stuff.insert_all(
[
{"id": 1, "owner": "Terryterryterry", "size": 5},
@@ -45,7 +45,7 @@ def big_db_to_analyze_path(tmpdir):
"all_null": None,
}
)
- db["stuff"].insert_all(to_insert)
+ db.table("stuff").insert_all(to_insert)
return path
@@ -126,7 +126,7 @@ def big_db_to_analyze_path(tmpdir):
)
def test_analyze_column(db_to_analyze, column, extra_kwargs, expected):
assert (
- db_to_analyze["stuff"].analyze_column(
+ db_to_analyze.table("stuff").analyze_column(
column, common_limit=2, value_truncate=5, **extra_kwargs
)
== expected
@@ -186,7 +186,7 @@ def test_analyze_table_save(db_to_analyze_path):
cli.cli, ["analyze-tables", db_to_analyze_path, "--save"]
)
assert result.exit_code == 0
- rows = list(Database(db_to_analyze_path)["_analyze_tables_"].rows)
+ rows = list(Database(db_to_analyze_path).table("_analyze_tables_").rows)
assert rows == [
{
"table": "stuff",
@@ -248,7 +248,7 @@ def test_analyze_table_save_no_most_no_least_options(
args.append("--no-least")
result = CliRunner().invoke(cli.cli, args)
assert result.exit_code == 0
- rows = list(Database(big_db_to_analyze_path)["_analyze_tables_"].rows)
+ rows = list(Database(big_db_to_analyze_path).table("_analyze_tables_").rows)
expected = {
"table": "stuff",
"column": "category",
@@ -297,13 +297,13 @@ def test_analyze_table_column_all_nulls(big_db_to_analyze_path):
def test_analyze_table_validate_columns(tmpdir, args, expected_error):
path = str(tmpdir / "test_validate_columns.db")
db = Database(path)
- db["one"].insert(
+ db.table("one").insert(
{
"id": 1,
"name": "one",
}
)
- db["two"].insert(
+ db.table("two").insert(
{
"id": 1,
"age": 5,
diff --git a/tests/test_atomic.py b/tests/test_atomic.py
index ba16ca5..89a318a 100644
--- a/tests/test_atomic.py
+++ b/tests/test_atomic.py
@@ -45,30 +45,30 @@ def test_iter_complete_sql_statements(sql, expected):
def test_atomic_commits(fresh_db):
with fresh_db.atomic():
- fresh_db["dogs"].insert({"id": 1, "name": "Cleo"}, pk="id")
+ fresh_db.table("dogs").insert({"id": 1, "name": "Cleo"}, pk="id")
- assert list(fresh_db["dogs"].rows) == [{"id": 1, "name": "Cleo"}]
+ assert list(fresh_db.table("dogs").rows) == [{"id": 1, "name": "Cleo"}]
def test_atomic_rolls_back(fresh_db):
with pytest.raises(RuntimeError), fresh_db.atomic():
- fresh_db["dogs"].insert({"id": 1, "name": "Cleo"}, pk="id")
+ fresh_db.table("dogs").insert({"id": 1, "name": "Cleo"}, pk="id")
raise RuntimeError("boom")
- assert not fresh_db["dogs"].exists()
+ assert not fresh_db.table("dogs").exists()
def test_nested_atomic_rolls_back_to_savepoint(fresh_db):
- fresh_db["dogs"].create({"id": int, "name": str}, pk="id")
+ fresh_db.table("dogs").create({"id": int, "name": str}, pk="id")
with fresh_db.atomic():
- fresh_db["dogs"].insert({"id": 1, "name": "Cleo"})
+ fresh_db.table("dogs").insert({"id": 1, "name": "Cleo"})
with pytest.raises(RuntimeError), fresh_db.atomic():
- fresh_db["dogs"].insert({"id": 2, "name": "Pancakes"})
+ fresh_db.table("dogs").insert({"id": 2, "name": "Pancakes"})
raise RuntimeError("boom")
- fresh_db["dogs"].insert({"id": 3, "name": "Marnie"})
+ fresh_db.table("dogs").insert({"id": 3, "name": "Marnie"})
- assert list(fresh_db["dogs"].rows) == [
+ assert list(fresh_db.table("dogs").rows) == [
{"id": 1, "name": "Cleo"},
{"id": 3, "name": "Marnie"},
]
@@ -76,12 +76,12 @@ def test_nested_atomic_rolls_back_to_savepoint(fresh_db):
def test_outer_atomic_rolls_back_released_savepoint(fresh_db):
with pytest.raises(RuntimeError), fresh_db.atomic():
- fresh_db["dogs"].insert({"id": 1, "name": "Cleo"}, pk="id")
+ fresh_db.table("dogs").insert({"id": 1, "name": "Cleo"}, pk="id")
with fresh_db.atomic():
- fresh_db["dogs"].insert({"id": 2, "name": "Pancakes"})
+ fresh_db.table("dogs").insert({"id": 2, "name": "Pancakes"})
raise RuntimeError("boom")
- assert not fresh_db["dogs"].exists()
+ assert not fresh_db.table("dogs").exists()
def test_executescript_does_not_commit_open_atomic_block(fresh_db):
@@ -97,41 +97,41 @@ def test_executescript_does_not_commit_open_atomic_block(fresh_db):
""")
raise RuntimeError("boom")
- assert not fresh_db["dogs"].exists()
+ assert not fresh_db.table("dogs").exists()
def test_transform_does_not_commit_open_atomic_block(fresh_db):
- fresh_db["dogs"].insert({"id": 1, "name": "Cleo", "age": "5"}, pk="id")
+ fresh_db.table("dogs").insert({"id": 1, "name": "Cleo", "age": "5"}, pk="id")
with pytest.raises(RuntimeError), fresh_db.atomic():
- fresh_db["dogs"].insert({"id": 2, "name": "Pancakes", "age": "6"})
- fresh_db["dogs"].transform(rename={"age": "dog_age"})
+ fresh_db.table("dogs").insert({"id": 2, "name": "Pancakes", "age": "6"})
+ fresh_db.table("dogs").transform(rename={"age": "dog_age"})
raise RuntimeError("boom")
assert (
- fresh_db["dogs"].schema
+ fresh_db.table("dogs").schema
== 'CREATE TABLE "dogs" (\n "id" INTEGER PRIMARY KEY,\n "name" TEXT,\n "age" TEXT\n)'
)
- assert list(fresh_db["dogs"].rows) == [
+ assert list(fresh_db.table("dogs").rows) == [
{"id": 1, "name": "Cleo", "age": "5"},
]
def test_transform_parent_table_with_foreign_keys_in_atomic(fresh_db):
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
- fresh_db["authors"].insert({"id": 1, "name": "Tina"}, pk="id")
- fresh_db["books"].insert(
+ fresh_db.table("authors").insert({"id": 1, "name": "Tina"}, pk="id")
+ fresh_db.table("books").insert(
{"id": 1, "title": "Book", "author_id": 1},
pk="id",
foreign_keys={"author_id"},
)
with fresh_db.atomic():
- fresh_db["authors"].transform(rename={"name": "full_name"})
+ fresh_db.table("authors").transform(rename={"name": "full_name"})
assert fresh_db.conn.execute("PRAGMA foreign_keys").fetchone()[0]
assert (
- fresh_db["authors"].schema
+ fresh_db.table("authors").schema
== 'CREATE TABLE "authors" (\n "id" INTEGER PRIMARY KEY,\n "full_name" TEXT\n)'
)
assert fresh_db.execute("PRAGMA foreign_key_check").fetchall() == []
@@ -139,19 +139,19 @@ def test_transform_parent_table_with_foreign_keys_in_atomic(fresh_db):
def test_transform_parent_table_with_foreign_keys_rolls_back(fresh_db):
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
- fresh_db["authors"].insert({"id": 1, "name": "Tina"}, pk="id")
- fresh_db["books"].insert(
+ fresh_db.table("authors").insert({"id": 1, "name": "Tina"}, pk="id")
+ fresh_db.table("books").insert(
{"id": 1, "title": "Book", "author_id": 1},
pk="id",
foreign_keys={"author_id"},
)
with pytest.raises(RuntimeError), fresh_db.atomic():
- fresh_db["authors"].transform(rename={"name": "full_name"})
+ fresh_db.table("authors").transform(rename={"name": "full_name"})
raise RuntimeError("boom")
assert (
- fresh_db["authors"].schema
+ fresh_db.table("authors").schema
== 'CREATE TABLE "authors" (\n "id" INTEGER PRIMARY KEY,\n "name" TEXT\n)'
)
assert fresh_db.conn.execute("PRAGMA foreign_keys").fetchone()[0]
@@ -160,49 +160,51 @@ def test_transform_parent_table_with_foreign_keys_rolls_back(fresh_db):
def test_transform_detects_foreign_key_check_violations(fresh_db):
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
- fresh_db["authors"].insert({"id": 1, "name": "Tina"}, pk="id")
- fresh_db["books"].insert({"id": 1, "author_id": 2}, pk="id")
+ fresh_db.table("authors").insert({"id": 1, "name": "Tina"}, pk="id")
+ fresh_db.table("books").insert({"id": 1, "author_id": 2}, pk="id")
with pytest.raises(sqlite3.IntegrityError):
- fresh_db["books"].transform(add_foreign_keys=(("author_id", "authors", "id"),))
+ fresh_db.table("books").transform(
+ add_foreign_keys=(("author_id", "authors", "id"),)
+ )
- assert fresh_db["books"].foreign_keys == []
+ assert fresh_db.table("books").foreign_keys == []
assert fresh_db.conn.execute("PRAGMA foreign_keys").fetchone()[0]
def test_atomic_inside_manual_transaction_uses_savepoint(fresh_db):
- fresh_db["t"].insert({"id": 1}, pk="id")
+ fresh_db.table("t").insert({"id": 1}, pk="id")
fresh_db.execute("begin")
with fresh_db.atomic():
- fresh_db["t"].insert({"id": 2}, pk="id")
+ fresh_db.table("t").insert({"id": 2}, pk="id")
# Nothing is committed until the user's own transaction commits
assert fresh_db.conn.in_transaction
fresh_db.rollback()
- assert [r["id"] for r in fresh_db["t"].rows] == [1]
+ assert [r["id"] for r in fresh_db.table("t").rows] == [1]
# And with a commit instead, the atomic block's writes persist
fresh_db.execute("begin")
with fresh_db.atomic():
- fresh_db["t"].insert({"id": 3}, pk="id")
+ fresh_db.table("t").insert({"id": 3}, pk="id")
fresh_db.commit()
- assert [r["id"] for r in fresh_db["t"].rows] == [1, 3]
+ assert [r["id"] for r in fresh_db.table("t").rows] == [1, 3]
def test_begin_commit_rollback(tmpdir):
path = str(tmpdir / "test.db")
db = Database(path)
- db["t"].insert({"id": 1}, pk="id")
+ db.table("t").insert({"id": 1}, pk="id")
db.begin()
- db["t"].insert({"id": 2}, pk="id")
+ db.table("t").insert({"id": 2}, pk="id")
assert db.conn.in_transaction
db.rollback()
assert not db.conn.in_transaction
- assert [r["id"] for r in db["t"].rows] == [1]
+ assert [r["id"] for r in db.table("t").rows] == [1]
db.begin()
- db["t"].insert({"id": 3}, pk="id")
+ db.table("t").insert({"id": 3}, pk="id")
db.commit()
db.close()
db2 = Database(path)
- assert [r["id"] for r in db2["t"].rows] == [1, 3]
+ assert [r["id"] for r in db2.table("t").rows] == [1, 3]
db2.close()
@@ -222,7 +224,7 @@ def test_commit_and_rollback_without_transaction_are_noops(fresh_db):
def test_execute_write_commits_immediately(tmpdir):
path = str(tmpdir / "test.db")
db = Database(path)
- db["t"].insert({"id": 1}, pk="id")
+ db.table("t").insert({"id": 1}, pk="id")
db.execute("insert into t (id) values (2)")
# No implicit transaction is left open
assert not db.conn.in_transaction
@@ -234,24 +236,24 @@ def test_execute_write_commits_immediately(tmpdir):
def test_execute_write_respects_explicit_transaction(fresh_db):
- fresh_db["t"].insert({"id": 1}, pk="id")
+ fresh_db.table("t").insert({"id": 1}, pk="id")
fresh_db.begin()
fresh_db.execute("insert into t (id) values (2)")
# Still inside the explicit transaction - not committed
assert fresh_db.conn.in_transaction
fresh_db.rollback()
- assert [r["id"] for r in fresh_db["t"].rows] == [1]
+ assert [r["id"] for r in fresh_db.table("t").rows] == [1]
def test_execute_comment_prefixed_begin_leaves_transaction_open(fresh_db):
# A BEGIN hidden behind a leading comment must not be auto-committed
# out from under the caller
- fresh_db["t"].insert({"id": 1}, pk="id")
+ fresh_db.table("t").insert({"id": 1}, pk="id")
fresh_db.execute("-- start a transaction\nbegin")
assert fresh_db.conn.in_transaction
fresh_db.execute("insert into t (id) values (2)")
fresh_db.rollback()
- assert [r["id"] for r in fresh_db["t"].rows] == [1]
+ assert [r["id"] for r in fresh_db.table("t").rows] == [1]
def _sqlite_accepts_bom():
@@ -269,12 +271,12 @@ def test_execute_prefixed_begin_leaves_transaction_open(fresh_db, begin_sql):
# out from under the caller
if begin_sql.startswith("\ufeff") and not _sqlite_accepts_bom():
pytest.skip("This SQLite version rejects a leading byte order mark")
- fresh_db["t"].insert({"id": 1}, pk="id")
+ fresh_db.table("t").insert({"id": 1}, pk="id")
fresh_db.execute(begin_sql)
assert fresh_db.conn.in_transaction
fresh_db.execute("insert into t (id) values (2)")
fresh_db.rollback()
- assert [r["id"] for r in fresh_db["t"].rows] == [1]
+ assert [r["id"] for r in fresh_db.table("t").rows] == [1]
def test_execute_failed_write_rolls_back_implicit_transaction(tmpdir):
@@ -282,40 +284,40 @@ def test_execute_failed_write_rolls_back_implicit_transaction(tmpdir):
# that would silently disable auto-commit for every subsequent write
path = str(tmpdir / "test.db")
db = Database(path)
- db["t"].insert({"id": 1}, pk="id")
+ db.table("t").insert({"id": 1}, pk="id")
with pytest.raises(sqlite3.IntegrityError):
db.execute("insert into t (id) values (1)")
assert not db.conn.in_transaction
# Subsequent writes commit as normal and survive closing the connection
- db["other"].insert({"id": 2})
+ db.table("other").insert({"id": 2})
db.close()
db2 = Database(path)
- assert db2["other"].exists()
+ assert db2.table("other").exists()
db2.close()
def test_execute_failed_write_preserves_explicit_transaction(fresh_db):
# A failed write inside an explicit transaction must not roll back
# the caller's earlier work - only the caller decides that
- fresh_db["t"].insert({"id": 1}, pk="id")
+ fresh_db.table("t").insert({"id": 1}, pk="id")
fresh_db.begin()
fresh_db.execute("insert into t (id) values (2)")
with pytest.raises(sqlite3.IntegrityError):
fresh_db.execute("insert into t (id) values (1)")
assert fresh_db.conn.in_transaction
fresh_db.commit()
- assert [r["id"] for r in fresh_db["t"].rows] == [1, 2]
+ assert [r["id"] for r in fresh_db.table("t").rows] == [1, 2]
def test_execute_failed_write_inside_atomic_preserves_block(fresh_db):
# A caught failure inside an atomic() block must leave the block's
# transaction open so its other work still commits
- fresh_db["t"].insert({"id": 1}, pk="id")
+ fresh_db.table("t").insert({"id": 1}, pk="id")
with fresh_db.atomic():
fresh_db.execute("insert into t (id) values (2)")
with pytest.raises(sqlite3.IntegrityError):
fresh_db.execute("insert into t (id) values (1)")
- assert [r["id"] for r in fresh_db["t"].rows] == [1, 2]
+ assert [r["id"] for r in fresh_db.table("t").rows] == [1, 2]
def test_query_returning_commits_after_iteration(tmpdir):
@@ -325,7 +327,7 @@ def test_query_returning_commits_after_iteration(tmpdir):
_pytest.skip("RETURNING requires SQLite 3.35.0 or higher")
path = str(tmpdir / "test.db")
db = Database(path)
- db["t"].insert({"id": 1}, pk="id")
+ db.table("t").insert({"id": 1}, pk="id")
rows = list(db.query("insert into t (id) values (2) returning id"))
assert rows == [{"id": 2}]
assert not db.conn.in_transaction
@@ -375,7 +377,7 @@ def test_nested_atomic_preserves_error_from_transaction_destroying_trigger(
def test_atomic_preserves_error_from_insert_or_rollback(fresh_db):
- fresh_db["t"].insert({"id": 1}, pk="id")
+ fresh_db.table("t").insert({"id": 1}, pk="id")
with pytest.raises(sqlite3.IntegrityError), fresh_db.atomic():
fresh_db.execute("insert or rollback into t (id) values (1)")
assert not fresh_db.conn.in_transaction
diff --git a/tests/test_attach.py b/tests/test_attach.py
index b594b3b..2b11e36 100644
--- a/tests/test_attach.py
+++ b/tests/test_attach.py
@@ -6,10 +6,10 @@ def test_attach(tmpdir):
bar_path = str(tmpdir / "bar.db")
db = Database(foo_path)
with db.conn:
- db["foo"].insert({"id": 1, "text": "foo"})
+ db.table("foo").insert({"id": 1, "text": "foo"})
db2 = Database(bar_path)
with db2.conn:
- db2["bar"].insert({"id": 1, "text": "bar"})
+ db2.table("bar").insert({"id": 1, "text": "bar"})
db.attach("bar", bar_path)
assert db.execute(
"select * from foo union all select * from bar.bar"
diff --git a/tests/test_cli.py b/tests/test_cli.py
index d3ad228..012900c 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -72,13 +72,13 @@ def test_views(db_path):
def test_tables_fts4(db_path):
- Database(db_path)["Gosh"].enable_fts(["c2"], fts_version="FTS4")
+ Database(db_path).table("Gosh").enable_fts(["c2"], fts_version="FTS4")
result = CliRunner().invoke(cli.cli, ["tables", "--fts4", db_path])
assert '[{"table": "Gosh_fts"}]' == result.output.strip()
def test_tables_fts5(db_path):
- Database(db_path)["Gosh"].enable_fts(["c2"], fts_version="FTS5")
+ Database(db_path).table("Gosh").enable_fts(["c2"], fts_version="FTS5")
result = CliRunner().invoke(cli.cli, ["tables", "--fts5", db_path])
assert '[{"table": "Gosh_fts"}]' == result.output.strip()
@@ -86,7 +86,7 @@ def test_tables_fts5(db_path):
def test_tables_counts_and_columns(db_path):
db = Database(db_path)
with db.conn:
- db["lots"].insert_all([{"id": i, "age": i + 1} for i in range(30)])
+ db.table("lots").insert_all([{"id": i, "age": i + 1} for i in range(30)])
result = CliRunner().invoke(cli.cli, ["tables", "--counts", "--columns", db_path])
assert (
'[{"table": "Gosh", "count": 0, "columns": ["c1", "c2", "c3"]},\n'
@@ -121,7 +121,7 @@ def test_tables_counts_and_columns(db_path):
def test_tables_counts_and_columns_csv(db_path, format, expected):
db = Database(db_path)
with db.conn:
- db["lots"].insert_all([{"id": i, "age": i + 1} for i in range(30)])
+ db.table("lots").insert_all([{"id": i, "age": i + 1} for i in range(30)])
result = CliRunner().invoke(
cli.cli, ["tables", "--counts", "--columns", format, db_path]
)
@@ -131,7 +131,7 @@ def test_tables_counts_and_columns_csv(db_path, format, expected):
def test_tables_schema(db_path):
db = Database(db_path)
with db.conn:
- db["lots"].insert_all([{"id": i, "age": i + 1} for i in range(30)])
+ db.table("lots").insert_all([{"id": i, "age": i + 1} for i in range(30)])
result = CliRunner().invoke(cli.cli, ["tables", "--schema", db_path])
assert (
'[{"table": "Gosh", "schema": "CREATE TABLE Gosh (c1 text, c2 text, c3 text)"},\n'
@@ -183,7 +183,7 @@ def test_tables_schema(db_path):
def test_output_table(db_path, options, expected):
db = Database(db_path)
with db.conn:
- db["rows"].insert_all(
+ db.table("rows").insert_all(
[
{
"c1": f"verb{i}",
@@ -207,7 +207,7 @@ def test_output_table_no_headers(db_path, fmt_option):
# tabulate formats and the column names were always printed.
db = Database(db_path)
with db.conn:
- db["dogs"].insert_all(
+ db.table("dogs").insert_all(
[
{"id": 1, "name": "Cleo", "age": 4},
{"id": 2, "name": "Pancakes", "age": 2},
@@ -244,14 +244,14 @@ def test_output_table_no_headers(db_path, fmt_option):
def test_create_index(db_path):
db = Database(db_path)
- assert [] == db["Gosh"].indexes
+ assert [] == db.table("Gosh").indexes
result = CliRunner().invoke(cli.cli, ["create-index", db_path, "Gosh", "c1"])
assert result.exit_code == 0
assert [
Index(
seq=0, name="idx_Gosh_c1", unique=0, origin="c", partial=0, columns=["c1"]
)
- ] == db["Gosh"].indexes
+ ] == db.table("Gosh").indexes
# Try with a custom name
result = CliRunner().invoke(
cli.cli, ["create-index", db_path, "Gosh", "c2", "--name", "blah"]
@@ -262,7 +262,7 @@ def test_create_index(db_path):
Index(
seq=1, name="idx_Gosh_c1", unique=0, origin="c", partial=0, columns=["c1"]
),
- ] == db["Gosh"].indexes
+ ] == db.table("Gosh").indexes
# Try a two-column unique index
create_index_unique_args = [
"create-index",
@@ -283,7 +283,7 @@ def test_create_index(db_path):
partial=0,
columns=["c1", "c2"],
)
- ] == db["Gosh2"].indexes
+ ] == db.table("Gosh2").indexes
# Trying to create the same index should fail
assert CliRunner().invoke(cli.cli, create_index_unique_args).exit_code != 0
# ... unless we use --if-not-exists or --ignore
@@ -296,11 +296,11 @@ def test_create_index(db_path):
def test_drop_index(db_path):
db = Database(db_path)
- db["Gosh"].create_index(["c1"])
- assert [index.name for index in db["Gosh"].indexes] == ["idx_Gosh_c1"]
+ db.table("Gosh").create_index(["c1"])
+ assert [index.name for index in db.table("Gosh").indexes] == ["idx_Gosh_c1"]
result = CliRunner().invoke(cli.cli, ["drop-index", db_path, "Gosh", "idx_Gosh_c1"])
assert result.exit_code == 0
- assert db["Gosh"].indexes == []
+ assert db.table("Gosh").indexes == []
result = CliRunner().invoke(cli.cli, ["drop-index", db_path, "Gosh", "idx_Gosh_c1"])
assert result.exit_code == 1
@@ -315,7 +315,7 @@ def test_drop_index(db_path):
def test_create_index_analyze(db_path):
db = Database(db_path)
assert "sqlite_stat1" not in db.table_names()
- assert [] == db["Gosh"].indexes
+ assert [] == db.table("Gosh").indexes
result = CliRunner().invoke(
cli.cli, ["create-index", db_path, "Gosh", "c1", "--analyze"]
)
@@ -325,7 +325,7 @@ def test_create_index_analyze(db_path):
def test_create_index_desc(db_path):
db = Database(db_path)
- assert [] == db["Gosh"].indexes
+ assert [] == db.table("Gosh").indexes
result = CliRunner().invoke(cli.cli, ["create-index", db_path, "Gosh", "--", "-c1"])
assert result.exit_code == 0
assert (
@@ -361,12 +361,12 @@ def test_create_index_desc(db_path):
def test_add_column(db_path, col_name, col_type, expected_schema):
db = Database(db_path)
db.create_table("dogs", {"name": str})
- assert db["dogs"].schema == 'CREATE TABLE "dogs" (\n "name" TEXT\n)'
+ assert db.table("dogs").schema == 'CREATE TABLE "dogs" (\n "name" TEXT\n)'
args = ["add-column", db_path, "dogs", col_name]
if col_type is not None:
args.append(col_type)
assert CliRunner().invoke(cli.cli, args).exit_code == 0
- assert db["dogs"].schema == expected_schema
+ assert db.table("dogs").schema == expected_schema
@pytest.mark.parametrize("ignore", (True, False))
@@ -385,7 +385,7 @@ def test_add_column_ignore(db_path, ignore):
def test_add_column_not_null_default(db_path):
db = Database(db_path)
db.create_table("dogs", {"name": str})
- assert db["dogs"].schema == 'CREATE TABLE "dogs" (\n "name" TEXT\n)'
+ assert db.table("dogs").schema == 'CREATE TABLE "dogs" (\n "name" TEXT\n)'
args = [
"add-column",
db_path,
@@ -395,7 +395,7 @@ def test_add_column_not_null_default(db_path):
"dogs'dawg",
]
assert CliRunner().invoke(cli.cli, args).exit_code == 0
- assert db["dogs"].schema == (
+ assert db.table("dogs").schema == (
'CREATE TABLE "dogs" (\n'
' "name" TEXT\n'
", \"nickname\" TEXT NOT NULL DEFAULT 'dogs''dawg')"
@@ -415,10 +415,10 @@ def test_add_column_not_null_default(db_path):
)
def test_add_foreign_key(db_path, args, assert_message):
db = Database(db_path)
- db["authors"].insert_all(
+ db.table("authors").insert_all(
[{"id": 1, "name": "Sally"}, {"id": 2, "name": "Asheesh"}], pk="id"
)
- db["books"].insert_all(
+ db.table("books").insert_all(
[
{"title": "Hedgehogs of the world", "author_id": 1},
{"title": "How to train your wolf", "author_id": 2},
@@ -431,7 +431,7 @@ def test_add_foreign_key(db_path, args, assert_message):
ForeignKey(
table="books", column="author_id", other_table="authors", other_column="id"
)
- ] == db["books"].foreign_keys
+ ] == db.table("books").foreign_keys
# Error if we try to add it twice:
result = CliRunner().invoke(
@@ -460,14 +460,14 @@ def test_add_foreign_key(db_path, args, assert_message):
def test_add_column_foreign_key(db_path):
db = Database(db_path)
- db["authors"].insert({"id": 1, "name": "Sally"}, pk="id")
- db["books"].insert({"title": "Hedgehogs of the world"})
+ db.table("authors").insert({"id": 1, "name": "Sally"}, pk="id")
+ db.table("books").insert({"title": "Hedgehogs of the world"})
# Add an author_id foreign key column to the books table
result = CliRunner().invoke(
cli.cli, ["add-column", db_path, "books", "author_id", "--fk", "authors"]
)
assert result.exit_code == 0, result.output
- assert db["books"].schema == (
+ assert db.table("books").schema == (
'CREATE TABLE "books" (\n'
' "title" TEXT,\n'
' "author_id" INTEGER REFERENCES "authors"("id")\n'
@@ -488,7 +488,7 @@ def test_add_column_foreign_key(db_path):
],
)
assert result.exit_code == 0, result.output
- assert db["books"].schema == (
+ assert db.table("books").schema == (
'CREATE TABLE "books" (\n'
' "title" TEXT,\n'
' "author_id" INTEGER REFERENCES "authors"("id"),\n'
@@ -505,7 +505,7 @@ def test_add_column_foreign_key(db_path):
def test_suggest_alter_if_column_missing(db_path):
db = Database(db_path)
- db["authors"].insert({"id": 1, "name": "Sally"}, pk="id")
+ db.table("authors").insert({"id": 1, "name": "Sally"}, pk="id")
result = CliRunner().invoke(
cli.cli,
["insert", db_path, "authors", "-"],
@@ -521,27 +521,27 @@ def test_suggest_alter_if_column_missing(db_path):
def test_index_foreign_keys(db_path):
test_add_column_foreign_key(db_path)
db = Database(db_path)
- assert [] == db["books"].indexes
+ assert [] == db.table("books").indexes
result = CliRunner().invoke(cli.cli, ["index-foreign-keys", db_path])
assert result.exit_code == 0
assert [["author_id"], ["author_name_ref"]] == [
- i.columns for i in db["books"].indexes
+ i.columns for i in db.table("books").indexes
]
def test_enable_fts(db_path):
db = Database(db_path)
- assert db["Gosh"].detect_fts() is None
+ assert db.table("Gosh").detect_fts() is None
result = CliRunner().invoke(
cli.cli, ["enable-fts", db_path, "Gosh", "c1", "--fts4"]
)
assert result.exit_code == 0
- assert "Gosh_fts" == db["Gosh"].detect_fts()
+ assert "Gosh_fts" == db.table("Gosh").detect_fts()
# Table names with restricted chars are handled correctly.
# colons and dots are restricted characters for table names.
- db["http://example.com"].create({"c1": str, "c2": str, "c3": str})
- assert db["http://example.com"].detect_fts() is None
+ db.table("http://example.com").create({"c1": str, "c2": str, "c3": str})
+ assert db.table("http://example.com").detect_fts() is None
result = CliRunner().invoke(
cli.cli,
[
@@ -555,7 +555,7 @@ def test_enable_fts(db_path):
],
)
assert result.exit_code == 0
- assert "http://example.com_fts" == db["http://example.com"].detect_fts()
+ assert "http://example.com_fts" == db.table("http://example.com").detect_fts()
# Check tokenize was set to porter
assert (
'CREATE VIRTUAL TABLE "http://example.com_fts" USING FTS4 (\n'
@@ -563,19 +563,19 @@ def test_enable_fts(db_path):
" tokenize='porter',\n"
' content="http://example.com"'
"\n)"
- ) == db["http://example.com_fts"].schema
- db["http://example.com"].drop()
+ ) == db.table("http://example.com_fts").schema
+ db.table("http://example.com").drop()
def test_enable_fts_replace(db_path):
db = Database(db_path)
- assert db["Gosh"].detect_fts() is None
+ assert db.table("Gosh").detect_fts() is None
result = CliRunner().invoke(
cli.cli, ["enable-fts", db_path, "Gosh", "c1", "--fts4"]
)
assert result.exit_code == 0
- assert "Gosh_fts" == db["Gosh"].detect_fts()
- assert db["Gosh_fts"].columns_dict == {"c1": str}
+ assert "Gosh_fts" == db.table("Gosh").detect_fts()
+ assert db.table("Gosh_fts").columns_dict == {"c1": str}
# This should throw an error
result2 = CliRunner().invoke(
@@ -589,11 +589,11 @@ def test_enable_fts_replace(db_path):
cli.cli, ["enable-fts", db_path, "Gosh", "c2", "--fts4", "--replace"]
)
assert result3.exit_code == 0
- assert db["Gosh_fts"].columns_dict == {"c2": str}
+ assert db.table("Gosh_fts").columns_dict == {"c2": str}
def test_enable_fts_with_triggers(db_path):
- Database(db_path)["Gosh"].insert_all([{"c1": "baz"}])
+ Database(db_path).table("Gosh").insert_all([{"c1": "baz"}])
exit_code = (
CliRunner()
.invoke(
@@ -612,12 +612,12 @@ def test_enable_fts_with_triggers(db_path):
)
assert [("baz",)] == search("baz")
- Database(db_path)["Gosh"].insert_all([{"c1": "martha"}])
+ Database(db_path).table("Gosh").insert_all([{"c1": "martha"}])
assert [("martha",)] == search("martha")
def test_populate_fts(db_path):
- Database(db_path)["Gosh"].insert_all([{"c1": "baz"}])
+ Database(db_path).table("Gosh").insert_all([{"c1": "baz"}])
exit_code = (
CliRunner()
.invoke(cli.cli, ["enable-fts", db_path, "Gosh", "c1", "--fts4"])
@@ -633,7 +633,7 @@ def test_populate_fts(db_path):
)
assert [("baz",)] == search("baz")
- Database(db_path)["Gosh"].insert_all([{"c1": "martha"}])
+ Database(db_path).table("Gosh").insert_all([{"c1": "martha"}])
assert [] == search("martha")
exit_code = (
CliRunner().invoke(cli.cli, ["populate-fts", db_path, "Gosh", "c1"]).exit_code
@@ -645,7 +645,7 @@ def test_populate_fts(db_path):
def test_disable_fts(db_path):
db = Database(db_path)
assert {"Gosh", "Gosh2"} == set(db.table_names())
- db["Gosh"].enable_fts(["c1"], create_triggers=True)
+ db.table("Gosh").enable_fts(["c1"], create_triggers=True)
assert {
"Gosh_fts",
"Gosh_fts_idx",
@@ -677,7 +677,7 @@ def test_optimize(db_path, tables):
db = Database(db_path)
with db.conn:
for table in ("Gosh", "Gosh2"):
- db[table].insert_all(
+ db.table(table).insert_all(
[
{
"c1": f"verb{i}",
@@ -687,8 +687,8 @@ def test_optimize(db_path, tables):
for i in range(10000)
]
)
- db["Gosh"].enable_fts(["c1", "c2", "c3"], fts_version="FTS4")
- db["Gosh2"].enable_fts(["c1", "c2", "c3"], fts_version="FTS5")
+ db.table("Gosh").enable_fts(["c1", "c2", "c3"], fts_version="FTS4")
+ db.table("Gosh2").enable_fts(["c1", "c2", "c3"], fts_version="FTS5")
size_before_optimize = os.stat(db_path).st_size
result = CliRunner().invoke(cli.cli, ["optimize", db_path] + tables)
assert result.exit_code == 0
@@ -713,22 +713,22 @@ def test_rebuild_fts_fixes_docsize_error(db_path):
for i in range(10000)
]
with db.conn:
- db["fts5_table"].insert_all(records, pk="c1")
- db["fts5_table"].enable_fts(
+ db.table("fts5_table").insert_all(records, pk="c1")
+ db.table("fts5_table").enable_fts(
["c1", "c2", "c3"], fts_version="FTS5", create_triggers=True
)
# Search should work
- assert list(db["fts5_table"].search("verb1"))
+ assert list(db.table("fts5_table").search("verb1"))
# Replicate docsize error from this issue for FTS5
# https://github.com/simonw/sqlite-utils/issues/149
- assert db["fts5_table_fts_docsize"].count == 10000
- db["fts5_table"].insert_all(records, replace=True)
- assert db["fts5_table"].count == 10000
- assert db["fts5_table_fts_docsize"].count == 20000
+ assert db.table("fts5_table_fts_docsize").count == 10000
+ db.table("fts5_table").insert_all(records, replace=True)
+ assert db.table("fts5_table").count == 10000
+ assert db.table("fts5_table_fts_docsize").count == 20000
# Running rebuild-fts should fix this
result = CliRunner().invoke(cli.cli, ["rebuild-fts", db_path, "fts5_table"])
assert result.exit_code == 0
- assert db["fts5_table_fts_docsize"].count == 10000
+ assert db.table("fts5_table_fts_docsize").count == 10000
@pytest.mark.parametrize(
@@ -741,7 +741,7 @@ def test_rebuild_fts_fixes_docsize_error(db_path):
def test_query_csv(db_path, format, expected):
db = Database(db_path)
with db.conn:
- db["dogs"].insert_all(
+ db.table("dogs").insert_all(
[
{"id": 1, "age": 4, "name": "Cleo"},
{"id": 2, "age": 2, "name": "Pancakes"},
@@ -793,7 +793,7 @@ _one_query = "select id, name, age from dogs where id = 1"
def test_query_json(db_path, sql, args, expected):
db = Database(db_path)
with db.conn:
- db["dogs"].insert_all(
+ db.table("dogs").insert_all(
[
{"id": 1, "age": 4, "name": "Cleo"},
{"id": 2, "age": 2, "name": "Pancakes"},
@@ -807,7 +807,7 @@ def test_query_sql_from_stdin(db_path):
# https://github.com/simonw/sqlite-utils/issues/765
db = Database(db_path)
with db.conn:
- db["dogs"].insert_all(
+ db.table("dogs").insert_all(
[
{"id": 1, "age": 4, "name": "Cleo"},
{"id": 2, "age": 2, "name": "Pancakes"},
@@ -1004,7 +1004,7 @@ LOREM_IPSUM_COMPRESSED = (
def test_query_json_binary(db_path):
db = Database(db_path)
with db.conn:
- db["files"].insert(
+ db.table("files").insert(
{
"name": "lorem.txt",
"sz": 16984,
@@ -1059,7 +1059,7 @@ def test_query_params(db_path, sql, params, expected):
def test_query_json_with_json_cols(db_path):
db = Database(db_path)
with db.conn:
- db["dogs"].insert(
+ db.table("dogs").insert(
{
"id": 1,
"name": "Cleo",
@@ -1088,7 +1088,7 @@ def test_query_json_with_json_cols(db_path):
def test_query_json_unicode_not_escaped_by_default(db_path):
db = Database(db_path)
with db.conn:
- db["text"].insert({"id": 1, "text": "Japanese 日本語"}, pk="id")
+ db.table("text").insert({"id": 1, "text": "Japanese 日本語"}, pk="id")
result = CliRunner().invoke(cli.cli, [db_path, "select id, text from text"])
assert result.exit_code == 0
assert result.output.strip() == '[{"id": 1, "text": "Japanese 日本語"}]'
@@ -1102,7 +1102,7 @@ def test_query_json_unicode_not_escaped_by_default(db_path):
def test_query_json_ascii_option(db_path, command):
db = Database(db_path)
with db.conn:
- db["text"].insert({"id": 1, "text": "Japanese 日本語"}, pk="id")
+ db.table("text").insert({"id": 1, "text": "Japanese 日本語"}, pk="id")
if command == "query":
args = [db_path, "select id, text from text", "--ascii"]
else:
@@ -1118,7 +1118,7 @@ def test_query_json_ascii_option(db_path, command):
[(b"\x00\x0fbinary", True), ("this is text", False), (1, False), (1.5, False)],
)
def test_query_raw(db_path, content, is_binary):
- Database(db_path)["files"].insert({"content": content})
+ Database(db_path).table("files").insert({"content": content})
result = CliRunner().invoke(
cli.cli, [db_path, "select content from files", "--raw"]
)
@@ -1133,7 +1133,7 @@ def test_query_raw(db_path, content, is_binary):
[(b"\x00\x0fbinary", True), ("this is text", False), (1, False), (1.5, False)],
)
def test_query_raw_lines(db_path, content, is_binary):
- Database(db_path)["files"].insert_all({"content": content} for _ in range(3))
+ Database(db_path).table("files").insert_all({"content": content} for _ in range(3))
result = CliRunner().invoke(
cli.cli, [db_path, "select content from files", "--raw-lines"]
)
@@ -1215,7 +1215,7 @@ def test_query_memory_does_not_create_file(tmpdir):
def test_rows(db_path, args, expected):
db = Database(db_path)
with db.conn:
- db["dogs"].insert_all(
+ db.table("dogs").insert_all(
[
{"id": 1, "age": 4, "name": "Cleo"},
{"id": 2, "age": 2, "name": "Pancakes"},
@@ -1240,7 +1240,7 @@ def test_upsert(db_path, tmpdir):
catch_exceptions=False,
)
assert result.exit_code == 0, result.output
- assert 2 == db["dogs"].count
+ assert 2 == db.table("dogs").count
# Now run the upsert to update just their ages
upsert_dogs = [
{"id": 1, "age": 5},
@@ -1295,8 +1295,8 @@ def test_upsert_pk_inferred_from_existing_table(db_path, tmpdir):
def test_upsert_analyze(db_path, tmpdir):
db = Database(db_path)
- db["rows"].insert({"id": 1, "foo": "x", "n": 3}, pk="id")
- db["rows"].create_index(["n"])
+ db.table("rows").insert({"id": 1, "foo": "x", "n": 3}, pk="id")
+ db.table("rows").create_index(["n"])
assert "sqlite_stat1" not in db.table_names()
result = CliRunner().invoke(
cli.cli,
@@ -1310,7 +1310,7 @@ def test_upsert_analyze(db_path, tmpdir):
def test_upsert_flatten(tmpdir):
db_path = str(tmpdir / "flat.db")
db = Database(db_path)
- db["upsert_me"].insert({"id": 1, "name": "Example"}, pk="id")
+ db.table("upsert_me").insert({"id": 1, "name": "Example"}, pk="id")
result = CliRunner().invoke(
cli.cli,
["upsert", db_path, "upsert_me", "-", "--flatten", "--pk", "id", "--alter"],
@@ -1424,7 +1424,7 @@ def test_create_table(args, schema):
)
assert result.exit_code == 0
db = Database("test.db")
- assert schema == db["t"].schema
+ assert schema == db.table("t").schema
def test_create_table_foreign_key():
@@ -1459,21 +1459,21 @@ def test_create_table_foreign_key():
' "id" INTEGER PRIMARY KEY,\n'
' "name" TEXT\n'
")"
- ) == db["authors"].schema
+ ) == db.table("authors").schema
assert (
'CREATE TABLE "books" (\n'
' "id" INTEGER PRIMARY KEY,\n'
' "title" TEXT,\n'
' "author_id" INTEGER REFERENCES "authors"("id")\n'
")"
- ) == db["books"].schema
+ ) == db.table("books").schema
def test_create_table_error_if_table_exists():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
result = runner.invoke(
cli.cli, ["create-table", "test.db", "dogs", "id", "integer"]
)
@@ -1488,24 +1488,24 @@ def test_create_table_ignore():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
result = runner.invoke(
cli.cli, ["create-table", "test.db", "dogs", "id", "integer", "--ignore"]
)
assert result.exit_code == 0
- assert 'CREATE TABLE "dogs" (\n "name" TEXT\n)' == db["dogs"].schema
+ assert 'CREATE TABLE "dogs" (\n "name" TEXT\n)' == db.table("dogs").schema
def test_create_table_replace():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
result = runner.invoke(
cli.cli, ["create-table", "test.db", "dogs", "id", "integer", "--replace"]
)
assert result.exit_code == 0
- assert 'CREATE TABLE "dogs" (\n "id" INTEGER\n)' == db["dogs"].schema
+ assert 'CREATE TABLE "dogs" (\n "id" INTEGER\n)' == db.table("dogs").schema
def test_create_view():
@@ -1517,7 +1517,8 @@ def test_create_view():
)
assert result.exit_code == 0
assert (
- 'CREATE VIEW "version" AS select sqlite_version()' == db["version"].schema
+ 'CREATE VIEW "version" AS select sqlite_version()'
+ == db.view("version").schema
)
@@ -1554,7 +1555,7 @@ def test_create_view_ignore():
assert result.exit_code == 0
assert (
'CREATE VIEW "version" AS select sqlite_version() + 1'
- == db["version"].schema
+ == db.view("version").schema
)
@@ -1575,7 +1576,8 @@ def test_create_view_replace():
)
assert result.exit_code == 0
assert (
- 'CREATE VIEW "version" AS select sqlite_version()' == db["version"].schema
+ 'CREATE VIEW "version" AS select sqlite_version()'
+ == db.view("version").schema
)
@@ -1583,7 +1585,7 @@ def test_drop_table():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["t"].create({"pk": int}, pk="pk")
+ db.table("t").create({"pk": int}, pk="pk")
assert "t" in db.table_names()
result = runner.invoke(
cli.cli,
@@ -1601,7 +1603,7 @@ def test_drop_table_error():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["t"].create({"pk": int}, pk="pk")
+ db.table("t").create({"pk": int}, pk="pk")
result = runner.invoke(
cli.cli,
[
@@ -1624,7 +1626,7 @@ def test_drop_table_on_view_errors():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["t"].insert({"id": 1})
+ db.table("t").insert({"id": 1})
db.create_view("v", "select * from t")
result = runner.invoke(cli.cli, ["drop-table", "test.db", "v"])
assert result.exit_code == 1
@@ -1660,7 +1662,7 @@ def test_drop_view_on_table_errors():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["t"].insert({"id": 1})
+ db.table("t").insert({"id": 1})
result = runner.invoke(cli.cli, ["drop-view", "test.db", "t"])
assert result.exit_code == 1
assert 'Error: "t" is a table, not a view - use drop-table to drop it' == (
@@ -1677,7 +1679,7 @@ def test_drop_view_error():
runner = CliRunner()
with runner.isolated_filesystem():
db = Database("test.db")
- db["t"].create({"pk": int}, pk="pk")
+ db.table("t").create({"pk": int}, pk="pk")
result = runner.invoke(
cli.cli,
[
@@ -1702,7 +1704,7 @@ def test_enable_wal():
with runner.isolated_filesystem():
for dbname in dbs:
db = Database(dbname)
- db["t"].create({"pk": int}, pk="pk")
+ db.table("t").create({"pk": int}, pk="pk")
assert db.journal_mode == "delete"
result = runner.invoke(cli.cli, ["enable-wal"] + dbs, catch_exceptions=False)
assert result.exit_code == 0
@@ -1717,7 +1719,7 @@ def test_disable_wal():
with runner.isolated_filesystem():
for dbname in dbs:
db = Database(dbname)
- db["t"].create({"pk": int}, pk="pk")
+ db.table("t").create({"pk": int}, pk="pk")
db.enable_wal()
assert db.journal_mode == "wal"
result = runner.invoke(cli.cli, ["disable-wal"] + dbs)
@@ -1740,7 +1742,7 @@ def test_disable_wal():
def test_query_update(db_path, args, expected):
db = Database(db_path)
with db.conn:
- db["dogs"].insert_all(
+ db.table("dogs").insert_all(
[
{"id": 1, "age": 4, "name": "Cleo"},
]
@@ -1756,11 +1758,13 @@ def test_query_update(db_path, args, expected):
def test_add_foreign_keys(db_path):
db = Database(db_path)
- db["countries"].insert({"id": 7, "name": "Panama"}, pk="id")
- db["authors"].insert({"id": 3, "name": "Matilda", "country_id": 7}, pk="id")
- db["books"].insert({"id": 2, "title": "Wolf anatomy", "author_id": 3}, pk="id")
- assert db["authors"].foreign_keys == []
- assert db["books"].foreign_keys == []
+ db.table("countries").insert({"id": 7, "name": "Panama"}, pk="id")
+ db.table("authors").insert({"id": 3, "name": "Matilda", "country_id": 7}, pk="id")
+ db.table("books").insert(
+ {"id": 2, "title": "Wolf anatomy", "author_id": 3}, pk="id"
+ )
+ assert db.table("authors").foreign_keys == []
+ assert db.table("books").foreign_keys == []
result = CliRunner().invoke(
cli.cli,
[
@@ -1777,7 +1781,7 @@ def test_add_foreign_keys(db_path):
],
)
assert result.exit_code == 0
- assert db["authors"].foreign_keys == [
+ assert db.table("authors").foreign_keys == [
ForeignKey(
table="authors",
column="country_id",
@@ -1785,7 +1789,7 @@ def test_add_foreign_keys(db_path):
other_column="id",
)
]
- assert db["books"].foreign_keys == [
+ assert db.table("books").foreign_keys == [
ForeignKey(
table="books", column="author_id", other_table="authors", other_column="id"
)
@@ -1909,7 +1913,7 @@ def test_add_foreign_keys(db_path):
def test_transform(db_path, args, expected_schema):
db = Database(db_path)
with db.conn:
- db["dogs"].insert(
+ db.table("dogs").insert(
{"id": 1, "age": 4, "name": "Cleo"},
not_null={"age"},
defaults={"age": 1},
@@ -1918,20 +1922,20 @@ def test_transform(db_path, args, expected_schema):
result = CliRunner().invoke(cli.cli, ["transform", db_path, "dogs"] + args)
print(result.output)
assert result.exit_code == 0
- schema = db["dogs"].schema
+ schema = db.table("dogs").schema
assert schema == expected_schema
def test_transform_sql(db_path):
db = Database(db_path)
with db.conn:
- db["dogs"].insert(
+ db.table("dogs").insert(
{"id": 1, "age": 4, "name": "Cleo"},
not_null={"age"},
defaults={"age": 1},
pk="id",
)
- original_schema = db["dogs"].schema
+ original_schema = db.table("dogs").schema
result = CliRunner().invoke(
cli.cli, ["transform", db_path, "dogs", "--drop", "name", "--sql"]
@@ -1942,7 +1946,7 @@ def test_transform_sql(db_path):
assert '"age" INTEGER NOT NULL DEFAULT' in result.output
assert 'DROP TABLE "dogs";' in result.output
assert 'ALTER TABLE "dogs_new_' in result.output
- assert db["dogs"].schema == original_schema
+ assert db.table("dogs").schema == original_schema
@pytest.mark.parametrize(
@@ -1958,12 +1962,12 @@ def test_transform_strict_option(db_path, initial_strict, args, expected_strict)
db = Database(db_path)
if not db.supports_strict:
pytest.skip("SQLite version does not support strict tables")
- db["dogs"].create({"id": int}, strict=initial_strict)
+ db.table("dogs").create({"id": int}, strict=initial_strict)
result = CliRunner().invoke(cli.cli, ["transform", db_path, "dogs"] + args)
assert result.exit_code == 0, result.output
- assert db["dogs"].strict is expected_strict
+ assert db.table("dogs").strict is expected_strict
@pytest.mark.parametrize(
@@ -1977,20 +1981,20 @@ def test_transform_strict_option_sql(db_path, initial_strict, flag, sql_is_stric
db = Database(db_path)
if not db.supports_strict:
pytest.skip("SQLite version does not support strict tables")
- db["dogs"].create({"id": int}, strict=initial_strict)
+ db.table("dogs").create({"id": int}, strict=initial_strict)
result = CliRunner().invoke(cli.cli, ["transform", db_path, "dogs", flag, "--sql"])
assert result.exit_code == 0, result.output
assert (") STRICT;" in result.output) is sql_is_strict
- assert db["dogs"].strict is initial_strict
+ assert db.table("dogs").strict is initial_strict
def test_transform_strict_option_with_invalid_data(db_path):
db = Database(db_path)
if not db.supports_strict:
pytest.skip("SQLite version does not support strict tables")
- dogs = db["dogs"]
+ dogs = db.table("dogs")
dogs.create({"id": int})
dogs.insert({"id": "not-an-integer"})
@@ -2048,10 +2052,10 @@ def test_transform_add_or_drop_foreign_key(db_path, extra_args, expected_schema)
db = Database(db_path)
with db.conn:
# Create table with three foreign keys so we can drop two of them
- db["continent"].insert({"id": 1, "name": "Europe"}, pk="id")
- db["country"].insert({"id": 1, "name": "France"}, pk="id")
- db["city"].insert({"id": 24, "name": "Paris"}, pk="id")
- db["places"].insert(
+ db.table("continent").insert({"id": 1, "name": "Europe"}, pk="id")
+ db.table("country").insert({"id": 1, "name": "France"}, pk="id")
+ db.table("city").insert({"id": 24, "name": "Paris"}, pk="id")
+ db.table("places").insert(
{
"id": 32,
"name": "Caveau de la Huchette",
@@ -2072,7 +2076,7 @@ def test_transform_add_or_drop_foreign_key(db_path, extra_args, expected_schema)
+ extra_args,
)
assert result.exit_code == 0
- schema = db["places"].schema
+ schema = db.table("places").schema
assert schema == expected_schema
@@ -2133,7 +2137,7 @@ _common_other_schema = (
def test_extract(db_path, args, expected_table_schema, expected_other_schema):
db = Database(db_path)
with db.conn:
- db["trees"].insert(
+ db.table("trees").insert(
{"id": 1, "address": "4 Park Ave", "species": "Palm"},
pk="id",
)
@@ -2142,7 +2146,7 @@ def test_extract(db_path, args, expected_table_schema, expected_other_schema):
)
print(result.output)
assert result.exit_code == 0
- schema = db["trees"].schema
+ schema = db.table("trees").schema
assert schema == expected_table_schema
other_schema = next(
t for t in db.tables if t.name not in ("trees", "Gosh", "Gosh2")
@@ -2190,7 +2194,7 @@ def test_insert_encoding(tmpdir):
)
assert good_result.exit_code == 0
db = Database(db_path)
- assert list(db["places"].rows) == [
+ assert list(db.table("places").rows) == [
{
"date": "2020-01-01",
"name": "Barra da Lagoa",
@@ -2226,7 +2230,7 @@ def test_insert_encoding(tmpdir):
def test_search(tmpdir, fts, extra_arg, expected):
db_path = str(tmpdir / "test.db")
db = Database(db_path)
- db["articles"].insert_all(
+ db.table("articles").insert_all(
[
{"id": 1, "title": "Title the first"},
{"id": 2, "title": "Title the second"},
@@ -2234,7 +2238,7 @@ def test_search(tmpdir, fts, extra_arg, expected):
],
pk="id",
)
- db["articles"].enable_fts(["title"], fts_version=fts)
+ db.table("articles").enable_fts(["title"], fts_version=fts)
result = CliRunner().invoke(
cli.cli,
["search", db_path, "articles", "second"] + ([extra_arg] if extra_arg else []),
@@ -2247,7 +2251,7 @@ def test_search(tmpdir, fts, extra_arg, expected):
def test_search_quote(tmpdir):
db_path = str(tmpdir / "test.db")
db = Database(db_path)
- db["creatures"].insert({"name": "dog."}).enable_fts(["name"])
+ db.table("creatures").insert({"name": "dog."}).enable_fts(["name"])
# Without --quote should return an error
error_result = CliRunner().invoke(cli.cli, ["search", db_path, "creatures", 'dog"'])
assert error_result.exit_code == 1
@@ -2355,11 +2359,11 @@ _TRIGGERS_EXPECTED = (
def test_triggers(tmpdir, extra_args, expected):
db_path = str(tmpdir / "test.db")
db = Database(db_path)
- db["articles"].insert(
+ db.table("articles").insert(
{"id": 1, "title": "Title the first"},
pk="id",
)
- db["counter"].insert({"count": 1})
+ db.table("counter").insert({"count": 1})
db.conn.execute(textwrap.dedent("""
CREATE TRIGGER blah AFTER INSERT ON articles
BEGIN
@@ -2420,9 +2424,9 @@ def test_triggers(tmpdir, extra_args, expected):
def test_schema(tmpdir, options, expected):
db_path = str(tmpdir / "test.db")
db = Database(db_path)
- db["dogs"].create({"id": int, "name": str})
- db["chickens"].create({"id": int, "name": str, "breed": str})
- db["chickens"].create_index(["breed"])
+ db.table("dogs").create({"id": int, "name": str})
+ db.table("chickens").create({"id": int, "name": str, "breed": str})
+ db.table("chickens").create_index(["breed"])
result = CliRunner().invoke(
cli.cli,
["schema", db_path] + options,
@@ -2446,7 +2450,7 @@ def test_long_csv_column_value(tmpdir):
)
assert result.exit_code == 0
db = Database(db_path)
- rows = list(db["bigtable"].rows)
+ rows = list(db.table("bigtable").rows)
assert len(rows) == 1
assert rows[0]["text"] == long_string
@@ -2473,7 +2477,7 @@ def test_import_no_headers(tmpdir, args, tsv):
)
assert result.exit_code == 0, result.output
db = Database(db_path)
- schema = db["creatures"].schema
+ schema = db.table("creatures").schema
assert schema == (
'CREATE TABLE "creatures" (\n'
' "untitled_1" TEXT,\n'
@@ -2481,7 +2485,7 @@ def test_import_no_headers(tmpdir, args, tsv):
' "untitled_3" TEXT\n'
")"
)
- rows = list(db["creatures"].rows)
+ rows = list(db.table("creatures").rows)
assert rows == [
{"untitled_1": "Cleo", "untitled_2": "Dog", "untitled_3": "5"},
{"untitled_1": "Tracy", "untitled_2": "Spider", "untitled_3": "7"},
@@ -2493,10 +2497,10 @@ def test_attach(tmpdir):
bar_path = str(tmpdir / "bar.db")
db = Database(foo_path)
with db.conn:
- db["foo"].insert({"id": 1, "text": "foo"})
+ db.table("foo").insert({"id": 1, "text": "foo"})
db2 = Database(bar_path)
with db2.conn:
- db2["bar"].insert({"id": 1, "text": "bar"})
+ db2.table("bar").insert({"id": 1, "text": "bar"})
db.attach("bar", bar_path)
sql = "select * from foo union all select * from bar.bar"
result = CliRunner().invoke(
@@ -2557,7 +2561,7 @@ def test_insert_detect_types(tmpdir):
)
assert result.exit_code == 0
db = Database(db_path)
- assert list(db["creatures"].rows) == [
+ assert list(db.table("creatures").rows) == [
{"name": "Cleo", "age": 6, "weight": 45.5},
{"name": "Dori", "age": 1, "weight": 3.5},
]
@@ -2589,7 +2593,7 @@ def test_upsert_detect_types(tmpdir):
)
assert result.exit_code == 0
db = Database(db_path)
- assert list(db["creatures"].rows) == [
+ assert list(db.table("creatures").rows) == [
{"id": 1, "name": "Cleo", "age": 6, "weight": 45.5},
{"id": 2, "name": "Dori", "age": 1, "weight": 3.5},
]
@@ -2608,7 +2612,7 @@ def test_csv_detect_types_creates_real_columns(tmpdir):
assert result.exit_code == 0
db = Database(db_path)
# Check that the schema uses REAL for the weight column
- assert db["creatures"].schema == (
+ assert db.table("creatures").schema == (
'CREATE TABLE "creatures" (\n'
' "name" TEXT,\n'
' "age" INTEGER,\n'
@@ -2630,11 +2634,11 @@ def test_insert_no_detect_types(tmpdir):
assert result.exit_code == 0
db = Database(db_path)
# All columns should be TEXT when --no-detect-types is used
- assert list(db["creatures"].rows) == [
+ assert list(db.table("creatures").rows) == [
{"name": "Cleo", "age": "6", "weight": "45.5"},
{"name": "Dori", "age": "1", "weight": "3.5"},
]
- assert db["creatures"].schema == (
+ assert db.table("creatures").schema == (
'CREATE TABLE "creatures" (\n'
' "name" TEXT,\n'
' "age" TEXT,\n'
@@ -2665,11 +2669,11 @@ def test_upsert_no_detect_types(tmpdir):
assert result.exit_code == 0
db = Database(db_path)
# All columns should be TEXT when --no-detect-types is used
- assert list(db["creatures"].rows) == [
+ assert list(db.table("creatures").rows) == [
{"id": "1", "name": "Cleo", "age": "6", "weight": "45.5"},
{"id": "2", "name": "Dori", "age": "1", "weight": "3.5"},
]
- assert db["creatures"].schema == (
+ assert db.table("creatures").schema == (
'CREATE TABLE "creatures" (\n'
' "id" TEXT PRIMARY KEY,\n'
' "name" TEXT,\n'
@@ -2751,20 +2755,20 @@ def test_create_database(tmpdir, enable_wal):
def test_analyze(tmpdir, options, expected):
db_path = str(tmpdir / "test.db")
db = Database(db_path)
- db["one_index"].insert({"id": 1, "name": "Cleo"}, pk="id")
- db["one_index"].create_index(["name"])
- db["two_indexes"].insert({"id": 1, "name": "Cleo", "species": "dog"}, pk="id")
- db["two_indexes"].create_index(["name"])
- db["two_indexes"].create_index(["species"])
+ db.table("one_index").insert({"id": 1, "name": "Cleo"}, pk="id")
+ db.table("one_index").create_index(["name"])
+ db.table("two_indexes").insert({"id": 1, "name": "Cleo", "species": "dog"}, pk="id")
+ db.table("two_indexes").create_index(["name"])
+ db.table("two_indexes").create_index(["species"])
result = CliRunner().invoke(cli.cli, ["analyze", db_path] + options)
assert result.exit_code == 0
- assert list(db["sqlite_stat1"].rows) == expected
+ assert list(db.table("sqlite_stat1").rows) == expected
def test_rename_table(tmpdir):
db_path = str(tmpdir / "test.db")
db = Database(db_path)
- db["one"].insert({"id": 1, "name": "Cleo"}, pk="id")
+ db.table("one").insert({"id": 1, "name": "Cleo"}, pk="id")
# First try a non-existent table
result_error = CliRunner().invoke(
cli.cli,
@@ -2782,7 +2786,7 @@ def test_rename_table(tmpdir):
catch_exceptions=False,
)
assert result_error2.exit_code == 0
- previous_columns = db["one"].columns_dict
+ previous_columns = db.table("one").columns_dict
# Now try for a table that exists
result = CliRunner().invoke(
cli.cli,
@@ -2790,13 +2794,13 @@ def test_rename_table(tmpdir):
catch_exceptions=False,
)
assert result.exit_code == 0
- assert db["two"].columns_dict == previous_columns
+ assert db.table("two").columns_dict == previous_columns
def test_duplicate_table(tmpdir):
db_path = str(tmpdir / "test.db")
db = Database(db_path)
- db["one"].insert({"id": 1, "name": "Cleo"}, pk="id")
+ db.table("one").insert({"id": 1, "name": "Cleo"}, pk="id")
# First try a non-existent table
result_error = CliRunner().invoke(
cli.cli,
@@ -2819,8 +2823,8 @@ def test_duplicate_table(tmpdir):
catch_exceptions=False,
)
assert result.exit_code == 0
- assert db["one"].columns_dict == db["two"].columns_dict
- assert list(db["one"].rows) == list(db["two"].rows)
+ assert db.table("one").columns_dict == db.table("two").columns_dict
+ assert list(db.table("one").rows) == list(db.table("two").rows)
@pytest.mark.skipif(not _has_compiled_ext(), reason="Requires compiled ext.c")
@@ -2863,9 +2867,9 @@ def test_create_table_strict(strict):
+ (["--strict"] if strict else []),
)
assert result.exit_code == 0
- assert db["items"].strict == strict or not db.supports_strict
+ assert db.table("items").strict == strict or not db.supports_strict
# Should have a floating point column
- assert db["items"].columns_dict == {"id": int, "w": float}
+ assert db.table("items").columns_dict == {"id": int, "w": float}
@pytest.mark.parametrize("method", ("insert", "upsert"))
@@ -2880,12 +2884,12 @@ def test_insert_upsert_strict(tmpdir, method, strict):
)
assert result.exit_code == 0
db = Database(db_path)
- assert db["items"].strict == strict or not db.supports_strict
+ assert db.table("items").strict == strict or not db.supports_strict
def test_extract_bad_column_clean_error(db_path):
db = Database(db_path)
- db["trees"].insert({"id": 1, "species": "Palm"}, pk="id")
+ db.table("trees").insert({"id": 1, "species": "Palm"}, pk="id")
result = CliRunner().invoke(cli.cli, ["extract", db_path, "trees", "nope"])
assert result.exit_code == 1
assert result.exception is None or isinstance(result.exception, SystemExit)
@@ -2894,7 +2898,7 @@ def test_extract_bad_column_clean_error(db_path):
def test_extract_view_clean_error(db_path):
db = Database(db_path)
- db["trees"].insert({"id": 1, "species": "Palm"}, pk="id")
+ db.table("trees").insert({"id": 1, "species": "Palm"}, pk="id")
db.create_view("v", "select * from trees")
result = CliRunner().invoke(cli.cli, ["extract", db_path, "v", "species"])
assert result.exit_code == 1
diff --git a/tests/test_cli_bulk.py b/tests/test_cli_bulk.py
index 932269b..24889b3 100644
--- a/tests/test_cli_bulk.py
+++ b/tests/test_cli_bulk.py
@@ -13,7 +13,7 @@ from sqlite_utils import Database, cli
def test_db_and_path(tmpdir):
db_path = str(pathlib.Path(tmpdir) / "data.db")
db = Database(db_path)
- db["example"].insert_all(
+ db.table("example").insert_all(
[
{"id": 1, "name": "One"},
{"id": 2, "name": "Two"},
@@ -44,7 +44,7 @@ def test_cli_bulk(test_db_and_path):
{"id": 2, "name": "Two"},
{"id": 3, "name": "THREE"},
{"id": 4, "name": "FOUR"},
- ] == list(db["example"].rows)
+ ] == list(db.table("example").rows)
def test_cli_bulk_multiple_functions(test_db_and_path):
@@ -70,7 +70,7 @@ def test_cli_bulk_multiple_functions(test_db_and_path):
{"id": 2, "name": "Two"},
{"id": 3, "name": "THREE"},
{"id": 4, "name": "FOUR"},
- ] == list(db["example"].rows)
+ ] == list(db.table("example").rows)
def test_cli_bulk_batch_size(test_db_and_path):
@@ -95,13 +95,13 @@ def test_cli_bulk_batch_size(test_db_and_path):
proc.stdin.write(b'{"id": 3, "name": "Three"}\n\n')
proc.stdin.flush()
time.sleep(1)
- assert db["example"].count == 2
+ assert db.table("example").count == 2
# Writing another should trigger a commit:
proc.stdin.write(b'{"id": 4, "name": "Four"}\n\n')
proc.stdin.flush()
time.sleep(1)
- assert db["example"].count == 4
+ assert db.table("example").count == 4
proc.stdin.close()
proc.wait()
diff --git a/tests/test_cli_convert.py b/tests/test_cli_convert.py
index 65543b1..1101f0f 100644
--- a/tests/test_cli_convert.py
+++ b/tests/test_cli_convert.py
@@ -12,7 +12,7 @@ from sqlite_utils import cli
@pytest.fixture
def test_db_and_path(fresh_db_and_path):
db, db_path = fresh_db_and_path
- db["example"].insert_all(
+ db.table("example").insert_all(
[
{"id": 1, "dt": "5th October 2019 12:04"},
{"id": 2, "dt": "6th October 2019 00:05:06"},
@@ -47,12 +47,12 @@ def fresh_db_and_path(tmpdir):
)
def test_convert_code(fresh_db_and_path, code):
db, db_path = fresh_db_and_path
- db["t"].insert({"text": "October"})
+ db.table("t").insert({"text": "October"})
result = CliRunner().invoke(
cli.cli, ["convert", db_path, "t", "text", code], catch_exceptions=False
)
assert result.exit_code == 0, result.output
- value = next(iter(db["t"].rows))["text"]
+ value = next(iter(db.table("t").rows))["text"]
assert value == "Spooktober"
@@ -65,7 +65,7 @@ def test_convert_code(fresh_db_and_path, code):
)
def test_convert_code_errors(fresh_db_and_path, bad_code):
db, db_path = fresh_db_and_path
- db["t"].insert({"text": "October"})
+ db.table("t").insert({"text": "October"})
result = CliRunner().invoke(
cli.cli, ["convert", db_path, "t", "text", bad_code], catch_exceptions=False
)
@@ -93,12 +93,12 @@ def test_convert_import(test_db_and_path):
{"id": 2, "dt": "6th OXXober 2019 00:05:06"},
{"id": 3, "dt": ""},
{"id": 4, "dt": None},
- ] == list(db["example"].rows)
+ ] == list(db.table("example").rows)
def test_convert_import_nested(fresh_db_and_path):
db, db_path = fresh_db_and_path
- db["example"].insert({"xml": '" == repr(table)
- assert "" == repr(fresh_db["cats"])
+ assert "" == repr(fresh_db.table("cats"))
def test_indexes(fresh_db):
@@ -125,7 +133,7 @@ def test_indexes(fresh_db):
columns=["c2", "c3"],
),
Index(seq=1, name="Gosh_c1", unique=0, origin="c", partial=0, columns=["c1"]),
- ] == fresh_db["Gosh"].indexes
+ ] == fresh_db.table("Gosh").indexes
def test_xindexes(fresh_db):
@@ -134,7 +142,7 @@ def test_xindexes(fresh_db):
create index Gosh_c1 on Gosh(c1);
create index Gosh_c2c3 on Gosh(c2, c3 desc);
""")
- assert fresh_db["Gosh"].xindexes == [
+ assert fresh_db.table("Gosh").xindexes == [
XIndex(
name="Gosh_c2c3",
columns=[
@@ -166,15 +174,15 @@ def test_xindexes(fresh_db):
def test_guess_foreign_table(fresh_db, column, expected_table_guess):
fresh_db.create_table("authors", {"name": str})
fresh_db.create_table("genre", {"name": str})
- assert expected_table_guess == fresh_db["books"].guess_foreign_table(column)
+ assert expected_table_guess == fresh_db.table("books").guess_foreign_table(column)
@pytest.mark.parametrize(
"pk,expected", ((None, ["rowid"]), ("id", ["id"]), (["id", "id2"], ["id", "id2"]))
)
def test_pks(fresh_db, pk, expected):
- fresh_db["foo"].insert_all([{"id": 1, "id2": 2}], pk=pk)
- assert expected == fresh_db["foo"].pks
+ fresh_db.table("foo").insert_all([{"id": 1, "id2": 2}], pk=pk)
+ assert expected == fresh_db.table("foo").pks
def test_checks(fresh_db):
@@ -185,7 +193,7 @@ def test_checks(fresh_db):
CONSTRAINT within_maximum CHECK(score <= maximum)
)
""")
- scores = fresh_db["scores"]
+ scores = fresh_db.table("scores")
expected_column = Check("score > 0", name="positive", column="score")
expected_table = Check("score <= maximum", name="within_maximum")
assert scores.checks == [expected_column, expected_table]
@@ -195,26 +203,26 @@ def test_checks(fresh_db):
def test_checks_nonexistent_and_virtual_tables(fresh_db):
- assert fresh_db["does_not_exist"].checks == []
- fresh_db["searchable"].insert({"text": "hello"}).enable_fts(
+ assert fresh_db.table("does_not_exist").checks == []
+ fresh_db.table("searchable").insert({"text": "hello"}).enable_fts(
["text"], fts_version="FTS5"
)
- assert fresh_db["searchable_fts"].checks == []
+ assert fresh_db.table("searchable_fts").checks == []
def test_triggers_and_triggers_dict(fresh_db):
assert [] == fresh_db.triggers
- authors = fresh_db["authors"]
+ authors = fresh_db.table("authors")
authors.insert_all(
[
{"name": "Frank Herbert", "famous_works": "Dune"},
{"name": "Neal Stephenson", "famous_works": "Cryptonomicon"},
]
)
- fresh_db["other"].insert({"foo": "bar"})
+ fresh_db.table("other").insert({"foo": "bar"})
assert authors.triggers == []
assert authors.triggers_dict == {}
- assert fresh_db["other"].triggers == []
+ assert fresh_db.table("other").triggers == []
assert fresh_db.triggers_dict == {}
authors.enable_fts(
["name", "famous_works"], fts_version="FTS4", create_triggers=True
@@ -226,7 +234,7 @@ def test_triggers_and_triggers_dict(fresh_db):
}
assert expected_triggers == {(t.name, t.table) for t in fresh_db.triggers}
assert expected_triggers == {
- (t.name, t.table) for t in fresh_db["authors"].triggers
+ (t.name, t.table) for t in fresh_db.table("authors").triggers
}
expected_triggers = {
"authors_ai": (
@@ -246,13 +254,13 @@ def test_triggers_and_triggers_dict(fresh_db):
),
}
assert authors.triggers_dict == expected_triggers
- assert fresh_db["other"].triggers == []
- assert fresh_db["other"].triggers_dict == {}
+ assert fresh_db.table("other").triggers == []
+ assert fresh_db.table("other").triggers_dict == {}
assert fresh_db.triggers_dict == expected_triggers
def test_has_counts_triggers(fresh_db):
- authors = fresh_db["authors"]
+ authors = fresh_db.table("authors")
authors.insert({"name": "Frank Herbert"})
assert not authors.has_counts_triggers
authors.enable_counts()
@@ -301,14 +309,14 @@ def test_has_counts_triggers(fresh_db):
)
def test_virtual_table_using(fresh_db, sql, expected_name, expected_using):
fresh_db.execute(sql)
- assert fresh_db[expected_name].virtual_table_using == expected_using
+ assert fresh_db.table(expected_name).virtual_table_using == expected_using
def test_use_rowid(fresh_db):
- fresh_db["rowid_table"].insert({"name": "Cleo"})
- fresh_db["regular_table"].insert({"id": 1, "name": "Cleo"}, pk="id")
- assert fresh_db["rowid_table"].use_rowid
- assert not fresh_db["regular_table"].use_rowid
+ fresh_db.table("rowid_table").insert({"name": "Cleo"})
+ fresh_db.table("regular_table").insert({"id": 1, "name": "Cleo"}, pk="id")
+ assert fresh_db.table("rowid_table").use_rowid
+ assert not fresh_db.table("regular_table").use_rowid
@pytest.mark.skipif(
@@ -327,7 +335,7 @@ def test_use_rowid(fresh_db):
)
def test_table_strict(fresh_db, create_table, expected_strict):
fresh_db.execute(create_table)
- table = fresh_db["t"]
+ table = fresh_db.table("t")
assert table.strict == expected_strict
@@ -343,10 +351,10 @@ def test_table_strict(fresh_db, create_table, expected_strict):
),
)
def test_table_default_values(fresh_db, value):
- fresh_db["default_values"].insert(
+ fresh_db.table("default_values").insert(
{"nodefault": 1, "value": value}, defaults={"value": value}
)
- default_values = fresh_db["default_values"].default_values
+ default_values = fresh_db.table("default_values").default_values
assert default_values == {"value": value}
@@ -356,8 +364,8 @@ def test_table_default_values_escaped_quotes(fresh_db):
fresh_db.execute(
"create table t (id integer primary key, name text default 'O''Brien')"
)
- assert "default 'O''Brien'" in fresh_db["t"].schema
- assert fresh_db["t"].default_values == {"name": "O'Brien"}
+ assert "default 'O''Brien'" in fresh_db.table("t").schema
+ assert fresh_db.table("t").default_values == {"name": "O'Brien"}
def test_pks_use_primary_key_declaration_order(fresh_db):
@@ -365,11 +373,11 @@ def test_pks_use_primary_key_declaration_order(fresh_db):
# pks must follow the declaration order, which is what SQLite uses to
# resolve implicit foreign key references and compound pk lookups
fresh_db.execute("create table t (b text, a text, primary key (a, b))")
- assert fresh_db["t"].pks == ["a", "b"]
+ assert fresh_db.table("t").pks == ["a", "b"]
def test_transform_preserves_compound_pk_declaration_order(fresh_db):
fresh_db.execute("create table t (a text, b text, c text, primary key (b, a))")
- fresh_db["t"].transform(drop={"c"})
- assert fresh_db["t"].pks == ["b", "a"]
- assert 'PRIMARY KEY ("b", "a")' in fresh_db["t"].schema
+ fresh_db.table("t").transform(drop={"c"})
+ assert fresh_db.table("t").pks == ["b", "a"]
+ assert 'PRIMARY KEY ("b", "a")' in fresh_db.table("t").schema
diff --git a/tests/test_list_mode.py b/tests/test_list_mode.py
index 646098e..b9ab812 100644
--- a/tests/test_list_mode.py
+++ b/tests/test_list_mode.py
@@ -19,9 +19,9 @@ def test_insert_all_list_mode_basic():
yield [2, "Bob", 25]
yield [3, "Charlie", 35]
- db["people"].insert_all(data_generator())
+ db.table("people").insert_all(data_generator())
- rows = list(db["people"].rows)
+ rows = list(db.table("people").rows)
assert len(rows) == 3
assert rows[0] == {"id": 1, "name": "Alice", "age": 30}
assert rows[1] == {"id": 2, "name": "Bob", "age": 25}
@@ -37,10 +37,10 @@ def test_insert_all_list_mode_with_pk():
yield [1, "Alice", 95]
yield [2, "Bob", 87]
- db["scores"].insert_all(data_generator(), pk="id")
+ db.table("scores").insert_all(data_generator(), pk="id")
- assert db["scores"].pks == ["id"]
- rows = list(db["scores"].rows)
+ assert db.table("scores").pks == ["id"]
+ rows = list(db.table("scores").rows)
assert len(rows) == 2
@@ -54,7 +54,7 @@ def test_upsert_all_list_mode():
yield [1, "Alice", 100]
yield [2, "Bob", 200]
- db["data"].insert_all(initial_data(), pk="id")
+ db.table("data").insert_all(initial_data(), pk="id")
# Upsert with some updates and new records
def upsert_data():
@@ -62,9 +62,9 @@ def test_upsert_all_list_mode():
yield [1, "Alice", 150] # Update existing
yield [3, "Charlie", 300] # Insert new
- db["data"].upsert_all(upsert_data(), pk="id")
+ db.table("data").upsert_all(upsert_data(), pk="id")
- rows = list(db["data"].rows_where(order_by="id"))
+ rows = list(db.table("data").rows_where(order_by="id"))
assert len(rows) == 3
assert rows[0] == {"id": 1, "name": "Alice", "value": 150}
assert rows[1] == {"id": 2, "name": "Bob", "value": 200}
@@ -81,9 +81,9 @@ def test_list_mode_with_various_types():
yield [2, "Bob", 87.3, False]
yield [3, "Charlie", None, True]
- db["mixed"].insert_all(data_generator())
+ db.table("mixed").insert_all(data_generator())
- rows = list(db["mixed"].rows)
+ rows = list(db.table("mixed").rows)
assert len(rows) == 3
assert rows[0]["score"] == 95.5
assert rows[1]["active"] == 0 # SQLite stores boolean as int
@@ -99,7 +99,7 @@ def test_list_mode_error_non_string_columns():
yield ["a", "b", "c"]
with pytest.raises(ValueError, match="must be a list of column name strings"):
- db["bad"].insert_all(bad_data())
+ db.table("bad").insert_all(bad_data())
def test_list_mode_error_mixed_types():
@@ -111,7 +111,7 @@ def test_list_mode_error_mixed_types():
yield {"id": 1, "name": "Alice"} # Should be a list, not dict
with pytest.raises(ValueError, match="must also be lists"):
- db["bad"].insert_all(bad_data())
+ db.table("bad").insert_all(bad_data())
def test_list_mode_empty_after_headers():
@@ -122,9 +122,9 @@ def test_list_mode_empty_after_headers():
yield ["id", "name", "age"]
# No data rows
- result = db["people"].insert_all(data_generator())
+ result = db.table("people").insert_all(data_generator())
assert result is not None
- assert not db["people"].exists()
+ assert not db.table("people").exists()
def test_list_mode_batch_processing():
@@ -136,7 +136,7 @@ def test_list_mode_batch_processing():
for i in range(1000):
yield [i, f"value_{i}"]
- db["large"].insert_all(large_data(), batch_size=100)
+ db.table("large").insert_all(large_data(), batch_size=100)
count = db.execute("SELECT COUNT(*) as c FROM large").fetchone()[0]
assert count == 1000
@@ -152,9 +152,9 @@ def test_list_mode_shorter_rows():
yield [2, "Bob"] # Missing age and city
yield [3, "Charlie", 35] # Missing city
- db["people"].insert_all(data_generator())
+ db.table("people").insert_all(data_generator())
- rows = list(db["people"].rows_where(order_by="id"))
+ rows = list(db.table("people").rows_where(order_by="id"))
assert rows[0] == {"id": 1, "name": "Alice", "age": 30, "city": "NYC"}
assert rows[1] == {"id": 2, "name": "Bob", "age": None, "city": None}
assert rows[2] == {"id": 3, "name": "Charlie", "age": 35, "city": None}
@@ -170,9 +170,9 @@ def test_backwards_compatibility_dict_mode():
{"id": 2, "name": "Bob", "age": 25},
]
- db["people"].insert_all(data)
+ db.table("people").insert_all(data)
- rows = list(db["people"].rows)
+ rows = list(db.table("people").rows)
assert len(rows) == 2
assert rows[0] == {"id": 1, "name": "Alice", "age": 30}
@@ -189,9 +189,9 @@ def test_insert_all_tuple_mode_basic():
yield (2, "Bob", 25)
yield (3, "Charlie", 35)
- db["people"].insert_all(data_generator())
+ db.table("people").insert_all(data_generator())
- rows = list(db["people"].rows)
+ rows = list(db.table("people").rows)
assert len(rows) == 3
assert rows[0] == {"id": 1, "name": "Alice", "age": 30}
assert rows[1] == {"id": 2, "name": "Bob", "age": 25}
@@ -211,9 +211,9 @@ def test_insert_all_mixed_list_tuple():
yield [3, "Charlie", 35]
yield (4, "Diana", 40)
- db["people"].insert_all(data_generator())
+ db.table("people").insert_all(data_generator())
- rows = list(db["people"].rows)
+ rows = list(db.table("people").rows)
assert len(rows) == 4
assert rows[0] == {"id": 1, "name": "Alice", "age": 30}
assert rows[1] == {"id": 2, "name": "Bob", "age": 25}
@@ -231,7 +231,7 @@ def test_upsert_all_tuple_mode():
yield (1, "Alice", 100)
yield (2, "Bob", 200)
- db["data"].insert_all(initial_data(), pk="id")
+ db.table("data").insert_all(initial_data(), pk="id")
# Upsert with tuples
def upsert_data():
@@ -239,9 +239,9 @@ def test_upsert_all_tuple_mode():
yield (1, "Alice", 150) # Update existing
yield (3, "Charlie", 300) # Insert new
- db["data"].upsert_all(upsert_data(), pk="id")
+ db.table("data").upsert_all(upsert_data(), pk="id")
- rows = list(db["data"].rows_where(order_by="id"))
+ rows = list(db.table("data").rows_where(order_by="id"))
assert len(rows) == 3
assert rows[0] == {"id": 1, "name": "Alice", "value": 150}
assert rows[1] == {"id": 2, "name": "Bob", "value": 200}
@@ -258,9 +258,9 @@ def test_tuple_mode_shorter_rows():
yield 2, "Bob" # Missing age and city
yield 3, "Charlie", 35 # Missing city
- db["people"].insert_all(data_generator())
+ db.table("people").insert_all(data_generator())
- rows = list(db["people"].rows_where(order_by="id"))
+ rows = list(db.table("people").rows_where(order_by="id"))
assert rows[0] == {"id": 1, "name": "Alice", "age": 30, "city": "NYC"}
assert rows[1] == {"id": 2, "name": "Bob", "age": None, "city": None}
assert rows[2] == {"id": 3, "name": "Charlie", "age": 35, "city": None}
@@ -271,18 +271,18 @@ def test_list_mode_single_record_upsert_last_pk():
db = Database(memory=True)
# Create table first
- db["data"].insert({"id": 1, "name": "Alice", "value": 100}, pk="id")
+ db.table("data").insert({"id": 1, "name": "Alice", "value": 100}, pk="id")
# Now upsert a single record using list mode
def upsert_data():
yield ["id", "name", "value"]
yield [1, "Alice", 150] # Update existing
- table = db["data"]
+ table = db.table("data")
table.upsert_all(upsert_data(), pk="id")
# Verify the data was updated
- rows = list(db["data"].rows)
+ rows = list(db.table("data").rows)
assert rows == [{"id": 1, "name": "Alice", "value": 150}]
# Verify last_pk is populated correctly
diff --git a/tests/test_lookup.py b/tests/test_lookup.py
index c93d1ed..f96cfef 100644
--- a/tests/test_lookup.py
+++ b/tests/test_lookup.py
@@ -4,7 +4,7 @@ from sqlite_utils.db import Index
def test_lookup_new_table(fresh_db):
- species = fresh_db["species"]
+ species = fresh_db.table("species")
palm_id = species.lookup({"name": "Palm"})
oak_id = species.lookup({"name": "Oak"})
cherry_id = species.lookup({"name": "Cherry"})
@@ -26,7 +26,7 @@ def test_lookup_new_table(fresh_db):
def test_lookup_new_table_compound_key(fresh_db):
- species = fresh_db["species"]
+ species = fresh_db.table("species")
palm_id = species.lookup({"name": "Palm", "type": "Tree"})
oak_id = species.lookup({"name": "Oak", "type": "Tree"})
assert palm_id == species.lookup({"name": "Palm", "type": "Tree"})
@@ -70,7 +70,7 @@ def test_lookup_fails_if_constraint_cannot_be_added(fresh_db):
def test_lookup_with_extra_values(fresh_db):
- species = fresh_db["species"]
+ species = fresh_db.table("species")
id = species.lookup({"name": "Palm", "type": "Tree"}, {"first_seen": "2020-01-01"})
assert species.get(id) == {
"id": 1,
@@ -90,9 +90,9 @@ def test_lookup_with_extra_values(fresh_db):
def test_lookup_with_extra_insert_parameters(fresh_db):
- other_table = fresh_db["other_table"]
+ other_table = fresh_db.table("other_table")
other_table.insert({"id": 1, "name": "Name"}, pk="id")
- species = fresh_db["species"]
+ species = fresh_db.table("species")
id = species.lookup(
{"name": "Palm", "type": "Tree"},
{
@@ -156,15 +156,15 @@ def test_lookup_with_extra_insert_parameters(fresh_db):
@pytest.mark.parametrize("strict", (False, True))
def test_lookup_new_table_strict(fresh_db, strict):
- fresh_db["species"].lookup({"name": "Palm"}, strict=strict)
- assert fresh_db["species"].strict == strict or not fresh_db.supports_strict
+ fresh_db.table("species").lookup({"name": "Palm"}, strict=strict)
+ assert fresh_db.table("species").strict == strict or not fresh_db.supports_strict
def test_lookup_null_value_idempotent(fresh_db):
# https://github.com/simonw/sqlite-utils/issues/186
# Repeated lookups of a null value should return the same row,
# not insert a duplicate row each time
- species = fresh_db["species"]
+ species = fresh_db.table("species")
first_id = species.lookup({"name": None})
second_id = species.lookup({"name": None})
assert first_id == second_id
@@ -172,7 +172,7 @@ def test_lookup_null_value_idempotent(fresh_db):
def test_lookup_compound_key_with_null_idempotent(fresh_db):
- species = fresh_db["species"]
+ species = fresh_db.table("species")
palm_id = species.lookup({"name": "Palm", "type": None})
oak_id = species.lookup({"name": "Oak", "type": "Tree"})
assert palm_id == species.lookup({"name": "Palm", "type": None})
diff --git a/tests/test_m2m.py b/tests/test_m2m.py
index 4fca918..4dde7e4 100644
--- a/tests/test_m2m.py
+++ b/tests/test_m2m.py
@@ -4,45 +4,45 @@ from sqlite_utils.db import ForeignKey, NoObviousTable
def test_insert_m2m_single(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id").m2m(
"humans", {"id": 1, "name": "Natalie D"}, pk="id"
)
assert {"dogs_humans", "humans", "dogs"} == set(fresh_db.table_names())
- humans = fresh_db["humans"]
- dogs_humans = fresh_db["dogs_humans"]
+ humans = fresh_db.table("humans")
+ dogs_humans = fresh_db.table("dogs_humans")
assert [{"id": 1, "name": "Natalie D"}] == list(humans.rows)
assert [{"humans_id": 1, "dogs_id": 1}] == list(dogs_humans.rows)
def test_insert_m2m_alter(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id").m2m(
"humans", {"id": 1, "name": "Natalie D"}, pk="id"
)
dogs.update(1).m2m(
"humans", {"id": 2, "name": "Simon W", "nerd": True}, pk="id", alter=True
)
- assert list(fresh_db["humans"].rows) == [
+ assert list(fresh_db.table("humans").rows) == [
{"id": 1, "name": "Natalie D", "nerd": None},
{"id": 2, "name": "Simon W", "nerd": 1},
]
- assert list(fresh_db["dogs_humans"].rows) == [
+ assert list(fresh_db.table("dogs_humans").rows) == [
{"humans_id": 1, "dogs_id": 1},
{"humans_id": 2, "dogs_id": 1},
]
def test_insert_m2m_list(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id").m2m(
"humans",
[{"id": 1, "name": "Natalie D"}, {"id": 2, "name": "Simon W"}],
pk="id",
)
assert {"dogs", "humans", "dogs_humans"} == set(fresh_db.table_names())
- humans = fresh_db["humans"]
- dogs_humans = fresh_db["dogs_humans"]
+ humans = fresh_db.table("humans")
+ dogs_humans = fresh_db.table("dogs_humans")
assert [{"humans_id": 1, "dogs_id": 1}, {"humans_id": 2, "dogs_id": 1}] == list(
dogs_humans.rows
)
@@ -68,7 +68,7 @@ def test_insert_m2m_iterable(fresh_db):
def iterable():
yield from iterable_records
- platypuses = fresh_db["platypuses"]
+ platypuses = fresh_db.table("platypuses")
platypuses.insert({"id": 1, "name": "Perry"}, pk="id").m2m(
"humans",
iterable(),
@@ -76,8 +76,8 @@ def test_insert_m2m_iterable(fresh_db):
)
assert {"platypuses", "humans", "humans_platypuses"} == set(fresh_db.table_names())
- humans = fresh_db["humans"]
- humans_platypuses = fresh_db["humans_platypuses"]
+ humans = fresh_db.table("humans")
+ humans_platypuses = fresh_db.table("humans_platypuses")
assert [
{"humans_id": 1, "platypuses_id": 1},
{"humans_id": 2, "platypuses_id": 1},
@@ -111,14 +111,14 @@ def test_m2m_with_table_objects(fresh_db):
assert expected_tables == set(fresh_db.table_names())
assert dogs.count == 1
assert humans.count == 2
- assert fresh_db["dogs_humans"].count == 2
+ assert fresh_db.table("dogs_humans").count == 2
def test_m2m_lookup(fresh_db):
people = fresh_db.table("people", pk="id")
people.insert({"name": "Wahyu"}).m2m("tags", lookup={"tag": "Coworker"})
- people_tags = fresh_db["people_tags"]
- tags = fresh_db["tags"]
+ people_tags = fresh_db.table("people_tags")
+ tags = fresh_db.table("tags")
assert people_tags.exists()
assert tags.exists()
assert [
@@ -150,9 +150,9 @@ def test_m2m_explicit_table_name_argument(fresh_db):
people.insert({"name": "Wahyu"}).m2m(
"tags", lookup={"tag": "Coworker"}, m2m_table="tagged"
)
- assert fresh_db["tags"].exists
- assert fresh_db["tagged"].exists
- assert not fresh_db["people_tags"].exists()
+ assert fresh_db.table("tags").exists
+ assert fresh_db.table("tagged").exists
+ assert not fresh_db.table("people_tags").exists()
def test_m2m_table_candidates(fresh_db):
@@ -181,25 +181,25 @@ def test_uses_existing_m2m_table_if_exists(fresh_db):
# Code should look for an existing table with fks to both tables
# and use that if it exists.
people = fresh_db.create_table("people", {"id": int, "name": str}, pk="id")
- fresh_db["tags"].lookup({"tag": "Coworker"})
+ fresh_db.table("tags").lookup({"tag": "Coworker"})
fresh_db.create_table(
"tagged",
{"people_id": int, "tags_id": int},
foreign_keys=["people_id", "tags_id"],
)
people.insert({"name": "Wahyu"}).m2m("tags", lookup={"tag": "Coworker"})
- assert fresh_db["tags"].exists()
- assert fresh_db["tagged"].exists()
- assert not fresh_db["people_tags"].exists()
- assert not fresh_db["tags_people"].exists()
- assert [{"people_id": 1, "tags_id": 1}] == list(fresh_db["tagged"].rows)
+ assert fresh_db.table("tags").exists()
+ assert fresh_db.table("tagged").exists()
+ assert not fresh_db.table("people_tags").exists()
+ assert not fresh_db.table("tags_people").exists()
+ assert [{"people_id": 1, "tags_id": 1}] == list(fresh_db.table("tagged").rows)
def test_requires_explicit_m2m_table_if_multiple_options(fresh_db):
# If the code scans for m2m tables and finds more than one candidate
# it should require that the m2m_table=x argument is used
people = fresh_db.create_table("people", {"id": int, "name": str}, pk="id")
- fresh_db["tags"].lookup({"tag": "Coworker"})
+ fresh_db.table("tags").lookup({"tag": "Coworker"})
fresh_db.create_table(
"tagged",
{"people_id": int, "tags_id": int},
diff --git a/tests/test_migrations.py b/tests/test_migrations.py
index 3f3dfea..fa419ec 100644
--- a/tests/test_migrations.py
+++ b/tests/test_migrations.py
@@ -10,11 +10,11 @@ def migrations():
@migrations()
def m001(db):
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
@migrations()
def m002(db):
- db["cats"].create({"name": str})
+ db.table("cats").create({"name": str})
db.execute("insert into dogs (name) values ('Pancakes')")
return migrations
@@ -28,11 +28,11 @@ def migrations_not_ordered_alphabetically():
@migrations()
def m002(db):
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
@migrations()
def m001(db):
- db["cats"].create({"name": str})
+ db.table("cats").create({"name": str})
db.execute("insert into dogs (name) values ('Pancakes')")
return migrations
@@ -44,7 +44,7 @@ def migrations2():
@migrations()
def m001(db):
- db["dogs2"].insert({"name": "Cleo"})
+ db.table("dogs2").insert({"name": "Cleo"})
return migrations
@@ -96,7 +96,7 @@ def test_applied_at_is_a_string(migrations):
def test_failing_migration_rolls_back(migrations):
@migrations()
def m003(db):
- db["birds"].create({"name": str})
+ db.table("birds").create({"name": str})
db.execute("insert into dogs (name) values ('Dozer')")
raise ValueError("boom")
@@ -105,7 +105,7 @@ def test_failing_migration_rolls_back(migrations):
migrations.apply(db)
# m001 and m002 committed before the failure and stay applied
assert set(db.table_names()) == {"_sqlite_migrations", "dogs", "cats"}
- assert [r["name"] for r in db["dogs"].rows] == ["Cleo", "Pancakes"]
+ assert [r["name"] for r in db.table("dogs").rows] == ["Cleo", "Pancakes"]
assert [m.name for m in migrations.applied(db)] == ["m001", "m002"]
# Everything m003 did was rolled back and it is still pending
assert [m.name for m in migrations.pending(db)] == ["m003"]
@@ -117,11 +117,11 @@ def test_rerun_after_failure_applies_each_migration_once():
@migrations()
def m001(db):
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
@migrations()
def m002(db):
- db["dogs"].insert({"name": "Pancakes"})
+ db.table("dogs").insert({"name": "Pancakes"})
if state["fail"]:
raise ValueError("boom")
@@ -131,7 +131,7 @@ def test_rerun_after_failure_applies_each_migration_once():
state["fail"] = False
migrations.apply(db)
# m001 must not have been re-applied, m002 applied exactly once
- assert [r["name"] for r in db["dogs"].rows] == ["Cleo", "Pancakes"]
+ assert [r["name"] for r in db.table("dogs").rows] == ["Cleo", "Pancakes"]
assert [m.name for m in migrations.applied(db)] == ["m001", "m002"]
@@ -142,7 +142,7 @@ def test_non_transactional_migration_allows_vacuum(tmpdir):
@migrations()
def m001(db):
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
@migrations(transactional=False)
def m002(db):
@@ -185,11 +185,13 @@ def test_apply_composes_inside_outer_transaction(migrations):
)
def test_upgrades_sqlite_migrations(migrations, create_table, pk):
db = sqlite_utils.Database(memory=True)
- db["_sqlite_migrations"].create(create_table, pk=pk)
+ db.table("_sqlite_migrations").create(create_table, pk=pk)
assert db.table_names() == ["_sqlite_migrations"]
- assert db["_sqlite_migrations"].pks == ([pk] if isinstance(pk, str) else list(pk))
+ assert db.table("_sqlite_migrations").pks == (
+ [pk] if isinstance(pk, str) else list(pk)
+ )
migrations.apply(db)
- assert db["_sqlite_migrations"].pks == ["id"]
+ assert db.table("_sqlite_migrations").pks == ["id"]
def test_pending_and_applied_are_read_only(migrations):
@@ -227,7 +229,7 @@ def test_stop_before_applied_migration_errors(migrations):
assert "m001" in str(ex.value)
assert "already been applied" in str(ex.value)
# Nothing else was applied
- assert not db["cats"].exists()
+ assert not db.table("cats").exists()
def test_stop_before_applied_migration_errors_before_any_apply(migrations):
@@ -238,9 +240,9 @@ def test_stop_before_applied_migration_errors_before_any_apply(migrations):
@only_second()
def m002(db):
- db["cats"].create({"name": str})
+ db.table("cats").create({"name": str})
only_second.apply(db) # m002 applied, m001 still pending
with pytest.raises(ValueError):
migrations.apply(db, stop_before="m002")
- assert not db["dogs"].exists()
+ assert not db.table("dogs").exists()
diff --git a/tests/test_mutator_transactions.py b/tests/test_mutator_transactions.py
index 37ae1b6..3f13c6b 100644
--- a/tests/test_mutator_transactions.py
+++ b/tests/test_mutator_transactions.py
@@ -112,7 +112,7 @@ def test_mutator_commits_by_default(tmp_path, mutate, expected_rows):
db = seed_database(path)
assert not db.conn.in_transaction
- mutate(db["items"])
+ mutate(db.table("items"))
assert current_rows(db) == expected_rows
assert not db.conn.in_transaction
@@ -127,7 +127,7 @@ def test_mutator_commits_with_outer_atomic(tmp_path, mutate, expected_rows):
with db.atomic():
assert db.conn.in_transaction
- mutate(db["items"])
+ mutate(db.table("items"))
assert current_rows(db) == expected_rows
assert db.conn.in_transaction
@@ -143,7 +143,7 @@ def test_mutator_rolls_back_outer_atomic(tmp_path, mutate, expected_rows):
db = seed_database(path)
with pytest.raises(RollbackTest), db.atomic():
- mutate(db["items"])
+ mutate(db.table("items"))
assert current_rows(db) == expected_rows
assert db.conn.in_transaction
raise RollbackTest
diff --git a/tests/test_query.py b/tests/test_query.py
index 9d79755..ac0d924 100644
--- a/tests/test_query.py
+++ b/tests/test_query.py
@@ -6,7 +6,7 @@ from sqlite_utils.utils import sqlite3
def test_query(fresh_db):
- fresh_db["dogs"].insert_all([{"name": "Cleo"}, {"name": "Pancakes"}])
+ fresh_db.table("dogs").insert_all([{"name": "Cleo"}, {"name": "Pancakes"}])
results = fresh_db.query("select * from dogs order by name desc")
assert isinstance(results, types.GeneratorType)
assert list(results) == [{"name": "Pancakes"}, {"name": "Cleo"}]
@@ -20,13 +20,13 @@ def test_query_executes_eagerly(fresh_db):
def test_query_rejects_statements_that_return_no_rows(fresh_db):
- fresh_db["dogs"].insert({"name": "Cleo"})
+ fresh_db.table("dogs").insert({"name": "Cleo"})
with pytest.raises(ValueError) as ex:
fresh_db.query("update dogs set name = 'Cleopaws'")
assert "execute()" in str(ex.value)
# The rejected update was rolled back, and no transaction is left open
assert not fresh_db.conn.in_transaction
- assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
+ assert [row["name"] for row in fresh_db.table("dogs").rows] == ["Cleo"]
def test_query_rejected_ddl_is_rolled_back(fresh_db):
@@ -37,7 +37,7 @@ def test_query_rejected_ddl_is_rolled_back(fresh_db):
def test_query_rejected_write_inside_transaction_is_rolled_back(fresh_db):
- fresh_db["dogs"].insert({"name": "Cleo"})
+ fresh_db.table("dogs").insert({"name": "Cleo"})
fresh_db.begin()
fresh_db.execute("insert into dogs (name) values ('Pancakes')")
with pytest.raises(ValueError):
@@ -45,7 +45,7 @@ def test_query_rejected_write_inside_transaction_is_rolled_back(fresh_db):
# The transaction is still open and the earlier insert is intact
assert fresh_db.conn.in_transaction
fresh_db.commit()
- assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo", "Pancakes"]
+ assert [row["name"] for row in fresh_db.table("dogs").rows] == ["Cleo", "Pancakes"]
@pytest.mark.parametrize(
@@ -77,7 +77,7 @@ def test_query_comment_prefixed_commit_does_not_commit_transaction(fresh_db):
# A COMMIT hidden behind a leading comment must not slip past the
# keyword check - previously it committed the caller's open
# transaction before the ValueError was raised
- fresh_db["dogs"].insert({"name": "Cleo"})
+ fresh_db.table("dogs").insert({"name": "Cleo"})
fresh_db.begin()
fresh_db.execute("insert into dogs (name) values ('Pancakes')")
with pytest.raises(ValueError):
@@ -85,7 +85,7 @@ def test_query_comment_prefixed_commit_does_not_commit_transaction(fresh_db):
# The explicit transaction is still open and can still be rolled back
assert fresh_db.conn.in_transaction
fresh_db.rollback()
- assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
+ assert [row["name"] for row in fresh_db.table("dogs").rows] == ["Cleo"]
@pytest.mark.parametrize("sql", ["; COMMIT", "\ufeffCOMMIT"])
@@ -94,7 +94,7 @@ def test_query_prefixed_commit_does_not_commit_transaction(fresh_db, sql):
# real token, so the keyword scanner must skip them too - previously
# '; COMMIT' slipped past the check and committed the caller's open
# transaction before raising OperationalError
- fresh_db["dogs"].insert({"name": "Cleo"})
+ fresh_db.table("dogs").insert({"name": "Cleo"})
fresh_db.begin()
fresh_db.execute("insert into dogs (name) values ('Pancakes')")
with pytest.raises(ValueError):
@@ -102,7 +102,7 @@ def test_query_prefixed_commit_does_not_commit_transaction(fresh_db, sql):
# The explicit transaction is still open and can still be rolled back
assert fresh_db.conn.in_transaction
fresh_db.rollback()
- assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
+ assert [row["name"] for row in fresh_db.table("dogs").rows] == ["Cleo"]
def test_query_error_leaves_no_transaction_open(fresh_db):
@@ -190,12 +190,12 @@ def test_first_keyword(sql, expected):
reason="RETURNING requires SQLite 3.35.0 or higher",
)
def test_query_insert_returning(fresh_db):
- fresh_db["dogs"].insert({"name": "Cleo"})
+ fresh_db.table("dogs").insert({"name": "Cleo"})
rows = list(
fresh_db.query("insert into dogs (name) values ('Pancakes') returning name")
)
assert rows == [{"name": "Pancakes"}]
- assert fresh_db["dogs"].count == 2
+ assert fresh_db.table("dogs").count == 2
@pytest.mark.skipif(
@@ -207,7 +207,7 @@ def test_query_insert_returning_commits_without_iteration(tmpdir):
path = str(tmpdir / "test.db")
db = Database(path)
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
# Never iterate over the results
db.query("insert into dogs (name) values ('Pancakes') returning name")
assert not db.conn.in_transaction
@@ -227,7 +227,7 @@ def test_query_insert_returning_partial_iteration_still_commits(tmpdir):
path = str(tmpdir / "test.db")
db = Database(path)
- db["dogs"].insert({"name": "Cleo"})
+ db.table("dogs").insert({"name": "Cleo"})
row = next(
db.query(
"insert into dogs (name) values ('Pancakes'), ('Marnie') returning name"
@@ -246,7 +246,7 @@ def test_query_insert_returning_partial_iteration_still_commits(tmpdir):
reason="RETURNING requires SQLite 3.35.0 or higher",
)
def test_query_insert_returning_respects_explicit_transaction(fresh_db):
- fresh_db["dogs"].insert({"name": "Cleo"})
+ fresh_db.table("dogs").insert({"name": "Cleo"})
fresh_db.begin()
rows = list(
fresh_db.query("insert into dogs (name) values ('Pancakes') returning name")
@@ -255,13 +255,13 @@ def test_query_insert_returning_respects_explicit_transaction(fresh_db):
# Still inside the explicit transaction - not committed
assert fresh_db.conn.in_transaction
fresh_db.rollback()
- assert [row["name"] for row in fresh_db["dogs"].rows] == ["Cleo"]
+ assert [row["name"] for row in fresh_db.table("dogs").rows] == ["Cleo"]
def test_query_duplicate_column_names_are_deduped(fresh_db):
# https://github.com/simonw/sqlite-utils/issues/624
- fresh_db["one"].insert({"id": 1, "value": "left"})
- fresh_db["two"].insert({"id": 2, "value": "right"})
+ fresh_db.table("one").insert({"id": 1, "value": "left"})
+ fresh_db.table("two").insert({"id": 2, "value": "right"})
rows = list(
fresh_db.query("select one.id, two.id, one.value, two.value from one, two")
)
@@ -277,7 +277,7 @@ def test_query_deduped_column_avoids_existing_names(fresh_db):
def test_execute_returning_dicts(fresh_db):
# Like db.query() but returns a list, included for backwards compatibility
# see https://github.com/simonw/sqlite-utils/issues/290
- fresh_db["test"].insert({"id": 1, "bar": 2}, pk="id")
+ fresh_db.table("test").insert({"id": 1, "bar": 2}, pk="id")
assert fresh_db.execute_returning_dicts("select * from test") == [
{"id": 1, "bar": 2}
]
diff --git a/tests/test_recipes.py b/tests/test_recipes.py
index c6222a3..c6a548c 100644
--- a/tests/test_recipes.py
+++ b/tests/test_recipes.py
@@ -8,7 +8,7 @@ from sqlite_utils.utils import sqlite3
@pytest.fixture
def dates_db(fresh_db):
- fresh_db["example"].insert_all(
+ fresh_db.table("example").insert_all(
[
{"id": 1, "dt": "5th October 2019 12:04"},
{"id": 2, "dt": "6th October 2019 00:05:06"},
@@ -21,8 +21,8 @@ def dates_db(fresh_db):
def test_parsedate(dates_db):
- dates_db["example"].convert("dt", recipes.parsedate)
- assert list(dates_db["example"].rows) == [
+ dates_db.table("example").convert("dt", recipes.parsedate)
+ assert list(dates_db.table("example").rows) == [
{"id": 1, "dt": "2019-10-05"},
{"id": 2, "dt": "2019-10-06"},
{"id": 3, "dt": ""},
@@ -31,8 +31,8 @@ def test_parsedate(dates_db):
def test_parsedatetime(dates_db):
- dates_db["example"].convert("dt", recipes.parsedatetime)
- assert list(dates_db["example"].rows) == [
+ dates_db.table("example").convert("dt", recipes.parsedatetime)
+ assert list(dates_db.table("example").rows) == [
{"id": 1, "dt": "2019-10-05T12:04:00"},
{"id": 2, "dt": "2019-10-06T00:05:06"},
{"id": 3, "dt": ""},
@@ -50,16 +50,16 @@ def test_parsedatetime(dates_db):
),
)
def test_dayfirst_yearfirst(fresh_db, recipe, kwargs, expected):
- fresh_db["example"].insert_all(
+ fresh_db.table("example").insert_all(
[
{"id": 1, "dt": "03/04/05"},
],
pk="id",
)
- fresh_db["example"].convert(
+ fresh_db.table("example").convert(
"dt", lambda value: getattr(recipes, recipe)(value, **kwargs)
)
- assert list(fresh_db["example"].rows) == [
+ assert list(fresh_db.table("example").rows) == [
{"id": 1, "dt": expected},
]
@@ -68,7 +68,7 @@ def test_dayfirst_yearfirst(fresh_db, recipe, kwargs, expected):
@pytest.mark.parametrize("fn", ("parsedate", "parsedatetime"))
def test_dateparse_errors_raises(fresh_db, fn):
"""Test that invalid dates raise errors when errors=None"""
- fresh_db["example"].insert_all(
+ fresh_db.table("example").insert_all(
[
{"id": 1, "dt": "invalid"},
],
@@ -76,30 +76,32 @@ def test_dateparse_errors_raises(fresh_db, fn):
)
# Exception in SQLite callback surfaces as OperationalError
with pytest.raises(sqlite3.OperationalError):
- fresh_db["example"].convert("dt", lambda value: getattr(recipes, fn)(value))
+ fresh_db.table("example").convert(
+ "dt", lambda value: getattr(recipes, fn)(value)
+ )
@pytest.mark.parametrize("fn", ("parsedate", "parsedatetime"))
@pytest.mark.parametrize("errors", (recipes.SET_NULL, recipes.IGNORE))
def test_dateparse_errors_handled(fresh_db, fn, errors):
"""Test error handling modes for invalid dates"""
- fresh_db["example"].insert_all(
+ fresh_db.table("example").insert_all(
[
{"id": 1, "dt": "invalid"},
],
pk="id",
)
- fresh_db["example"].convert(
+ fresh_db.table("example").convert(
"dt", lambda value: getattr(recipes, fn)(value, errors=errors)
)
- rows = list(fresh_db["example"].rows)
+ rows = list(fresh_db.table("example").rows)
expected = [{"id": 1, "dt": None if errors is recipes.SET_NULL else "invalid"}]
assert rows == expected
@pytest.mark.parametrize("delimiter", [None, ";", "-"])
def test_jsonsplit(fresh_db, delimiter):
- fresh_db["example"].insert_all(
+ fresh_db.table("example").insert_all(
[
{"id": 1, "tags": (delimiter or ",").join(["foo", "bar"])},
{"id": 2, "tags": (delimiter or ",").join(["bar", "baz"])},
@@ -114,8 +116,8 @@ def test_jsonsplit(fresh_db, delimiter):
else:
fn = recipes.jsonsplit
- fresh_db["example"].convert("tags", fn)
- assert list(fresh_db["example"].rows) == [
+ fresh_db.table("example").convert("tags", fn)
+ assert list(fresh_db.table("example").rows) == [
{"id": 1, "tags": '["foo", "bar"]'},
{"id": 2, "tags": '["bar", "baz"]'},
]
@@ -130,7 +132,7 @@ def test_jsonsplit(fresh_db, delimiter):
),
)
def test_jsonsplit_type(fresh_db, type, expected):
- fresh_db["example"].insert_all(
+ fresh_db.table("example").insert_all(
[
{"id": 1, "records": "1,2,3"},
],
@@ -144,5 +146,5 @@ def test_jsonsplit_type(fresh_db, type, expected):
else:
fn = recipes.jsonsplit
- fresh_db["example"].convert("records", fn)
- assert json.loads(fresh_db["example"].get(1)["records"]) == expected
+ fresh_db.table("example").convert("records", fn)
+ assert json.loads(fresh_db.table("example").get(1)["records"]) == expected
diff --git a/tests/test_recreate.py b/tests/test_recreate.py
index 09e237e..d8b846e 100644
--- a/tests/test_recreate.py
+++ b/tests/test_recreate.py
@@ -33,8 +33,8 @@ def test_recreate(tmp_path, use_path, create_file_first):
filepath = pathlib.Path(filepath)
if create_file_first:
db = Database(filepath)
- db["t1"].insert({"foo": "bar"})
+ db.table("t1").insert({"foo": "bar"})
assert ["t1"] == db.table_names()
db.close()
- Database(filepath, recreate=True)["t2"].insert({"foo": "bar"})
+ Database(filepath, recreate=True).table("t2").insert({"foo": "bar"})
assert ["t2"] == Database(filepath).table_names()
diff --git a/tests/test_rows.py b/tests/test_rows.py
index dccb6ad..476569e 100644
--- a/tests/test_rows.py
+++ b/tests/test_rows.py
@@ -3,7 +3,7 @@ import pytest
def test_rows(existing_db):
assert [{"text": "one"}, {"text": "two"}, {"text": "three"}] == list(
- existing_db["foo"].rows
+ existing_db.table("foo").rows
)
@@ -18,7 +18,7 @@ def test_rows(existing_db):
],
)
def test_rows_where(where, where_args, expected_ids, fresh_db):
- table = fresh_db["dogs"]
+ table = fresh_db.table("dogs")
table.insert_all(
[
{"id": 1, "name": "Cleo", "age": 4, "is_good": True},
@@ -41,7 +41,7 @@ def test_rows_where(where, where_args, expected_ids, fresh_db):
],
)
def test_rows_where_order_by(where, order_by, expected_ids, fresh_db):
- table = fresh_db["dogs"]
+ table = fresh_db.table("dogs")
table.insert_all(
[
{"id": 1, "name": "Cleo", "age": 4},
@@ -65,7 +65,7 @@ def test_rows_where_order_by(where, order_by, expected_ids, fresh_db):
],
)
def test_rows_where_offset_limit(fresh_db, offset, limit, expected):
- table = fresh_db["rows"]
+ table = fresh_db.table("rows")
table.insert_all([{"id": id} for id in range(1, 101)], pk="id")
assert table.count == 100
assert expected == [
@@ -74,13 +74,13 @@ def test_rows_where_offset_limit(fresh_db, offset, limit, expected):
def test_pks_and_rows_where_offset_without_limit(fresh_db):
- table = fresh_db["rows"]
+ table = fresh_db.table("rows")
table.insert_all([{"id": id} for id in range(1, 6)], pk="id")
assert [pk for pk, _ in table.pks_and_rows_where(offset=3, order_by="id")] == [4, 5]
def test_pks_and_rows_where_rowid(fresh_db):
- table = fresh_db["rowid_table"]
+ table = fresh_db.table("rowid_table")
table.insert_all({"number": i + 10} for i in range(3))
pks_and_rows = list(table.pks_and_rows_where())
assert pks_and_rows == [
@@ -91,7 +91,7 @@ def test_pks_and_rows_where_rowid(fresh_db):
def test_pks_and_rows_where_simple_pk(fresh_db):
- table = fresh_db["simple_pk_table"]
+ table = fresh_db.table("simple_pk_table")
table.insert_all(({"id": i + 10} for i in range(3)), pk="id")
pks_and_rows = list(table.pks_and_rows_where())
assert pks_and_rows == [
@@ -102,7 +102,7 @@ def test_pks_and_rows_where_simple_pk(fresh_db):
def test_pks_and_rows_where_compound_pk(fresh_db):
- table = fresh_db["compound_pk_table"]
+ table = fresh_db.table("compound_pk_table")
table.insert_all(
({"type": "number", "number": i, "plusone": i + 1} for i in range(3)),
pk=("type", "number"),
@@ -117,8 +117,8 @@ def test_pks_and_rows_where_compound_pk(fresh_db):
def test_rows_where_duplicate_select_columns_are_deduped(fresh_db):
# https://github.com/simonw/sqlite-utils/issues/624
- fresh_db["t"].insert({"id": 1, "name": "Cleo"})
- rows = list(fresh_db["t"].rows_where(select="id, id, name"))
+ fresh_db.table("t").insert({"id": 1, "name": "Cleo"})
+ rows = list(fresh_db.table("t").rows_where(select="id, id, name"))
assert rows == [{"id": 1, "id_2": 1, "name": "Cleo"}]
@@ -130,10 +130,10 @@ def test_pks_and_rows_where_view(fresh_db):
# an AttributeError from View lacking Table-only properties
from sqlite_utils.utils import sqlite3
- fresh_db["dogs"].insert({"id": 1, "name": "Cleo"}, pk="id")
+ fresh_db.table("dogs").insert({"id": 1, "name": "Cleo"}, pk="id")
fresh_db.create_view("dog_names", "select name from dogs")
try:
- result = list(fresh_db["dog_names"].pks_and_rows_where())
+ result = list(fresh_db.view("dog_names").pks_and_rows_where())
except sqlite3.OperationalError:
pass # SQLite 3.36+: no such column: rowid
else:
@@ -144,6 +144,6 @@ def test_pks_and_rows_where_view(fresh_db):
def test_pks_and_rows_where_compound_pk_declaration_order(fresh_db):
# Compound pks are returned in PRIMARY KEY declaration order
fresh_db.execute("create table t (b text, a text, primary key (a, b))")
- fresh_db["t"].insert({"a": "A", "b": "B"})
- pks_and_rows = list(fresh_db["t"].pks_and_rows_where())
+ fresh_db.table("t").insert({"a": "A", "b": "B"})
+ pks_and_rows = list(fresh_db.table("t").pks_and_rows_where())
assert pks_and_rows == [(("A", "B"), {"b": "B", "a": "A"})]
diff --git a/tests/test_sniff.py b/tests/test_sniff.py
index 7149978..029a7fc 100644
--- a/tests/test_sniff.py
+++ b/tests/test_sniff.py
@@ -19,7 +19,7 @@ def test_sniff(tmpdir, filepath):
)
assert result.exit_code == 0, result.stdout
db = Database(db_path)
- assert list(db["creatures"].rows) == [
+ assert list(db.table("creatures").rows) == [
{"id": "1", "species": "dog", "name": "Cleo", "age": "5"},
{"id": "2", "species": "dog", "name": "Pancakes", "age": "4"},
{"id": "3", "species": "cat", "name": "Mozie", "age": "8"},
diff --git a/tests/test_transform.py b/tests/test_transform.py
index 980ee9d..28fa4d7 100644
--- a/tests/test_transform.py
+++ b/tests/test_transform.py
@@ -128,7 +128,7 @@ def test_transform_sql_table_with_primary_key(
def tracer(sql, params):
return captured.append((sql, params))
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
if use_pragma_foreign_keys:
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
dogs.insert({"id": 1, "name": "Cleo", "age": "5"}, pk="id")
@@ -209,7 +209,7 @@ def test_transform_sql_table_with_no_primary_key(
def tracer(sql, params):
return captured.append((sql, params))
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
if use_pragma_foreign_keys:
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
dogs.insert({"id": 1, "name": "Cleo", "age": "5"})
@@ -229,7 +229,7 @@ def test_transform_sql_table_with_no_primary_key(
def test_transform_sql_with_no_primary_key_to_primary_key_of_id(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": "5"})
assert (
dogs.schema
@@ -244,7 +244,7 @@ def test_transform_sql_with_no_primary_key_to_primary_key_of_id(fresh_db):
def test_transform_rename_pk(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": "5"}, pk="id")
dogs.transform(rename={"id": "pk"})
assert (
@@ -265,7 +265,7 @@ def test_transform_preserves_keyword_literal_defaults(fresh_db):
" note TEXT DEFAULT NULL"
")"
)
- table = fresh_db["t"]
+ table = fresh_db.table("t")
table.insert({"id": 1})
before = fresh_db.execute("SELECT is_active, flag, note FROM t").fetchone()
assert before == (1, 0, None)
@@ -288,7 +288,7 @@ def test_transform_preserves_keyword_literal_defaults(fresh_db):
def test_transform_not_null(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": "5"}, pk="id")
dogs.transform(not_null={"name"})
assert (
@@ -298,7 +298,7 @@ def test_transform_not_null(fresh_db):
def test_transform_remove_a_not_null(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": "5"}, not_null={"age"}, pk="id")
dogs.transform(not_null={"name": True, "age": False})
assert (
@@ -309,7 +309,7 @@ def test_transform_remove_a_not_null(fresh_db):
@pytest.mark.parametrize("not_null", [{"age"}, {"age": True}])
def test_transform_add_not_null_with_rename(fresh_db, not_null):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": "5"}, pk="id")
dogs.transform(not_null=not_null, rename={"age": "dog_age"})
assert (
@@ -319,7 +319,7 @@ def test_transform_add_not_null_with_rename(fresh_db, not_null):
def test_transform_defaults(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": 5}, pk="id")
dogs.transform(defaults={"age": 1})
assert (
@@ -329,7 +329,7 @@ def test_transform_defaults(fresh_db):
def test_transform_defaults_and_rename_column(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": 5}, pk="id")
dogs.transform(rename={"age": "dog_age"}, defaults={"age": 1})
assert (
@@ -339,7 +339,7 @@ def test_transform_defaults_and_rename_column(fresh_db):
def test_remove_defaults(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": 5}, defaults={"age": 1}, pk="id")
dogs.transform(defaults={"age": None})
assert (
@@ -350,8 +350,8 @@ def test_remove_defaults(fresh_db):
@pytest.fixture
def authors_db(fresh_db):
- books = fresh_db["books"]
- authors = fresh_db["authors"]
+ books = fresh_db.table("books")
+ authors = fresh_db.table("authors")
authors.insert({"id": 5, "name": "Jane McGonical"}, pk="id")
books.insert(
{"id": 2, "title": "Reality is Broken", "author_id": 5},
@@ -362,13 +362,13 @@ def authors_db(fresh_db):
def test_transform_foreign_keys_persist(authors_db):
- assert authors_db["books"].foreign_keys == [
+ assert authors_db.table("books").foreign_keys == [
ForeignKey(
table="books", column="author_id", other_table="authors", other_column="id"
)
]
- authors_db["books"].transform(rename={"title": "book_title"})
- assert authors_db["books"].foreign_keys == [
+ authors_db.table("books").transform(rename={"title": "book_title"})
+ assert authors_db.table("books").foreign_keys == [
ForeignKey(
table="books", column="author_id", other_table="authors", other_column="id"
)
@@ -381,8 +381,8 @@ def test_transform_foreign_keys_survive_renamed_column(
):
if use_pragma_foreign_keys:
authors_db.conn.execute("PRAGMA foreign_keys=ON")
- authors_db["books"].transform(rename={"author_id": "author_id_2"})
- assert authors_db["books"].foreign_keys == [
+ authors_db.table("books").transform(rename={"author_id": "author_id_2"})
+ assert authors_db.table("books").foreign_keys == [
ForeignKey(
table="books",
column="author_id_2",
@@ -393,9 +393,9 @@ def test_transform_foreign_keys_survive_renamed_column(
def _add_country_city_continent(db):
- db["country"].insert({"id": 1, "name": "France"}, pk="id")
- db["continent"].insert({"id": 2, "name": "Europe"}, pk="id")
- db["city"].insert({"id": 24, "name": "Paris"}, pk="id")
+ db.table("country").insert({"id": 1, "name": "France"}, pk="id")
+ db.table("continent").insert({"id": 2, "name": "Europe"}, pk="id")
+ db.table("city").insert({"id": 24, "name": "Paris"}, pk="id")
_CAVEAU = {
@@ -413,11 +413,11 @@ def test_transform_drop_foreign_keys(fresh_db, use_pragma_foreign_keys):
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
# Create table with three foreign keys so we can drop two of them
_add_country_city_continent(fresh_db)
- fresh_db["places"].insert(
+ fresh_db.table("places").insert(
_CAVEAU,
foreign_keys=("country", "continent", "city"),
)
- assert fresh_db["places"].foreign_keys == [
+ assert fresh_db.table("places").foreign_keys == [
ForeignKey(
table="places", column="city", other_table="city", other_column="id"
),
@@ -432,9 +432,9 @@ def test_transform_drop_foreign_keys(fresh_db, use_pragma_foreign_keys):
),
]
# Drop two of those foreign keys
- fresh_db["places"].transform(drop_foreign_keys=("country", "continent"))
+ fresh_db.table("places").transform(drop_foreign_keys=("country", "continent"))
# Should be only one foreign key now
- assert fresh_db["places"].foreign_keys == [
+ assert fresh_db.table("places").foreign_keys == [
ForeignKey(table="places", column="city", other_table="city", other_column="id")
]
if use_pragma_foreign_keys:
@@ -443,17 +443,17 @@ def test_transform_drop_foreign_keys(fresh_db, use_pragma_foreign_keys):
def test_transform_verify_foreign_keys(fresh_db):
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
- fresh_db["authors"].insert({"id": 3, "name": "Tina"}, pk="id")
- fresh_db["books"].insert(
+ fresh_db.table("authors").insert({"id": 3, "name": "Tina"}, pk="id")
+ fresh_db.table("books").insert(
{"id": 1, "title": "Book", "author_id": 3}, pk="id", foreign_keys={"author_id"}
)
# Renaming the id column on authors should break everything
with pytest.raises(OperationalError) as e:
- fresh_db["authors"].transform(rename={"id": "id2"})
+ fresh_db.table("authors").transform(rename={"id": "id2"})
assert e.value.args[0] == 'foreign key mismatch - "books" referencing "authors"'
# This should have rolled us back
assert (
- fresh_db["authors"].schema
+ fresh_db.table("authors").schema
== 'CREATE TABLE "authors" (\n "id" INTEGER PRIMARY KEY,\n "name" TEXT\n)'
)
assert fresh_db.conn.execute("PRAGMA foreign_keys").fetchone()[0]
@@ -476,20 +476,22 @@ def test_transform_on_delete_cascade_does_not_delete_records(
author_id INTEGER REFERENCES authors(id) ON DELETE CASCADE
);
""")
- fresh_db["authors"].insert({"id": 1, "name": "Ursula K. Le Guin"})
- fresh_db["books"].insert({"id": 1, "title": "The Dispossessed", "author_id": 1})
+ fresh_db.table("authors").insert({"id": 1, "name": "Ursula K. Le Guin"})
+ fresh_db.table("books").insert(
+ {"id": 1, "title": "The Dispossessed", "author_id": 1}
+ )
# Transform the table on the other end of the cascading foreign key
- fresh_db["authors"].transform(rename={"name": "author_name"})
- assert list(fresh_db["authors"].rows) == [
+ fresh_db.table("authors").transform(rename={"name": "author_name"})
+ assert list(fresh_db.table("authors").rows) == [
{"id": 1, "author_name": "Ursula K. Le Guin"}
]
- assert list(fresh_db["books"].rows) == [
+ assert list(fresh_db.table("books").rows) == [
{"id": 1, "title": "The Dispossessed", "author_id": 1}
]
# Transforming the table with the cascading foreign key should not
# delete its records either
- fresh_db["books"].transform(rename={"title": "book_title"})
- assert list(fresh_db["books"].rows) == [
+ fresh_db.table("books").transform(rename={"title": "book_title"})
+ assert list(fresh_db.table("books").rows) == [
{"id": 1, "book_title": "The Dispossessed", "author_id": 1}
]
if use_pragma_foreign_keys:
@@ -511,17 +513,19 @@ def test_transform_in_transaction_refuses_destructive_on_delete(fresh_db, on_del
author_id INTEGER REFERENCES authors(id) ON DELETE {on_delete}
);
""")
- fresh_db["authors"].insert({"id": 1, "name": "Ursula K. Le Guin"})
- fresh_db["books"].insert({"id": 1, "title": "The Dispossessed", "author_id": 1})
- previous_schema = fresh_db["authors"].schema
+ fresh_db.table("authors").insert({"id": 1, "name": "Ursula K. Le Guin"})
+ fresh_db.table("books").insert(
+ {"id": 1, "title": "The Dispossessed", "author_id": 1}
+ )
+ previous_schema = fresh_db.table("authors").schema
with fresh_db.atomic(), pytest.raises(TransactionError) as excinfo:
- fresh_db["authors"].transform(rename={"name": "author_name"})
+ fresh_db.table("authors").transform(rename={"name": "author_name"})
message = str(excinfo.value)
assert "books" in message
assert f"ON DELETE {on_delete.upper()}" in message
# Nothing should have changed
- assert fresh_db["authors"].schema == previous_schema
- assert list(fresh_db["books"].rows) == [
+ assert fresh_db.table("authors").schema == previous_schema
+ assert list(fresh_db.table("books").rows) == [
{"id": 1, "title": "The Dispossessed", "author_id": 1}
]
assert fresh_db.conn.execute("PRAGMA foreign_keys").fetchone()[0]
@@ -538,16 +542,16 @@ def test_transform_in_transaction_refuses_self_referential_cascade(fresh_db):
parent_id INTEGER REFERENCES categories(id) ON DELETE CASCADE
);
""")
- fresh_db["categories"].insert_all(
+ fresh_db.table("categories").insert_all(
[
{"id": 1, "name": "Fiction", "parent_id": None},
{"id": 2, "name": "Science Fiction", "parent_id": 1},
]
)
with fresh_db.atomic(), pytest.raises(TransactionError) as excinfo:
- fresh_db["categories"].transform(rename={"name": "title"})
+ fresh_db.table("categories").transform(rename={"name": "title"})
assert "categories" in str(excinfo.value)
- assert fresh_db["categories"].count == 2
+ assert fresh_db.table("categories").count == 2
def test_transform_in_transaction_allowed_with_no_action_foreign_key(fresh_db):
@@ -562,14 +566,16 @@ def test_transform_in_transaction_allowed_with_no_action_foreign_key(fresh_db):
author_id INTEGER REFERENCES authors(id)
);
""")
- fresh_db["authors"].insert({"id": 1, "name": "Ursula K. Le Guin"})
- fresh_db["books"].insert({"id": 1, "title": "The Dispossessed", "author_id": 1})
+ fresh_db.table("authors").insert({"id": 1, "name": "Ursula K. Le Guin"})
+ fresh_db.table("books").insert(
+ {"id": 1, "title": "The Dispossessed", "author_id": 1}
+ )
with fresh_db.atomic():
- fresh_db["authors"].transform(rename={"name": "author_name"})
- assert list(fresh_db["authors"].rows) == [
+ fresh_db.table("authors").transform(rename={"name": "author_name"})
+ assert list(fresh_db.table("authors").rows) == [
{"id": 1, "author_name": "Ursula K. Le Guin"}
]
- assert list(fresh_db["books"].rows) == [
+ assert list(fresh_db.table("books").rows) == [
{"id": 1, "title": "The Dispossessed", "author_id": 1}
]
assert fresh_db.conn.execute("PRAGMA foreign_keys").fetchone()[0]
@@ -587,11 +593,13 @@ def test_transform_in_transaction_allowed_for_child_table(fresh_db):
author_id INTEGER REFERENCES authors(id) ON DELETE CASCADE
);
""")
- fresh_db["authors"].insert({"id": 1, "name": "Ursula K. Le Guin"})
- fresh_db["books"].insert({"id": 1, "title": "The Dispossessed", "author_id": 1})
+ fresh_db.table("authors").insert({"id": 1, "name": "Ursula K. Le Guin"})
+ fresh_db.table("books").insert(
+ {"id": 1, "title": "The Dispossessed", "author_id": 1}
+ )
with fresh_db.atomic():
- fresh_db["books"].transform(rename={"title": "book_title"})
- assert list(fresh_db["books"].rows) == [
+ fresh_db.table("books").transform(rename={"title": "book_title"})
+ assert list(fresh_db.table("books").rows) == [
{"id": 1, "book_title": "The Dispossessed", "author_id": 1}
]
@@ -607,24 +615,28 @@ def test_transform_in_transaction_allowed_with_foreign_keys_off(fresh_db):
author_id INTEGER REFERENCES authors(id) ON DELETE CASCADE
);
""")
- fresh_db["authors"].insert({"id": 1, "name": "Ursula K. Le Guin"})
- fresh_db["books"].insert({"id": 1, "title": "The Dispossessed", "author_id": 1})
+ fresh_db.table("authors").insert({"id": 1, "name": "Ursula K. Le Guin"})
+ fresh_db.table("books").insert(
+ {"id": 1, "title": "The Dispossessed", "author_id": 1}
+ )
with fresh_db.atomic():
- fresh_db["authors"].transform(rename={"name": "author_name"})
- assert list(fresh_db["books"].rows) == [
+ fresh_db.table("authors").transform(rename={"name": "author_name"})
+ assert list(fresh_db.table("books").rows) == [
{"id": 1, "title": "The Dispossessed", "author_id": 1}
]
def test_transform_add_foreign_keys_from_scratch(fresh_db):
_add_country_city_continent(fresh_db)
- fresh_db["places"].insert(_CAVEAU)
+ fresh_db.table("places").insert(_CAVEAU)
# Should have no foreign keys
- assert fresh_db["places"].foreign_keys == []
+ assert fresh_db.table("places").foreign_keys == []
# Now add them using .transform()
- fresh_db["places"].transform(add_foreign_keys=("country", "continent", "city"))
+ fresh_db.table("places").transform(
+ add_foreign_keys=("country", "continent", "city")
+ )
# Should now have all three:
- assert fresh_db["places"].foreign_keys == [
+ assert fresh_db.table("places").foreign_keys == [
ForeignKey(
table="places", column="city", other_table="city", other_column="id"
),
@@ -638,7 +650,7 @@ def test_transform_add_foreign_keys_from_scratch(fresh_db):
table="places", column="country", other_table="country", other_column="id"
),
]
- assert fresh_db["places"].schema == (
+ assert fresh_db.table("places").schema == (
'CREATE TABLE "places" (\n'
' "id" INTEGER,\n'
' "name" TEXT,\n'
@@ -662,18 +674,18 @@ def test_transform_add_foreign_keys_from_scratch(fresh_db):
)
def test_transform_add_foreign_keys_from_partial(fresh_db, add_foreign_keys):
_add_country_city_continent(fresh_db)
- fresh_db["places"].insert(
+ fresh_db.table("places").insert(
_CAVEAU,
foreign_keys=("city",),
)
# Should have one foreign keys
- assert fresh_db["places"].foreign_keys == [
+ assert fresh_db.table("places").foreign_keys == [
ForeignKey(table="places", column="city", other_table="city", other_column="id")
]
# Now add three more using .transform()
- fresh_db["places"].transform(add_foreign_keys=add_foreign_keys)
+ fresh_db.table("places").transform(add_foreign_keys=add_foreign_keys)
# Should now have all three:
- assert fresh_db["places"].foreign_keys == [
+ assert fresh_db.table("places").foreign_keys == [
ForeignKey(
table="places", column="city", other_table="city", other_column="id"
),
@@ -702,14 +714,14 @@ def test_transform_add_foreign_keys_from_partial(fresh_db, add_foreign_keys):
)
def test_transform_replace_foreign_keys(fresh_db, foreign_keys):
_add_country_city_continent(fresh_db)
- fresh_db["places"].insert(
+ fresh_db.table("places").insert(
_CAVEAU,
foreign_keys=("city",),
)
- assert len(fresh_db["places"].foreign_keys) == 1
+ assert len(fresh_db.table("places").foreign_keys) == 1
# Replace with two different ones
- fresh_db["places"].transform(foreign_keys=foreign_keys)
- assert fresh_db["places"].schema == (
+ fresh_db.table("places").transform(foreign_keys=foreign_keys)
+ assert fresh_db.table("places").schema == (
'CREATE TABLE "places" (\n'
' "id" INTEGER,\n'
' "name" TEXT,\n'
@@ -729,7 +741,7 @@ def test_transform_preserves_rowids(fresh_db, table_type):
pk = ("id", "name")
elif table_type == "rowid":
pk = None
- fresh_db["places"].insert_all(
+ fresh_db.table("places").insert_all(
[
{"id": "1", "name": "Paris", "country": "France"},
{"id": "2", "name": "London", "country": "UK"},
@@ -738,13 +750,13 @@ def test_transform_preserves_rowids(fresh_db, table_type):
pk=pk,
)
# Now delete and insert a row to mix up the `rowid` sequence
- fresh_db["places"].delete_where("id = ?", ["2"])
- fresh_db["places"].insert({"id": "4", "name": "London", "country": "UK"})
+ fresh_db.table("places").delete_where("id = ?", ["2"])
+ fresh_db.table("places").insert({"id": "4", "name": "London", "country": "UK"})
previous_rows = [
tuple(row) for row in fresh_db.execute("select rowid, id, name from places")
]
# Transform it
- fresh_db["places"].transform(column_order=("country", "name"))
+ fresh_db.table("places").transform(column_order=("country", "name"))
# Should be the same
next_rows = [
tuple(row) for row in fresh_db.execute("select rowid, id, name from places")
@@ -774,7 +786,7 @@ def test_transform_strict(fresh_db, initial_strict, transform_strict, expected_s
def test_transform_to_strict_with_invalid_data(fresh_db):
if not fresh_db.supports_strict:
pytest.skip("SQLite version does not support strict tables")
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.create({"id": int})
dogs.insert({"id": "not-an-integer"})
@@ -801,7 +813,7 @@ def test_transform_strict_updates_default(fresh_db):
@pytest.mark.parametrize("method_name", ("transform", "transform_sql"))
def test_transform_to_strict_not_supported(fresh_db, method_name):
- table = fresh_db["items"]
+ table = fresh_db.table("items")
table.create({"id": int})
fresh_db._supports_strict = False
@@ -823,7 +835,7 @@ def test_transform_to_strict_not_supported(fresh_db, method_name):
def test_transform_indexes(fresh_db, indexes, transform_params):
# https://github.com/simonw/sqlite-utils/issues/633
# New table should have same indexes as old table after transformation
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": 5, "breed": "Labrador"}, pk="id")
for index in indexes:
@@ -849,13 +861,13 @@ def test_transform_indexes(fresh_db, indexes, transform_params):
if "keep_table" in transform_params:
assert all(
index.origin == "pk"
- for index in fresh_db[transform_params["keep_table"]].indexes
+ for index in fresh_db.table(transform_params["keep_table"]).indexes
)
def test_transform_retains_indexes_with_foreign_keys(fresh_db):
- dogs = fresh_db["dogs"]
- owners = fresh_db["owners"]
+ dogs = fresh_db.table("dogs")
+ owners = fresh_db.table("owners")
dogs.insert({"id": 1, "name": "Cleo", "owner_id": 1}, pk="id")
owners.insert({"id": 1, "name": "Alice"}, pk="id")
@@ -890,7 +902,7 @@ def test_transform_retains_indexes_with_foreign_keys(fresh_db):
)
def test_transform_with_indexes_errors(fresh_db, transform_params):
# Should error with a compound (name, age) index if age is renamed or dropped
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "age": 5}, pk="id")
dogs.create_index(["name", "age"])
@@ -906,7 +918,7 @@ def test_transform_with_indexes_errors(fresh_db, transform_params):
def test_transform_with_unique_constraint_implicit_index(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
# Create a table with a UNIQUE constraint on 'name', which creates an implicit index
fresh_db.execute("""
CREATE TABLE dogs (
@@ -933,7 +945,7 @@ def test_transform_with_unique_constraint_implicit_index(fresh_db):
def test_transform_preserves_view(fresh_db):
# https://github.com/simonw/sqlite-utils/issues/831
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id")
fresh_db.execute("create view dogs_view as select id, name from dogs")
view_sql_before = fresh_db.execute(
@@ -958,8 +970,8 @@ def test_transform_preserves_view(fresh_db):
def test_transform_variants_preserve_view(fresh_db, transform_params):
# Covers retyping, changing primary key and foreign key modifications,
# with a view whose columns are untouched by the transform
- fresh_db["other"].insert({"id": 1}, pk="id")
- dogs = fresh_db["dogs"]
+ fresh_db.table("other").insert({"id": 1}, pk="id")
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo", "other_id": 1}, pk="id")
if "drop_foreign_keys" in transform_params:
dogs.transform(add_foreign_keys=[("other_id", "other", "id")])
@@ -972,13 +984,13 @@ def test_transform_variants_preserve_view(fresh_db, transform_params):
"select sql from sqlite_master where name = 'dogs_view'"
).fetchone()[0]
assert view_sql_before == view_sql_after
- assert list(fresh_db["dogs_view"].rows) == [{"id": 1, "name": "Cleo"}]
+ assert list(fresh_db.view("dogs_view").rows) == [{"id": 1, "name": "Cleo"}]
def test_transform_view_referencing_renamed_column(fresh_db):
# The view survives but querying it raises "no such column" - inherent
# to SQLite views, whose SQL is stored as text
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id")
fresh_db.execute("create view dogs_view as select id, name from dogs")
dogs.transform(rename={"name": "title"})
@@ -987,7 +999,7 @@ def test_transform_view_referencing_renamed_column(fresh_db):
def test_transform_view_on_view(fresh_db):
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id")
fresh_db.execute("create view v1 as select id, name from dogs")
fresh_db.execute("create view v2 as select name from v1")
@@ -999,13 +1011,13 @@ def test_transform_view_on_view(fresh_db):
"select sql from sqlite_master where type = 'view' order by name"
).fetchall()
assert sqls_before == sqls_after
- assert list(fresh_db["v2"].rows) == [{"name": "Cleo"}]
+ assert list(fresh_db.view("v2").rows) == [{"name": "Cleo"}]
def test_transform_keep_table_does_not_repoint_view(fresh_db):
# Without legacy_alter_table the ALTER TABLE dogs RENAME TO dogs_backup
# step would rewrite the view to select from "dogs_backup"
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id")
fresh_db.execute("create view dogs_view as select id, name from dogs")
dogs.transform(types={"name": str}, keep_table="dogs_backup")
@@ -1015,7 +1027,7 @@ def test_transform_keep_table_does_not_repoint_view(fresh_db):
assert "dogs_backup" not in view_sql
# View reads from the live table, not the frozen backup
dogs.insert({"id": 2, "name": "Pancakes"})
- assert list(fresh_db["dogs_view"].rows) == [
+ assert list(fresh_db.view("dogs_view").rows) == [
{"id": 1, "name": "Cleo"},
{"id": 2, "name": "Pancakes"},
]
@@ -1024,7 +1036,7 @@ def test_transform_keep_table_does_not_repoint_view(fresh_db):
def test_transform_sql_standalone_statements_work_with_view(fresh_db):
# The documented "run these statements yourself" workflow should be
# standalone-correct, so the pragmas must come from transform_sql()
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id")
fresh_db.execute("create view dogs_view as select id, name from dogs")
sqls = dogs.transform_sql(types={"name": str}, tmp_suffix="suffix")
@@ -1033,12 +1045,12 @@ def test_transform_sql_standalone_statements_work_with_view(fresh_db):
assert sqls[-1] == "PRAGMA legacy_alter_table=OFF;"
for sql in sqls:
fresh_db.execute(sql)
- assert list(fresh_db["dogs_view"].rows) == [{"id": 1, "name": "Cleo"}]
+ assert list(fresh_db.view("dogs_view").rows) == [{"id": 1, "name": "Cleo"}]
def test_transform_with_view_in_open_transaction(fresh_db):
fresh_db.conn.execute("PRAGMA foreign_keys=ON")
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id")
fresh_db.execute("create view dogs_view as select id, name from dogs")
with fresh_db.conn:
@@ -1054,7 +1066,7 @@ def test_transform_with_view_in_open_transaction(fresh_db):
def test_transform_restores_legacy_alter_table_setting(fresh_db):
if sqlite3.sqlite_version_info < (3, 25, 0):
pytest.skip("legacy_alter_table pragma requires SQLite 3.25 or higher")
- dogs = fresh_db["dogs"]
+ dogs = fresh_db.table("dogs")
dogs.insert({"id": 1, "name": "Cleo"}, pk="id")
# Default is OFF, reset to OFF afterwards
dogs.transform(types={"name": str})
@@ -1075,7 +1087,7 @@ def test_transform_preserves_check_constraints(fresh_db):
CONSTRAINT nonzero_id CHECK(id != 0)
)
""")
- scores = fresh_db["scores"]
+ scores = fresh_db.table("scores")
scores.insert({"id": 1, "score": 50})
scores.transform()
assert scores.checks == [
@@ -1095,7 +1107,7 @@ def test_transform_preserves_check_ending_in_line_comment(fresh_db):
)
)
""")
- inventory = fresh_db["inventory"]
+ inventory = fresh_db.table("inventory")
inventory.transform(types={"quantity": float})
assert inventory.checks == [Check("quantity >= 0 -- Quantity cannot be negative")]
with pytest.raises(sqlite3.IntegrityError, match="CHECK constraint failed"):
@@ -1113,7 +1125,7 @@ def test_transform_preserves_comments_owned_by_columns(fresh_db):
age INTEGER -- May be NULL
)
""")
- people = fresh_db["people"]
+ people = fresh_db.table("people")
people.insert({"id": 1, "name": "Cleo", "age": 5})
people.transform(
rename={"name": "display_name"},
@@ -1143,8 +1155,8 @@ def test_transform_drops_comments_owned_by_dropped_column(fresh_db):
obsolete TEXT /* Drop this too */
)
""")
- fresh_db["t"].transform(drop={"obsolete"})
- schema = fresh_db["t"].schema
+ fresh_db.table("t").transform(drop={"obsolete"})
+ schema = fresh_db.table("t").schema
assert "Keep this explanation" in schema
assert "Drop this explanation" not in schema
assert "Drop this too" not in schema
@@ -1159,7 +1171,7 @@ def test_transform_renames_columns_inside_check_constraints(fresh_db):
CONSTRAINT within_maximum CHECK(quantity <= maximum)
)
""")
- inventory = fresh_db["inventory"]
+ inventory = fresh_db.table("inventory")
inventory.insert({"quantity": 2, "maximum": 3})
inventory.transform(rename={"quantity": "amount"})
assert inventory.checks == [
@@ -1182,7 +1194,7 @@ def test_transform_check_rewrite_preserves_functions_and_quotes(fresh_db):
CHECK(length("old name") > 0 AND length != '')
)
""")
- items = fresh_db["items"]
+ items = fresh_db.table("items")
items.insert({"length": "label", "old name": "hello"})
items.transform(rename={"length": "description", "old name": "new name"})
assert items.checks == [Check("length(\"new name\") > 0 AND description != ''")]
@@ -1190,9 +1202,9 @@ def test_transform_check_rewrite_preserves_functions_and_quotes(fresh_db):
def test_transform_check_rewrite_quotes_keyword_column(fresh_db):
fresh_db.execute("CREATE TABLE t(old_name TEXT CHECK(old_name != ''))")
- fresh_db["t"].insert({"old_name": "value"})
- fresh_db["t"].transform(rename={"old_name": "select"})
- assert fresh_db["t"].checks == [Check("\"select\" != ''", column="select")]
+ fresh_db.table("t").insert({"old_name": "value"})
+ fresh_db.table("t").transform(rename={"old_name": "select"})
+ assert fresh_db.table("t").checks == [Check("\"select\" != ''", column="select")]
def test_transform_check_rewrite_does_not_rename_collations_or_cast_types(fresh_db):
@@ -1209,9 +1221,9 @@ def test_transform_check_rewrite_does_not_rename_collations_or_cast_types(fresh_
)
)
""")
- fresh_db["t"].insert({"nocase": "n", "kind": "k", "other": "o"})
- fresh_db["t"].transform(rename={"nocase": "label", "kind": "category"})
- check = fresh_db["t"].checks[0].check
+ fresh_db.table("t").insert({"nocase": "n", "kind": "k", "other": "o"})
+ fresh_db.table("t").transform(rename={"nocase": "label", "kind": "category"})
+ check = fresh_db.table("t").checks[0].check
assert "COLLATE nocase" in check
assert "AS kind" in check
assert "AND label != ''" in check
@@ -1226,9 +1238,9 @@ def test_transform_drops_check_owned_by_dropped_column(fresh_db):
CHECK(id > 0)
)
""")
- fresh_db["t"].insert({"id": 1, "obsolete": 2})
- fresh_db["t"].transform(drop={"obsolete"})
- assert fresh_db["t"].checks == [Check("id > 0")]
+ fresh_db.table("t").insert({"id": 1, "obsolete": 2})
+ fresh_db.table("t").transform(drop={"obsolete"})
+ assert fresh_db.table("t").checks == [Check("id > 0")]
def test_transform_refuses_to_drop_column_used_by_remaining_check(fresh_db):
@@ -1239,7 +1251,7 @@ def test_transform_refuses_to_drop_column_used_by_remaining_check(fresh_db):
CHECK(minimum <= maximum)
)
""")
- ranges = fresh_db["ranges"]
+ ranges = fresh_db.table("ranges")
ranges.insert({"minimum": 1, "maximum": 2})
schema_before = ranges.schema
with pytest.raises(
diff --git a/tests/test_update.py b/tests/test_update.py
index e6ae7d8..44cc098 100644
--- a/tests/test_update.py
+++ b/tests/test_update.py
@@ -7,14 +7,14 @@ from sqlite_utils.db import NotFoundError
def test_update_rowid_table(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
rowid = table.insert({"foo": "bar"}).last_pk
table.update(rowid, {"foo": "baz"})
assert [{"foo": "baz"}] == list(table.rows)
def test_update_pk_table(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
pk = table.insert({"foo": "bar", "id": 5}, pk="id").last_pk
assert 5 == pk
table.update(pk, {"foo": "baz"})
@@ -22,7 +22,7 @@ def test_update_pk_table(fresh_db):
def test_update_compound_pk_table(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
pk = table.insert({"id1": 5, "id2": 3, "v": 1}, pk=("id1", "id2")).last_pk
assert (5, 3) == pk
table.update(pk, {"v": 2})
@@ -42,14 +42,14 @@ def test_update_compound_pk_table(fresh_db):
),
)
def test_update_invalid_pk(fresh_db, pk, update_pk):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
table.insert({"id1": 5, "id2": 3, "v": 1}, pk=pk)
with pytest.raises(NotFoundError):
table.update(update_pk, {"v": 2})
def test_update_alter(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
rowid = table.insert({"foo": "bar"}).last_pk
table.update(rowid, {"new_col": 1.2}, alter=True)
assert [{"foo": "bar", "new_col": 1.2}] == list(table.rows)
@@ -72,7 +72,7 @@ def test_update_alter(fresh_db):
def test_update_alter_with_special_column_characters(fresh_db):
# With double-quote escaping, columns with special characters are now valid
- table = fresh_db["table"]
+ table = fresh_db.table("table")
rowid = table.insert({"foo": "bar"}).last_pk
table.update(rowid, {"new_col[abc]": 1.2}, alter=True)
assert list(table.rows) == [{"foo": "bar", "new_col[abc]": 1.2}]
@@ -106,8 +106,8 @@ def test_update_with_no_values_sets_last_pk(fresh_db):
),
)
def test_update_dictionaries_and_lists_as_json(fresh_db, data_structure):
- fresh_db["test"].insert({"id": 1, "data": ""}, pk="id")
- fresh_db["test"].update(1, {"data": data_structure})
+ fresh_db.table("test").insert({"id": 1, "data": ""}, pk="id")
+ fresh_db.table("test").update(1, {"data": data_structure})
row = fresh_db.execute("select id, data from test").fetchone()
assert row[0] == 1
assert data_structure == json.loads(row[1])
diff --git a/tests/test_upsert.py b/tests/test_upsert.py
index 0eaae9b..0f44cc7 100644
--- a/tests/test_upsert.py
+++ b/tests/test_upsert.py
@@ -7,7 +7,7 @@ from sqlite_utils.db import PrimaryKeyRequired
@pytest.mark.parametrize("use_old_upsert", (False, True))
def test_upsert(use_old_upsert):
db = Database(memory=True, use_old_upsert=use_old_upsert)
- table = db["table"]
+ table = db.table("table")
table.insert({"id": 1, "name": "Cleo"}, pk="id")
table.upsert({"id": 1, "age": 5}, pk="id", alter=True)
assert list(table.rows) == [{"id": 1, "name": "Cleo", "age": 5}]
@@ -15,7 +15,7 @@ def test_upsert(use_old_upsert):
def test_upsert_all(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
table.upsert_all([{"id": 1, "name": "Cleo"}, {"id": 2, "name": "Nixie"}], pk="id")
table.upsert_all([{"id": 1, "age": 5}, {"id": 2, "age": 5}], pk="id", alter=True)
assert list(table.rows) == [
@@ -26,7 +26,7 @@ def test_upsert_all(fresh_db):
def test_upsert_all_single_column(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
table.upsert_all([{"name": "Cleo"}], pk="name")
assert list(table.rows) == [{"name": "Cleo"}]
assert table.pks == ["name"]
@@ -34,16 +34,16 @@ def test_upsert_all_single_column(fresh_db):
def test_upsert_all_not_null(fresh_db):
# https://github.com/simonw/sqlite-utils/issues/538
- fresh_db["comments"].upsert_all(
+ fresh_db.table("comments").upsert_all(
[{"id": 1, "name": "Cleo"}],
pk="id",
not_null=["name"],
)
- assert list(fresh_db["comments"].rows) == [{"id": 1, "name": "Cleo"}]
+ assert list(fresh_db.table("comments").rows) == [{"id": 1, "name": "Cleo"}]
def test_upsert_error_if_no_pk(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
with pytest.raises(PrimaryKeyRequired):
table.upsert_all([{"id": 1, "name": "Cleo"}])
with pytest.raises(PrimaryKeyRequired):
@@ -53,7 +53,7 @@ def test_upsert_error_if_no_pk(fresh_db):
@pytest.mark.parametrize("use_old_upsert", (False, True))
def test_upsert_empty_record_errors(use_old_upsert):
db = Database(memory=True, use_old_upsert=use_old_upsert)
- table = db["table"]
+ table = db.table("table")
table.insert({"id": 1, "name": "Cleo"}, pk="id")
with pytest.raises(PrimaryKeyRequired):
table.upsert({}, pk="id")
@@ -66,7 +66,7 @@ def test_upsert_empty_record_errors(use_old_upsert):
@pytest.mark.parametrize("use_old_upsert", (False, True))
def test_upsert_missing_pk_value_errors(use_old_upsert):
db = Database(memory=True, use_old_upsert=use_old_upsert)
- table = db["table"]
+ table = db.table("table")
table.insert({"id": 1, "name": "Cleo"}, pk="id")
# Records that omit the pk column entirely
with pytest.raises(PrimaryKeyRequired):
@@ -78,7 +78,7 @@ def test_upsert_missing_pk_value_errors(use_old_upsert):
def test_upsert_missing_compound_pk_value_errors(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
table.insert({"a": "x", "b": "y", "v": 1}, pk=("a", "b"))
# Missing one component of the detected compound primary key
with pytest.raises(PrimaryKeyRequired):
@@ -105,7 +105,7 @@ def test_upsert_uses_compound_pk_from_existing_table(use_old_upsert):
primary key (Source, Object, Category)
)
""")
- table = db["summary"]
+ table = db.table("summary")
table.upsert(
{
"Source": "Client A",
@@ -134,7 +134,7 @@ def test_upsert_uses_compound_pk_from_existing_table(use_old_upsert):
def test_upsert_with_hash_id(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
table.upsert({"foo": "bar"}, hash_id="pk")
assert [{"pk": "a5e744d0164540d33b1d7ea616c28f2fa97e754a", "foo": "bar"}] == list(
table.rows
@@ -144,7 +144,7 @@ def test_upsert_with_hash_id(fresh_db):
@pytest.mark.parametrize("hash_id", (None, "custom_id"))
def test_upsert_with_hash_id_columns(fresh_db, hash_id):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
table.upsert({"a": 1, "b": 2, "c": 3}, hash_id=hash_id, hash_id_columns=("a", "b"))
assert list(table.rows) == [
{
@@ -167,7 +167,7 @@ def test_upsert_with_hash_id_columns(fresh_db, hash_id):
def test_upsert_compound_primary_key(fresh_db):
- table = fresh_db["table"]
+ table = fresh_db.table("table")
table.upsert_all(
[
{"species": "dog", "id": 1, "name": "Cleo", "age": 4},
diff --git a/tests/test_wal.py b/tests/test_wal.py
index 35318f8..0e8f332 100644
--- a/tests/test_wal.py
+++ b/tests/test_wal.py
@@ -18,7 +18,7 @@ def test_enable_disable_wal(db_path_tmpdir):
assert "test.db-wal" not in [f.basename for f in tmpdir.listdir()]
db.enable_wal()
assert "wal" == db.journal_mode
- db["test"].insert({"foo": "bar"})
+ db.table("test").insert({"foo": "bar"})
assert "test.db-wal" in [f.basename for f in tmpdir.listdir()]
db.disable_wal()
assert "delete" == db.journal_mode
@@ -27,25 +27,25 @@ def test_enable_disable_wal(db_path_tmpdir):
def test_enable_wal_inside_transaction_raises(db_path_tmpdir):
db, _path, _tmpdir = db_path_tmpdir
- db["test"].insert({"id": 1}, pk="id")
+ db.table("test").insert({"id": 1}, pk="id")
with pytest.raises(TransactionError), db.atomic():
- db["test"].insert({"id": 2}, pk="id")
+ db.table("test").insert({"id": 2}, pk="id")
db.enable_wal()
# The atomic() block must have rolled back cleanly and the
# journal mode must be unchanged
assert db.journal_mode == "delete"
- assert [r["id"] for r in db["test"].rows] == [1]
+ assert [r["id"] for r in db.table("test").rows] == [1]
def test_disable_wal_inside_transaction_raises(db_path_tmpdir):
db, _path, _tmpdir = db_path_tmpdir
db.enable_wal()
- db["test"].insert({"id": 1}, pk="id")
+ db.table("test").insert({"id": 1}, pk="id")
with pytest.raises(TransactionError), db.atomic():
- db["test"].insert({"id": 2}, pk="id")
+ db.table("test").insert({"id": 2}, pk="id")
db.disable_wal()
assert db.journal_mode == "wal"
- assert [r["id"] for r in db["test"].rows] == [1]
+ assert [r["id"] for r in db.table("test").rows] == [1]
def test_ensure_autocommit_on(db_path_tmpdir):
@@ -65,9 +65,9 @@ def test_enable_wal_noop_inside_transaction_is_allowed(db_path_tmpdir):
db, _path, _tmpdir = db_path_tmpdir
db.enable_wal()
with db.atomic():
- db["test"].insert({"id": 1}, pk="id")
+ db.table("test").insert({"id": 1}, pk="id")
db.enable_wal()
- assert [r["id"] for r in db["test"].rows] == [1]
+ assert [r["id"] for r in db.table("test").rows] == [1]
def test_ensure_autocommit_on_inside_transaction_raises(db_path_tmpdir):
@@ -75,7 +75,7 @@ def test_ensure_autocommit_on_inside_transaction_raises(db_path_tmpdir):
# effect, silently breaking the caller's rollback guarantee - so
# entering autocommit mode with a transaction open is an error
db, _path, _tmpdir = db_path_tmpdir
- db["test"].insert({"id": 1}, pk="id")
+ db.table("test").insert({"id": 1}, pk="id")
db.begin()
db.execute("insert into test (id) values (2)")
with pytest.raises(TransactionError), db.ensure_autocommit_on():
@@ -83,4 +83,4 @@ def test_ensure_autocommit_on_inside_transaction_raises(db_path_tmpdir):
# The transaction is still open and can still be rolled back
assert db.conn.in_transaction
db.rollback()
- assert [r["id"] for r in db["test"].rows] == [1]
+ assert [r["id"] for r in db.table("test").rows] == [1]