{"id": "configuration:configuration-reference-settings", "page": "configuration", "ref": "configuration-reference-settings", "title": "Settings", "content": "Settings  can be configured in  datasette.yaml  with the  settings  key: \n                 [[[cog\nfrom metadata_doc import config_example\nimport textwrap\nconfig_example(cog, textwrap.dedent(\n  \"\"\"\n    # inside datasette.yaml\n    settings:\n      default_allow_sql: off\n      default_page_size: 50\n    \"\"\").strip()\n  ) \n                 ]]] \n                 [[[end]]] \n                 The full list of settings is available in the  settings documentation . Settings can also be passed to Datasette using one or more  --setting name value  command line options.`", "breadcrumbs": "[\"Configuration\", null]", "references": "[]"}
{"id": "settings:id1", "page": "settings", "ref": "id1", "title": "Settings", "content": "", "breadcrumbs": "[]", "references": "[]"}
{"id": "settings:id2", "page": "settings", "ref": "id2", "title": "Settings", "content": "The following options can be set using  --setting name value , or by storing them in the  settings.json  file for use with  Configuration directory mode .", "breadcrumbs": "[\"Settings\"]", "references": "[]"}
{"id": "metadata:metadata-sortable-columns", "page": "metadata", "ref": "metadata-sortable-columns", "title": "Setting which columns can be used for sorting", "content": "Datasette allows any column to be used for sorting by default. If you need to\n                control which columns are available for sorting you can do so using the optional\n                 sortable_columns  key: \n             [[[cog\nmetadata_example(cog, {\n    \"databases\": {\n        \"database1\": {\n            \"tables\": {\n                \"example_table\": {\n                    \"sortable_columns\": [\n                        \"height\",\n                        \"weight\"\n                    ]\n                }\n            }\n        }\n    }\n}) \n             ]]] \n             [[[end]]] \n             This will restrict sorting of  example_table  to just the  height  and\n                 weight  columns. \n             You can also disable sorting entirely by setting  \"sortable_columns\": [] \n             You can use  sortable_columns  to enable specific sort orders for a view called  name_of_view  in the database  my_database  like so: \n             [[[cog\nmetadata_example(cog, {\n    \"databases\": {\n        \"my_database\": {\n            \"tables\": {\n                \"name_of_view\": {\n                    \"sortable_columns\": [\n                        \"clicks\",\n                        \"impressions\"\n                    ]\n                }\n            }\n        }\n    }\n}) \n             ]]] \n             [[[end]]]", "breadcrumbs": "[\"Metadata\"]", "references": "[]"}
{"id": "contributing:devenvironment", "page": "contributing", "ref": "devenvironment", "title": "Setting up a development environment", "content": "If you have Python 3.8 or higher installed on your computer (on OS X the quickest way to do this  is using homebrew ) you can install an editable copy of Datasette using the following steps. \n             If you want to use GitHub to publish your changes, first  create a fork of datasette  under your own GitHub account. \n             Now clone that repository somewhere on your computer: \n             git clone git@github.com:YOURNAME/datasette \n             If you want to get started without creating your own fork, you can do this instead: \n             git clone git@github.com:simonw/datasette \n             The next step is to create a virtual environment for your project and use it to install Datasette's dependencies: \n             cd datasette\n# Create a virtual environment in ./venv\npython3 -m venv ./venv\n# Now activate the virtual environment, so pip can install into it\nsource venv/bin/activate\n# Install Datasette and its testing dependencies\npython3 -m pip install -e '.[test]' \n             That last line does most of the work:  pip install -e  means \"install this package in a way that allows me to edit the source code in place\". The  .[test]  option means \"use the setup.py in this directory and install the optional testing dependencies as well\".", "breadcrumbs": "[\"Contributing\"]", "references": "[{\"href\": \"https://docs.python-guide.org/starting/install3/osx/\", \"label\": \"is using homebrew\"}, {\"href\": \"https://github.com/simonw/datasette/fork\", \"label\": \"create a fork of datasette\"}]"}
{"id": "testing_plugins:testing-plugins-datasette-test-instance", "page": "testing_plugins", "ref": "testing-plugins-datasette-test-instance", "title": "Setting up a Datasette test instance", "content": "The above example shows the easiest way to start writing tests against a Datasette instance: \n             from datasette.app import Datasette\nimport pytest\n\n\n@pytest.mark.asyncio\nasync def test_plugin_is_installed():\n    datasette = Datasette(memory=True)\n    response = await datasette.client.get(\"/-/plugins.json\")\n    assert response.status_code == 200 \n             Creating a  Datasette()  instance like this as useful shortcut in tests, but there is one detail you need to be aware of. It's important to ensure that the async method  .invoke_startup()  is called on that instance. You can do that like this: \n             datasette = Datasette(memory=True)\nawait datasette.invoke_startup() \n             This method registers any  startup(datasette)  or  prepare_jinja2_environment(env, datasette)  plugins that might themselves need to make async calls. \n             If you are using  await datasette.client.get()  and similar methods then you don't need to worry about this - Datasette automatically calls  invoke_startup()  the first time it handles a request.", "breadcrumbs": "[\"Testing plugins\"]", "references": "[]"}
{"id": "internals:internals-response-set-cookie", "page": "internals", "ref": "internals-response-set-cookie", "title": "Setting cookies with response.set_cookie()", "content": "To set cookies on the response, use the  response.set_cookie(...)  method. The method signature looks like this: \n                 def set_cookie(\n    self,\n    key,\n    value=\"\",\n    max_age=None,\n    expires=None,\n    path=\"/\",\n    domain=None,\n    secure=False,\n    httponly=False,\n    samesite=\"lax\",\n): ... \n                 You can use this with  datasette.sign()  to set signed cookies. Here's how you would set the  ds_actor cookie  for use with Datasette  authentication : \n                 response = Response.redirect(\"/\")\nresponse.set_cookie(\n    \"ds_actor\",\n    datasette.sign({\"a\": {\"id\": \"cleopaws\"}}, \"actor\"),\n)\nreturn response", "breadcrumbs": "[\"Internals for plugins\", \"Response class\"]", "references": "[]"}
{"id": "metadata:metadata-default-sort", "page": "metadata", "ref": "metadata-default-sort", "title": "Setting a default sort order", "content": "By default Datasette tables are sorted by primary key. You can over-ride this default for a specific table using the  \"sort\"  or  \"sort_desc\"  metadata properties: \n             [[[cog\nmetadata_example(cog, {\n    \"databases\": {\n        \"mydatabase\": {\n            \"tables\": {\n                \"example_table\": {\n                    \"sort\": \"created\"\n                }\n            }\n        }\n    }\n}) \n             ]]] \n             [[[end]]] \n             Or use  \"sort_desc\"  to sort in descending order: \n             [[[cog\nmetadata_example(cog, {\n    \"databases\": {\n        \"mydatabase\": {\n            \"tables\": {\n                \"example_table\": {\n                    \"sort_desc\": \"created\"\n                }\n            }\n        }\n    }\n}) \n             ]]] \n             [[[end]]]", "breadcrumbs": "[\"Metadata\"]", "references": "[]"}
{"id": "metadata:metadata-page-size", "page": "metadata", "ref": "metadata-page-size", "title": "Setting a custom page size", "content": "Datasette defaults to displaying 100 rows per page, for both tables and views. You can change this default page size on a per-table or per-view basis using the  \"size\"  key in  metadata.json : \n             [[[cog\nmetadata_example(cog, {\n    \"databases\": {\n        \"mydatabase\": {\n            \"tables\": {\n                \"example_table\": {\n                    \"size\": 10\n                }\n            }\n        }\n    }\n}) \n             ]]] \n             [[[end]]] \n             This size can still be over-ridden by passing e.g.  ?_size=50  in the query string.", "breadcrumbs": "[\"Metadata\"]", "references": "[]"}
{"id": "custom_templates:customization-static-files", "page": "custom_templates", "ref": "customization-static-files", "title": "Serving static files", "content": "Datasette can serve static files for you, using the  --static  option.\n                Consider the following directory structure: \n             metadata.json\nstatic-files/styles.css\nstatic-files/app.js \n             You can start Datasette using  --static assets:static-files/  to serve those\n                files from the  /assets/  mount point: \n             datasette --config datasette.yaml --static assets:static-files/ --memory \n             The following URLs will now serve the content from those CSS and JS files: \n             http://localhost:8001/assets/styles.css\nhttp://localhost:8001/assets/app.js \n             You can reference those files from  datasette.yaml  like this, see  custom CSS and JavaScript  for more details: \n             [[[cog\nfrom metadata_doc import config_example\nconfig_example(cog, \"\"\"\n    extra_css_urls:\n    - /assets/styles.css\n    extra_js_urls:\n    - /assets/app.js\n\"\"\") \n             ]]] \n             [[[end]]]", "breadcrumbs": "[\"Custom pages and templates\"]", "references": "[]"}
{"id": "javascript_plugins:javascript-datasette-manager-selectors", "page": "javascript_plugins", "ref": "javascript-datasette-manager-selectors", "title": "Selectors", "content": "These are available on the  selectors  property of the  datasetteManager  object. \n             const DOM_SELECTORS = {\n  /** Should have one match */\n  jsonExportLink: \".export-links a[href*=json]\",\n\n  /** Event listeners that go outside of the main table, e.g. existing scroll listener */\n  tableWrapper: \".table-wrapper\",\n  table: \"table.rows-and-columns\",\n  aboveTablePanel: \".above-table-panel\",\n\n  // These could have multiple matches\n  /** Used for selecting table headers. Use makeColumnActions if you want to add menu items. */\n  tableHeaders: `table.rows-and-columns th`,\n\n  /** Used to add \"where\"  clauses to query using direct manipulation */\n  filterRows: \".filter-row\",\n  /** Used to show top available enum values for a column (\"facets\") */\n  facetResults: \".facet-results [data-column]\",\n};", "breadcrumbs": "[\"JavaScript plugins\"]", "references": "[]"}
{"id": "plugins:plugins-installed", "page": "plugins", "ref": "plugins-installed", "title": "Seeing what plugins are installed", "content": "You can see a list of installed plugins by navigating to the  /-/plugins  page of your Datasette instance - for example:  https://fivethirtyeight.datasettes.com/-/plugins \n             You can also use the  datasette plugins  command: \n             datasette plugins \n             Which outputs: \n             [\n    {\n        \"name\": \"datasette_json_html\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": \"0.4.0\"\n    }\n] \n             [[[cog\nfrom datasette import cli\nfrom click.testing import CliRunner\nimport textwrap, json\ncog.out(\"\\n\")\nresult = CliRunner().invoke(cli.cli, [\"plugins\", \"--all\"])\n# cog.out() with text containing newlines was unindenting for some reason\ncog.outl(\"If you run ``datasette plugins --all`` it will include default plugins that ship as part of Datasette:\\n\")\ncog.outl(\".. code-block:: json\\n\")\nplugins = [p for p in json.loads(result.output) if p[\"name\"].startswith(\"datasette.\")]\nindented = textwrap.indent(json.dumps(plugins, indent=4), \"    \")\nfor line in indented.split(\"\\n\"):\n    cog.outl(line)\ncog.out(\"\\n\\n\") \n             ]]] \n             If you run  datasette plugins --all  it will include default plugins that ship as part of Datasette: \n             [\n    {\n        \"name\": \"datasette.actor_auth_cookie\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"actor_from_request\"\n        ]\n    },\n    {\n        \"name\": \"datasette.blob_renderer\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"register_output_renderer\"\n        ]\n    },\n    {\n        \"name\": \"datasette.default_magic_parameters\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"register_magic_parameters\"\n        ]\n    },\n    {\n        \"name\": \"datasette.default_menu_links\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"menu_links\"\n        ]\n    },\n    {\n        \"name\": \"datasette.default_permissions\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"actor_from_request\",\n            \"permission_allowed\",\n            \"register_permissions\",\n            \"skip_csrf\"\n        ]\n    },\n    {\n        \"name\": \"datasette.events\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"register_events\"\n        ]\n    },\n    {\n        \"name\": \"datasette.facets\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"register_facet_classes\"\n        ]\n    },\n    {\n        \"name\": \"datasette.filters\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"filters_from_request\"\n        ]\n    },\n    {\n        \"name\": \"datasette.forbidden\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"forbidden\"\n        ]\n    },\n    {\n        \"name\": \"datasette.handle_exception\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"handle_exception\"\n        ]\n    },\n    {\n        \"name\": \"datasette.publish.cloudrun\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"publish_subcommand\"\n        ]\n    },\n    {\n        \"name\": \"datasette.publish.heroku\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"publish_subcommand\"\n        ]\n    },\n    {\n        \"name\": \"datasette.sql_functions\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": null,\n        \"hooks\": [\n            \"prepare_connection\"\n        ]\n    }\n] \n             [[[end]]] \n             You can add the  --plugins-dir=  option to include any plugins found in that directory. \n             Add  --requirements  to output a list of installed plugins that can then be installed in another Datasette instance using  datasette install -r requirements.txt : \n             datasette plugins --requirements \n             The output will look something like this: \n             datasette-codespaces==0.1.1\ndatasette-graphql==2.2\ndatasette-json-html==1.0.1\ndatasette-pretty-json==0.2.2\ndatasette-x-forwarded-host==0.1 \n             To write that to a  requirements.txt  file, run this: \n             datasette plugins --requirements > requirements.txt", "breadcrumbs": "[\"Plugins\"]", "references": "[{\"href\": \"https://fivethirtyeight.datasettes.com/-/plugins\", \"label\": \"https://fivethirtyeight.datasettes.com/-/plugins\"}]"}
{"id": "changelog:secret-plugin-configuration-options", "page": "changelog", "ref": "secret-plugin-configuration-options", "title": "Secret plugin configuration options", "content": "Plugins like  datasette-auth-github  need a safe way to set secret configuration options. Since the default mechanism for configuring plugins exposes those settings in  /-/metadata  a new mechanism was needed.  Secret configuration values  describes how plugins can now specify that their settings should be read from a file or an environment variable: \n                 {\n    \"plugins\": {\n        \"datasette-auth-github\": {\n            \"client_secret\": {\n                \"$env\": \"GITHUB_CLIENT_SECRET\"\n            }\n        }\n    }\n} \n                 These plugin secrets can be set directly using  datasette publish . See  Custom metadata and plugins  for details. ( #538  and  #543 )", "breadcrumbs": "[\"Changelog\", \"0.29 (2019-07-07)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-auth-github\", \"label\": \"datasette-auth-github\"}, {\"href\": \"https://github.com/simonw/datasette/issues/538\", \"label\": \"#538\"}, {\"href\": \"https://github.com/simonw/datasette/issues/543\", \"label\": \"#543\"}]"}
{"id": "plugins:plugins-configuration-secret", "page": "plugins", "ref": "plugins-configuration-secret", "title": "Secret configuration values", "content": "Some plugins may need configuration that should stay secret - API keys for example. There are two ways in which you can store secret configuration values. \n                 As environment variables . If your secret lives in an environment variable that is available to the Datasette process, you can indicate that the configuration value should be read from that environment variable like so: \n                 [[[cog\nconfig_example(cog, {\n    \"plugins\": {\n        \"datasette-auth-github\": {\n            \"client_secret\": {\n                \"$env\": \"GITHUB_CLIENT_SECRET\"\n            }\n        }\n    }\n}) \n                 ]]] \n                 [[[end]]] \n                 As values in separate files . Your secrets can also live in files on disk. To specify a secret should be read from a file, provide the full file path like this: \n                 [[[cog\nconfig_example(cog, {\n    \"plugins\": {\n        \"datasette-auth-github\": {\n            \"client_secret\": {\n                \"$file\": \"/secrets/client-secret\"\n            }\n        }\n    }\n}) \n                 ]]] \n                 [[[end]]] \n                 If you are publishing your data using the  datasette publish  family of commands, you can use the  --plugin-secret  option to set these secrets at publish time. For example, using Heroku you might run the following command: \n                 datasette publish heroku my_database.db \\\n    --name my-heroku-app-demo \\\n    --install=datasette-auth-github \\\n    --plugin-secret datasette-auth-github client_id your_client_id \\\n    --plugin-secret datasette-auth-github client_secret your_client_secret \n                 This will set the necessary environment variables and add the following to the deployed  metadata.yaml : \n                 [[[cog\nconfig_example(cog, {\n    \"plugins\": {\n        \"datasette-auth-github\": {\n            \"client_id\": {\n                \"$env\": \"DATASETTE_AUTH_GITHUB_CLIENT_ID\"\n            },\n            \"client_secret\": {\n                \"$env\": \"DATASETTE_AUTH_GITHUB_CLIENT_SECRET\"\n            }\n        }\n    }\n}) \n                 ]]] \n                 [[[end]]]", "breadcrumbs": "[\"Plugins\", \"Plugin configuration\"]", "references": "[]"}
{"id": "full_text_search:full-text-search-custom-sql", "page": "full_text_search", "ref": "full-text-search-custom-sql", "title": "Searches using custom SQL", "content": "You can include full-text search results in custom SQL queries. The general pattern with SQLite search is to run the search as a sub-select that returns rowid values, then include those rowids in another part of the query. \n             You can see the syntax for a basic search by running that search on a table page and then clicking \"View and edit SQL\" to see the underlying SQL. For example, consider this search for  manafort is the US FARA database : \n             /fara/FARA_All_ShortForms?_search=manafort \n             If you click  View and edit SQL  you'll see that the underlying SQL looks like this: \n             select\n  rowid,\n  Short_Form_Termination_Date,\n  Short_Form_Date,\n  Short_Form_Last_Name,\n  Short_Form_First_Name,\n  Registration_Number,\n  Registration_Date,\n  Registrant_Name,\n  Address_1,\n  Address_2,\n  City,\n  State,\n  Zip\nfrom\n  FARA_All_ShortForms\nwhere\n  rowid in (\n    select\n      rowid\n    from\n      FARA_All_ShortForms_fts\n    where\n      FARA_All_ShortForms_fts match escape_fts(:search)\n  )\norder by\n  rowid\nlimit\n  101", "breadcrumbs": "[\"Full-text search\"]", "references": "[{\"href\": \"https://fara.datasettes.com/fara/FARA_All_ShortForms?_search=manafort\", \"label\": \"manafort is the US FARA database\"}, {\"href\": \"https://fara.datasettes.com/fara?sql=select%0D%0A++rowid%2C%0D%0A++Short_Form_Termination_Date%2C%0D%0A++Short_Form_Date%2C%0D%0A++Short_Form_Last_Name%2C%0D%0A++Short_Form_First_Name%2C%0D%0A++Registration_Number%2C%0D%0A++Registration_Date%2C%0D%0A++Registrant_Name%2C%0D%0A++Address_1%2C%0D%0A++Address_2%2C%0D%0A++City%2C%0D%0A++State%2C%0D%0A++Zip%0D%0Afrom%0D%0A++FARA_All_ShortForms%0D%0Awhere%0D%0A++rowid+in+%28%0D%0A++++select%0D%0A++++++rowid%0D%0A++++from%0D%0A++++++FARA_All_ShortForms_fts%0D%0A++++where%0D%0A++++++FARA_All_ShortForms_fts+match+escape_fts%28%3Asearch%29%0D%0A++%29%0D%0Aorder+by%0D%0A++rowid%0D%0Alimit%0D%0A++101&search=manafort\", \"label\": \"View and edit SQL\"}]"}
{"id": "contributing:contributing-running-tests", "page": "contributing", "ref": "contributing-running-tests", "title": "Running the tests", "content": "Once you have done this, you can run the Datasette unit tests from inside your  datasette/  directory using  pytest  like so: \n             pytest \n             You can run the tests faster using multiple CPU cores with  pytest-xdist  like this: \n             pytest -n auto -m \"not serial\" \n             -n auto  detects the number of available cores automatically. The  -m \"not serial\"  skips tests that don't work well in a parallel test environment. You can run those tests separately like so: \n             pytest -m \"serial\"", "breadcrumbs": "[\"Contributing\"]", "references": "[{\"href\": \"https://docs.pytest.org/\", \"label\": \"pytest\"}, {\"href\": \"https://pypi.org/project/pytest-xdist/\", \"label\": \"pytest-xdist\"}]"}
{"id": "sql_queries:sql", "page": "sql_queries", "ref": "sql", "title": "Running SQL queries", "content": "Datasette treats SQLite database files as read-only and immutable. This means it is not possible to execute INSERT or UPDATE statements using Datasette, which allows us to expose SELECT statements to the outside world without needing to worry about SQL injection attacks. \n         The easiest way to execute custom SQL against Datasette is through the web UI. The database index page includes a SQL editor that lets you run any SELECT query you like. You can also construct queries using the filter interface on the tables page, then click \"View and edit SQL\" to open that query in the custom SQL editor. \n         Note that this interface is only available if the  execute-sql  permission is allowed. See  Controlling the ability to execute arbitrary SQL . \n         Any Datasette SQL query is reflected in the URL of the page, allowing you to bookmark them, share them with others and navigate through previous queries using your browser back button. \n         You can also retrieve the results of any query as JSON by adding  .json  to the base URL.", "breadcrumbs": "[]", "references": "[]"}
{"id": "deploying:deploying-systemd", "page": "deploying", "ref": "deploying-systemd", "title": "Running Datasette using systemd", "content": "You can run Datasette on Ubuntu or Debian systems using  systemd . \n             First, ensure you have Python 3 and  pip  installed. On Ubuntu you can use  sudo apt-get install python3 python3-pip . \n             You can install Datasette into a virtual environment, or you can install it system-wide. To install system-wide, use  sudo pip3 install datasette . \n             Now create a folder for your Datasette databases, for example using  mkdir /home/ubuntu/datasette-root . \n             You can copy a test database into that folder like so: \n             cd /home/ubuntu/datasette-root\ncurl -O https://latest.datasette.io/fixtures.db \n             Create a file at  /etc/systemd/system/datasette.service  with the following contents: \n             [Unit]\nDescription=Datasette\nAfter=network.target\n\n[Service]\nType=simple\nUser=ubuntu\nEnvironment=DATASETTE_SECRET=\nWorkingDirectory=/home/ubuntu/datasette-root\nExecStart=datasette serve . -h 127.0.0.1 -p 8000\nRestart=on-failure\n\n[Install]\nWantedBy=multi-user.target \n             Add a random value for the  DATASETTE_SECRET  - this will be used to sign Datasette cookies such as the CSRF token cookie. You can generate a suitable value like so: \n             python3 -c 'import secrets; print(secrets.token_hex(32))' \n             This configuration will run Datasette against all database files contained in the  /home/ubuntu/datasette-root  directory. If that directory contains a  metadata.yml  (or  .json ) file or a  templates/  or  plugins/  sub-directory those will automatically be loaded by Datasette - see  Configuration directory mode  for details. \n             You can start the Datasette process running using the following: \n             sudo systemctl daemon-reload\nsudo systemctl start datasette.service \n             You will need to restart the Datasette service after making changes to its  metadata.json  configuration or adding a new database file to that directory. You can do that using: \n             sudo systemctl restart datasette.service \n             Once the service has started you can confirm that Datasette is running on port 8000 like so: \n             curl 127.0.0.1:8000/-/versions.json\n# Should output JSON showing the installed version \n             Datasette will not be accessible from outside the server because it is listening on  127.0.0.1 . You can expose it by instead listening on  0.0.0.0 , but a better way is to set up a proxy such as  nginx  - see  Running Datasette behind a proxy .", "breadcrumbs": "[\"Deploying Datasette\"]", "references": "[]"}
{"id": "deploying:deploying-openrc", "page": "deploying", "ref": "deploying-openrc", "title": "Running Datasette using OpenRC", "content": "OpenRC is the service manager on non-systemd Linux distributions like  Alpine Linux  and  Gentoo . \n             Create an init script at  /etc/init.d/datasette  with the following contents: \n             #!/sbin/openrc-run\n\nname=\"datasette\"\ncommand=\"datasette\"\ncommand_args=\"serve -h 0.0.0.0 /path/to/db.db\"\ncommand_background=true\npidfile=\"/run/${RC_SVCNAME}.pid\" \n             You then need to configure the service to run at boot and start it: \n             rc-update add datasette\nrc-service datasette start", "breadcrumbs": "[\"Deploying Datasette\"]", "references": "[{\"href\": \"https://www.alpinelinux.org/\", \"label\": \"Alpine Linux\"}, {\"href\": \"https://www.gentoo.org/\", \"label\": \"Gentoo\"}]"}
{"id": "changelog:running-datasette-behind-a-proxy", "page": "changelog", "ref": "running-datasette-behind-a-proxy", "title": "Running Datasette behind a proxy", "content": "The  base_url  configuration option is designed to help run Datasette on a specific path behind a proxy - for example if you want to run an instance of Datasette at  /my-datasette/  within your existing site's URL hierarchy, proxied behind nginx or Apache. \n                 Support for this configuration option has been greatly improved ( #1023 ), and guidelines for using it are now available in a new documentation section on  Running Datasette behind a proxy . ( #1027 )", "breadcrumbs": "[\"Changelog\", \"0.51 (2020-10-31)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/1023\", \"label\": \"#1023\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1027\", \"label\": \"#1027\"}]"}
{"id": "deploying:deploying-proxy", "page": "deploying", "ref": "deploying-proxy", "title": "Running Datasette behind a proxy", "content": "You may wish to run Datasette behind an Apache or nginx proxy, using a path within your existing site. \n             You can use the  base_url  configuration setting to tell Datasette to serve traffic with a specific URL prefix. For example, you could run Datasette like this: \n             datasette my-database.db --setting base_url /my-datasette/ -p 8009 \n             This will run Datasette with the following URLs: \n             \n                 \n                     http://127.0.0.1:8009/my-datasette/  - the Datasette homepage \n                 \n                 \n                     http://127.0.0.1:8009/my-datasette/my-database  - the page for the  my-database.db  database \n                 \n                 \n                     http://127.0.0.1:8009/my-datasette/my-database/some_table  - the page for the  some_table  table \n                 \n             \n             You can now set your nginx or Apache server to proxy the  /my-datasette/  path to this Datasette instance.", "breadcrumbs": "[\"Deploying Datasette\"]", "references": "[]"}
{"id": "contributing:contributing-documentation-cog", "page": "contributing", "ref": "contributing-documentation-cog", "title": "Running Cog", "content": "Some pages of documentation (in particular the  CLI reference ) are automatically updated using  Cog . \n                 To update these pages, run the following command: \n                 cog -r docs/*.rst", "breadcrumbs": "[\"Contributing\", \"Editing and building the documentation\"]", "references": "[{\"href\": \"https://github.com/nedbat/cog\", \"label\": \"Cog\"}]"}
{"id": "contributing:contributing-formatting-black", "page": "contributing", "ref": "contributing-formatting-black", "title": "Running Black", "content": "Black will be installed when you run  pip install -e '.[test]' . To test that your code complies with Black, run the following in your root  datasette  repository checkout: \n                 black . --check \n                 All done! \u2728 \ud83c\udf70 \u2728\n95 files would be left unchanged. \n                 If any of your code does not conform to Black you can run this to automatically fix those problems: \n                 black . \n                 reformatted ../datasette/setup.py\nAll done! \u2728 \ud83c\udf70 \u2728\n1 file reformatted, 94 files left unchanged.", "breadcrumbs": "[\"Contributing\", \"Code formatting\"]", "references": "[]"}
{"id": "pages:rowview", "page": "pages", "ref": "rowview", "title": "Row", "content": "Every row in every Datasette table has its own URL. This means individual records can be linked to directly. \n             Table cells with extremely long text contents are truncated on the table view according to the  truncate_cells_html  setting. If a cell has been truncated the full length version of that cell will be available on the row page. \n             Rows which are the targets of foreign key references from other tables will show a link to a filtered search for all records that reference that row. Here's an example from the Registers of Members Interests database: \n             ../people/uk~2Eorg~2Epublicwhip~2Fperson~2F10001 \n             Note that this URL includes the encoded primary key of the record. \n             Here's that same page as JSON: \n             ../people/uk~2Eorg~2Epublicwhip~2Fperson~2F10001.json", "breadcrumbs": "[\"Pages and API endpoints\"]", "references": "[{\"href\": \"https://register-of-members-interests.datasettes.com/regmem/people/uk~2Eorg~2Epublicwhip~2Fperson~2F10001\", \"label\": \"../people/uk~2Eorg~2Epublicwhip~2Fperson~2F10001\"}, {\"href\": \"https://register-of-members-interests.datasettes.com/regmem/people/uk~2Eorg~2Epublicwhip~2Fperson~2F10001.json\", \"label\": \"../people/uk~2Eorg~2Epublicwhip~2Fperson~2F10001.json\"}]"}
{"id": "internals:internals-response-asgi-send", "page": "internals", "ref": "internals-response-asgi-send", "title": "Returning a response with .asgi_send(send)", "content": "In most cases you will return  Response  objects from your own view functions. You can also use a  Response  instance to respond at a lower level via ASGI, for example if you are writing code that uses the  asgi_wrapper(datasette)  hook. \n                 Create a  Response  object and then use  await response.asgi_send(send) , passing the ASGI  send  function. For example: \n                 async def require_authorization(scope, receive, send):\n    response = Response.text(\n        \"401 Authorization Required\",\n        headers={\n            \"www-authenticate\": 'Basic realm=\"Datasette\", charset=\"UTF-8\"'\n        },\n        status=401,\n    )\n    await response.asgi_send(send)", "breadcrumbs": "[\"Internals for plugins\", \"Response class\"]", "references": "[]"}
{"id": "custom_templates:custom-pages-404", "page": "custom_templates", "ref": "custom-pages-404", "title": "Returning 404s", "content": "To indicate that content could not be found and display the default 404 page you can use the  raise_404(message)  function: \n             {% if not rows %}\n    {{ raise_404(\"Content not found\") }}\n{% endif %} \n             If you call  raise_404()  the other content in your template will be ignored.", "breadcrumbs": "[\"Custom pages and templates\"]", "references": "[]"}
{"id": "internals:database-results", "page": "internals", "ref": "database-results", "title": "Results", "content": "The  db.execute()  method returns a single  Results  object. This can be used to access the rows returned by the query. \n                 Iterating over a  Results  object will yield SQLite  Row objects . Each of these can be treated as a tuple or can be accessed using  row[\"column\"]  syntax: \n                 info = []\nresults = await db.execute(\"select name from sqlite_master\")\nfor row in results:\n    info.append(row[\"name\"]) \n                 The  Results  object also has the following properties and methods: \n                 \n                     \n                         .truncated  - boolean \n                         \n                             Indicates if this query was truncated - if it returned more results than the specified  page_size . If this is true then the results object will only provide access to the first  page_size  rows in the query result. You can disable truncation by passing  truncate=False  to the  db.query()  method. \n                         \n                     \n                     \n                         .columns  - list of strings \n                         \n                             A list of column names returned by the query. \n                         \n                     \n                     \n                         .rows  - list of  sqlite3.Row \n                         \n                             This property provides direct access to the list of rows returned by the database. You can access specific rows by index using  results.rows[0] . \n                         \n                     \n                     \n                         .first()  - row or None \n                         \n                             Returns the first row in the results, or  None  if no rows were returned. \n                         \n                     \n                     \n                         .single_value() \n                         \n                             Returns the value of the first column of the first row of results - but only if the query returned a single row with a single column. Raises a  datasette.database.MultipleValues  exception otherwise. \n                         \n                     \n                     \n                         .__len__() \n                         \n                             Calling  len(results)  returns the (truncated) number of returned results.", "breadcrumbs": "[\"Internals for plugins\", \"Database class\"]", "references": "[{\"href\": \"https://docs.python.org/3/library/sqlite3.html#row-objects\", \"label\": \"Row objects\"}]"}
{"id": "authentication:authentication-cli-create-token-restrict", "page": "authentication", "ref": "authentication-cli-create-token-restrict", "title": "Restricting the actions that a token can perform", "content": "Tokens created using  datasette create-token ACTOR_ID  will inherit all of the permissions of the actor that they are associated with. \n                     You can pass additional options to create tokens that are restricted to a subset of that actor's permissions. \n                     To restrict the token to just specific permissions against all available databases, use the  --all  option: \n                     datasette create-token root --all insert-row --all update-row \n                     This option can be passed as many times as you like. In the above example the token will only be allowed to insert and update rows. \n                     You can also restrict permissions such that they can only be used within specific databases: \n                     datasette create-token root --database mydatabase insert-row \n                     The resulting token will only be able to insert rows, and only to tables in the  mydatabase  database. \n                     Finally, you can restrict permissions to individual resources - tables, SQL views and  named queries  - within a specific database: \n                     datasette create-token root --resource mydatabase mytable insert-row \n                     These options have short versions:  -a  for  --all ,  -d  for  --database  and  -r  for  --resource . \n                     You can add  --debug  to see a JSON representation of the token that has been created. Here's a full example: \n                     datasette create-token root \\\n    --secret mysecret \\\n    --all view-instance \\\n    --all view-table \\\n    --database docs view-query \\\n    --resource docs documents insert-row \\\n    --resource docs documents update-row \\\n    --debug \n                     This example outputs the following: \n                     dstok_.eJxFizEKgDAMRe_y5w4qYrFXERGxDkVsMI0uxbubdjFL8l_ez1jhwEQCA6Fjjxp90qtkuHawzdjYrh8MFobLxZ_wBH0_gtnAF-hpS5VfmF8D_lnd97lHqUJgLd6sls4H1qwlhA.nH_7RecYHj5qSzvjhMU95iy0Xlc\n\nDecoded:\n\n{\n  \"a\": \"root\",\n  \"token\": \"dstok\",\n  \"t\": 1670907246,\n  \"_r\": {\n    \"a\": [\n      \"vi\",\n      \"vt\"\n    ],\n    \"d\": {\n      \"docs\": [\n        \"vq\"\n      ]\n    },\n    \"r\": {\n      \"docs\": {\n        \"documents\": [\n          \"ir\",\n          \"ur\"\n        ]\n      }\n    }\n  }\n}", "breadcrumbs": "[\"Authentication and permissions\", \"API Tokens\", \"datasette create-token\"]", "references": "[]"}
{"id": "internals:internals-response", "page": "internals", "ref": "internals-response", "title": "Response class", "content": "The  Response  class can be returned from view functions that have been registered using the  register_routes(datasette)  hook. \n             The  Response()  constructor takes the following arguments: \n             \n                 \n                     body  - string \n                     \n                         The body of the response. \n                     \n                 \n                 \n                     status  - integer (optional) \n                     \n                         The HTTP status - defaults to 200. \n                     \n                 \n                 \n                     headers  - dictionary (optional) \n                     \n                         A dictionary of extra HTTP headers, e.g.  {\"x-hello\": \"world\"} . \n                     \n                 \n                 \n                     content_type  - string (optional) \n                     \n                         The content-type for the response. Defaults to  text/plain . \n                     \n                 \n             \n             For example: \n             from datasette.utils.asgi import Response\n\nresponse = Response(\n    \"<xml>This is XML</xml>\",\n    content_type=\"application/xml; charset=utf-8\",\n) \n             The quickest way to create responses is using the  Response.text(...) ,  Response.html(...) ,  Response.json(...)  or  Response.redirect(...)  helper methods: \n             from datasette.utils.asgi import Response\n\nhtml_response = Response.html(\"This is HTML\")\njson_response = Response.json({\"this_is\": \"json\"})\ntext_response = Response.text(\n    \"This will become utf-8 encoded text\"\n)\n# Redirects are served as 302, unless you pass status=301:\nredirect_response = Response.redirect(\n    \"https://latest.datasette.io/\"\n) \n             Each of these responses will use the correct corresponding content-type -  text/html; charset=utf-8 ,  application/json; charset=utf-8  or  text/plain; charset=utf-8  respectively. \n             Each of the helper methods take optional  status=  and  headers=  arguments, documented above.", "breadcrumbs": "[\"Internals for plugins\"]", "references": "[]"}
{"id": "internals:internals-request", "page": "internals", "ref": "internals-request", "title": "Request object", "content": "The request object is passed to various plugin hooks. It represents an incoming HTTP request. It has the following properties: \n             \n                 \n                     .scope  - dictionary \n                     \n                         The ASGI scope that was used to construct this request, described in the  ASGI HTTP connection scope  specification. \n                     \n                 \n                 \n                     .method  - string \n                     \n                         The HTTP method for this request, usually  GET  or  POST . \n                     \n                 \n                 \n                     .url  - string \n                     \n                         The full URL for this request, e.g.  https://latest.datasette.io/fixtures . \n                     \n                 \n                 \n                     .scheme  - string \n                     \n                         The request scheme - usually  https  or  http . \n                     \n                 \n                 \n                     .headers  - dictionary (str -> str) \n                     \n                         A dictionary of incoming HTTP request headers. Header names have been converted to lowercase. \n                     \n                 \n                 \n                     .cookies  - dictionary (str -> str) \n                     \n                         A dictionary of incoming cookies \n                     \n                 \n                 \n                     .host  - string \n                     \n                         The host header from the incoming request, e.g.  latest.datasette.io  or  localhost . \n                     \n                 \n                 \n                     .path  - string \n                     \n                         The path of the request excluding the query string, e.g.  /fixtures . \n                     \n                 \n                 \n                     .full_path  - string \n                     \n                         The path of the request including the query string if one is present, e.g.  /fixtures?sql=select+sqlite_version() . \n                     \n                 \n                 \n                     .query_string  - string \n                     \n                         The query string component of the request, without the  ?  - e.g.  name__contains=sam&age__gt=10 . \n                     \n                 \n                 \n                     .args  - MultiParams \n                     \n                         An object representing the parsed query string parameters, see below. \n                     \n                 \n                 \n                     .url_vars  - dictionary (str -> str) \n                     \n                         Variables extracted from the URL path, if that path was defined using a regular expression. See  register_routes(datasette) . \n                     \n                 \n                 \n                     .actor  - dictionary (str -> Any) or None \n                     \n                         The currently authenticated actor (see  actors ), or  None  if the request is unauthenticated. \n                     \n                 \n             \n             The object also has two awaitable methods: \n             \n                 \n                     await request.post_vars()  - dictionary \n                     \n                         Returns a dictionary of form variables that were submitted in the request body via  POST . Don't forget to read about  CSRF protection ! \n                     \n                 \n                 \n                     await request.post_body()  - bytes \n                     \n                         Returns the un-parsed body of a request submitted by  POST  - useful for things like incoming JSON data. \n                     \n                 \n             \n             And a class method that can be used to create fake request objects for use in tests: \n             \n                 \n                     fake(path_with_query_string, method=\"GET\", scheme=\"http\", url_vars=None) \n                     \n                         Returns a  Request  instance for the specified path and method. For example: \n                         from datasette import Request\nfrom pprint import pprint\n\nrequest = Request.fake(\n    \"/fixtures/facetable/\",\n    url_vars={\"database\": \"fixtures\", \"table\": \"facetable\"},\n)\npprint(request.scope) \n                         This outputs: \n                         {'http_version': '1.1',\n 'method': 'GET',\n 'path': '/fixtures/facetable/',\n 'query_string': b'',\n 'raw_path': b'/fixtures/facetable/',\n 'scheme': 'http',\n 'type': 'http',\n 'url_route': {'kwargs': {'database': 'fixtures', 'table': 'facetable'}}}", "breadcrumbs": "[\"Internals for plugins\"]", "references": "[{\"href\": \"https://asgi.readthedocs.io/en/latest/specs/www.html#connection-scope\", \"label\": \"ASGI HTTP connection scope\"}]"}
{"id": "contributing:contributing-bug-fix-branch", "page": "contributing", "ref": "contributing-bug-fix-branch", "title": "Releasing bug fixes from a branch", "content": "If it's necessary to publish a bug fix release without shipping new features that have landed on  main  a release branch can be used. \n             Create it from the relevant last tagged release like so: \n             git branch 0.52.x 0.52.4\ngit checkout 0.52.x \n             Next cherry-pick the commits containing the bug fixes: \n             git cherry-pick COMMIT \n             Write the release notes in the branch, and update the version number in  version.py . Then push the branch: \n             git push -u origin 0.52.x \n             Once the tests have completed, publish the release from that branch target using the GitHub  Draft a new release  form. \n             Finally, cherry-pick the commit with the release notes and version number bump across to  main : \n             git checkout main\ngit cherry-pick COMMIT\ngit push", "breadcrumbs": "[\"Contributing\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/releases/new\", \"label\": \"Draft a new release\"}]"}
{"id": "contributing:contributing-release", "page": "contributing", "ref": "contributing-release", "title": "Release process", "content": "Datasette releases are performed using tags. When a new release is published on GitHub, a  GitHub Action workflow  will perform the following: \n             \n                 \n                     Run the unit tests against all supported Python versions. If the tests pass... \n                 \n                 \n                     Build a Docker image of the release and push a tag to  https://hub.docker.com/r/datasetteproject/datasette \n                 \n                 \n                     Re-point the \"latest\" tag on Docker Hub to the new image \n                 \n                 \n                     Build a wheel bundle of the underlying Python source code \n                 \n                 \n                     Push that new wheel up to PyPI:  https://pypi.org/project/datasette/ \n                 \n                 \n                     If the release is an alpha, navigate to  https://readthedocs.org/projects/datasette/versions/  and search for the tag name in the \"Activate a version\" filter, then mark that version as \"active\" to ensure it will appear on the public ReadTheDocs documentation site. \n                 \n             \n             To deploy new releases you will need to have push access to the main Datasette GitHub repository. \n             Datasette follows  Semantic Versioning : \n             major.minor.patch \n             We increment  major  for backwards-incompatible releases. Datasette is currently pre-1.0 so the major version is always  0 . \n             We increment  minor  for new features. \n             We increment  patch  for bugfix releass. \n             Alpha and beta releases  may have an additional  a0  or  b0  prefix - the integer component will be incremented with each subsequent alpha or beta. \n             To release a new version, first create a commit that updates the version number in  datasette/version.py  and the  the changelog  with highlights of the new version. An example  commit can be seen here : \n             # Update changelog\ngit commit -m \" Release 0.51a1\n\nRefs #1056, #1039, #998, #1045, #1033, #1036, #1034, #976, #1057, #1058, #1053, #1064, #1066\" -a\ngit push \n             Referencing the issues that are part of the release in the commit message ensures the name of the release shows up on those issue pages, e.g.  here . \n             You can generate the list of issue references for a specific release by copying and pasting text from the release notes or GitHub changes-since-last-release view into this  Extract issue numbers from pasted text  tool. \n             To create the tag for the release, create  a new release  on GitHub matching the new version number. You can convert the release notes to Markdown by copying and pasting the rendered HTML into this  Paste to Markdown tool . \n             Finally, post a news item about the release on  datasette.io  by editing the  news.yaml  file in that site's repository.", "breadcrumbs": "[\"Contributing\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/blob/main/.github/workflows/deploy-latest.yml\", \"label\": \"GitHub Action workflow\"}, {\"href\": \"https://hub.docker.com/r/datasetteproject/datasette\", \"label\": \"https://hub.docker.com/r/datasetteproject/datasette\"}, {\"href\": \"https://pypi.org/project/datasette/\", \"label\": \"https://pypi.org/project/datasette/\"}, {\"href\": \"https://readthedocs.org/projects/datasette/versions/\", \"label\": \"https://readthedocs.org/projects/datasette/versions/\"}, {\"href\": \"https://semver.org/\", \"label\": \"Semantic Versioning\"}, {\"href\": \"https://github.com/simonw/datasette/commit/0e1e89c6ba3d0fbdb0823272952cf356f3016def\", \"label\": \"commit can be seen here\"}, {\"href\": \"https://github.com/simonw/datasette/issues/581#ref-commit-d56f402\", \"label\": \"here\"}, {\"href\": \"https://observablehq.com/@simonw/extract-issue-numbers-from-pasted-text\", \"label\": \"Extract issue numbers from pasted text\"}, {\"href\": \"https://github.com/simonw/datasette/releases/new\", \"label\": \"a new release\"}, {\"href\": \"https://euangoddard.github.io/clipboard2markdown/\", \"label\": \"Paste to Markdown tool\"}, {\"href\": \"https://datasette.io/\", \"label\": \"datasette.io\"}, {\"href\": \"https://github.com/simonw/datasette.io/blob/main/news.yaml\", \"label\": \"news.yaml\"}]"}
{"id": "testing_plugins:testing-plugins-register-in-test", "page": "testing_plugins", "ref": "testing-plugins-register-in-test", "title": "Registering a plugin for the duration of a test", "content": "When writing tests for plugins you may find it useful to register a test plugin just for the duration of a single test. You can do this using  pm.register()  and  pm.unregister()  like this: \n             from datasette import hookimpl\nfrom datasette.app import Datasette\nfrom datasette.plugins import pm\nimport pytest\n\n\n@pytest.mark.asyncio\nasync def test_using_test_plugin():\n    class TestPlugin:\n        __name__ = \"TestPlugin\"\n\n        # Use hookimpl and method names to register hooks\n        @hookimpl\n        def register_routes(self):\n            return [\n                (r\"^/error$\", lambda: 1 / 0),\n            ]\n\n    pm.register(TestPlugin(), name=\"undo\")\n    try:\n        # The test implementation goes here\n        datasette = Datasette()\n        response = await datasette.client.get(\"/error\")\n        assert response.status_code == 500\n    finally:\n        pm.unregister(name=\"undo\") \n             To reuse the same temporary plugin in multiple tests, you can register it inside a fixture in your  conftest.py  file like this: \n             from datasette import hookimpl\nfrom datasette.app import Datasette\nfrom datasette.plugins import pm\nimport pytest\nimport pytest_asyncio\n\n\n@pytest_asyncio.fixture\nasync def datasette_with_plugin():\n    class TestPlugin:\n        __name__ = \"TestPlugin\"\n\n        @hookimpl\n        def register_routes(self):\n            return [\n                (r\"^/error$\", lambda: 1 / 0),\n            ]\n\n    pm.register(TestPlugin(), name=\"undo\")\n    try:\n        yield Datasette()\n    finally:\n        pm.unregister(name=\"undo\")\n \n             Note the  yield  statement here - this ensures that the  finally:  block that unregisters the plugin is executed only after the test function itself has completed. \n             Then in a test: \n             @pytest.mark.asyncio\nasync def test_error(datasette_with_plugin):\n    response = await datasette_with_plugin.client.get(\"/error\")\n    assert response.status_code == 500", "breadcrumbs": "[\"Testing plugins\"]", "references": "[]"}
{"id": "spatialite:querying-polygons-using-within", "page": "spatialite", "ref": "querying-polygons-using-within", "title": "Querying polygons using within()", "content": "The  within()  SQL function can be used to check if a point is within a geometry: \n             select\n    name\nfrom\n    places\nwhere\n   within(GeomFromText('POINT(-3.1724366 51.4704448)'), places.geom); \n             The  GeomFromText()  function takes a string of well-known text. Note that the order used here is  longitude  then   latitude . \n             To run that same  within()  query in a way that benefits from the spatial index, use the following: \n             select\n    name\nfrom\n    places\nwhere\n    within(GeomFromText('POINT(-3.1724366 51.4704448)'), places.geom)\n    and rowid in (\n        SELECT pkid FROM idx_places_geom\n        where xmin < -3.1724366\n        and xmax > -3.1724366\n        and ymin < 51.4704448\n        and ymax > 51.4704448\n    );", "breadcrumbs": "[\"SpatiaLite\"]", "references": "[]"}
{"id": "publish:publish-vercel", "page": "publish", "ref": "publish-vercel", "title": "Publishing to Vercel", "content": "Vercel   - previously known as Zeit Now - provides a layer over AWS Lambda to allow for quick, scale-to-zero deployment. You can deploy Datasette instances to Vercel using the  datasette-publish-vercel  plugin. \n                 pip install datasette-publish-vercel\ndatasette publish vercel mydatabase.db --project my-database-project \n                 Not every feature is supported: consult the  datasette-publish-vercel README  for more details.", "breadcrumbs": "[\"Publishing data\", \"datasette publish\"]", "references": "[{\"href\": \"https://vercel.com/\", \"label\": \"Vercel\"}, {\"href\": \"https://github.com/simonw/datasette-publish-vercel\", \"label\": \"datasette-publish-vercel\"}, {\"href\": \"https://github.com/simonw/datasette-publish-vercel/blob/main/README.md\", \"label\": \"datasette-publish-vercel README\"}]"}
{"id": "publish:publish-heroku", "page": "publish", "ref": "publish-heroku", "title": "Publishing to Heroku", "content": "To publish your data using  Heroku , first create an account there and install and configure the  Heroku CLI tool . \n                 You can publish one or more databases to Heroku using the following command: \n                 datasette publish heroku mydatabase.db \n                 This will output some details about the new deployment, including a URL like this one: \n                 https://limitless-reef-88278.herokuapp.com/ deployed to Heroku \n                 You can specify a custom app name by passing  -n my-app-name  to the publish command. This will also allow you to overwrite an existing app. \n                 Rather than deploying directly you can use the  --generate-dir  option to output the files that would be deployed to a directory: \n                 datasette publish heroku mydatabase.db --generate-dir=/tmp/deploy-this-to-heroku \n                 See  datasette publish heroku  for the full list of options for this command.", "breadcrumbs": "[\"Publishing data\", \"datasette publish\"]", "references": "[{\"href\": \"https://www.heroku.com/\", \"label\": \"Heroku\"}, {\"href\": \"https://devcenter.heroku.com/articles/heroku-cli\", \"label\": \"Heroku CLI tool\"}]"}
{"id": "publish:publish-cloud-run", "page": "publish", "ref": "publish-cloud-run", "title": "Publishing to Google Cloud Run", "content": "Google Cloud Run  allows you to publish data in a scale-to-zero environment, so your application will start running when the first request is received and will shut down again when traffic ceases. This means you only pay for time spent serving traffic. \n                 \n                     Cloud Run is a great option for inexpensively hosting small, low traffic projects - but costs can add up for projects that serve a lot of requests. \n                     Be particularly careful if your project has tables with large numbers of rows. Search engine crawlers that index a page for every row could result in a high bill. \n                     The  datasette-block-robots  plugin can be used to request search engine crawlers omit crawling your site, which can help avoid this issue. \n                 \n                 You will first need to install and configure the Google Cloud CLI tools by following  these instructions . \n                 You can then publish one or more SQLite database files to Google Cloud Run using the following command: \n                 datasette publish cloudrun mydatabase.db --service=my-database \n                 A Cloud Run  service  is a single hosted application. The service name you specify will be used as part of the Cloud Run URL. If you deploy to a service name that you have used in the past your new deployment will replace the previous one. \n                 If you omit the  --service  option you will be asked to pick a service name interactively during the deploy. \n                 You may need to interact with prompts from the tool. Many of the prompts ask for values that can be  set as properties for the Google Cloud SDK  if you want to avoid the prompts. \n                 For example, the default region for the deployed instance can be set using the command: \n                 gcloud config set run/region us-central1 \n                 You should replace  us-central1  with your desired  region . Alternately, you can specify the region by setting the  CLOUDSDK_RUN_REGION  environment variable. \n                 Once it has finished it will output a URL like this one: \n                 Service [my-service] revision [my-service-00001] has been deployed\nand is serving traffic at https://my-service-j7hipcg4aq-uc.a.run.app \n                 Cloud Run provides a URL on the  .run.app  domain, but you can also point your own domain or subdomain at your Cloud Run service - see  mapping custom domains  in the Cloud Run documentation for details. \n                 See  datasette publish cloudrun  for the full list of options for this command.", "breadcrumbs": "[\"Publishing data\", \"datasette publish\"]", "references": "[{\"href\": \"https://cloud.google.com/run/\", \"label\": \"Google Cloud Run\"}, {\"href\": \"https://datasette.io/plugins/datasette-block-robots\", \"label\": \"datasette-block-robots\"}, {\"href\": \"https://cloud.google.com/sdk/\", \"label\": \"these instructions\"}, {\"href\": \"https://cloud.google.com/sdk/docs/properties\", \"label\": \"set as properties for the Google Cloud SDK\"}, {\"href\": \"https://cloud.google.com/about/locations\", \"label\": \"region\"}, {\"href\": \"https://cloud.google.com/run/docs/mapping-custom-domains\", \"label\": \"mapping custom domains\"}]"}
{"id": "publish:publish-fly", "page": "publish", "ref": "publish-fly", "title": "Publishing to Fly", "content": "Fly  is a  competitively priced  Docker-compatible hosting platform that supports running applications in globally distributed data centers close to your end users. You can deploy Datasette instances to Fly using the  datasette-publish-fly  plugin. \n                 pip install datasette-publish-fly\ndatasette publish fly mydatabase.db --app=\"my-app\" \n                 Consult the  datasette-publish-fly README  for more details.", "breadcrumbs": "[\"Publishing data\", \"datasette publish\"]", "references": "[{\"href\": \"https://fly.io/\", \"label\": \"Fly\"}, {\"href\": \"https://fly.io/docs/pricing/\", \"label\": \"competitively priced\"}, {\"href\": \"https://github.com/simonw/datasette-publish-fly\", \"label\": \"datasette-publish-fly\"}, {\"href\": \"https://github.com/simonw/datasette-publish-fly/blob/main/README.md\", \"label\": \"datasette-publish-fly README\"}]"}
{"id": "custom_templates:publishing-static-assets", "page": "custom_templates", "ref": "publishing-static-assets", "title": "Publishing static assets", "content": "The  datasette publish  command can be used to publish your static assets,\n                using the same syntax as above: \n             datasette publish cloudrun mydb.db --static assets:static-files/ \n             This will upload the contents of the  static-files/  directory as part of the\n                deployment, and configure Datasette to correctly serve the assets from  /assets/ .", "breadcrumbs": "[\"Custom pages and templates\"]", "references": "[]"}
{"id": "publish:publishing", "page": "publish", "ref": "publishing", "title": "Publishing data", "content": "Datasette includes tools for publishing and deploying your data to the internet. The  datasette publish  command will deploy a new Datasette instance containing your databases directly to a Heroku or Google Cloud hosting account. You can also use  datasette package  to create a Docker image that bundles your databases together with the datasette application that is used to serve them.", "breadcrumbs": "[]", "references": "[]"}
{"id": "contributing:contributing-formatting-prettier", "page": "contributing", "ref": "contributing-formatting-prettier", "title": "Prettier", "content": "To install Prettier,  install Node.js  and then run the following in the root of your  datasette  repository checkout: \n                 npm install \n                 This will install Prettier in a  node_modules  directory. You can then check that your code matches the coding style like so: \n                 npm run prettier -- --check \n                 > prettier\n> prettier 'datasette/static/*[!.min].js' \"--check\"\n\nChecking formatting...\n[warn] datasette/static/plugins.js\n[warn] Code style issues found in the above file(s). Forgot to run Prettier? \n                 You can fix any problems by running: \n                 npm run fix", "breadcrumbs": "[\"Contributing\", \"Code formatting\"]", "references": "[{\"href\": \"https://nodejs.org/en/download/package-manager/\", \"label\": \"install Node.js\"}]"}
{"id": "writing_plugins:writing-plugins-extra-hooks", "page": "writing_plugins", "ref": "writing-plugins-extra-hooks", "title": "Plugins that define new plugin hooks", "content": "Plugins can define new plugin hooks that other plugins can use to further extend their functionality. \n             datasette-graphql  is one example of a plugin that does this. It defines a new hook called  graphql_extra_fields ,  described here , which other plugins can use to define additional fields that should be included in the GraphQL schema. \n             To define additional hooks, add a file to the plugin called  datasette_your_plugin/hookspecs.py  with content that looks like this: \n             from pluggy import HookspecMarker\n\nhookspec = HookspecMarker(\"datasette\")\n\n\n@hookspec\ndef name_of_your_hook_goes_here(datasette):\n    \"Description of your hook.\" \n             You should define your own hook name and arguments here, following the documentation for  Pluggy specifications . Make sure to pick a name that is unlikely to clash with hooks provided by any other plugins. \n             Then, to register your plugin hooks, add the following code to your  datasette_your_plugin/__init__.py  file: \n             from datasette.plugins import pm\nfrom . import hookspecs\n\npm.add_hookspecs(hookspecs) \n             This will register your plugin hooks as part of the  datasette  plugin hook namespace. \n             Within your plugin code you can trigger the hook using this pattern: \n             from datasette.plugins import pm\n\nfor (\n    plugin_return_value\n) in pm.hook.name_of_your_hook_goes_here(\n    datasette=datasette\n):\n    # Do something with plugin_return_value\n    pass \n             Other plugins will then be able to register their own implementations of your hook using this syntax: \n             from datasette import hookimpl\n\n\n@hookimpl\ndef name_of_your_hook_goes_here(datasette):\n    return \"Response from this plugin hook\" \n             These plugin implementations can accept 0 or more of the named arguments that you defined in your hook specification.", "breadcrumbs": "[\"Writing plugins\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-graphql\", \"label\": \"datasette-graphql\"}, {\"href\": \"https://github.com/simonw/datasette-graphql/blob/main/README.md#adding-custom-fields-with-plugins\", \"label\": \"described here\"}, {\"href\": \"https://pluggy.readthedocs.io/en/stable/#specs\", \"label\": \"Pluggy specifications\"}]"}
{"id": "changelog:plugins-can-now-add-links-within-datasette", "page": "changelog", "ref": "plugins-can-now-add-links-within-datasette", "title": "Plugins can now add links within Datasette", "content": "A number of existing Datasette plugins add new pages to the Datasette interface, providig tools for things like  uploading CSVs ,  editing table schemas  or  configuring full-text search . \n                 Plugins like this can now link to themselves from other parts of Datasette interface. The  menu_links(datasette, actor, request)  hook ( #1064 ) lets plugins add links to Datasette's new top-right application menu, and the  table_actions(datasette, actor, database, table, request)  hook ( #1066 ) adds links to a new \"table actions\" menu on the table page. \n                 The demo at  latest.datasette.io  now includes some example plugins. To see the new table actions menu first  sign into that demo as root  and then visit the  facetable  table to see the new cog icon menu at the top of the page.", "breadcrumbs": "[\"Changelog\", \"0.51 (2020-10-31)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-upload-csvs\", \"label\": \"uploading CSVs\"}, {\"href\": \"https://github.com/simonw/datasette-edit-schema\", \"label\": \"editing table schemas\"}, {\"href\": \"https://github.com/simonw/datasette-configure-fts\", \"label\": \"configuring full-text search\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1064\", \"label\": \"#1064\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1066\", \"label\": \"#1066\"}, {\"href\": \"https://latest.datasette.io/\", \"label\": \"latest.datasette.io\"}, {\"href\": \"https://latest.datasette.io/login-as-root\", \"label\": \"sign into that demo as root\"}, {\"href\": \"https://latest.datasette.io/fixtures/facetable\", \"label\": \"facetable\"}]"}
{"id": "changelog:plugins-and-internals", "page": "changelog", "ref": "plugins-and-internals", "title": "Plugins and internals", "content": "New plugin hook:  filters_from_request(request, database, table, datasette) , which runs on the table page and can be used to support new custom query string parameters that modify the SQL query. ( #473 ) \n                     \n                     \n                         Added two additional methods for writing to the database:  await db.execute_write_script(sql, block=True)  and  await db.execute_write_many(sql, params_seq, block=True) . ( #1570 ) \n                     \n                     \n                         The  db.execute_write()  internal method now defaults to blocking until the write operation has completed. Previously it defaulted to queuing the write and then continuing to run code while the write was in the queue. ( #1579 ) \n                     \n                     \n                         Database write connections now execute the  prepare_connection(conn, database, datasette)  plugin hook. ( #1564 ) \n                     \n                     \n                         The  Datasette()  constructor no longer requires the  files=  argument, and is now documented at  Datasette class . ( #1563 ) \n                     \n                     \n                         The tracing feature now traces write queries, not just read queries. ( #1568 ) \n                     \n                     \n                         The query string variables exposed by  request.args  will now include blank strings for arguments such as  foo  in  ?foo=&bar=1  rather than ignoring those parameters entirely. ( #1551 )", "breadcrumbs": "[\"Changelog\", \"0.60 (2022-01-13)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/473\", \"label\": \"#473\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1570\", \"label\": \"#1570\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1579\", \"label\": \"#1579\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1564\", \"label\": \"#1564\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1563\", \"label\": \"#1563\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1568\", \"label\": \"#1568\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1551\", \"label\": \"#1551\"}]"}
{"id": "plugins:id1", "page": "plugins", "ref": "id1", "title": "Plugins", "content": "Datasette's plugin system allows additional features to be implemented as Python\n            code (or front-end JavaScript) which can be wrapped up in a separate Python\n            package. The underlying mechanism uses  pluggy . \n         See the  Datasette plugins directory  for a list of existing plugins, or take a look at the\n             datasette-plugin  topic on GitHub. \n         Things you can do with plugins include: \n         \n             \n                 Add visualizations to Datasette, for example\n                     datasette-cluster-map  and\n                     datasette-vega . \n             \n             \n                 Make new custom SQL functions available for use within Datasette, for example\n                     datasette-haversine  and\n                     datasette-jellyfish . \n             \n             \n                 Define custom output formats with custom extensions, for example  datasette-atom  and\n                     datasette-ics . \n             \n             \n                 Add template functions that can be called within your Jinja custom templates,\n                    for example  datasette-render-markdown . \n             \n             \n                 Customize how database values are rendered in the Datasette interface, for example\n                     datasette-render-binary  and\n                     datasette-pretty-json . \n             \n             \n                 Customize how Datasette's authentication and permissions systems work, for example  datasette-auth-passwords  and\n                     datasette-permissions-sql .", "breadcrumbs": "[]", "references": "[{\"href\": \"https://pluggy.readthedocs.io/\", \"label\": \"pluggy\"}, {\"href\": \"https://datasette.io/plugins\", \"label\": \"Datasette plugins directory\"}, {\"href\": \"https://github.com/topics/datasette-plugin\", \"label\": \"datasette-plugin\"}, {\"href\": \"https://github.com/simonw/datasette-cluster-map\", \"label\": \"datasette-cluster-map\"}, {\"href\": \"https://github.com/simonw/datasette-vega\", \"label\": \"datasette-vega\"}, {\"href\": \"https://github.com/simonw/datasette-haversine\", \"label\": \"datasette-haversine\"}, {\"href\": \"https://github.com/simonw/datasette-jellyfish\", \"label\": \"datasette-jellyfish\"}, {\"href\": \"https://github.com/simonw/datasette-atom\", \"label\": \"datasette-atom\"}, {\"href\": \"https://github.com/simonw/datasette-ics\", \"label\": \"datasette-ics\"}, {\"href\": \"https://github.com/simonw/datasette-render-markdown#markdown-in-templates\", \"label\": \"datasette-render-markdown\"}, {\"href\": \"https://github.com/simonw/datasette-render-binary\", \"label\": \"datasette-render-binary\"}, {\"href\": \"https://github.com/simonw/datasette-pretty-json\", \"label\": \"datasette-pretty-json\"}, {\"href\": \"https://github.com/simonw/datasette-auth-passwords\", \"label\": \"datasette-auth-passwords\"}, {\"href\": \"https://github.com/simonw/datasette-permissions-sql\", \"label\": \"datasette-permissions-sql\"}]"}
{"id": "changelog:plugin-hooks-and-internals", "page": "changelog", "ref": "plugin-hooks-and-internals", "title": "Plugin hooks and internals", "content": "The  prepare_jinja2_environment(env, datasette)  plugin hook now accepts an optional  datasette  argument. Hook implementations can also now return an  async  function which will be awaited automatically. ( #1809 ) \n                     \n                     \n                         Database(is_mutable=)  now defaults to  True . ( #1808 ) \n                     \n                     \n                         The  datasette.check_visibility()  method now accepts an optional  permissions=  list, allowing it to take multiple permissions into account at once when deciding if something should be shown as public or private. This has been used to correctly display padlock icons in more places in the Datasette interface. ( #1829 ) \n                     \n                     \n                         Datasette no longer enforces upper bounds on its dependencies. ( #1800 )", "breadcrumbs": "[\"Changelog\", \"0.63 (2022-10-27)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/1809\", \"label\": \"#1809\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1808\", \"label\": \"#1808\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1829\", \"label\": \"#1829\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1800\", \"label\": \"#1800\"}]"}
{"id": "changelog:id15", "page": "changelog", "ref": "id15", "title": "Plugin hooks", "content": "New plugin hook:  handle_exception() , for custom handling of exceptions caught by Datasette. ( #1770 ) \n                     \n                     \n                         The  render_cell()  plugin hook is now also passed a  row  argument, representing the  sqlite3.Row  object that is being rendered. ( #1300 ) \n                     \n                     \n                         The  configuration directory  is now stored in  datasette.config_dir , making it available to plugins. Thanks, Chris Amico. ( #1766 )", "breadcrumbs": "[\"Changelog\", \"0.62 (2022-08-14)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/1770\", \"label\": \"#1770\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1300\", \"label\": \"#1300\"}, {\"href\": \"https://github.com/simonw/datasette/pull/1766\", \"label\": \"#1766\"}]"}
{"id": "changelog:plugin-hooks", "page": "changelog", "ref": "plugin-hooks", "title": "Plugin hooks", "content": "New  jinja2_environment_from_request(datasette, request, env)  plugin hook, which can be used to customize the current Jinja environment based on the incoming request. This can be used to modify the template lookup path based on the incoming request hostname, among other things. ( #2225 ) \n                     \n                     \n                         New  family of template slot plugin hooks :  top_homepage ,  top_database ,  top_table ,  top_row ,  top_query ,  top_canned_query . Plugins can use these to provide additional HTML to be injected at the top of the corresponding pages. ( #1191 ) \n                     \n                     \n                         \n                             \n                                 New  track_event() mechanism  for plugins to emit and receive events when certain events occur within Datasette. ( #2240 ) \n                                 \n                                     \n                                         \n                                             Plugins can register additional event classes using  register_events(datasette) . \n                                         \n                                         \n                                             They can then trigger those events with the  datasette.track_event(event)  internal method. \n                                         \n                                         \n                                             Plugins can subscribe to notifications of events using the  track_event(datasette, event)  plugin hook. \n                                         \n                                         \n                                             Datasette core now emits  login ,  logout ,  create-token ,  create-table ,  drop-table ,  insert-rows ,  upsert-rows ,  update-row ,  delete-row  events,  documented here . \n                                         \n                                     \n                                 \n                             \n                         \n                     \n                     \n                         New internal function for plugin authors:  await db.execute_isolated_fn(fn) , for creating a new SQLite connection, executing code and then closing that connection, all while preventing other code from writing to that particular database. This connection will not have the  prepare_connection()  plugin hook executed against it, allowing plugins to perform actions that might otherwise be blocked by existing connection configuration. ( #2218 )", "breadcrumbs": "[\"Changelog\", \"1.0a8 (2024-02-07)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/2225\", \"label\": \"#2225\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1191\", \"label\": \"#1191\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2240\", \"label\": \"#2240\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2218\", \"label\": \"#2218\"}]"}
{"id": "plugin_hooks:id1", "page": "plugin_hooks", "ref": "id1", "title": "Plugin hooks", "content": "Datasette  plugins  use  plugin hooks  to customize Datasette's behavior. These hooks are powered by the  pluggy  plugin system. \n         Each plugin can implement one or more hooks using the  @hookimpl  decorator against a function named that matches one of the hooks documented on this page. \n         When you implement a plugin hook you can accept any or all of the parameters that are documented as being passed to that hook. \n         For example, you can implement the  render_cell  plugin hook like this even though the full documented hook signature is  render_cell(row, value, column, table, database, datasette) : \n         @hookimpl\ndef render_cell(value, column):\n    if column == \"stars\":\n        return \"*\" * int(value) \n         \n             List of plugin hooks \n             \n                 \n                     prepare_connection(conn, database, datasette) \n                 \n                 \n                     prepare_jinja2_environment(env, datasette) \n                 \n                 \n                     Page extras \n                     \n                         \n                             extra_template_vars(template, database, table, columns, view_name, request, datasette) \n                         \n                         \n                             extra_css_urls(template, database, table, columns, view_name, request, datasette) \n                         \n                         \n                             extra_js_urls(template, database, table, columns, view_name, request, datasette) \n                         \n                         \n                             extra_body_script(template, database, table, columns, view_name, request, datasette) \n                         \n                     \n                 \n                 \n                     publish_subcommand(publish) \n                 \n                 \n                     render_cell(row, value, column, table, database, datasette, request) \n                 \n                 \n                     register_output_renderer(datasette) \n                 \n                 \n                     register_routes(datasette) \n                 \n                 \n                     register_commands(cli) \n                 \n                 \n                     register_facet_classes() \n                 \n                 \n                     register_permissions(datasette) \n                 \n                 \n                     asgi_wrapper(datasette) \n                 \n                 \n                     startup(datasette) \n                 \n                 \n                     canned_queries(datasette, database, actor) \n                 \n                 \n                     actor_from_request(datasette, request) \n                 \n                 \n                     actors_from_ids(datasette, actor_ids) \n                 \n                 \n                     jinja2_environment_from_request(datasette, request, env) \n                 \n                 \n                     filters_from_request(request, database, table, datasette) \n                 \n                 \n                     permission_allowed(datasette, actor, action, resource) \n                 \n                 \n                     register_magic_parameters(datasette) \n                 \n                 \n                     forbidden(datasette, request, message) \n                 \n                 \n                     handle_exception(datasette, request, exception) \n                 \n                 \n                     skip_csrf(datasette, scope) \n                 \n                 \n                     get_metadata(datasette, key, database, table) \n                 \n                 \n                     menu_links(datasette, actor, request) \n                 \n                 \n                     Action hooks \n                     \n                         \n                             table_actions(datasette, actor, database, table, request) \n                         \n                         \n                             view_actions(datasette, actor, database, view, request) \n                         \n                         \n                             query_actions(datasette, actor, database, query_name, request, sql, params) \n                         \n                         \n                             row_actions(datasette, actor, request, database, table, row) \n                         \n                         \n                             database_actions(datasette, actor, database, request) \n                         \n                         \n                             homepage_actions(datasette, actor, request) \n                         \n                     \n                 \n                 \n                     Template slots \n                     \n                         \n                             top_homepage(datasette, request) \n                         \n                         \n                             top_database(datasette, request, database) \n                         \n                         \n                             top_table(datasette, request, database, table) \n                         \n                         \n                             top_row(datasette, request, database, table, row) \n                         \n                         \n                             top_query(datasette, request, database, sql) \n                         \n                         \n                             top_canned_query(datasette, request, database, query_name) \n                         \n                     \n                 \n                 \n                     Event tracking \n                     \n                         \n                             track_event(datasette, event) \n                         \n                         \n                             register_events(datasette)", "breadcrumbs": "[]", "references": "[{\"href\": \"https://pluggy.readthedocs.io/\", \"label\": \"pluggy\"}]"}
{"id": "configuration:configuration-reference-plugins", "page": "configuration", "ref": "configuration-reference-plugins", "title": "Plugin configuration", "content": "Datasette plugins  often require configuration. This plugin configuration should be placed in  plugins  keys inside  datasette.yaml . \n                 Most plugins are configured at the top-level of the file, using the  plugins  key: \n                 [[[cog\nfrom metadata_doc import config_example\nimport textwrap\nconfig_example(cog, textwrap.dedent(\n  \"\"\"\n    # inside datasette.yaml\n    plugins:\n      datasette-my-plugin:\n        key: my_value\n    \"\"\").strip()\n  ) \n                 ]]] \n                 [[[end]]] \n                 Some plugins can be configured at the database or table level. These should use a  plugins  key nested under the appropriate place within the  databases  object: \n                 [[[cog\nfrom metadata_doc import config_example\nimport textwrap\nconfig_example(cog, textwrap.dedent(\n  \"\"\"\n    # inside datasette.yaml\n    databases:\n      my_database:\n        # plugin configuration for the my_database database\n        plugins:\n          datasette-my-plugin:\n            key: my_value\n      my_other_database:\n        tables:\n          my_table:\n            # plugin configuration for the my_table table inside the my_other_database database\n            plugins:\n              datasette-my-plugin:\n                key: my_value\n  \"\"\").strip()\n  ) \n                 ]]] \n                 [[[end]]]", "breadcrumbs": "[\"Configuration\", null]", "references": "[]"}
{"id": "plugins:plugins-configuration", "page": "plugins", "ref": "plugins-configuration", "title": "Plugin configuration", "content": "Plugins can have their own configuration, embedded in a  configuration file . Configuration options for plugins live within a  \"plugins\"  key in that file, which can be included at the root, database or table level. \n             Here is an example of some plugin configuration for a specific table: \n             [[[cog\nfrom metadata_doc import config_example\nconfig_example(cog, {\n    \"databases\": {\n        \"sf-trees\": {\n            \"tables\": {\n                \"Street_Tree_List\": {\n                    \"plugins\": {\n                        \"datasette-cluster-map\": {\n                            \"latitude_column\": \"lat\",\n                            \"longitude_column\": \"lng\"\n                        }\n                    }\n                }\n            }\n        }\n    }\n}) \n             ]]] \n             [[[end]]] \n             This tells the  datasette-cluster-map  column which latitude and longitude columns should be used for a table called  Street_Tree_List  inside a database file called  sf-trees.db .", "breadcrumbs": "[\"Plugins\"]", "references": "[]"}
{"id": "getting_started:getting-started-demo", "page": "getting_started", "ref": "getting-started-demo", "title": "Play with a live demo", "content": "The best way to experience Datasette for the first time is with a demo: \n             \n                 \n                     global-power-plants.datasettes.com  provides a searchable database of power plants around the world, using data from the  World Resources Institude  rendered using the  datasette-cluster-map  plugin. \n                 \n                 \n                     fivethirtyeight.datasettes.com  shows Datasette running against over 400 datasets imported from the  FiveThirtyEight GitHub repository .", "breadcrumbs": "[\"Getting started\"]", "references": "[{\"href\": \"https://global-power-plants.datasettes.com/global-power-plants/global-power-plants\", \"label\": \"global-power-plants.datasettes.com\"}, {\"href\": \"https://www.wri.org/publication/global-power-plant-database\", \"label\": \"World Resources Institude\"}, {\"href\": \"https://github.com/simonw/datasette-cluster-map\", \"label\": \"datasette-cluster-map\"}, {\"href\": \"https://fivethirtyeight.datasettes.com/fivethirtyeight\", \"label\": \"fivethirtyeight.datasettes.com\"}, {\"href\": \"https://github.com/fivethirtyeight/data\", \"label\": \"FiveThirtyEight GitHub repository\"}]"}
{"id": "changelog:permissions-fix-for-the-upsert-api", "page": "changelog", "ref": "permissions-fix-for-the-upsert-api", "title": "Permissions fix for the upsert API", "content": "The  /database/table/-/upsert API  had a minor permissions bug, only affecting Datasette instances that had configured the  insert-row  and  update-row  permissions to apply to a specific table rather than the database or instance as a whole. Full details in issue  #2262 . \n                 To avoid similar mistakes in the future the  datasette.permission_allowed()  method now specifies  default=  as a keyword-only argument.", "breadcrumbs": "[\"Changelog\", \"1.0a9 (2024-02-16)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/2262\", \"label\": \"#2262\"}]"}
{"id": "configuration:configuration-reference-permissions", "page": "configuration", "ref": "configuration-reference-permissions", "title": "Permissions configuration", "content": "Datasette's  authentication and permissions  system can also be configured using  datasette.yaml . \n                 Here is a simple example: \n                 [[[cog\nfrom metadata_doc import config_example\nimport textwrap\nconfig_example(cog, textwrap.dedent(\n  \"\"\"\n    # Instance is only available to users 'sharon' and 'percy':\n    allow:\n      id:\n      - sharon\n      - percy\n\n    # Only 'percy' is allowed access to the accounting database:\n    databases:\n      accounting:\n        allow:\n          id: percy\n  \"\"\").strip()\n  ) \n                 ]]] \n                 [[[end]]] \n                 Access permissions in datasette.yaml  has the full details.", "breadcrumbs": "[\"Configuration\", null]", "references": "[]"}
{"id": "authentication:authentication-permissions", "page": "authentication", "ref": "authentication-permissions", "title": "Permissions", "content": "Datasette has an extensive permissions system built-in, which can be further extended and customized by plugins. \n             The key question the permissions system answers is this: \n             \n                 Is this  actor  allowed to perform this  action , optionally against this particular  resource ? \n             \n             Actors  are  described above . \n             An  action  is a string describing the action the actor would like to perform. A full list is  provided below  - examples include  view-table  and  execute-sql . \n             A  resource  is the item the actor wishes to interact with - for example a specific database or table. Some actions, such as  permissions-debug , are not associated with a particular resource. \n             Datasette's built-in view permissions ( view-database ,  view-table  etc) default to  allow  - unless you  configure additional permission rules  unauthenticated users will be allowed to access content. \n             Permissions with potentially harmful effects should default to  deny . Plugin authors should account for this when designing new plugins - for example, the  datasette-upload-csvs  plugin defaults to deny so that installations don't accidentally allow unauthenticated users to create new tables by uploading a CSV file.", "breadcrumbs": "[\"Authentication and permissions\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-upload-csvs\", \"label\": \"datasette-upload-csvs\"}]"}
{"id": "changelog:permissions", "page": "changelog", "ref": "permissions", "title": "Permissions", "content": "Datasette also now has a built-in concept of  Permissions . The permissions system answers the following question: \n                 \n                     Is this  actor  allowed to perform this  action , optionally against this particular  resource ? \n                 \n                 You can use the new  \"allow\"  block syntax in  metadata.json  (or  metadata.yaml ) to set required permissions at the instance, database, table or canned query level. For example, to restrict access to the  fixtures.db  database to the  \"root\"  user: \n                 {\n    \"databases\": {\n        \"fixtures\": {\n            \"allow\": {\n                \"id\" \"root\"\n            }\n        }\n    }\n} \n                 See  Defining permissions with \"allow\" blocks  for more details. \n                 Plugins can implement their own custom permission checks using the new  permission_allowed(datasette, actor, action, resource)  hook. \n                 A new debug page at  /-/permissions  shows recent permission checks, to help administrators and plugin authors understand exactly what checks are being performed. This tool defaults to only being available to the root user, but can be exposed to other users by plugins that respond to the  permissions-debug  permission. ( #788 )", "breadcrumbs": "[\"Changelog\", \"0.44 (2020-06-11)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/788\", \"label\": \"#788\"}]"}
{"id": "changelog:permission-checks-now-consider-opinions-from-every-plugin", "page": "changelog", "ref": "permission-checks-now-consider-opinions-from-every-plugin", "title": "Permission checks now consider opinions from every plugin", "content": "The  datasette.permission_allowed()  method previously consulted every plugin that implemented the  permission_allowed()  plugin hook and obeyed the opinion of the last plugin to return a value. ( #2275 ) \n                 Datasette now consults every plugin and checks to see if any of them returned  False  (the veto rule), and if none of them did, it then checks to see if any of them returned  True . \n                 This is explained at length in the new documentation covering  How permissions are resolved .", "breadcrumbs": "[\"Changelog\", \"1.0a9 (2024-02-16)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/2275\", \"label\": \"#2275\"}]"}
{"id": "performance:performance", "page": "performance", "ref": "performance", "title": "Performance and caching", "content": "Datasette runs on top of SQLite, and SQLite has excellent performance.  For small databases almost any query should return in just a few milliseconds, and larger databases (100s of MBs or even GBs of data) should perform extremely well provided your queries make sensible use of database indexes. \n         That said, there are a number of tricks you can use to improve Datasette's performance.", "breadcrumbs": "[]", "references": "[]"}
{"id": "metadata:per-database-and-per-table-metadata", "page": "metadata", "ref": "per-database-and-per-table-metadata", "title": "Per-database and per-table metadata", "content": "Metadata at the top level of the file will be shown on the index page and in the\n                footer on every page of the site. The license and source is expected to apply to\n                all of your data. \n             You can also provide metadata at the per-database or per-table level, like this: \n             [[[cog\nmetadata_example(cog, {\n    \"databases\": {\n        \"database1\": {\n            \"source\": \"Alternative source\",\n            \"source_url\": \"http://example.com/\",\n            \"tables\": {\n                \"example_table\": {\n                    \"description_html\": \"Custom <em>table</em> description\",\n                    \"license\": \"CC BY 3.0 US\",\n                    \"license_url\": \"https://creativecommons.org/licenses/by/3.0/us/\"\n                }\n            }\n        }\n    }\n}) \n             ]]] \n             [[[end]]] \n             Each of the top-level metadata fields can be used at the database and table level.", "breadcrumbs": "[\"Metadata\"]", "references": "[]"}
{"id": "custom_templates:custom-pages-parameters", "page": "custom_templates", "ref": "custom-pages-parameters", "title": "Path parameters for pages", "content": "You can define custom pages that match multiple paths by creating files with  {variable}  definitions in their filenames. \n             For example, to capture any request to a URL matching  /about/* , you would create a template in the following location: \n             templates/pages/about/{slug}.html \n             A hit to  /about/news  would render that template and pass in a variable called  slug  with a value of  \"news\" . \n             If you use this mechanism don't forget to return a 404 if the referenced content could not be found. You can do this using  {{ raise_404() }}  described below. \n             Templates defined using custom page routes work particularly well with the  sql()  template function from  datasette-template-sql  or the  graphql()  template function from  datasette-graphql .", "breadcrumbs": "[\"Custom pages and templates\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-template-sql\", \"label\": \"datasette-template-sql\"}, {\"href\": \"https://github.com/simonw/datasette-graphql#the-graphql-template-function\", \"label\": \"datasette-graphql\"}]"}
{"id": "json_api:json-api-pagination", "page": "json_api", "ref": "json-api-pagination", "title": "Pagination", "content": "The default JSON representation includes a  \"next_url\"  key which can be used to access the next page of results. If that key is null or missing then it means you have reached the final page of results. \n             Other representations include pagination information in the  link  HTTP header. That header will look something like this: \n             link: <https://latest.datasette.io/fixtures/sortable.json?_next=d%2Cv>; rel=\"next\" \n             Here is an example Python function built using  requests  that returns a list of all of the paginated items from one of these API endpoints: \n             def paginate(url):\n    items = []\n    while url:\n        response = requests.get(url)\n        try:\n            url = response.links.get(\"next\").get(\"url\")\n        except AttributeError:\n            url = None\n        items.extend(response.json())\n    return items", "breadcrumbs": "[\"JSON API\"]", "references": "[{\"href\": \"https://requests.readthedocs.io/\", \"label\": \"requests\"}]"}
{"id": "sql_queries:id2", "page": "sql_queries", "ref": "id2", "title": "Pagination", "content": "Datasette's default table pagination is designed to be extremely efficient. SQL OFFSET/LIMIT pagination can have a significant performance penalty once you get into multiple thousands of rows, as each page still requires the database to scan through every preceding row to find the correct offset. \n             When paginating through tables, Datasette instead orders the rows in the table by their primary key and performs a WHERE clause against the last seen primary key for the previous page. For example: \n             select rowid, * from Tree_List where rowid > 200 order by rowid limit 101 \n             This represents page three for this particular table, with a page size of 100. \n             Note that we request 101 items in the limit clause rather than 100. This allows us to detect if we are on the last page of the results: if the query returns less than 101 rows we know we have reached the end of the pagination set. Datasette will only return the first 100 rows - the 101st is used purely to detect if there should be another page. \n             Since the where clause acts against the index on the primary key, the query is extremely fast even for records that are a long way into the overall pagination set.", "breadcrumbs": "[\"Running SQL queries\"]", "references": "[]"}
{"id": "pages:pages", "page": "pages", "ref": "pages", "title": "Pages and API endpoints", "content": "The Datasette web application offers a number of different pages that can be accessed to explore the data in question, each of which is accompanied by an equivalent JSON API.", "breadcrumbs": "[]", "references": "[]"}
{"id": "plugin_hooks:plugin-page-extras", "page": "plugin_hooks", "ref": "plugin-page-extras", "title": "Page extras", "content": "These plugin hooks can be used to affect the way HTML pages for different Datasette interfaces are rendered.", "breadcrumbs": "[\"Plugin hooks\"]", "references": "[]"}
{"id": "writing_plugins:writing-plugins-packaging", "page": "writing_plugins", "ref": "writing-plugins-packaging", "title": "Packaging a plugin", "content": "Plugins can be packaged using Python setuptools. You can see an example of a packaged plugin at  https://github.com/simonw/datasette-plugin-demos \n             The example consists of two files: a  setup.py  file that defines the plugin: \n             from setuptools import setup\n\nVERSION = \"0.1\"\n\nsetup(\n    name=\"datasette-plugin-demos\",\n    description=\"Examples of plugins for Datasette\",\n    author=\"Simon Willison\",\n    url=\"https://github.com/simonw/datasette-plugin-demos\",\n    license=\"Apache License, Version 2.0\",\n    version=VERSION,\n    py_modules=[\"datasette_plugin_demos\"],\n    entry_points={\n        \"datasette\": [\n            \"plugin_demos = datasette_plugin_demos\"\n        ]\n    },\n    install_requires=[\"datasette\"],\n) \n             And a Python module file,  datasette_plugin_demos.py , that implements the plugin: \n             from datasette import hookimpl\nimport random\n\n\n@hookimpl\ndef prepare_jinja2_environment(env):\n    env.filters[\"uppercase\"] = lambda u: u.upper()\n\n\n@hookimpl\ndef prepare_connection(conn):\n    conn.create_function(\n        \"random_integer\", 2, random.randint\n    ) \n             Having built a plugin in this way you can turn it into an installable package using the following command: \n             python3 setup.py sdist \n             This will create a  .tar.gz  file in the  dist/  directory. \n             You can then install your new plugin into a Datasette virtual environment or Docker container using  pip : \n             pip install datasette-plugin-demos-0.1.tar.gz \n             To learn how to upload your plugin to  PyPI  for use by other people, read the PyPA guide to  Packaging and distributing projects .", "breadcrumbs": "[\"Writing plugins\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-plugin-demos\", \"label\": \"https://github.com/simonw/datasette-plugin-demos\"}, {\"href\": \"https://pypi.org/\", \"label\": \"PyPI\"}, {\"href\": \"https://packaging.python.org/tutorials/distributing-packages/\", \"label\": \"Packaging and distributing projects\"}]"}
{"id": "changelog:other-small-fixes", "page": "changelog", "ref": "other-small-fixes", "title": "Other small fixes", "content": "Made several performance improvements to the database schema introspection code that runs when Datasette first starts up. ( #1555 ) \n                     \n                     \n                         Label columns detected for foreign keys are now case-insensitive, so  Name  or  TITLE  will be detected in the same way as  name  or  title . ( #1544 ) \n                     \n                     \n                         Upgraded Pluggy dependency to 1.0. ( #1575 ) \n                     \n                     \n                         Now using  Plausible analytics  for the Datasette documentation. \n                     \n                     \n                         explain query plan  is now allowed with varying amounts of whitespace in the query. ( #1588 ) \n                     \n                     \n                         New  CLI reference  page showing the output of  --help  for each of the  datasette  sub-commands. This lead to several small improvements to the help copy. ( #1594 ) \n                     \n                     \n                         Fixed bug where writable canned queries could not be used with custom templates.  ( #1547 ) \n                     \n                     \n                         Improved fix for a bug where columns with a underscore prefix could result in unnecessary hidden form fields. ( #1527 )", "breadcrumbs": "[\"Changelog\", \"0.60 (2022-01-13)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/1555\", \"label\": \"#1555\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1544\", \"label\": \"#1544\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1575\", \"label\": \"#1575\"}, {\"href\": \"https://plausible.io/\", \"label\": \"Plausible analytics\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1588\", \"label\": \"#1588\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1594\", \"label\": \"#1594\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1547\", \"label\": \"#1547\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1527\", \"label\": \"#1527\"}]"}
{"id": "authentication:authentication-permissions-other", "page": "authentication", "ref": "authentication-permissions-other", "title": "Other permissions in ", "content": "For all other permissions, you can use one or more  \"permissions\"  blocks in your  datasette.yaml  configuration file. \n             To grant access to the  permissions debug tool  to all signed in users, you can grant  permissions-debug  to any actor with an  id  matching the wildcard  *  by adding this a the root of your configuration: \n             [[[cog\nconfig_example(cog, \"\"\"\n    permissions:\n      debug-menu:\n        id: '*'\n\"\"\") \n             ]]] \n             [[[end]]] \n             To grant  create-table  to the user with  id  of  editor  for the  docs  database: \n             [[[cog\nconfig_example(cog, \"\"\"\n    databases:\n      docs:\n        permissions:\n          create-table:\n            id: editor\n\"\"\") \n             ]]] \n             [[[end]]] \n             And for  insert-row  against the  reports  table in that  docs  database: \n             [[[cog\nconfig_example(cog, \"\"\"\n    databases:\n      docs:\n        tables:\n          reports:\n            permissions:\n              insert-row:\n                id: editor\n\"\"\") \n             ]]] \n             [[[end]]] \n             The  permissions debug tool  can be useful for helping test permissions that you have configured in this way.", "breadcrumbs": "[\"Authentication and permissions\"]", "references": "[]"}
{"id": "changelog:id36", "page": "changelog", "ref": "id36", "title": "Other changes", "content": "Datasette can now open multiple database files with the same name, e.g. if you run  datasette path/to/one.db path/to/other/one.db . ( #509 ) \n                     \n                     \n                         datasette publish cloudrun  now sets  force_https_urls  for every deployment, fixing some incorrect  http://  links. ( #1178 ) \n                     \n                     \n                         Fixed a bug in the example nginx configuration in  Running Datasette behind a proxy . ( #1091 ) \n                     \n                     \n                         The  Datasette Ecosystem  documentation page has been reduced in size in favour of the  datasette.io   tools  and  plugins  directories. ( #1182 ) \n                     \n                     \n                         The request object now provides a  request.full_path  property, which returns the path including any query string. ( #1184 ) \n                     \n                     \n                         Better error message for disallowed  PRAGMA  clauses in SQL queries. ( #1185 ) \n                     \n                     \n                         datasette publish heroku  now deploys using  python-3.8.7 . \n                     \n                     \n                         New plugin testing documentation on  Testing outbound HTTP calls with pytest-httpx . ( #1198 ) \n                     \n                     \n                         All  ?_*  query string parameters passed to the table page are now persisted in hidden form fields, so parameters such as  ?_size=10  will be correctly passed to the next page when query filters are changed. ( #1194 ) \n                     \n                     \n                         Fixed a bug loading a database file called  test-database (1).sqlite . ( #1181 )", "breadcrumbs": "[\"Changelog\", \"0.54 (2021-01-25)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/509\", \"label\": \"#509\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1178\", \"label\": \"#1178\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1091\", \"label\": \"#1091\"}, {\"href\": \"https://datasette.io/tools\", \"label\": \"tools\"}, {\"href\": \"https://datasette.io/plugins\", \"label\": \"plugins\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1182\", \"label\": \"#1182\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1184\", \"label\": \"#1184\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1185\", \"label\": \"#1185\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1198\", \"label\": \"#1198\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1194\", \"label\": \"#1194\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1181\", \"label\": \"#1181\"}]"}
{"id": "changelog:other-changes", "page": "changelog", "ref": "other-changes", "title": "Other changes", "content": "The new  DATASETTE_TRACE_PLUGINS=1 environment variable  turns on detailed trace output for every executed plugin hook, useful for debugging and understanding how the plugin system works at a low level. ( #2274 ) \n                     \n                     \n                         Datasette on Python 3.9 or above marks its non-cryptographic uses of the MD5 hash function as  usedforsecurity=False , for compatibility with FIPS systems. ( #2270 ) \n                     \n                     \n                         SQL relating to  Datasette's internal database  now executes inside a transaction, avoiding a potential database locked error. ( #2273 ) \n                     \n                     \n                         The  /-/threads  debug page now identifies the database in the name associated with each dedicated write thread. ( #2265 ) \n                     \n                     \n                         The  /db/-/create  API now fires a  insert-rows  event if rows were inserted after the table was created. ( #2260 )", "breadcrumbs": "[\"Changelog\", \"1.0a9 (2024-02-16)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/2274\", \"label\": \"#2274\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2270\", \"label\": \"#2270\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2273\", \"label\": \"#2273\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2265\", \"label\": \"#2265\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2260\", \"label\": \"#2260\"}]"}
{"id": "plugins:one-off-plugins-using-plugins-dir", "page": "plugins", "ref": "one-off-plugins-using-plugins-dir", "title": "One-off plugins using --plugins-dir", "content": "You can also define one-off per-project plugins by saving them as  plugin_name.py  functions in a  plugins/  folder and then passing that folder to  datasette  using the  --plugins-dir  option: \n                 datasette mydb.db --plugins-dir=plugins/", "breadcrumbs": "[\"Plugins\", \"Installing plugins\"]", "references": "[]"}
{"id": "deploying:nginx-proxy-configuration", "page": "deploying", "ref": "nginx-proxy-configuration", "title": "Nginx proxy configuration", "content": "Here is an example of an  nginx  configuration file that will proxy traffic to Datasette: \n                 daemon off;\n\nevents {\n  worker_connections  1024;\n}\nhttp {\n  server {\n    listen 80;\n    location /my-datasette {\n      proxy_pass http://127.0.0.1:8009/my-datasette;\n      proxy_set_header Host $host;\n    }\n  }\n} \n                 You can also use the  --uds  option to Datasette to listen on a Unix domain socket instead of a port, configuring the nginx upstream proxy like this: \n                 daemon off;\nevents {\n  worker_connections  1024;\n}\nhttp {\n  server {\n    listen 80;\n    location /my-datasette {\n      proxy_pass http://datasette/my-datasette;\n      proxy_set_header Host $host;\n    }\n  }\n  upstream datasette {\n    server unix:/tmp/datasette.sock;\n  }\n} \n                 Then run Datasette with  datasette --uds /tmp/datasette.sock path/to/database.db --setting base_url /my-datasette/ .", "breadcrumbs": "[\"Deploying Datasette\", \"Running Datasette behind a proxy\"]", "references": "[{\"href\": \"https://nginx.org/\", \"label\": \"nginx\"}]"}
{"id": "changelog:new-visual-design", "page": "changelog", "ref": "new-visual-design", "title": "New visual design", "content": "Datasette is no longer white and grey with blue and purple links!  Natalie Downe  has been working on a visual refresh, the first iteration of which is included in this release. ( #1056 )", "breadcrumbs": "[\"Changelog\", \"0.51 (2020-10-31)\"]", "references": "[{\"href\": \"https://twitter.com/natbat\", \"label\": \"Natalie Downe\"}, {\"href\": \"https://github.com/simonw/datasette/pull/1056\", \"label\": \"#1056\"}]"}
{"id": "changelog:new-plugin-hooks", "page": "changelog", "ref": "new-plugin-hooks", "title": "New plugin hooks", "content": "register_magic_parameters(datasette)  can be used to define new types of magic canned query parameters. \n                     \n                     \n                         startup(datasette)  can run custom code when Datasette first starts up.  datasette-init  is a new plugin that uses this hook to create database tables and views on startup if they have not yet been created. ( #834 ) \n                     \n                     \n                         canned_queries(datasette, database, actor)  lets plugins provide additional canned queries beyond those defined in Datasette's metadata. See  datasette-saved-queries  for an example of this hook in action. ( #852 ) \n                     \n                     \n                         forbidden(datasette, request, message)  is a hook for customizing how Datasette responds to 403 forbidden errors. ( #812 )", "breadcrumbs": "[\"Changelog\", \"0.45 (2020-07-01)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-init\", \"label\": \"datasette-init\"}, {\"href\": \"https://github.com/simonw/datasette/issues/834\", \"label\": \"#834\"}, {\"href\": \"https://github.com/simonw/datasette-saved-queries\", \"label\": \"datasette-saved-queries\"}, {\"href\": \"https://github.com/simonw/datasette/issues/852\", \"label\": \"#852\"}, {\"href\": \"https://github.com/simonw/datasette/issues/812\", \"label\": \"#812\"}]"}
{"id": "changelog:new-plugin-hook-extra-template-vars", "page": "changelog", "ref": "new-plugin-hook-extra-template-vars", "title": "New plugin hook: extra_template_vars", "content": "The  extra_template_vars(template, database, table, columns, view_name, request, datasette)  plugin hook allows plugins to inject their own additional variables into the Datasette template context. This can be used in conjunction with custom templates to customize the Datasette interface.  datasette-auth-github  uses this hook to add custom HTML to the new top navigation bar (which is designed to be modified by plugins, see  #540 ).", "breadcrumbs": "[\"Changelog\", \"0.29 (2019-07-07)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette-auth-github\", \"label\": \"datasette-auth-github\"}, {\"href\": \"https://github.com/simonw/datasette/issues/540\", \"label\": \"#540\"}]"}
{"id": "changelog:new-plugin-hook-asgi-wrapper", "page": "changelog", "ref": "new-plugin-hook-asgi-wrapper", "title": "New plugin hook: asgi_wrapper", "content": "The  asgi_wrapper(datasette)  plugin hook allows plugins to entirely wrap the Datasette ASGI application in their own ASGI middleware. ( #520 ) \n                 Two new plugins take advantage of this hook: \n                 \n                     \n                         datasette-auth-github  adds a authentication layer: users will have to sign in using their GitHub account before they can view data or interact with Datasette. You can also use it to restrict access to specific GitHub users, or to members of specified GitHub  organizations  or  teams . \n                     \n                     \n                         datasette-cors  allows you to configure  CORS headers  for your Datasette instance. You can use this to enable JavaScript running on a whitelisted set of domains to make  fetch()  calls to the JSON API provided by your Datasette instance.", "breadcrumbs": "[\"Changelog\", \"0.29 (2019-07-07)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/520\", \"label\": \"#520\"}, {\"href\": \"https://github.com/simonw/datasette-auth-github\", \"label\": \"datasette-auth-github\"}, {\"href\": \"https://help.github.com/en/articles/about-organizations\", \"label\": \"organizations\"}, {\"href\": \"https://help.github.com/en/articles/organizing-members-into-teams\", \"label\": \"teams\"}, {\"href\": \"https://github.com/simonw/datasette-cors\", \"label\": \"datasette-cors\"}, {\"href\": \"https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS\", \"label\": \"CORS headers\"}]"}
{"id": "changelog:new-features", "page": "changelog", "ref": "new-features", "title": "New features", "content": "If an error occurs while executing a user-provided SQL query, that query is now re-displayed in an editable form along with the error message. ( #619 ) \n                     \n                     \n                         New  ?_col=  and  ?_nocol=  parameters to show and hide columns in a table, plus an interface for hiding and showing columns in the column cog menu. ( #615 ) \n                     \n                     \n                         A new  ?_facet_size=  parameter for customizing the number of facet results returned on a table or view page. ( #1332 ) \n                     \n                     \n                         ?_facet_size=max  sets that to the maximum, which defaults to 1,000 and is controlled by the the  max_returned_rows  setting. If facet results are truncated the \u2026 at the bottom of the facet list now links to this parameter. ( #1337 ) \n                     \n                     \n                         ?_nofacet=1  option to disable all facet calculations on a page, used as a performance optimization for CSV exports and  ?_shape=array/object . ( #1349 ,  #263 ) \n                     \n                     \n                         ?_nocount=1  option to disable full query result counts. ( #1353 ) \n                     \n                     \n                         ?_trace=1  debugging option is now controlled by the new  trace_debug  setting, which is turned off by default. ( #1359 )", "breadcrumbs": "[\"Changelog\", \"0.57 (2021-06-05)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/619\", \"label\": \"#619\"}, {\"href\": \"https://github.com/simonw/datasette/issues/615\", \"label\": \"#615\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1332\", \"label\": \"#1332\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1337\", \"label\": \"#1337\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1349\", \"label\": \"#1349\"}, {\"href\": \"https://github.com/simonw/datasette/issues/263\", \"label\": \"#263\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1353\", \"label\": \"#1353\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1359\", \"label\": \"#1359\"}]"}
{"id": "changelog:new-configuration-settings", "page": "changelog", "ref": "new-configuration-settings", "title": "New configuration settings", "content": "Datasette's  Settings  now also supports boolean settings. A number of new\n                    configuration options have been added: \n                 \n                     \n                         num_sql_threads  - the number of threads used to execute SQLite queries. Defaults to 3. \n                     \n                     \n                         allow_facet  - enable or disable custom  Facets  using the  _facet=  parameter. Defaults to on. \n                     \n                     \n                         suggest_facets  - should Datasette suggest facets? Defaults to on. \n                     \n                     \n                         allow_download  - should users be allowed to download the entire SQLite database? Defaults to on. \n                     \n                     \n                         allow_sql  - should users be allowed to execute custom SQL queries? Defaults to on. \n                     \n                     \n                         default_cache_ttl  - Default HTTP caching max-age header in seconds. Defaults to 365 days - caching can be disabled entirely by settings this to 0. \n                     \n                     \n                         cache_size_kb  - Set the amount of memory SQLite uses for its  per-connection cache , in KB. \n                     \n                     \n                         allow_csv_stream  - allow users to stream entire result sets as a single CSV file. Defaults to on. \n                     \n                     \n                         max_csv_mb  - maximum size of a returned CSV file in MB. Defaults to 100MB, set to 0 to disable this limit.", "breadcrumbs": "[\"Changelog\", \"0.23 (2018-06-18)\"]", "references": "[{\"href\": \"https://www.sqlite.org/pragma.html#pragma_cache_size\", \"label\": \"per-connection cache\"}]"}
{"id": "sql_queries:sql-parameters", "page": "sql_queries", "ref": "sql-parameters", "title": "Named parameters", "content": "Datasette has special support for SQLite named parameters. Consider a SQL query like this: \n             select * from Street_Tree_List\nwhere \"PermitNotes\" like :notes\nand \"qSpecies\" = :species \n             If you execute this query using the custom query editor, Datasette will extract the two named parameters and use them to construct form fields for you to provide values. \n             You can also provide values for these fields by constructing a URL: \n             /mydatabase?sql=select...&species=44 \n             SQLite string escaping rules will be applied to values passed using named parameters - they will be wrapped in quotes and their content will be correctly escaped. \n             Values from named parameters are treated as SQLite strings. If you need to perform numeric comparisons on them you should cast them to an integer or float first using  cast(:name as integer)  or  cast(:name as real) , for example: \n             select * from Street_Tree_List\nwhere latitude > cast(:min_latitude as real)\nand latitude < cast(:max_latitude as real) \n             Datasette disallows custom SQL queries containing the string PRAGMA (with a small number  of exceptions ) as SQLite pragma statements can be used to change database settings at runtime. If you need to include the string \"pragma\" in a query you can do so safely using a named parameter.", "breadcrumbs": "[\"Running SQL queries\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/761\", \"label\": \"of exceptions\"}]"}
{"id": "changelog:named-in-memory-database-support", "page": "changelog", "ref": "named-in-memory-database-support", "title": "Named in-memory database support", "content": "As part of the work building the  _internal  database, Datasette now supports named in-memory databases that can be shared across multiple connections. This allows plugins to create in-memory databases which will persist data for the lifetime of the Datasette server process. ( #1151 ) \n                 The new  memory_name=  parameter to the  Database class  can be used to create named, shared in-memory databases.", "breadcrumbs": "[\"Changelog\", \"0.54 (2021-01-25)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/1151\", \"label\": \"#1151\"}]"}
{"id": "changelog:miscellaneous", "page": "changelog", "ref": "miscellaneous", "title": "Miscellaneous", "content": "Got JSON data in one of your columns? Use the new  ?_json=COLNAME  argument\n                            to tell Datasette to return that JSON value directly rather than encoding it\n                            as a string. \n                     \n                     \n                         If you just want an array of the first value of each row, use the new\n                             ?_shape=arrayfirst  option -  example .", "breadcrumbs": "[\"Changelog\", \"0.23 (2018-06-18)\"]", "references": "[{\"href\": \"https://latest.datasette.io/fixtures.json?sql=select+neighborhood+from+facetable+order+by+pk+limit+101&_shape=arrayfirst\", \"label\": \"example\"}]"}
{"id": "changelog:minor-fixes", "page": "changelog", "ref": "minor-fixes", "title": "Minor fixes", "content": "Datasette no longer attempts to run SQL queries in parallel when rendering a table page, as this was leading to some rare crashing bugs. ( #2189 ) \n                     \n                     \n                         Fixed warning:  DeprecationWarning: pkg_resources is deprecated as an API  ( #2057 ) \n                     \n                     \n                         Fixed bug where  ?_extra=columns  parameter returned an incorrectly shaped response. ( #2230 )", "breadcrumbs": "[\"Changelog\", \"1.0a8 (2024-02-07)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/2189\", \"label\": \"#2189\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2057\", \"label\": \"#2057\"}, {\"href\": \"https://github.com/simonw/datasette/issues/2230\", \"label\": \"#2230\"}]"}
{"id": "metadata:id2", "page": "metadata", "ref": "id2", "title": "Metadata reference", "content": "A full reference of every supported option in a  metadata.json  or  metadata.yaml  file.", "breadcrumbs": "[\"Metadata\"]", "references": "[]"}
{"id": "metadata:id1", "page": "metadata", "ref": "id1", "title": "Metadata", "content": "Data loves metadata. Any time you run Datasette you can optionally include a\n            YAML or JSON file with metadata about your databases and tables. Datasette will then\n            display that information in the web UI. \n         Run Datasette like this: \n         datasette database1.db database2.db --metadata metadata.yaml \n         Your  metadata.yaml  file can look something like this: \n         [[[cog\nfrom metadata_doc import metadata_example\nmetadata_example(cog, {\n    \"title\": \"Custom title for your index page\",\n    \"description\": \"Some description text can go here\",\n    \"license\": \"ODbL\",\n    \"license_url\": \"https://opendatacommons.org/licenses/odbl/\",\n    \"source\": \"Original Data Source\",\n    \"source_url\": \"http://example.com/\"\n}) \n         ]]] \n         [[[end]]] \n         Choosing YAML over JSON adds support for multi-line strings and comments. \n         The above metadata will be displayed on the index page of your Datasette-powered\n            site. The source and license information will also be included in the footer of\n            every page served by Datasette. \n         Any special HTML characters in  description  will be escaped. If you want to\n            include HTML in your description, you can use a  description_html  property\n            instead.", "breadcrumbs": "[]", "references": "[]"}
{"id": "changelog:v0-28-medium-changes", "page": "changelog", "ref": "v0-28-medium-changes", "title": "Medium changes", "content": "Datasette now conforms to the  Black coding style  ( #449 ) - and has a unit test to enforce this in the future \n                     \n                     \n                         \n                             \n                                 New  Special table arguments : \n                                 \n                                     \n                                         \n                                             ?columnname__in=value1,value2,value3  filter for executing SQL IN queries against a table, see  Table arguments  ( #433 ) \n                                         \n                                         \n                                             ?columnname__date=yyyy-mm-dd  filter which returns rows where the spoecified datetime column falls on the specified date ( 583b22a ) \n                                         \n                                         \n                                             ?tags__arraycontains=tag  filter which acts against a JSON array contained in a column ( 78e45ea ) \n                                         \n                                         \n                                             ?_where=sql-fragment  filter for the table view  ( #429 ) \n                                         \n                                         \n                                             ?_fts_table=mytable  and  ?_fts_pk=mycolumn  query string options can be used to specify which FTS table to use for a search query - see  Configuring full-text search for a table or view  ( #428 ) \n                                         \n                                     \n                                 \n                             \n                         \n                     \n                     \n                         You can now pass the same table filter multiple times - for example,  ?content__not=world&content__not=hello  will return all rows where the content column is neither  hello  or  world  ( #288 ) \n                     \n                     \n                         You can now specify  about  and  about_url  metadata (in addition to  source  and  license ) linking to further information about a project - see  Source, license and about \n                     \n                     \n                         New  ?_trace=1  parameter now adds debug information showing every SQL query that was executed while constructing the page ( #435 ) \n                     \n                     \n                         datasette inspect  now just calculates table counts, and does not introspect other database metadata ( #462 ) \n                     \n                     \n                         Removed  /-/inspect  page entirely - this will be replaced by something similar in the future, see  #465 \n                     \n                     \n                         Datasette can now run against an in-memory SQLite database. You can do this by starting it without passing any files or by using the new  --memory  option to  datasette serve . This can be useful for experimenting with SQLite queries that do not access any data, such as  SELECT 1+1  or  SELECT sqlite_version() .", "breadcrumbs": "[\"Changelog\", \"0.28 (2019-05-19)\"]", "references": "[{\"href\": \"https://github.com/python/black\", \"label\": \"Black coding style\"}, {\"href\": \"https://github.com/simonw/datasette/pull/449\", \"label\": \"#449\"}, {\"href\": \"https://github.com/simonw/datasette/issues/433\", \"label\": \"#433\"}, {\"href\": \"https://github.com/simonw/datasette/commit/583b22aa28e26c318de0189312350ab2688c90b1\", \"label\": \"583b22a\"}, {\"href\": \"https://github.com/simonw/datasette/commit/78e45ead4d771007c57b307edf8fc920101f8733\", \"label\": \"78e45ea\"}, {\"href\": \"https://github.com/simonw/datasette/issues/429\", \"label\": \"#429\"}, {\"href\": \"https://github.com/simonw/datasette/issues/428\", \"label\": \"#428\"}, {\"href\": \"https://github.com/simonw/datasette/issues/288\", \"label\": \"#288\"}, {\"href\": \"https://github.com/simonw/datasette/issues/435\", \"label\": \"#435\"}, {\"href\": \"https://github.com/simonw/datasette/issues/462\", \"label\": \"#462\"}, {\"href\": \"https://github.com/simonw/datasette/issues/465\", \"label\": \"#465\"}]"}
{"id": "spatialite:making-use-of-a-spatial-index", "page": "spatialite", "ref": "making-use-of-a-spatial-index", "title": "Making use of a spatial index", "content": "SpatiaLite spatial indexes are R*Trees. They allow you to run efficient bounding box queries using a sub-select, with a similar pattern to that used for  Searches using custom SQL . \n             In the above example, the resulting index will be called  idx_museums_point_geom . This takes the form of a SQLite virtual table. You can inspect its contents using the following query: \n             select * from idx_museums_point_geom limit 10; \n             Here's a live example:  timezones-api.datasette.io/timezones/idx_timezones_Geometry \n             \n                 \n                     \n                     \n                     \n                     \n                     \n                     \n                         \n                             \n                                 pkid \n                             \n                             \n                                 xmin \n                             \n                             \n                                 xmax \n                             \n                             \n                                 ymin \n                             \n                             \n                                 ymax \n                             \n                         \n                     \n                     \n                         \n                             \n                                 1 \n                             \n                             \n                                 -8.601725578308105 \n                             \n                             \n                                 -2.4930307865142822 \n                             \n                             \n                                 4.162120819091797 \n                             \n                             \n                                 10.74019718170166 \n                             \n                         \n                         \n                             \n                                 2 \n                             \n                             \n                                 -3.2607860565185547 \n                             \n                             \n                                 1.27329421043396 \n                             \n                             \n                                 4.539252281188965 \n                             \n                             \n                                 11.174856185913086 \n                             \n                         \n                         \n                             \n                                 3 \n                             \n                             \n                                 32.997581481933594 \n                             \n                             \n                                 47.98238754272461 \n                             \n                             \n                                 3.3974475860595703 \n                             \n                             \n                                 14.894054412841797 \n                             \n                         \n                         \n                             \n                                 4 \n                             \n                             \n                                 -8.66890811920166 \n                             \n                             \n                                 11.997337341308594 \n                             \n                             \n                                 18.9681453704834 \n                             \n                             \n                                 37.296207427978516 \n                             \n                         \n                         \n                             \n                                 5 \n                             \n                             \n                                 36.43336486816406 \n                             \n                             \n                                 43.300174713134766 \n                             \n                             \n                                 12.354820251464844 \n                             \n                             \n                                 18.070993423461914 \n                             \n                         \n                     \n                 \n             \n             You can now construct efficient bounding box queries that will make use of the index like this: \n             select * from museums where museums.rowid in (\n    SELECT pkid FROM idx_museums_point_geom\n    -- left-hand-edge of point > left-hand-edge of bbox (minx)\n    where xmin > :bbox_minx\n    -- right-hand-edge of point < right-hand-edge of bbox (maxx)\n    and xmax < :bbox_maxx\n    -- bottom-edge of point > bottom-edge of bbox (miny)\n    and ymin > :bbox_miny\n    -- top-edge of point < top-edge of bbox (maxy)\n    and ymax < :bbox_maxy\n); \n             Spatial indexes can be created against polygon columns as well as point columns, in which case they will represent the minimum bounding rectangle of that polygon. This is useful for accelerating  within  queries, as seen in the Timezones API example.", "breadcrumbs": "[\"SpatiaLite\"]", "references": "[{\"href\": \"https://timezones-api.datasette.io/timezones/idx_timezones_Geometry\", \"label\": \"timezones-api.datasette.io/timezones/idx_timezones_Geometry\"}]"}
{"id": "changelog:magic-parameters-for-canned-queries", "page": "changelog", "ref": "magic-parameters-for-canned-queries", "title": "Magic parameters for canned queries", "content": "Canned queries now support  Magic parameters , which can be used to insert or select automatically generated values. For example: \n                 insert into logs\n  (user_id, timestamp)\nvalues\n  (:_actor_id, :_now_datetime_utc) \n                 This inserts the currently authenticated actor ID and the current datetime. ( #842 )", "breadcrumbs": "[\"Changelog\", \"0.45 (2020-07-01)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/842\", \"label\": \"#842\"}]"}
{"id": "sql_queries:canned-queries-magic-parameters", "page": "sql_queries", "ref": "canned-queries-magic-parameters", "title": "Magic parameters", "content": "Named parameters that start with an underscore are special: they can be used to automatically add values created by Datasette that are not contained in the incoming form fields or query string. \n                 These magic parameters are only supported for canned queries: to avoid security issues (such as queries that extract the user's private cookies) they are not available to SQL that is executed by the user as a custom SQL query. \n                 Available magic parameters are: \n                 \n                     \n                         _actor_*  - e.g.  _actor_id ,  _actor_name \n                         \n                             Fields from the currently authenticated  Actors . \n                         \n                     \n                     \n                         _header_*  - e.g.  _header_user_agent \n                         \n                             Header from the incoming HTTP request. The key should be in lower case and with hyphens converted to underscores e.g.  _header_user_agent  or  _header_accept_language . \n                         \n                     \n                     \n                         _cookie_*  - e.g.  _cookie_lang \n                         \n                             The value of the incoming cookie of that name. \n                         \n                     \n                     \n                         _now_epoch \n                         \n                             The number of seconds since the Unix epoch. \n                         \n                     \n                     \n                         _now_date_utc \n                         \n                             The date in UTC, e.g.  2020-06-01 \n                         \n                     \n                     \n                         _now_datetime_utc \n                         \n                             The ISO 8601 datetime in UTC, e.g.  2020-06-24T18:01:07Z \n                         \n                     \n                     \n                         _random_chars_*  - e.g.  _random_chars_128 \n                         \n                             A random string of characters of the specified length. \n                         \n                     \n                 \n                 Here's an example configuration that adds a message from the authenticated user, storing various pieces of additional metadata using magic parameters: \n                 [[[cog\nconfig_example(cog, \"\"\"\ndatabases:\n  mydatabase:\n    queries:\n      add_message:\n        allow:\n          id: \"*\"\n        sql: |-\n          INSERT INTO messages (\n            user_id, message, datetime\n          ) VALUES (\n            :_actor_id, :message, :_now_datetime_utc\n          )\n        write: true\n\"\"\") \n                 ]]] \n                 [[[end]]] \n                 The form presented at  /mydatabase/add_message  will have just a field for  message  - the other parameters will be populated by the magic parameter mechanism. \n                 Additional custom magic parameters can be added by plugins using the  register_magic_parameters(datasette)  hook.", "breadcrumbs": "[\"Running SQL queries\", \"Canned queries\"]", "references": "[]"}
{"id": "changelog:log-out", "page": "changelog", "ref": "log-out", "title": "Log out", "content": "The  ds_actor cookie  can be used by plugins (or by Datasette's  --root mechanism ) to authenticate users. The new  /-/logout  page provides a way to clear that cookie. \n                 A \"Log out\" button now shows in the global navigation provided the user is authenticated using the  ds_actor  cookie. ( #840 )", "breadcrumbs": "[\"Changelog\", \"0.45 (2020-07-01)\"]", "references": "[{\"href\": \"https://github.com/simonw/datasette/issues/840\", \"label\": \"#840\"}]"}
{"id": "installation:loading-spatialite", "page": "installation", "ref": "loading-spatialite", "title": "Loading SpatiaLite", "content": "The  datasetteproject/datasette  image includes a recent version of the\n                         SpatiaLite extension  for SQLite. To load and enable that\n                        module, use the following command: \n                     docker run -p 8001:8001 -v `pwd`:/mnt \\\n    datasetteproject/datasette \\\n    datasette -p 8001 -h 0.0.0.0 /mnt/fixtures.db \\\n    --load-extension=spatialite \n                     You can confirm that SpatiaLite is successfully loaded by visiting\n                         http://127.0.0.1:8001/-/versions", "breadcrumbs": "[\"Installation\", \"Advanced installation options\", \"Using Docker\"]", "references": "[{\"href\": \"http://127.0.0.1:8001/-/versions\", \"label\": \"http://127.0.0.1:8001/-/versions\"}]"}
{"id": "binary_data:binary-linking", "page": "binary_data", "ref": "binary-linking", "title": "Linking to binary downloads", "content": "The  .blob  output format is used to return binary data. It requires a  _blob_column=  query string argument specifying which BLOB column should be downloaded, for example: \n             https://latest.datasette.io/fixtures/binary_data/1.blob?_blob_column=data \n             This output format can also be used to return binary data from an arbitrary SQL query. Since such queries do not specify an exact row, an additional  ?_blob_hash=  parameter can be used to specify the SHA-256 hash of the value that is being linked to. \n             Consider the query  select data from binary_data  -  demonstrated here . \n             That page links to the binary value downloads. Those links look like this: \n             https://latest.datasette.io/fixtures.blob?sql=select+data+from+binary_data&_blob_column=data&_blob_hash=f3088978da8f9aea479ffc7f631370b968d2e855eeb172bea7f6c7a04262bb6d \n             These  .blob  links are also returned in the  .csv  exports Datasette provides for binary tables and queries, since the CSV format does not have a mechanism for representing binary data.", "breadcrumbs": "[\"Binary data\"]", "references": "[{\"href\": \"https://latest.datasette.io/fixtures/binary_data/1.blob?_blob_column=data\", \"label\": \"https://latest.datasette.io/fixtures/binary_data/1.blob?_blob_column=data\"}, {\"href\": \"https://latest.datasette.io/fixtures?sql=select+data+from+binary_data\", \"label\": \"demonstrated here\"}, {\"href\": \"https://latest.datasette.io/fixtures.blob?sql=select+data+from+binary_data&_blob_column=data&_blob_hash=f3088978da8f9aea479ffc7f631370b968d2e855eeb172bea7f6c7a04262bb6d\", \"label\": \"https://latest.datasette.io/fixtures.blob?sql=select+data+from+binary_data&_blob_column=data&_blob_hash=f3088978da8f9aea479ffc7f631370b968d2e855eeb172bea7f6c7a04262bb6d\"}]"}
{"id": "changelog:javascript-plugins", "page": "changelog", "ref": "javascript-plugins", "title": "JavaScript plugins", "content": "Datasette now includes a  JavaScript plugins mechanism , allowing JavaScript to customize Datasette in a way that can collaborate with other plugins. \n                 This provides two initial hooks, with more to come in the future: \n                 \n                     \n                         makeAboveTablePanelConfigs()  can add additional panels to the top of the table page. \n                     \n                     \n                         makeColumnActions()  can add additional actions to the column menu. \n                     \n                 \n                 Thanks  Cameron Yick  for contributing this feature. ( #2052 )", "breadcrumbs": "[\"Changelog\", \"1.0a8 (2024-02-07)\"]", "references": "[{\"href\": \"https://github.com/hydrosquall\", \"label\": \"Cameron Yick\"}, {\"href\": \"https://github.com/simonw/datasette/pull/2052\", \"label\": \"#2052\"}]"}
{"id": "javascript_plugins:id1", "page": "javascript_plugins", "ref": "id1", "title": "JavaScript plugins", "content": "Datasette can run custom JavaScript in several different ways: \n         \n             \n                 Datasette plugins written in Python can use the  extra_js_urls()  or  extra_body_script()  plugin hooks to inject JavaScript into a page \n             \n             \n                 Datasette instances with  custom templates  can include additional JavaScript in those templates \n             \n             \n                 The  extra_js_urls  key in  datasette.yaml   can be used to include extra JavaScript \n             \n         \n         There are no limitations on what this JavaScript can do. It is executed directly by the browser, so it can manipulate the DOM, fetch additional data and do anything else that JavaScript is capable of. \n         \n             Custom JavaScript has security implications, especially for authenticated Datasette instances where the JavaScript might run in the context of the authenticated user. It's important to carefully review any JavaScript you run in your Datasette instance.", "breadcrumbs": "[]", "references": "[]"}
{"id": "javascript_plugins:id2", "page": "javascript_plugins", "ref": "id2", "title": "JavaScript plugin objects", "content": "JavaScript plugins are blocks of code that can be registered with Datasette using the  registerPlugin()  method on the  datasetteManager  object. \n             The  implementation  object passed to this method should include a  version  key defining the plugin version, and one or more of the following named functions providing the implementation of the plugin:", "breadcrumbs": "[\"JavaScript plugins\"]", "references": "[]"}
{"id": "changelog:javascript-modules", "page": "changelog", "ref": "javascript-modules", "title": "JavaScript modules", "content": "JavaScript modules  were introduced in ECMAScript 2015 and provide native browser support for the  import  and  export  keywords. \n                 To use modules, JavaScript needs to be included in  <script>  tags with a  type=\"module\"  attribute. \n                 Datasette now has the ability to output  <script type=\"module\">  in places where you may wish to take advantage of modules. The  extra_js_urls  option described in  Custom CSS and JavaScript  can now be used with modules, and module support is also available for the  extra_body_script()  plugin hook. ( #1186 ,  #1187 ) \n                 datasette-leaflet-freedraw  is the first example of a Datasette plugin that takes advantage of the new support for JavaScript modules. See  Drawing shapes on a map to query a SpatiaLite database  for more on this plugin.", "breadcrumbs": "[\"Changelog\", \"0.54 (2021-01-25)\"]", "references": "[{\"href\": \"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules\", \"label\": \"JavaScript modules\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1186\", \"label\": \"#1186\"}, {\"href\": \"https://github.com/simonw/datasette/issues/1187\", \"label\": \"#1187\"}, {\"href\": \"https://datasette.io/plugins/datasette-leaflet-freedraw\", \"label\": \"datasette-leaflet-freedraw\"}, {\"href\": \"https://simonwillison.net/2021/Jan/24/drawing-shapes-spatialite/\", \"label\": \"Drawing shapes on a map to query a SpatiaLite database\"}]"}
{"id": "sql_queries:canned-queries-json-api", "page": "sql_queries", "ref": "canned-queries-json-api", "title": "JSON API for writable canned queries", "content": "Writable canned queries can also be accessed using a JSON API. You can POST data to them using JSON, and you can request that their response is returned to you as JSON. \n                 To submit JSON to a writable canned query, encode key/value parameters as a JSON document: \n                 POST /mydatabase/add_message\n\n{\"message\": \"Message goes here\"} \n                 You can also continue to submit data using regular form encoding, like so: \n                 POST /mydatabase/add_message\n\nmessage=Message+goes+here \n                 There are three options for specifying that you would like the response to your request to return JSON data, as opposed to an HTTP redirect to another page. \n                 \n                     \n                         Set an  Accept: application/json  header on your request \n                     \n                     \n                         Include  ?_json=1  in the URL that you POST to \n                     \n                     \n                         Include  \"_json\": 1  in your JSON body, or  &_json=1  in your form encoded body \n                     \n                 \n                 The JSON response will look like this: \n                 {\n    \"ok\": true,\n    \"message\": \"Query executed, 1 row affected\",\n    \"redirect\": \"/data/add_name\"\n} \n                 The  \"message\"  and  \"redirect\"  values here will take into account  on_success_message ,  on_success_message_sql ,   on_success_redirect ,  on_error_message  and  on_error_redirect , if they have been set.", "breadcrumbs": "[\"Running SQL queries\", \"Canned queries\"]", "references": "[]"}
{"id": "json_api:id1", "page": "json_api", "ref": "id1", "title": "JSON API", "content": "Datasette provides a JSON API for your SQLite databases. Anything you can do\n            through the Datasette user interface can also be accessed as JSON via the API. \n         To access the API for a page, either click on the  .json  link on that page or\n            edit the URL and add a  .json  extension to it.", "breadcrumbs": "[]", "references": "[]"}
{"id": "introspection:id1", "page": "introspection", "ref": "id1", "title": "Introspection", "content": "Datasette includes some pages and JSON API endpoints for introspecting the current instance. These can be used to understand some of the internals of Datasette and to see how a particular instance has been configured. \n         Each of these pages can be viewed in your browser. Add  .json  to the URL to get back the contents as JSON.", "breadcrumbs": "[]", "references": "[]"}
{"id": "internals:internals", "page": "internals", "ref": "internals", "title": "Internals for plugins", "content": "Many  Plugin hooks  are passed objects that provide access to internal Datasette functionality. The interface to these objects should not be considered stable with the exception of methods that are documented here.", "breadcrumbs": "[]", "references": "[]"}
{"id": "installation:installing-plugins-using-pipx", "page": "installation", "ref": "installing-plugins-using-pipx", "title": "Installing plugins using pipx", "content": "You can install additional datasette plugins with  pipx inject  like so: \n                     pipx inject datasette datasette-json-html \n                     injected package datasette-json-html into venv datasette\ndone! \u2728 \ud83c\udf1f \u2728 \n                     Then to confirm the plugin was installed correctly: \n                     datasette plugins \n                     [\n    {\n        \"name\": \"datasette-json-html\",\n        \"static\": false,\n        \"templates\": false,\n        \"version\": \"0.6\"\n    }\n]", "breadcrumbs": "[\"Installation\", \"Advanced installation options\", \"Using pipx\"]", "references": "[]"}
{"id": "installation:installing-plugins", "page": "installation", "ref": "installing-plugins", "title": "Installing plugins", "content": "If you want to install plugins into your local Datasette Docker image you can do\n                        so using the following recipe. This will install the plugins and then save a\n                        brand new local image called  datasette-with-plugins : \n                     docker run datasetteproject/datasette \\\n    pip install datasette-vega\n\ndocker commit $(docker ps -lq) datasette-with-plugins \n                     You can now run the new custom image like so: \n                     docker run -p 8001:8001 -v `pwd`:/mnt \\\n    datasette-with-plugins \\\n    datasette -p 8001 -h 0.0.0.0 /mnt/fixtures.db \n                     You can confirm that the plugins are installed by visiting\n                         http://127.0.0.1:8001/-/plugins \n                     Some plugins such as  datasette-ripgrep  may need additional system packages. You can install these by running  apt-get install  inside the container: \n                     docker run datasette-057a0 bash -c '\n    apt-get update &&\n    apt-get install ripgrep &&\n    pip install datasette-ripgrep'\n\ndocker commit $(docker ps -lq) datasette-with-ripgrep", "breadcrumbs": "[\"Installation\", \"Advanced installation options\", \"Using Docker\"]", "references": "[{\"href\": \"http://127.0.0.1:8001/-/plugins\", \"label\": \"http://127.0.0.1:8001/-/plugins\"}, {\"href\": \"https://datasette.io/plugins/datasette-ripgrep\", \"label\": \"datasette-ripgrep\"}]"}