mirror
/
datasette
kopia lustrzana https://github.com/simonw/datasette
1
0
Forkuj 0
Kod Zgłoszenia Packages Projekty Wydania Wiki Aktywność

Rename core_ to catalog_, closes #2163

pull/2165/head
Simon Willison 2023-08-29 10:01:28 -07:00
rodzic 50da908213
commit bb12229794
5 zmienionych plików z 24 dodań i 20 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

4
datasette/app.py
Wyświetl plik

@ -459,7 +459,7 @@ class Datasette:
current_schema_versions = {
row["database_name"]: row["schema_version"]
for row in await internal_db.execute(
"select database_name, schema_version from core_databases"
"select database_name, schema_version from catalog_databases"
)
}
for database_name, db in self.databases.items():
@ -474,7 +474,7 @@ class Datasette:
values = [database_name, db.is_memory, schema_version]
await internal_db.execute_write(
"""
INSERT OR REPLACE INTO core_databases (database_name, path, is_memory, schema_version)
INSERT OR REPLACE INTO catalog_databases (database_name, path, is_memory, schema_version)
VALUES {}
""".format(
placeholders

28
datasette/utils/internal_db.py
Wyświetl plik

@ -5,13 +5,13 @@ from datasette.utils import table_column_details
async def init_internal_db(db):
create_tables_sql = textwrap.dedent(
"""
CREATE TABLE IF NOT EXISTS core_databases (
CREATE TABLE IF NOT EXISTS catalog_databases (
database_name TEXT PRIMARY KEY,
path TEXT,
is_memory INTEGER,
schema_version INTEGER
);
CREATE TABLE IF NOT EXISTS core_tables (
CREATE TABLE IF NOT EXISTS catalog_tables (
database_name TEXT,
table_name TEXT,
rootpage INTEGER,
@ -19,7 +19,7 @@ async def init_internal_db(db):
PRIMARY KEY (database_name, table_name),
FOREIGN KEY (database_name) REFERENCES databases(database_name)
);
CREATE TABLE IF NOT EXISTS core_columns (
CREATE TABLE IF NOT EXISTS catalog_columns (
database_name TEXT,
table_name TEXT,
cid INTEGER,
@ -33,7 +33,7 @@ async def init_internal_db(db):
FOREIGN KEY (database_name) REFERENCES databases(database_name),
FOREIGN KEY (database_name, table_name) REFERENCES tables(database_name, table_name)
);
CREATE TABLE IF NOT EXISTS core_indexes (
CREATE TABLE IF NOT EXISTS catalog_indexes (
database_name TEXT,
table_name TEXT,
seq INTEGER,
@ -45,7 +45,7 @@ async def init_internal_db(db):
FOREIGN KEY (database_name) REFERENCES databases(database_name),
FOREIGN KEY (database_name, table_name) REFERENCES tables(database_name, table_name)
);
CREATE TABLE IF NOT EXISTS core_foreign_keys (
CREATE TABLE IF NOT EXISTS catalog_foreign_keys (
database_name TEXT,
table_name TEXT,
id INTEGER,
@ -69,15 +69,17 @@ async def populate_schema_tables(internal_db, db):
database_name = db.name
def delete_everything(conn):
conn.execute("DELETE FROM core_tables WHERE database_name = ?", [database_name])
conn.execute(
"DELETE FROM core_columns WHERE database_name = ?", [database_name]
"DELETE FROM catalog_tables WHERE database_name = ?", [database_name]
)
conn.execute(
"DELETE FROM core_foreign_keys WHERE database_name = ?", [database_name]
"DELETE FROM catalog_columns WHERE database_name = ?", [database_name]
)
conn.execute(
"DELETE FROM core_indexes WHERE database_name = ?", [database_name]
"DELETE FROM catalog_foreign_keys WHERE database_name = ?", [database_name]
)
conn.execute(
"DELETE FROM catalog_indexes WHERE database_name = ?", [database_name]
)
await internal_db.execute_write_fn(delete_everything)
@ -137,14 +139,14 @@ async def populate_schema_tables(internal_db, db):
await internal_db.execute_write_many(
"""
INSERT INTO core_tables (database_name, table_name, rootpage, sql)
INSERT INTO catalog_tables (database_name, table_name, rootpage, sql)
values (?, ?, ?, ?)
""",
tables_to_insert,
)
await internal_db.execute_write_many(
"""
INSERT INTO core_columns (
INSERT INTO catalog_columns (
database_name, table_name, cid, name, type, "notnull", default_value, is_pk, hidden
) VALUES (
:database_name, :table_name, :cid, :name, :type, :notnull, :default_value, :is_pk, :hidden
@ -154,7 +156,7 @@ async def populate_schema_tables(internal_db, db):
)
await internal_db.execute_write_many(
"""
INSERT INTO core_foreign_keys (
INSERT INTO catalog_foreign_keys (
database_name, table_name, "id", seq, "table", "from", "to", on_update, on_delete, match
) VALUES (
:database_name, :table_name, :id, :seq, :table, :from, :to, :on_update, :on_delete, :match
@ -164,7 +166,7 @@ async def populate_schema_tables(internal_db, db):
)
await internal_db.execute_write_many(
"""
INSERT INTO core_indexes (
INSERT INTO catalog_indexes (
database_name, table_name, seq, name, "unique", origin, partial
) VALUES (
:database_name, :table_name, :seq, :name, :unique, :origin, :partial

2
datasette/views/database.py
Wyświetl plik

@ -952,7 +952,7 @@ class TableCreateView(BaseView):
async def _table_columns(datasette, database_name):
internal_db = datasette.get_internal_database()
result = await internal_db.execute(
"select table_name, name from core_columns where database_name = ?",
"select table_name, name from catalog_columns where database_name = ?",
[database_name],
)
table_columns = {}

2
docs/internals.rst
Wyświetl plik

@ -1149,6 +1149,8 @@ Datasette's internal database
Datasette maintains an "internal" SQLite database used for configuration, caching, and storage. Plugins can store configuration, settings, and other data inside this database. By default, Datasette will use a temporary in-memory SQLite database as the internal database, which is created at startup and destroyed at shutdown. Users of Datasette can optionally pass in a `--internal` flag to specify the path to a SQLite database to use as the internal database, which will persist internal data across Datasette instances.
Datasette maintains tables called ``catalog_databases``, ``catalog_tables``, ``catalog_columns``, ``catalog_indexes``, ``catalog_foreign_keys`` with details of the attached databases and their schemas. These tables should not be considered a stable API - they may change between Datasette releases.
The internal database is not exposed in the Datasette application by default, which means private data can safely be stored without worry of accidentally leaking information through the default Datasette interface and API. However, other plugins do have full read and write access to the internal database.
Plugins can access this database by calling ``internal_db = datasette.get_internal_database()`` and then executing queries using the :ref:`Database API <internals_database>`.

8
tests/test_internal_db.py
Wyświetl plik

@ -10,7 +10,7 @@ async def ensure_internal(ds_client):
@pytest.mark.asyncio
async def test_internal_databases(ds_client):
internal_db = await ensure_internal(ds_client)
databases = await internal_db.execute("select * from core_databases")
databases = await internal_db.execute("select * from catalog_databases")
assert len(databases) == 1
assert databases.rows[0]["database_name"] == "fixtures"
@ -18,7 +18,7 @@ async def test_internal_databases(ds_client):
@pytest.mark.asyncio
async def test_internal_tables(ds_client):
internal_db = await ensure_internal(ds_client)
tables = await internal_db.execute("select * from core_tables")
tables = await internal_db.execute("select * from catalog_tables")
assert len(tables) > 5
table = tables.rows[0]
assert set(table.keys()) == {"rootpage", "table_name", "database_name", "sql"}
@ -27,7 +27,7 @@ async def test_internal_tables(ds_client):
@pytest.mark.asyncio
async def test_internal_indexes(ds_client):
internal_db = await ensure_internal(ds_client)
indexes = await internal_db.execute("select * from core_indexes")
indexes = await internal_db.execute("select * from catalog_indexes")
assert len(indexes) > 5
index = indexes.rows[0]
assert set(index.keys()) == {
@ -44,7 +44,7 @@ async def test_internal_indexes(ds_client):
@pytest.mark.asyncio
async def test_internal_foreign_keys(ds_client):
internal_db = await ensure_internal(ds_client)
foreign_keys = await internal_db.execute("select * from core_foreign_keys")
foreign_keys = await internal_db.execute("select * from catalog_foreign_keys")
assert len(foreign_keys) > 5
foreign_key = foreign_keys.rows[0]
assert set(foreign_key.keys()) == {