github/datasette
1
0
Fork 0
mirror of https://github.com/simonw/datasette.git synced 2025-12-10 16:51:24 +01:00
Code Issues Projects Releases Packages Wiki Activity

Refactoring: renamed "name" variable to "database"

Browse source
This commit is contained in:
Simon Willison 2018-08-28 11:17:13 +01:00
commit fbf446965b
No known key found for this signature in database
GPG key ID: 17E2DEA2588B7F52
3 changed files with 66 additions and 66 deletions
Download patch file Download diff file Expand all files Collapse all files

34
datasette/views/base.py
View file

@ -166,13 +166,13 @@ class BaseView(RenderMixin):
assert NotImplemented assert NotImplemented
async def get(self, request, db_name, **kwargs): async def get(self, request, db_name, **kwargs):
name, hash, should_redirect = self.resolve_db_name(db_name, **kwargs) database, hash, should_redirect = self.resolve_db_name(db_name, **kwargs)
if should_redirect: if should_redirect:
return self.redirect(request, should_redirect) return self.redirect(request, should_redirect)
return await self.view_get(request, name, hash, **kwargs) return await self.view_get(request, database, hash, **kwargs)
async def as_csv(self, request, name, hash, **kwargs): async def as_csv(self, request, database, hash, **kwargs):
stream = request.args.get("_stream") stream = request.args.get("_stream")
if stream: if stream:
# Some quick sanity checks # Some quick sanity checks
@ -186,7 +186,7 @@ class BaseView(RenderMixin):
# Fetch the first page # Fetch the first page
try: try:
response_or_template_contexts = await self.data( response_or_template_contexts = await self.data(
request, name, hash, **kwargs request, database, hash, **kwargs
) )
if isinstance(response_or_template_contexts, response.HTTPResponse): if isinstance(response_or_template_contexts, response.HTTPResponse):
return response_or_template_contexts return response_or_template_contexts
@ -223,7 +223,7 @@ class BaseView(RenderMixin):
kwargs["_next"] = next kwargs["_next"] = next
if not first: if not first:
data, extra_template_data, templates = await self.data( data, extra_template_data, templates = await self.data(
request, name, hash, **kwargs request, database, hash, **kwargs
) )
if first: if first:
writer.writerow(headings) writer.writerow(headings)
@ -255,7 +255,7 @@ class BaseView(RenderMixin):
if request.args.get("_dl", None): if request.args.get("_dl", None):
content_type = "text/csv; charset=utf-8" content_type = "text/csv; charset=utf-8"
disposition = 'attachment; filename="{}.csv"'.format( disposition = 'attachment; filename="{}.csv"'.format(
kwargs.get('table', name) kwargs.get('table', database)
) )
headers["Content-Disposition"] = disposition headers["Content-Disposition"] = disposition
@ -265,7 +265,7 @@ class BaseView(RenderMixin):
content_type=content_type content_type=content_type
) )
async def view_get(self, request, name, hash, **kwargs): async def view_get(self, request, database, hash, **kwargs):
# If ?_format= is provided, use that as the format # If ?_format= is provided, use that as the format
_format = request.args.get("_format", None) _format = request.args.get("_format", None)
if not _format: if not _format:
@ -275,7 +275,7 @@ class BaseView(RenderMixin):
table_and_format=urllib.parse.unquote_plus( table_and_format=urllib.parse.unquote_plus(
kwargs["table_and_format"] kwargs["table_and_format"]
), ),
table_exists=lambda t: self.ds.table_exists(name, t) table_exists=lambda t: self.ds.table_exists(database, t)
) )
_format = _format or _ext_format _format = _format or _ext_format
kwargs["table"] = table kwargs["table"] = table
@ -286,7 +286,7 @@ class BaseView(RenderMixin):
) )
if _format == "csv": if _format == "csv":
return await self.as_csv(request, name, hash, **kwargs) return await self.as_csv(request, database, hash, **kwargs)
if _format is None: if _format is None:
# HTML views default to expanding all forign key labels # HTML views default to expanding all forign key labels
@ -298,7 +298,7 @@ class BaseView(RenderMixin):
templates = [] templates = []
try: try:
response_or_template_contexts = await self.data( response_or_template_contexts = await self.data(
request, name, hash, **kwargs request, database, hash, **kwargs
) )
if isinstance(response_or_template_contexts, response.HTTPResponse): if isinstance(response_or_template_contexts, response.HTTPResponse):
return response_or_template_contexts return response_or_template_contexts
@ -381,7 +381,7 @@ class BaseView(RenderMixin):
data = { data = {
"ok": False, "ok": False,
"error": error, "error": error,
"database": name, "database": database,
"database_hash": hash, "database_hash": hash,
} }
elif shape == "array": elif shape == "array":
@ -458,7 +458,7 @@ class BaseView(RenderMixin):
return r return r
async def custom_sql( async def custom_sql(
self, request, name, hash, sql, editable=True, canned_query=None, self, request, database, hash, sql, editable=True, canned_query=None,
metadata=None, _size=None metadata=None, _size=None
): ):
params = request.raw_args params = request.raw_args
@ -484,16 +484,16 @@ class BaseView(RenderMixin):
if _size: if _size:
extra_args["page_size"] = _size extra_args["page_size"] = _size
results = await self.ds.execute( results = await self.ds.execute(
name, sql, params, truncate=True, **extra_args database, sql, params, truncate=True, **extra_args
) )
columns = [r[0] for r in results.description] columns = [r[0] for r in results.description]
templates = ["query-{}.html".format(to_css_class(name)), "query.html"] templates = ["query-{}.html".format(to_css_class(database)), "query.html"]
if canned_query: if canned_query:
templates.insert( templates.insert(
0, 0,
"query-{}-{}.html".format( "query-{}-{}.html".format(
to_css_class(name), to_css_class(canned_query) to_css_class(database), to_css_class(canned_query)
), ),
) )
@ -508,7 +508,7 @@ class BaseView(RenderMixin):
value=value, value=value,
column=column, column=column,
table=None, table=None,
database=name, database=database,
datasette=self.ds, datasette=self.ds,
) )
if plugin_value is not None: if plugin_value is not None:
@ -536,7 +536,7 @@ class BaseView(RenderMixin):
} }
return { return {
"database": name, "database": database,
"rows": results.rows, "rows": results.rows,
"truncated": results.truncated, "truncated": results.truncated,
"columns": columns, "columns": columns,

18
datasette/views/database.py
View file

@ -9,41 +9,41 @@ from .base import BaseView, DatasetteError
class DatabaseView(BaseView): class DatabaseView(BaseView):
async def data(self, request, name, hash, default_labels=False, _size=None): async def data(self, request, database, hash, default_labels=False, _size=None):
if request.args.get("sql"): if request.args.get("sql"):
if not self.ds.config("allow_sql"): if not self.ds.config("allow_sql"):
raise DatasetteError("sql= is not allowed", status=400) raise DatasetteError("sql= is not allowed", status=400)
sql = request.raw_args.pop("sql") sql = request.raw_args.pop("sql")
validate_sql_select(sql) validate_sql_select(sql)
return await self.custom_sql(request, name, hash, sql, _size=_size) return await self.custom_sql(request, database, hash, sql, _size=_size)
info = self.ds.inspect()[name] info = self.ds.inspect()[database]
metadata = (self.ds.metadata("databases") or {}).get(name, {}) metadata = (self.ds.metadata("databases") or {}).get(database, {})
self.ds.update_with_inherited_metadata(metadata) self.ds.update_with_inherited_metadata(metadata)
tables = list(info["tables"].values()) tables = list(info["tables"].values())
tables.sort(key=lambda t: (t["hidden"], t["name"])) tables.sort(key=lambda t: (t["hidden"], t["name"]))
return { return {
"database": name, "database": database,
"tables": tables, "tables": tables,
"hidden_count": len([t for t in tables if t["hidden"]]), "hidden_count": len([t for t in tables if t["hidden"]]),
"views": info["views"], "views": info["views"],
"queries": self.ds.get_canned_queries(name), "queries": self.ds.get_canned_queries(database),
}, { }, {
"database_hash": hash, "database_hash": hash,
"show_hidden": request.args.get("_show_hidden"), "show_hidden": request.args.get("_show_hidden"),
"editable": True, "editable": True,
"metadata": metadata, "metadata": metadata,
}, ( }, (
"database-{}.html".format(to_css_class(name)), "database.html" "database-{}.html".format(to_css_class(database)), "database.html"
) )
class DatabaseDownload(BaseView): class DatabaseDownload(BaseView):
async def view_get(self, request, name, hash, **kwargs): async def view_get(self, request, database, hash, **kwargs):
if not self.ds.config("allow_download"): if not self.ds.config("allow_download"):
raise DatasetteError("Database download is forbidden", status=403) raise DatasetteError("Database download is forbidden", status=403)
filepath = self.ds.inspect()[name]["file"] filepath = self.ds.inspect()[database]["file"]
return await response.file_stream( return await response.file_stream(
filepath, filepath,
filename=os.path.basename(filepath), filename=os.path.basename(filepath),

80
datasette/views/table.py
View file

@ -233,12 +233,12 @@ class RowTableShared(BaseView):
class TableView(RowTableShared): class TableView(RowTableShared):
async def data(self, request, name, hash, table, default_labels=False, _next=None, _size=None): async def data(self, request, database, hash, table, default_labels=False, _next=None, _size=None):
canned_query = self.ds.get_canned_query(name, table) canned_query = self.ds.get_canned_query(database, table)
if canned_query is not None: if canned_query is not None:
return await self.custom_sql( return await self.custom_sql(
request, request,
name, database,
hash, hash,
canned_query["sql"], canned_query["sql"],
metadata=canned_query, metadata=canned_query,
@ -246,9 +246,9 @@ class TableView(RowTableShared):
canned_query=table, canned_query=table,
) )
is_view = bool(await self.ds.get_view_definition(name, table)) is_view = bool(await self.ds.get_view_definition(database, table))
info = self.ds.inspect() info = self.ds.inspect()
table_info = info[name]["tables"].get(table) or {} table_info = info[database]["tables"].get(table) or {}
if not is_view and not table_info: if not is_view and not table_info:
raise NotFound("Table not found: {}".format(table)) raise NotFound("Table not found: {}".format(table))
@ -309,14 +309,14 @@ class TableView(RowTableShared):
forward_querystring=False, forward_querystring=False,
) )
table_metadata = self.table_metadata(name, table) table_metadata = self.table_metadata(database, table)
units = table_metadata.get("units", {}) units = table_metadata.get("units", {})
filters = Filters(sorted(other_args.items()), units, ureg) filters = Filters(sorted(other_args.items()), units, ureg)
where_clauses, params = filters.build_where_clauses() where_clauses, params = filters.build_where_clauses()
# _search support: # _search support:
fts_table = table_metadata.get( fts_table = table_metadata.get(
"fts_table", info[name]["tables"].get(table, {}).get("fts_table") "fts_table", info[database]["tables"].get(table, {}).get("fts_table")
) )
fts_pk = table_metadata.get("fts_pk", "rowid") fts_pk = table_metadata.get("fts_pk", "rowid")
search_args = dict( search_args = dict(
@ -338,7 +338,7 @@ class TableView(RowTableShared):
params["search"] = search params["search"] = search
else: else:
# More complex: search against specific columns # More complex: search against specific columns
valid_columns = set(info[name]["tables"][fts_table]["columns"]) valid_columns = set(info[database]["tables"][fts_table]["columns"])
for i, (key, search_text) in enumerate(search_args.items()): for i, (key, search_text) in enumerate(search_args.items()):
search_col = key.split("_search_", 1)[1] search_col = key.split("_search_", 1)[1]
if search_col not in valid_columns: if search_col not in valid_columns:
@ -363,7 +363,7 @@ class TableView(RowTableShared):
if not is_view: if not is_view:
table_rows_count = table_info["count"] table_rows_count = table_info["count"]
sortable_columns = self.sortable_columns_for_table(name, table, use_rowid) sortable_columns = self.sortable_columns_for_table(database, table, use_rowid)
# Allow for custom sort order # Allow for custom sort order
sort = special_args.get("_sort") sort = special_args.get("_sort")
@ -477,7 +477,7 @@ class TableView(RowTableShared):
table_name=escape_sqlite(table), table_name=escape_sqlite(table),
where=where_clause, where=where_clause,
) )
return await self.custom_sql(request, name, hash, sql, editable=True) return await self.custom_sql(request, database, hash, sql, editable=True)
extra_args = {} extra_args = {}
# Handle ?_size=500 # Handle ?_size=500
@ -515,7 +515,7 @@ class TableView(RowTableShared):
extra_args["custom_time_limit"] = int(request.raw_args["_timelimit"]) extra_args["custom_time_limit"] = int(request.raw_args["_timelimit"])
results = await self.ds.execute( results = await self.ds.execute(
name, sql, params, truncate=True, **extra_args database, sql, params, truncate=True, **extra_args
) )
# facets support # facets support
@ -545,7 +545,7 @@ class TableView(RowTableShared):
) )
try: try:
facet_rows_results = await self.ds.execute( facet_rows_results = await self.ds.execute(
name, facet_sql, params, database, facet_sql, params,
truncate=False, truncate=False,
custom_time_limit=self.ds.config("facet_time_limit_ms"), custom_time_limit=self.ds.config("facet_time_limit_ms"),
) )
@ -559,7 +559,7 @@ class TableView(RowTableShared):
# Attempt to expand foreign keys into labels # Attempt to expand foreign keys into labels
values = [row["value"] for row in facet_rows] values = [row["value"] for row in facet_rows]
expanded = (await self.expand_foreign_keys( expanded = (await self.expand_foreign_keys(
name, table, column, values database, table, column, values
)) ))
for row in facet_rows: for row in facet_rows:
selected = str(other_args.get(column)) == str(row["value"]) selected = str(other_args.get(column)) == str(row["value"])
@ -593,7 +593,7 @@ class TableView(RowTableShared):
# Expand labeled columns if requested # Expand labeled columns if requested
expanded_columns = [] expanded_columns = []
expandable_columns = self.expandable_columns(name, table) expandable_columns = self.expandable_columns(database, table)
columns_to_expand = None columns_to_expand = None
try: try:
all_labels = value_as_boolean(special_args.get("_labels", "")) all_labels = value_as_boolean(special_args.get("_labels", ""))
@ -620,7 +620,7 @@ class TableView(RowTableShared):
values = [row[column_index] for row in rows] values = [row[column_index] for row in rows]
# Expand them # Expand them
expanded_labels.update(await self.expand_foreign_keys( expanded_labels.update(await self.expand_foreign_keys(
name, table, column, values database, table, column, values
)) ))
if expanded_labels: if expanded_labels:
# Rewrite the rows # Rewrite the rows
@ -672,7 +672,7 @@ class TableView(RowTableShared):
if count_sql: if count_sql:
try: try:
count_rows = list(await self.ds.execute( count_rows = list(await self.ds.execute(
name, count_sql, from_sql_params database, count_sql, from_sql_params
)) ))
filtered_table_rows_count = count_rows[0][0] filtered_table_rows_count = count_rows[0][0]
except InterruptedError: except InterruptedError:
@ -701,7 +701,7 @@ class TableView(RowTableShared):
distinct_values = None distinct_values = None
try: try:
distinct_values = await self.ds.execute( distinct_values = await self.ds.execute(
name, suggested_facet_sql, from_sql_params, database, suggested_facet_sql, from_sql_params,
truncate=False, truncate=False,
custom_time_limit=self.ds.config("facet_suggest_time_limit_ms"), custom_time_limit=self.ds.config("facet_suggest_time_limit_ms"),
) )
@ -736,14 +736,14 @@ class TableView(RowTableShared):
async def extra_template(): async def extra_template():
display_columns, display_rows = await self.display_columns_and_rows( display_columns, display_rows = await self.display_columns_and_rows(
name, database,
table, table,
results.description, results.description,
rows, rows,
link_column=not is_view, link_column=not is_view,
truncate_cells=self.ds.config("truncate_cells_html"), truncate_cells=self.ds.config("truncate_cells_html"),
) )
metadata = (self.ds.metadata("databases") or {}).get(name, {}).get( metadata = (self.ds.metadata("databases") or {}).get(database, {}).get(
"tables", {} "tables", {}
).get( ).get(
table, {} table, {}
@ -775,20 +775,20 @@ class TableView(RowTableShared):
"disable_sort": is_view, "disable_sort": is_view,
"custom_rows_and_columns_templates": [ "custom_rows_and_columns_templates": [
"_rows_and_columns-{}-{}.html".format( "_rows_and_columns-{}-{}.html".format(
to_css_class(name), to_css_class(table) to_css_class(database), to_css_class(table)
), ),
"_rows_and_columns-table-{}-{}.html".format( "_rows_and_columns-table-{}-{}.html".format(
to_css_class(name), to_css_class(table) to_css_class(database), to_css_class(table)
), ),
"_rows_and_columns.html", "_rows_and_columns.html",
], ],
"metadata": metadata, "metadata": metadata,
"view_definition": await self.ds.get_view_definition(name, table), "view_definition": await self.ds.get_view_definition(database, table),
"table_definition": await self.ds.get_table_definition(name, table), "table_definition": await self.ds.get_table_definition(database, table),
} }
return { return {
"database": name, "database": database,
"table": table, "table": table,
"is_view": is_view, "is_view": is_view,
"human_description_en": human_description_en, "human_description_en": human_description_en,
@ -807,16 +807,16 @@ class TableView(RowTableShared):
"next": next_value and str(next_value) or None, "next": next_value and str(next_value) or None,
"next_url": next_url, "next_url": next_url,
}, extra_template, ( }, extra_template, (
"table-{}-{}.html".format(to_css_class(name), to_css_class(table)), "table-{}-{}.html".format(to_css_class(database), to_css_class(table)),
"table.html", "table.html",
) )
class RowView(RowTableShared): class RowView(RowTableShared):
async def data(self, request, name, hash, table, pk_path, default_labels=False): async def data(self, request, database, hash, table, pk_path, default_labels=False):
pk_values = urlsafe_components(pk_path) pk_values = urlsafe_components(pk_path)
info = self.ds.inspect()[name] info = self.ds.inspect()[database]
table_info = info["tables"].get(table) or {} table_info = info["tables"].get(table) or {}
pks = table_info.get("primary_keys") or [] pks = table_info.get("primary_keys") or []
use_rowid = not pks use_rowid = not pks
@ -832,7 +832,7 @@ class RowView(RowTableShared):
for i, pk_value in enumerate(pk_values): for i, pk_value in enumerate(pk_values):
params["p{}".format(i)] = pk_value params["p{}".format(i)] = pk_value
results = await self.ds.execute( results = await self.ds.execute(
name, sql, params, truncate=True database, sql, params, truncate=True
) )
columns = [r[0] for r in results.description] columns = [r[0] for r in results.description]
rows = list(results.rows) rows = list(results.rows)
@ -841,7 +841,7 @@ class RowView(RowTableShared):
async def template_data(): async def template_data():
display_columns, display_rows = await self.display_columns_and_rows( display_columns, display_rows = await self.display_columns_and_rows(
name, database,
table, table,
results.description, results.description,
rows, rows,
@ -853,22 +853,22 @@ class RowView(RowTableShared):
return { return {
"database_hash": hash, "database_hash": hash,
"foreign_key_tables": await self.foreign_key_tables( "foreign_key_tables": await self.foreign_key_tables(
name, table, pk_values database, table, pk_values
), ),
"display_columns": display_columns, "display_columns": display_columns,
"display_rows": display_rows, "display_rows": display_rows,
"custom_rows_and_columns_templates": [ "custom_rows_and_columns_templates": [
"_rows_and_columns-{}-{}.html".format( "_rows_and_columns-{}-{}.html".format(
to_css_class(name), to_css_class(table) to_css_class(database), to_css_class(table)
), ),
"_rows_and_columns-row-{}-{}.html".format( "_rows_and_columns-row-{}-{}.html".format(
to_css_class(name), to_css_class(table) to_css_class(database), to_css_class(table)
), ),
"_rows_and_columns.html", "_rows_and_columns.html",
], ],
"metadata": ( "metadata": (
self.ds.metadata("databases") or {} self.ds.metadata("databases") or {}
).get(name, {}).get( ).get(database, {}).get(
"tables", {} "tables", {}
).get( ).get(
table, {} table, {}
@ -876,29 +876,29 @@ class RowView(RowTableShared):
} }
data = { data = {
"database": name, "database": database,
"table": table, "table": table,
"rows": rows, "rows": rows,
"columns": columns, "columns": columns,
"primary_keys": pks, "primary_keys": pks,
"primary_key_values": pk_values, "primary_key_values": pk_values,
"units": self.table_metadata(name, table).get("units", {}), "units": self.table_metadata(database, table).get("units", {}),
} }
if "foreign_key_tables" in (request.raw_args.get("_extras") or "").split(","): if "foreign_key_tables" in (request.raw_args.get("_extras") or "").split(","):
data["foreign_key_tables"] = await self.foreign_key_tables( data["foreign_key_tables"] = await self.foreign_key_tables(
name, table, pk_values database, table, pk_values
) )
return data, template_data, ( return data, template_data, (
"row-{}-{}.html".format(to_css_class(name), to_css_class(table)), "row.html" "row-{}-{}.html".format(to_css_class(database), to_css_class(table)), "row.html"
) )
async def foreign_key_tables(self, name, table, pk_values): async def foreign_key_tables(self, database, table, pk_values):
if len(pk_values) != 1: if len(pk_values) != 1:
return [] return []
table_info = self.ds.inspect()[name]["tables"].get(table) table_info = self.ds.inspect()[database]["tables"].get(table)
if not table_info: if not table_info:
return [] return []
@ -916,7 +916,7 @@ class RowView(RowTableShared):
] ]
) )
try: try:
rows = list(await self.ds.execute(name, sql, {"id": pk_values[0]})) rows = list(await self.ds.execute(database, sql, {"id": pk_values[0]}))
except sqlite3.OperationalError: except sqlite3.OperationalError:
# Almost certainly hit the timeout # Almost certainly hit the timeout
return [] return []