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

Rename database->database_name and table-> table_name, refs #1715

tableview-asyncinject
Simon Willison 2022-04-26 13:56:27 -07:00
rodzic 579f59dcec
commit 7c8fbddb6f
1 zmienionych plików z 76 dodań i 67 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

143
datasette/views/table.py
Wyświetl plik

@ -68,22 +68,22 @@ class Row:
class TableView(DataView):
name = "table"
async def sortable_columns_for_table(self, database, table, use_rowid):
db = self.ds.databases[database]
table_metadata = self.ds.table_metadata(database, table)
async def sortable_columns_for_table(self, database_name, table_name, use_rowid):
db = self.ds.databases[database_name]
table_metadata = self.ds.table_metadata(database_name, table_name)
if "sortable_columns" in table_metadata:
sortable_columns = set(table_metadata["sortable_columns"])
else:
sortable_columns = set(await db.table_columns(table))
sortable_columns = set(await db.table_columns(table_name))
if use_rowid:
sortable_columns.add("rowid")
return sortable_columns
async def expandable_columns(self, database, table):
async def expandable_columns(self, database_name, table_name):
# Returns list of (fk_dict, label_column-or-None) pairs for that table
expandables = []
db = self.ds.databases[database]
for fk in await db.foreign_keys_for_table(table):
db = self.ds.databases[database_name]
for fk in await db.foreign_keys_for_table(table_name):
label_column = await db.label_column_for_table(fk["other_table"])
expandables.append((fk, label_column))
return expandables
@ -94,17 +94,19 @@ class TableView(DataView):
db = self.ds.get_database(route=database_route)
except KeyError:
raise NotFound("Database not found: {}".format(database_route))
database = db.name
table = tilde_decode(request.url_vars["table"])
database_name = db.name
table_name = tilde_decode(request.url_vars["table"])
# Handle POST to a canned query
canned_query = await self.ds.get_canned_query(database, table, request.actor)
canned_query = await self.ds.get_canned_query(
database_name, table_name, request.actor
)
assert canned_query, "You may only POST to a canned query"
return await QueryView(self.ds).data(
request,
canned_query["sql"],
metadata=canned_query,
editable=False,
canned_query=table,
canned_query=table_name,
named_parameters=canned_query.get("params"),
write=bool(canned_query.get("write")),
)
@ -150,45 +152,47 @@ class TableView(DataView):
_size=None,
):
database_route = tilde_decode(request.url_vars["database"])
table = tilde_decode(request.url_vars["table"])
table_name = tilde_decode(request.url_vars["table"])
try:
db = self.ds.get_database(route=database_route)
except KeyError:
raise NotFound("Database not found: {}".format(database_route))
database = db.name
database_name = db.name
# If this is a canned query, not a table, then dispatch to QueryView instead
canned_query = await self.ds.get_canned_query(database, table, request.actor)
canned_query = await self.ds.get_canned_query(
database_name, table_name, request.actor
)
if canned_query:
return await QueryView(self.ds).data(
request,
canned_query["sql"],
metadata=canned_query,
editable=False,
canned_query=table,
canned_query=table_name,
named_parameters=canned_query.get("params"),
write=bool(canned_query.get("write")),
)
is_view = bool(await db.get_view_definition(table))
table_exists = bool(await db.table_exists(table))
is_view = bool(await db.get_view_definition(table_name))
table_exists = bool(await db.table_exists(table_name))
# If table or view not found, return 404
if not is_view and not table_exists:
raise NotFound(f"Table not found: {table}")
raise NotFound(f"Table not found: {table_name}")
# Ensure user has permission to view this table
await self.ds.ensure_permissions(
request.actor,
[
("view-table", (database, table)),
("view-database", database),
("view-table", (database_name, table_name)),
("view-database", database_name),
"view-instance",
],
)
private = not await self.ds.permission_allowed(
None, "view-table", (database, table), default=True
None, "view-table", (database_name, table_name), default=True
)
# Handle ?_filter_column and redirect, if present
@ -216,8 +220,8 @@ class TableView(DataView):
)
# Introspect columns and primary keys for table
pks = await db.primary_keys(table)
table_columns = await db.table_columns(table)
pks = await db.primary_keys(table_name)
table_columns = await db.table_columns(table_name)
# Take ?_col= and ?_nocol= into account
specified_columns = await self.columns_to_select(table_columns, pks, request)
@ -248,7 +252,7 @@ class TableView(DataView):
nocount = True
nofacet = True
table_metadata = self.ds.table_metadata(database, table)
table_metadata = self.ds.table_metadata(database_name, table_name)
units = table_metadata.get("units", {})
# Arguments that start with _ and don't contain a __ are
@ -262,7 +266,7 @@ class TableView(DataView):
# Build where clauses from query string arguments
filters = Filters(sorted(filter_args), units, ureg)
where_clauses, params = filters.build_where_clauses(table)
where_clauses, params = filters.build_where_clauses(table_name)
# Execute filters_from_request plugin hooks - including the default
# ones that live in datasette/filters.py
@ -271,8 +275,8 @@ class TableView(DataView):
for hook in pm.hook.filters_from_request(
request=request,
table=table,
database=database,
table=table_name,
database=database_name,
datasette=self.ds,
):
filter_arguments = await await_me_maybe(hook)
@ -284,7 +288,7 @@ class TableView(DataView):
# Deal with custom sort orders
sortable_columns = await self.sortable_columns_for_table(
database, table, use_rowid
database_name, table_name, use_rowid
)
sort = request.args.get("_sort")
sort_desc = request.args.get("_sort_desc")
@ -309,7 +313,7 @@ class TableView(DataView):
order_by = f"{escape_sqlite(sort_desc)} desc"
from_sql = "from {table_name} {where}".format(
table_name=escape_sqlite(table),
table_name=escape_sqlite(table_name),
where=("where {} ".format(" and ".join(where_clauses)))
if where_clauses
else "",
@ -422,7 +426,7 @@ class TableView(DataView):
sql_no_order_no_limit = (
"select {select_all_columns} from {table_name} {where}".format(
select_all_columns=select_all_columns,
table_name=escape_sqlite(table),
table_name=escape_sqlite(table_name),
where=where_clause,
)
)
@ -430,7 +434,7 @@ class TableView(DataView):
# This is the SQL that populates the main table on the page
sql = "select {select_specified_columns} from {table_name} {where}{order_by} limit {page_size}{offset}".format(
select_specified_columns=select_specified_columns,
table_name=escape_sqlite(table),
table_name=escape_sqlite(table_name),
where=where_clause,
order_by=order_by,
page_size=page_size + 1,
@ -448,13 +452,13 @@ class TableView(DataView):
if (
not db.is_mutable
and self.ds.inspect_data
and count_sql == f"select count(*) from {table} "
and count_sql == f"select count(*) from {table_name} "
):
# We can use a previously cached table row count
try:
filtered_table_rows_count = self.ds.inspect_data[database]["tables"][
table
]["count"]
filtered_table_rows_count = self.ds.inspect_data[database_name][
"tables"
][table_name]["count"]
except KeyError:
pass
@ -484,10 +488,10 @@ class TableView(DataView):
klass(
self.ds,
request,
database,
database_name,
sql=sql_no_order_no_limit,
params=params,
table=table,
table=table_name,
metadata=table_metadata,
row_count=filtered_table_rows_count,
)
@ -527,7 +531,7 @@ class TableView(DataView):
# Expand labeled columns if requested
expanded_columns = []
expandable_columns = await self.expandable_columns(database, table)
expandable_columns = await self.expandable_columns(database_name, table_name)
columns_to_expand = None
try:
all_labels = value_as_boolean(request.args.get("_labels", ""))
@ -554,7 +558,9 @@ class TableView(DataView):
values = [row[column_index] for row in rows]
# Expand them
expanded_labels.update(
await self.ds.expand_foreign_keys(database, table, column, values)
await self.ds.expand_foreign_keys(
database_name, table_name, column, values
)
)
if expanded_labels:
# Rewrite the rows
@ -621,21 +627,21 @@ class TableView(DataView):
display_columns, display_rows = await display_columns_and_rows(
self.ds,
database,
table,
database_name,
table_name,
results.description,
rows,
link_column=not is_view,
truncate_cells=self.ds.setting("truncate_cells_html"),
sortable_columns=await self.sortable_columns_for_table(
database, table, use_rowid=True
database_name, table_name, use_rowid=True
),
)
metadata = (
(self.ds.metadata("databases") or {})
.get(database, {})
.get(database_name, {})
.get("tables", {})
.get(table, {})
.get(table_name, {})
)
self.ds.update_with_inherited_metadata(metadata)
@ -661,8 +667,8 @@ class TableView(DataView):
links = []
for hook in pm.hook.table_actions(
datasette=self.ds,
table=table,
database=database,
table=table_name,
database=database_name,
actor=request.actor,
request=request,
):
@ -703,13 +709,13 @@ class TableView(DataView):
"sort_desc": sort_desc,
"disable_sort": is_view,
"custom_table_templates": [
f"_table-{to_css_class(database)}-{to_css_class(table)}.html",
f"_table-table-{to_css_class(database)}-{to_css_class(table)}.html",
f"_table-{to_css_class(database_name)}-{to_css_class(table_name)}.html",
f"_table-table-{to_css_class(database_name)}-{to_css_class(table_name)}.html",
"_table.html",
],
"metadata": metadata,
"view_definition": await db.get_view_definition(table),
"table_definition": await db.get_table_definition(table),
"view_definition": await db.get_view_definition(table_name),
"table_definition": await db.get_table_definition(table_name),
"datasette_allow_facet": "true"
if self.ds.setting("allow_facet")
else "false",
@ -719,8 +725,8 @@ class TableView(DataView):
return (
{
"database": database,
"table": table,
"database": database_name,
"table": table_name,
"is_view": is_view,
"human_description_en": human_description_en,
"rows": rows[:page_size],
@ -738,12 +744,12 @@ class TableView(DataView):
"next_url": next_url,
"private": private,
"allow_execute_sql": await self.ds.permission_allowed(
request.actor, "execute-sql", database, default=True
request.actor, "execute-sql", database_name, default=True
),
},
extra_template,
(
f"table-{to_css_class(database)}-{to_css_class(table)}.html",
f"table-{to_css_class(database_name)}-{to_css_class(table_name)}.html",
"table.html",
),
)
@ -766,8 +772,8 @@ async def _sql_params_pks(db, table, pk_values):
async def display_columns_and_rows(
datasette,
database,
table,
database_name,
table_name,
description,
rows,
link_column=False,
@ -776,11 +782,13 @@ async def display_columns_and_rows(
):
"""Returns columns, rows for specified table - including fancy foreign key treatment"""
sortable_columns = sortable_columns or set()
db = datasette.databases[database]
table_metadata = datasette.table_metadata(database, table)
db = datasette.databases[database_name]
table_metadata = datasette.table_metadata(database_name, table_name)
column_descriptions = table_metadata.get("columns") or {}
column_details = {col.name: col for col in await db.table_column_details(table)}
pks = await db.primary_keys(table)
column_details = {
col.name: col for col in await db.table_column_details(table_name)
}
pks = await db.primary_keys(table_name)
pks_for_display = pks
if not pks_for_display:
pks_for_display = ["rowid"]
@ -805,7 +813,8 @@ async def display_columns_and_rows(
)
column_to_foreign_key_table = {
fk["column"]: fk["other_table"] for fk in await db.foreign_keys_for_table(table)
fk["column"]: fk["other_table"]
for fk in await db.foreign_keys_for_table(table_name)
}
cell_rows = []
@ -826,7 +835,7 @@ async def display_columns_and_rows(
"value": markupsafe.Markup(
'<a href="{table_path}/{flat_pks_quoted}">{flat_pks}</a>'.format(
base_url=base_url,
table_path=datasette.urls.table(database, table),
table_path=datasette.urls.table(database_name, table_name),
flat_pks=str(markupsafe.escape(pk_path)),
flat_pks_quoted=path_from_row_pks(row, pks, not pks),
)
@ -847,8 +856,8 @@ async def display_columns_and_rows(
for candidate in pm.hook.render_cell(
value=value,
column=column,
table=table,
database=database,
table=table_name,
database=database_name,
datasette=datasette,
):
candidate = await await_me_maybe(candidate)
@ -862,8 +871,8 @@ async def display_columns_and_rows(
display_value = markupsafe.Markup(
'<a class="blob-download" href="{}"{}>&lt;Binary:&nbsp;{:,}&nbsp;byte{}&gt;</a>'.format(
datasette.urls.row_blob(
database,
table,
database_name,
table_name,
path_from_row_pks(row, pks, not pks),
column,
),
@ -883,7 +892,7 @@ async def display_columns_and_rows(
link_template = LINK_WITH_LABEL if (label != value) else LINK_WITH_VALUE
display_value = markupsafe.Markup(
link_template.format(
database=database,
database=database_name,
base_url=base_url,
table=tilde_encode(other_table),
link_id=tilde_encode(str(value)),