rowid,title,content,sections_fts,rank
52,Upgrade guide,,345,
80,Getting started,,345,
180,Basic installation,,345,
183,Advanced installation options,,345,
257,Settings,,345,
299,Installation,,345,
311,Queries,,345,
454,Changelog,,345,
475,1.0a27 (2026-04-15),,345,
479,1.0a26 (2026-03-18),,345,
483,1.0a25 (2026-02-25),,345,
488,1.0a24 (2026-01-29),,345,
558,0.60 (2022-01-13),,345,
763,Permission classes and utilities,,345,
213,Database-level metadata,"""Database-level"" metadata refers to fields that can be specified for each database in a Datasette instance. These attributes should be listed under a database inside the  ""databases""  field. 
                 The following are the full list of allowed database-level metadata fields: 
                 
                     
                         source 
                     
                     
                         source_url 
                     
                     
                         license 
                     
                     
                         license_url 
                     
                     
                         about 
                     
                     
                         about_url",345,
214,Table-level metadata,"""Table-level"" metadata refers to fields that can be specified for each table in a Datasette instance. These attributes should be listed under a specific table using the  ""tables""  field. 
                 The following metadata fields are supported at the table level: 
                 
                     
                         source 
                     
                     
                         source_url 
                     
                     
                         license 
                     
                     
                         license_url 
                     
                     
                         about 
                     
                     
                         about_url 
                     
                     
                         columns  (see  Column descriptions ) 
                     
                 
                 Additionally, tables support a number of configuration options ( sort ,  sort_desc ,  size ,  sortable_columns ,  label_column ,  hidden ,  facets ,  facet_size ,  fts_table ,  fts_pk ,  searchmode ,  column_types ). See  table configuration  for full details.",345,
212,Top-level metadata,"""Top-level"" metadata refers to fields that can be specified at the root level  of a metadata file. These attributes are meant to describe the entire Datasette instance. 
                 The following are the full list of allowed top-level metadata fields: 
                 
                     
                         title 
                     
                     
                         description 
                     
                     
                         description_html 
                     
                     
                         license 
                     
                     
                         license_url 
                     
                     
                         source 
                     
                     
                         source_url",345,
642,0.30.2 (2019-11-02),"/-/plugins  page now uses distribution name e.g.  datasette-cluster-map  instead of the name of the underlying Python package ( datasette_cluster_map ) ( #606 ) 
                 
                 
                     Array faceting is now only suggested for columns that contain arrays of strings ( #562 ) 
                 
                 
                     Better documentation for the  --host  argument ( #574 ) 
                 
                 
                     Don't show  None  with a broken link for the label on a nullable foreign key ( #406 )",345,
666,0.26.1 (2019-01-10),"/-/versions  now includes SQLite  compile_options  ( #396 ) 
                 
                 
                     datasetteproject/datasette  Docker image now uses SQLite 3.26.0 ( #397 ) 
                 
                 
                     Cleaned up some deprecation warnings under Python 3.7",345,
362,Special table arguments,"?_col=COLUMN1&_col=COLUMN2 
                         
                             List specific columns to display. These will be shown along with any primary keys. 
                         
                     
                     
                         ?_nocol=COLUMN1&_nocol=COLUMN2 
                         
                             List specific columns to hide - any column not listed will be displayed. Primary keys cannot be hidden. 
                         
                     
                     
                         ?_labels=on/off 
                         
                             Expand foreign key references for every possible column. See below. 
                         
                     
                     
                         ?_label=COLUMN1&_label=COLUMN2 
                         
                             Expand foreign key references for one or more specified columns. 
                         
                     
                     
                         ?_size=1000  or  ?_size=max 
                         
                             Sets a custom page size. This cannot exceed the  max_returned_rows  limit
                                passed to  datasette serve . Use  max  to get  max_returned_rows . 
                         
                     
                     
                         ?_sort=COLUMN 
                         
                             Sorts the results by the specified column. 
                         
                     
                     
                         ?_sort_desc=COLUMN 
                         
                             Sorts the results by the specified column in descending order. 
                         
                     
                     
                         ?_search=keywords 
                         
                             For SQLite tables that have been configured for
                                 full-text search  executes a search
                                with the provided keywords. 
                         
                     
                     
                         ?_search_COLUMN=keywords 
                         
                             Like  _search=  but allows you to specify the column to be searched, as
                                opposed to searching all columns that have been indexed by FTS. 
                         
                     
                     
                         ?_searchmode=raw 
                         
                             With this option, queries passed to  ?_search=  or  ?_search_COLUMN=  will
                                not have special characters escaped. This means you can make use of the full
                                set of  advanced SQLite FTS syntax ,
                                though this could potentially result in errors if the wrong syntax is used. 
                         
                     
                     
                         ?_where=SQL-fragment 
                         
                             If the  execute-sql  permission is enabled, this parameter
                                can be used to pass one or more additional SQL fragments to be used in the
                                 WHERE  clause of the SQL used to query the table. 
                             This is particularly useful if you are building a JavaScript application
                                that needs to do something creative but still wants the other conveniences
                                provided by the table view (such as faceting) and hence would like not to
                                have to construct a completely custom SQL query. 
                             Some examples: 
                             
                                 
                                     facetable?_where=_neighborhood like ""%c%""&_where=_city_id=3 
                                 
                                 
                                     facetable?_where=_city_id in (select id from facet_cities where name != ""Detroit"") 
                                 
                             
                         
                     
                     
                         ?_through={json} 
                         
                             This can be used to filter rows via a join against another table. 
                             The JSON parameter must include three keys:  table ,  column  and  value . 
                             table  must be a table that the current table is related to via a foreign key relationship. 
                             column  must be a column in that other table. 
                             value  is the value that you want to match against. 
                             For example, to filter  roadside_attractions  to just show the attractions that have a characteristic of ""museum"", you would construct this JSON: 
                             {
    ""table"": ""roadside_attraction_characteristics"",
    ""column"": ""characteristic_id"",
    ""value"": ""1""
} 
                             As a URL, that looks like this: 
                             ?_through={%22table%22:%22roadside_attraction_characteristics%22,%22column%22:%22characteristic_id%22,%22value%22:%221%22} 
                             Here's  an example . 
                         
                     
                     
                         ?_next=TOKEN 
                         
                             Pagination by continuation token - pass the token that was returned in the
                                 ""next""  property by the previous page. 
                         
                     
                     
                         ?_facet=column 
                         
                             Facet by column. Can be applied multiple times, see  Facets . Only works on the default JSON output, not on any of the custom shapes. 
                         
                     
                     
                         ?_facet_size=100 
                         
                             Increase the number of facet results returned for each facet. Use  ?_facet_size=max  for the maximum available size, determined by  max_returned_rows . 
                         
                     
                     
                         ?_nofacet=1 
                         
                             Disable all facets and facet suggestions for this page, including any defined by  Facets in configuration . 
                         
                     
                     
                         ?_nosuggest=1 
                         
                             Disable facet suggestions for this page. 
                         
                     
                     
                         ?_nocount=1 
                         
                             Disable the  select count(*)  query used on this page - a count of  None  will be returned instead.",345,
657,0.28 (2019-05-19),A  salmagundi  of new features!,345,
187,Using Docker,"A Docker image containing the latest release of Datasette is published to Docker
                    Hub here:  https://hub.docker.com/r/datasetteproject/datasette/ 
                 If you have Docker installed (for example with  Docker for Mac  on OS X) you can download and run this
                    image like so: 
                 docker run -p 8001:8001 -v `pwd`:/mnt \
    datasetteproject/datasette \
    datasette -p 8001 -h 0.0.0.0 /mnt/fixtures.db 
                 This will start an instance of Datasette running on your machine's port 8001,
                    serving the  fixtures.db  file in your current directory. 
                 Now visit  http://127.0.0.1:8001/  to access Datasette. 
                 (You can download a copy of  fixtures.db  from
                     https://latest.datasette.io/fixtures.db  ) 
                 To upgrade to the most recent release of Datasette, run the following: 
                 docker pull datasetteproject/datasette",345,
211,Metadata reference,A full reference of every supported option in a  metadata.json  or  metadata.yaml  file.,345,
485,,"A new  register_token_handler()  plugin hook allows plugins to provide custom token backends for API authentication. ( #2650 ) 
                 This includes a  backwards incompatible change : the  datasette.create_token()  internal  method is now an  async  method. Consult the  upgrade guide  for details on how to update your code.",345,
484,,"A new  write_wrapper()  plugin hook allows plugins to intercept and wrap database write operations. ( #2636 ) 
                 Plugins implement the hook as a generator-based context manager: 
                 @hookimpl
def write_wrapper(datasette, database, request):
    def wrapper(conn):
        # Setup code runs before the write
        yield
        # Cleanup code runs after the write

    return wrapper",345,
591,0.51 (2020-10-31),"A new visual design, plugin hooks for adding navigation options, better handling of binary data, URL building utility methods and better support for running Datasette behind a proxy.",345,
593,Plugins can now add links within Datasette,"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 . 
                 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. 
                 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.",345,
671,0.24 (2018-07-23),"A number of small new features: 
             
                 
                     datasette publish heroku  now supports  --extra-options , fixes  #334 
                 
                 
                     Custom error message if SpatiaLite is needed for specified database, closes  #331 
                 
                 
                     New config option:  truncate_cells_html  for  truncating long cell values  in HTML view - closes  #330 
                 
                 
                     Documentation for  datasette publish and datasette package , closes  #337 
                 
                 
                     Fixed compatibility with Python 3.7 
                 
                 
                     datasette publish heroku  now supports app names via the  -n  option, which can also be used to overwrite an existing application [Russ Garrett] 
                 
                 
                     Title and description metadata can now be set for  canned SQL queries , closes  #342 
                 
                 
                     New  force_https_on  config option, fixes  https://  API URLs when deploying to Zeit Now - closes  #333 
                 
                 
                     ?_json_infinity=1  query string argument for handling Infinity/-Infinity values in JSON, closes  #332 
                 
                 
                     URLs displayed in the results of custom SQL queries are now URLified, closes  #298",345,
98,Returned control object,"A plugin that wants to handle a field should return an object. Datasette currently recognizes these properties: 
                     
                         
                             useTextarea  - boolean, optional 
                             
                                 If true, Datasette creates a  <textarea>  as the underlying  field.input  before calling  render() . If omitted, Datasette chooses either an  <input>  or  <textarea>  based on the column type and current value. 
                             
                         
                         
                             render(field)  - function 
                             
                                 Called once to render the custom field UI.  field  is a helper object described below. 
                                 The recommended pattern is to return a DOM node from  render() . Datasette appends that node to  field.root , a  <div>  inside the control area for that field in the row insert/edit dialog. A plugin can alternatively manipulate  field.root  directly and return nothing. 
                             
                         
                         
                             focus(field)  - function, optional 
                             
                                 Called when Datasette wants to focus this field, for example when focusing the first editable field in the dialog. Use this to focus the most useful interactive element inside the custom UI. 
                             
                         
                         
                             destroy(field)  - function, optional 
                             
                                 Called when Datasette tears down the insert/edit form. Use this to remove event listeners, close nested pickers, revoke object URLs, clear timers, or release other resources.",345,
627,0.42 (2020-05-08),"A small release which provides improved internal methods for use in plugins, along with documentation. See  #685 . 
             
                 
                     Added documentation for  db.execute() , see  await db.execute(sql, ...) . 
                 
                 
                     Renamed  db.execute_against_connection_in_thread()  to  db.execute_fn()  and made it a documented method, see  await db.execute_fn(fn) . 
                 
                 
                     New  results.first()  and  results.single_value()  methods, plus documentation for the  Results  class - see  Results .",345,
328,Trusted stored queries,"A trusted stored query can execute with  view-query  permission alone. It skips the additional  execute-sql  and write permission checks that are applied to untrusted stored queries. 
                     Trusted stored queries should only be used for SQL that has been reviewed by someone trusted to configure the Datasette instance. For that reason, trusted stored queries can only be added using configuration. Users cannot create trusted stored queries through the web interface or the stored query JSON API. 
                     Queries defined in  datasette.yaml  are trusted by default: 
                     databases:
  mydatabase:
    queries:
      report:
        sql: select * from report 
                     You can opt out of this behavior for a configured query using  is_trusted: false : 
                     databases:
  mydatabase:
    queries:
      report:
        sql: select * from report
        is_trusted: false",345,
649,ASGI,"ASGI  is the Asynchronous Server Gateway Interface standard. I've been wanting to convert Datasette into an ASGI application for over a year -  Port Datasette to ASGI #272  tracks thirteen months of intermittent development - but with Datasette 0.29 the change is finally released. This also means Datasette now runs on top of  Uvicorn  and no longer depends on  Sanic . 
                 I wrote about the significance of this change in  Porting Datasette to ASGI, and Turtles all the way down . 
                 The most exciting consequence of this change is that Datasette plugins can now take advantage of the ASGI standard.",345,
648,0.29 (2019-07-07),"ASGI, new plugin hooks, facet by date and much, much more...",345,
319,Instance schema,"Access  /-/schema  to see the complete schema for all attached databases in the Datasette instance. 
                 Use  /-/schema.md  to get the same information as Markdown. 
                 Use  /-/schema.json  to get the same information as JSON, which looks like this: 
                 {
  ""ok"": true,
  ""schemas"": [
    {
      ""database"": ""content"",
      ""schema"": ""create table posts ...""
    }
  ]
}",345,
427,Action hooks,"Action hooks can be used to add items to the action menus that appear at the top of different pages within Datasette. Unlike  menu_links() , actions which are displayed on every page, actions should only be relevant to the page the user is currently viewing. 
             Each of these hooks should return a list of menu items, with optional  ""description"": ""...""  keys describing each action in more detail. 
             The most common action item is a link to another page: 
             {
    ""href"": datasette.urls.path(""/-/custom-action""),
    ""label"": ""Custom action"",
    ""description"": ""Run this action on a separate page."",
} 
             Plugins can also return button actions for JavaScript-backed interactions: 
             {
    ""type"": ""button"",
    ""label"": ""Open custom dialog"",
    ""description"": ""Show a dialog without leaving this page."",
    ""attrs"": {
        ""aria-label"": ""Open custom dialog"",
        ""data-plugin-action"": ""open-custom-dialog"",
    },
} 
             These are rendered as  <button type=""button"" class=""button-as-link action-menu-button"" role=""menuitem"" tabindex=""-1""> . The optional  attrs  dictionary is added to the button, and is useful for  data-*  attributes that your plugin's JavaScript can use to attach event handlers. 
             Here is a minimal plugin example that adds a button to a table page and loads JavaScript to handle clicks on that button: 
             from datasette import hookimpl


@hookimpl
def table_actions(datasette, database, table):
    return [
        {
            ""type"": ""button"",
            ""label"": ""Show table name"",
            ""description"": ""Open a JavaScript-powered plugin action."",
            ""attrs"": {
                ""aria-label"": ""Show table name"",
                ""data-plugin-action"": ""show-table-name"",
                ""data-database"": database,
                ""data-table"": table,
            },
        }
    ]


@hookimpl
def extra_js_urls(datasette):
    return [
        datasette.static(
            ""show-table.js"", plugin=""datasette_show_table""
        )
    ] 
             The  static/show-table.js  file in that plugin could look like this: 
             document.addEventListener(""click"", (event) => {
  const button = event.target.closest(
    ""button[data-plugin-action='show-table-name']""
  );
  if (!button) {
    return;
  }
  alert(`${button.dataset.database}.${button.dataset.table}`);
}); 
             They can alternatively return an  async def  awaitable function which, when called, returns a list of those menu items.",345,
165,alter-table,"Actor is allowed to alter a database table. 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the table (string)",345,
163,create-table,"Actor is allowed to create a database table. 
                 
                     
                         resource  -  datasette.resources.DatabaseResource(database) 
                         
                             database  is the name of the database (string)",345,
164,create-view,"Actor is allowed to create a database view. 
                 
                     
                         resource  -  datasette.resources.DatabaseResource(database) 
                         
                             database  is the name of the database (string)",345,
157,store-query,"Actor is allowed to create stored queries against a database. 
                 
                     
                         resource  -  datasette.resources.DatabaseResource(database) 
                         
                             database  is the name of the database (string)",345,
159,delete-query,"Actor is allowed to delete a stored query. 
                 
                     
                         resource  -  datasette.resources.QueryResource(database, query) 
                         
                             database  is the name of the database (string) 
                             query  is the name of the query (string)",345,
161,delete-row,"Actor is allowed to delete rows from a table. 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the table (string)",345,
154,view-database-download,"Actor is allowed to download a database, e.g.  https://latest.datasette.io/fixtures.db 
                 
                     
                         resource  -  datasette.resources.DatabaseResource(database) 
                         
                             database  is the name of the database (string)",345,
167,drop-table,"Actor is allowed to drop a database table. 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the table (string)",345,
168,drop-view,"Actor is allowed to drop a database view. 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the view (string)",345,
160,insert-row,"Actor is allowed to insert rows into a table. 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the table (string)",345,
169,execute-sql,"Actor is allowed to run arbitrary read-only SQL queries against a specific database using the  custom SQL query page , e.g.  https://latest.datasette.io/fixtures/-/query?sql=select+100 
                 
                     
                         resource  -  datasette.resources.DatabaseResource(database) 
                         
                             database  is the name of the database (string) 
                         
                     
                 
                 See also  the default_allow_sql setting .",345,
170,execute-write-sql,"Actor is allowed to run arbitrary writable SQL queries against a specific database using the  write SQL queries page , subject to table-level write permissions such as  insert-row ,  update-row  and  delete-row . SQL functions are allowed and are not separately restricted by Datasette permissions. 
                 
                     
                         resource  -  datasette.resources.DatabaseResource(database) 
                         
                             database  is the name of the database (string)",345,
166,set-column-type,"Actor is allowed to set assigned  column types  for columns in a table. 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the table (string)",345,
158,update-query,"Actor is allowed to update a stored query. 
                 
                     
                         resource  -  datasette.resources.QueryResource(database, query) 
                         
                             database  is the name of the database (string) 
                             query  is the name of the query (string)",345,
162,update-row,"Actor is allowed to update rows in a table. 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the table (string)",345,
153,view-database,"Actor is allowed to view a database page, e.g.  https://latest.datasette.io/fixtures 
                 
                     
                         resource  -  datasette.permissions.DatabaseResource(database) 
                         
                             database  is the name of the database (string)",345,
156,view-query,"Actor is allowed to view a stored query page, e.g.  https://latest.datasette.io/fixtures/pragma_cache_size . Executing an untrusted stored query also requires  execute-sql  or the relevant write permissions;  trusted stored queries  can execute with  view-query  alone. 
                 
                     
                         resource  -  datasette.resources.QueryResource(database, query) 
                         
                             database  is the name of the database (string) 
                             query  is the name of the query (string)",345,
155,view-table,"Actor is allowed to view a table (or view) page, e.g.  https://latest.datasette.io/fixtures/complex_foreign_keys 
                 
                     
                         resource  -  datasette.resources.TableResource(database, table) 
                         
                             database  is the name of the database (string) 
                             table  is the name of the table (string)",345,
171,permissions-debug,Actor is allowed to view the  /-/permissions  debug tools.,345,
351,Executing custom SQL,"Actors with the  execute-sql  permission can execute read-only SQL against a database using  /-/query.json : 
             GET /<database>/-/query.json?sql=select+*+from+dogs 
             Values for named SQL parameters can be provided as additional query string parameters: 
             GET /<database>/-/query.json?sql=select+*+from+dogs+where+name=:name&name=Cleo 
             The response uses the same default representation described above.",345,
367,Executing write SQL,"Actors with the  execute-write-sql  permission can execute arbitrary writable SQL against a mutable database using  /-/execute-write . 
                 POST /<database>/-/execute-write
Content-Type: application/json
Authorization: Bearer dstok_<rest-of-token> 
                 The request body must include a  ""sql""  string. Named SQL parameters can be provided using the optional  ""params""  object: 
                 {
    ""sql"": ""insert into dogs (name) values (:name)"",
    ""params"": {
        ""name"": ""Cleo""
    }
} 
                 The SQL must be writable. Read-only  select  queries should use the regular  custom SQL query JSON API  instead. 
                 Datasette analyzes the SQL before executing it. The actor must have  execute-write-sql  permission for the database, and must also have any permissions required by the operations in the SQL. For example, inserts and updates against a table require  insert-row ,  update-row  and  delete-row  permissions for that table. Reads performed as part of the write, such as  insert into dogs select ... from other_table , require  view-table  permission on the source table. Schema changes require  create-table ,  alter-table  or  drop-table  permissions as appropriate. 
                 Unsupported SQL operations are rejected by default.  VACUUM  is not allowed in arbitrary write SQL, and writes to SQLite virtual tables or shadow tables are rejected. SQL functions are allowed and are not separately restricted by Datasette permissions. 
                 A successful response includes a message, the SQLite  rowcount , a  ""rows"" 
                    list, a  ""truncated""  flag and a summary of the operations that were executed: 
                 The shape of the  ""analysis""  block is not part of the  stable API  and may change in future Datasette releases. 
                 {
    ""ok"": true,
    ""message"": ""Query executed, 1 row affected"",
    ""rowcount"": 1,
    ""rows"": [],
    ""truncated"": false,
    ""analysis"": [
        {
            ""operation"": ""insert"",
            ""database"": ""data"",
            ""table"": ""dogs"",
            ""required_permission"": ""insert-row, update-row, delete-row"",
            ""source"": null
        }
    ]
} 
                 If SQLite reports  -1  for the row count, the message will be  ""Query executed"" . 
                 For most write statements  ""rows""  will be an empty list and  ""truncated"" 
                    will be  false . If the SQL uses SQLite's  RETURNING  clause,  ""rows"" 
                    will contain returned rows using the same default representation as table and
                    query JSON responses.  ""truncated""  indicates if more rows were returned than
                    the execute-write returning row limit, which defaults to 10: 
                 {
    ""ok"": true,
    ""message"": ""Query executed, 1 row affected"",
    ""rowcount"": 1,
    ""rows"": [
        {
            ""id"": 1,
            ""name"": ""Cleo""
        }
    ],
    ""truncated"": false,
    ""analysis"": [
        {
            ""operation"": ""insert"",
            ""database"": ""data"",
            ""table"": ""dogs"",
            ""required_permission"": ""insert-row, update-row, delete-row"",
            ""source"": null
        },
        {
            ""operation"": ""read"",
            ""database"": ""data"",
            ""table"": ""dogs"",
            ""required_permission"": ""view-table"",
            ""source"": null
        }
    ]
} 
                 Errors use the  standard Datasette error format : 
                 {
    ""ok"": false,
    ""error"": ""Permission denied: need execute-write-sql"",
    ""errors"": [
        ""Permission denied: need execute-write-sql""
    ],
    ""status"": 403
}",345,
696,0.9 (2017-11-13),"Added  --sql_time_limit_ms  and  --extra-options . 
                     The serve command now accepts  --sql_time_limit_ms  for customizing the SQL time
                        limit. 
                     The publish and package commands now accept  --extra-options  which can be used
                        to specify additional options to be passed to the datasite serve command when
                        it executes inside the resulting Docker containers.",345,
644,0.30 (2019-10-18),"Added  /-/threads  debugging page 
                 
                 
                     Allow  EXPLAIN WITH...  ( #583 ) 
                 
                 
                     Button to format SQL - thanks, Tobias Kunze ( #136 ) 
                 
                 
                     Sort databases on homepage by argument order - thanks, Tobias Kunze ( #585 ) 
                 
                 
                     Display metadata footer on custom SQL queries - thanks, Tobias Kunze ( #589 ) 
                 
                 
                     Use  --platform=managed  for  publish cloudrun  ( #587 ) 
                 
                 
                     Fixed bug returning non-ASCII characters in CSV ( #584 ) 
                 
                 
                     Fix for  /foo  v.s.  /foo-bar  bug ( #601 )",345,
693,0.12 (2017-11-16),"Added  __version__ , now displayed as tooltip in page footer ( #108 ). 
                 
                 
                     Added initial docs, including a changelog ( #99 ). 
                 
                 
                     Turned on auto-escaping in Jinja. 
                 
                 
                     Added a UI for editing named parameters ( #96 ). 
                     You can now construct a custom SQL statement using SQLite named
                        parameters (e.g.  :name ) and datasette will display form fields for
                        editing those parameters.  Here’s an example  which lets you see the
                        most popular names for dogs of different species registered through
                        various dog registration schemes in Australia. 
                 
             
             
             
                 
                     Pin to specific Jinja version. ( #100 ). 
                 
                 
                     Default to 127.0.0.1 not 0.0.0.0. ( #98 ). 
                 
                 
                     Added extra metadata options to publish and package commands. ( #92 ). 
                     You can now run these commands like so: 
                     datasette now publish mydb.db \
    --title=""My Title"" \
    --source=""Source"" \
    --source_url=""http://www.example.com/"" \
    --license=""CC0"" \
    --license_url=""https://creativecommons.org/publicdomain/zero/1.0/"" 
                     This will write those values into the metadata.json that is packaged with the
                        app. If you also pass  --metadata=metadata.json  that file will be updated with the extra
                        values before being written into the Docker image. 
                 
                 
                     Added production-ready Dockerfile ( #94 ) [Andrew
                        Cutler] 
                 
                 
                     New  ?_sql_time_limit_ms=10  argument to database and table page ( #95 ) 
                 
                 
                     SQL syntax highlighting with Codemirror ( #89 ) [Tom Dyson]",345,
694,0.11 (2017-11-14),"Added  datasette publish now --force  option. 
                     This calls  now  with  --force  - useful as it means you get a fresh copy of datasette even if Now has already cached that docker layer. 
                 
                 
                     Enable  --cors  by default when running in a container.",345,
635,0.35 (2020-02-04),"Added five new plugins and one new conversion tool to the  The Datasette Ecosystem . 
                 
                 
                     The  Datasette  class has a new  render_template()  method which can be used by plugins to render templates using Datasette's pre-configured  Jinja  templating library. 
                 
                 
                     You can now execute SQL queries that start with a  -- comment  - thanks, Jay Graves ( #653 )",345,
330,Additional query options,Additional options can be specified for configured queries in the YAML or JSON configuration.,345,
746,".add_memory_database(memory_name, name=None, route=None)","Adds a shared in-memory database with the specified name: 
                 datasette.add_memory_database(""statistics"") 
                 This is a shortcut for the following: 
                 from datasette.database import Database

datasette.add_database(
    Database(datasette, memory_name=""statistics"")
) 
                 Using either of these patterns will result in the in-memory database being served at  /statistics . 
                 The  name  and  route  parameters are optional and work the same way as they do for  .add_database(db, name=None, route=None) .",345,
734,"await .add_query(database, name, sql, ...)","Adds a stored query. 
                     async def add_query(
    self,
    database,
    name,
    sql,
    *,
    title=None,
    description=None,
    description_html=None,
    hide_sql=False,
    fragment=None,
    parameters=None,
    is_write=False,
    is_private=False,
    is_trusted=False,
    source=""plugin"",
    owner_id=None,
    on_success_message=None,
    on_success_message_sql=None,
    on_success_redirect=None,
    on_error_message=None,
    on_error_redirect=None,
    replace=True,
): ... 
                     
                         
                             database  - string 
                             
                                 The name of the database this query should belong to. 
                             
                         
                         
                             name  - string 
                             
                                 The name of the stored query, used in the URL for that query. 
                             
                         
                         
                             sql  - string 
                             
                                 The SQL for the stored query. 
                             
                         
                         
                             title  - string, optional 
                             
                                 A display title for the query. 
                             
                         
                         
                             description  - string, optional 
                             
                                 A plain text description. 
                             
                         
                         
                             description_html  - string, optional 
                             
                                 An HTML description. 
                             
                         
                         
                             hide_sql  - boolean, optional 
                             
                                 Set to  True  to hide the SQL by default on the query page. 
                             
                         
                         
                             fragment  - string, optional 
                             
                                 A URL fragment to append to query links, for example  ""chart"" . 
                             
                         
                         
                             parameters  - list of strings, optional 
                             
                                 Explicit parameter names for the query form. If omitted, Datasette derives parameters from the SQL. 
                             
                         
                         
                             is_write  - boolean, optional 
                             
                                 Set to  True  for writable queries. They will the run against the SQLite write connection for the database. 
                             
                         
                         
                             is_private  - boolean, optional 
                             
                                 Set to  True  for private queries. Private queries can only be viewed, updated or deleted by their owner. 
                             
                         
                         
                             is_trusted  - boolean, optional 
                             
                                 Set to  True  for  trusted stored queries . 
                             
                         
                         
                             source  - string, optional 
                             
                                 Identifies where the query came from. Defaults to  ""plugin"" . 
                             
                         
                         
                             owner_id  - string, optional 
                             
                                 Actor ID of the query owner, used by private query permissions. 
                             
                         
                         
                             on_success_message ,  on_success_message_sql ,  on_success_redirect ,  on_error_message ,  on_error_redirect  - strings, optional 
                             
                                 Options for  writable queries . 
                             
                         
                         
                             replace  - boolean, optional 
                             
                                 Defaults to  True , which replaces any existing stored query with the same  database  and  name . Set this to  False  to raise a SQLite integrity error if the query already exists. 
                             
                         
                     
                     Example: 
                     await datasette.add_query(
    database=""fixtures"",
    name=""recent_rows"",
    sql=""select * from facetable order by created desc limit 10"",
    title=""Recent rows"",
    source=""my-plugin"",
)",345,
759,Authenticating as an actor,"All  datasette.client  methods accept an optional  actor=  parameter. When set to a dictionary describing an actor, the request is made with a signed  ds_actor  cookie identifying that actor — as if the request had been made by a user who is signed in as that actor. 
                     This is a convenient shorthand equivalent to signing the cookie manually using  datasette.client.actor_cookie() . 
                     Example usage: 
                     response = await datasette.client.get(
    ""/-/actor.json"", actor={""id"": ""root""}
)
assert response.json() == {""actor"": {""id"": ""root""}} 
                     This parameter works with all HTTP methods ( get ,  post ,  put ,  patch ,  delete ,  options ,  head ) and the generic  request  method. 
                     Passing both  actor=  and a  ds_actor  cookie via  cookies=  raises a  TypeError . Other unrelated cookies can be combined with  actor= .",345,
760,Bypassing permission checks,"All  datasette.client  methods accept an optional  skip_permission_checks=True  parameter. When set, all permission checks will be bypassed for that request, allowing access to any resource regardless of the configured permissions. 
                     This is useful for plugins and internal operations that need to access all resources without being subject to permission restrictions. 
                     Example usage: 
                     # Regular request - respects permissions
response = await datasette.client.get(
    ""/private-db/secret-table.json""
)
# May return 403 Forbidden if access is denied

# With skip_permission_checks - bypasses all permission checks
response = await datasette.client.get(
    ""/private-db/secret-table.json"",
    skip_permission_checks=True,
)
# Will return 200 OK and the data, regardless of permissions 
                     This parameter works with all HTTP methods ( get ,  post ,  put ,  patch ,  delete ,  options ,  head ) and the generic  request  method. 
                     
                         Use  skip_permission_checks=True  with caution. It completely bypasses Datasette's permission system and should only be used in trusted plugin code or internal operations where you need guaranteed access to resources.",345,
268,allow_facet,"Allow users to specify columns they would like to facet on using the  ?_facet=COLNAME  URL parameter to the table view. 
                 This is enabled by default. If disabled, facets will still be displayed if they have been specifically enabled in  metadata.json  configuration for the table. 
                 Here's how to disable this feature: 
                 datasette mydatabase.db --setting allow_facet off",345,
39,Alpha and beta releases,"Alpha and beta releases are published to preview upcoming features that may not yet be stable - in particular to preview new plugin hooks. 
             You are welcome to try these out, but please be aware that details may change before the final release. 
             Please join  discussions on the issue tracker  to share your thoughts and experiences with on alpha and beta features that you try out.",345,
287,Datasette,"An open source multi-tool for exploring and publishing data 
         Datasette is a tool for exploring and publishing data. It helps people take data of any shape or size and publish that as an interactive, explorable website and accompanying API. 
         Datasette is aimed at data journalists, museum curators, archivists, local governments and anyone else who has data that they wish to share with the world. It is part of a  wider ecosystem of tools and plugins  dedicated to making working with structured data as productive as possible. 
         Explore a demo , watch  a presentation about the project . 
         Interested in learning Datasette? Start with  the official tutorials . 
         Support questions, feedback? Join the  Datasette Discord .",345,
369,Upserting rows,"An upsert is an insert or update operation. If a row with a matching primary key already exists it will be updated - otherwise a new row will be inserted. 
                 The upsert API is mostly the same shape as the  insert API . It requires both the  insert-row  and  update-row  permissions. 
                 It also accepts the same  binary value JSON format . 
                 POST /<database>/<table>/-/upsert
Content-Type: application/json
Authorization: Bearer dstok_<rest-of-token> 
                 {
    ""rows"": [
        {
            ""id"": 1,
            ""title"": ""Updated title for 1"",
            ""description"": ""Updated description for 1""
        },
        {
            ""id"": 2,
            ""description"": ""Updated description for 2"",
        },
        {
            ""id"": 3,
            ""title"": ""Item 3"",
            ""description"": ""Description for 3""
        }
    ]
} 
                 Imagine a table with a primary key of  id  and which already has rows with  id  values of  1  and  2 . 
                 The above example will: 
                 
                     
                         Update the row with  id  of  1  to set both  title  and  description  to the new values 
                     
                     
                         Update the row with  id  of  2  to set  title  to the new value -  description  will be left unchanged 
                     
                     
                         Insert a new row with  id  of  3  and both  title  and  description  set to the new values 
                     
                 
                 Similar to  /-/insert , a  row  key with an object can be used instead of a  rows  array to upsert a single row. 
                 If successful, this will return a  200  status code and a  {""ok"": true}  response body. This is deliberately different from the  201  returned by  insert : an upsert may update existing rows without creating anything, so it does not claim resource creation. 
                 Add  ""return"": true  to the request body to return full copies of the affected rows after they have been inserted or updated: 
                 {
    ""rows"": [
        {
            ""id"": 1,
            ""title"": ""Updated title for 1"",
            ""description"": ""Updated description for 1""
        },
        {
            ""id"": 2,
            ""description"": ""Updated description for 2"",
        },
        {
            ""id"": 3,
            ""title"": ""Item 3"",
            ""description"": ""Description for 3""
        }
    ],
    ""return"": true
} 
                 This will return the following: 
                 {
    ""ok"": true,
    ""rows"": [
        {
            ""id"": 1,
            ""title"": ""Updated title for 1"",
            ""description"": ""Updated description for 1""
        },
        {
            ""id"": 2,
            ""title"": ""Item 2"",
            ""description"": ""Updated description for 2""
        },
        {
            ""id"": 3,
            ""title"": ""Item 3"",
            ""description"": ""Description for 3""
        }
    ]
} 
                 When using upsert you must provide the primary key column (or columns if the table has a compound primary key) for every row, or you will get a  400  error: 
                 {
    ""ok"": false,
    ""error"": ""Row 0 is missing primary key column(s): \""id\"""",
    ""errors"": [
        ""Row 0 is missing primary key column(s): \""id\""""
    ],
    ""status"": 400
} 
                 If your table does not have an explicit primary key you should pass the SQLite  rowid  key instead. 
                 Pass  ""alter: true  to automatically add any missing columns to the table. This requires the  alter-table  permission.",345,
305,Importing GeoJSON polygons using Shapely,"Another common form of polygon data is the GeoJSON format. This can be imported into SpatiaLite directly, or by using the  Shapely  Python library. 
             Who's On First  is an excellent source of openly licensed GeoJSON polygons. Let's import the geographical polygon for Wales. First, we can use the Who's On First Spelunker tool to find the record for Wales: 
             spelunker.whosonfirst.org/id/404227475 
             That page includes a link to the GeoJSON record, which can be accessed here: 
             data.whosonfirst.org/404/227/475/404227475.geojson 
             Here's Python code to create a SQLite database, enable SpatiaLite, create a places table and then add a record for Wales: 
             import sqlite3

conn = sqlite3.connect(""places.db"")
# Enable SpatialLite extension
conn.enable_load_extension(True)
conn.load_extension(""/usr/local/lib/mod_spatialite.dylib"")
# Create the masic countries table
conn.execute(""select InitSpatialMetadata(1)"")
conn.execute(
    ""create table places (id integer primary key, name text);""
)
# Add a MULTIPOLYGON Geometry column
conn.execute(
    ""SELECT AddGeometryColumn('places', 'geom', 4326, 'MULTIPOLYGON', 2);""
)
# Add a spatial index against the new column
conn.execute(""SELECT CreateSpatialIndex('places', 'geom');"")
# Now populate the table
from shapely.geometry.multipolygon import MultiPolygon
from shapely.geometry import shape
import requests

geojson = requests.get(
    ""https://data.whosonfirst.org/404/227/475/404227475.geojson""
).json()
# Convert to ""Well Known Text"" format
wkt = shape(geojson[""geometry""]).wkt
# Insert and commit the record
conn.execute(
    ""INSERT INTO places (id, name, geom) VALUES(null, ?, GeomFromText(?, 4326))"",
    (""Wales"", wkt),
)
conn.commit()",345,
86,CSV export,"Any Datasette table, view or custom SQL query can be exported as CSV. 
         To obtain the CSV representation of the table you are looking, click the ""this
            data as CSV"" link. 
         You can also use the advanced export form for more control over the resulting
            file, which looks like this and has the following options: 
         
         
             
                 download file  - instead of displaying CSV in your browser, this forces
                    your browser to download the CSV to your downloads directory. 
             
             
                 expand labels  - if your table has any foreign key references this option
                    will cause the CSV to gain additional  COLUMN_NAME_label  columns with a
                    label for each foreign key derived from the linked table.  In this example 
                    the  city_id  column is accompanied by a  city_id_label  column. 
             
             
                 stream all rows  - by default CSV files only contain the first
                     max_returned_rows  records. This option will cause Datasette to
                    loop through every matching record and return them as a single CSV file. 
             
         
         You can try that out on  https://latest.datasette.io/fixtures/facetable?_size=4",345,
675,CSV export,"Any Datasette table, view or custom SQL query can now be exported as CSV. 
                 
                 Check out the  CSV export documentation  for more details, or
                    try the feature out on
                     https://fivethirtyeight.datasettes.com/fivethirtyeight/bechdel%2Fmovies 
                 If your table has more than  max_returned_rows  (default 1,000)
                    Datasette provides the option to  stream all rows . This option takes advantage
                    of async Python and Datasette's efficient  pagination  to
                    iterate through the entire matching result set and stream it back as a
                    downloadable CSV file.",345,
29,Debugging,"Any errors that occur while Datasette is running while display a stack trace on the console. 
             You can tell Datasette to open an interactive  pdb  (or  ipdb , if present) debugger session if an error occurs using the  --pdb  option: 
             uv run datasette --pdb fixtures.db 
             For  ipdb , first run this: 
             uv run datasette install ipdb",345,
325,Queries,"As an alternative to adding views to your database, you can define named queries inside your  datasette.yaml  file. Here's an example: 
             [[[cog
from metadata_doc import config_example, config_example
config_example(cog, {
    ""databases"": {
       ""sf-trees"": {
           ""queries"": {
               ""just_species"": {
                   ""sql"": ""select qSpecies from Street_Tree_List""
               }
           }
       }
    }
}) 
             ]]] 
             [[[end]]] 
             Then run Datasette like this: 
             datasette sf-trees.db -m metadata.json 
             Each configured query will be listed on the database index page, and will also get its own URL at: 
             /database-name/query-name 
             For the above example, that URL would be: 
             /sf-trees/just_species 
             You can optionally include  ""title""  and  ""description""  keys to show a title and description on the query page. As with regular table metadata you can alternatively specify  ""description_html""  to have your description rendered as HTML (rather than having HTML special characters escaped).",345,
61,The ,"As of Datasette  1.0a14 , the  .metadata()  method on the Datasette Python API has been removed. 
                     Instead, one should use the following methods on a Datasette class: 
                     
                         
                             get_instance_metadata() 
                         
                         
                             get_database_metadata() 
                         
                         
                             get_resource_metadata() 
                         
                         
                             get_column_metadata()",345,
60,The ,"As of Datasette  1.0a14 , the root level  /metadata.json  endpoint has been removed. Metadata for tables will become available through currently in-development extras in a future alpha.",345,
578,The _internal database,"As part of ongoing work to help Datasette handle much larger numbers of connected databases and tables (see  Datasette Library ) Datasette now maintains an in-memory SQLite database with details of all of the attached databases, tables, columns, indexes and foreign keys. ( #1150 ) 
                 This will support future improvements such as a searchable, paginated homepage of all available tables. 
                 You can explore an example of this database by  signing in as root  to the  latest.datasette.io  demo instance and then navigating to  latest.datasette.io/_internal . 
                 Plugins can use these tables to introspect attached data in an efficient way. Plugin authors should note that this is not yet considered a stable interface, so any plugins that use this may need to make changes prior to Datasette 1.0 if the  _internal  table schemas change.",345,
579,Named in-memory database support,"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 ) 
                 The new  memory_name=  parameter to the  Database class  can be used to create named, shared in-memory databases.",345,
788,"await async_call_with_supported_arguments(fn, **kwargs)","Async version of  call_with_supported_arguments . Use this for  async def  callback functions. 
                 
                 
                     async   datasette.utils. async_call_with_supported_arguments fn ** kwargs 
                     
                         Async version of  call_with_supported_arguments() . 
                         Calls  await fn(...)  with the subset of  **kwargs  matching its
                            signature. 
                         
                             
                                 Parameters 
                                 
                                     
                                         
                                             fn  -- An async callable 
                                         
                                         
                                             kwargs  -- All available keyword arguments 
                                         
                                     
                                 
                             
                             
                                 Returns 
                                 
                                     The return value of  await fn(...)",345,
56,,"Before Datasette 1.0, the  metadata.yaml  file became a kitchen sink if a mix of metadata, configuration, and settings. Now  metadata.yaml  is strictly for metadata (ex title and descriptions of database and tables, licensing info, etc). Other settings have been moved to a  datasette.yml  configuration file, described in  Configuration . 
                     To start Datasette with both metadata and configuration files, run it like this: 
                     datasette --metadata metadata.yaml --config datasette.yaml
# Or the shortened version:
datasette -m metadata.yml -c datasette.yml",345,
689,0.16 (2018-04-13),"Better mechanism for handling errors; 404s for missing table/database 
                     New error mechanism closes  #193 
                     404s for missing tables/databases closes  #184 
                 
                 
                     long_description in markdown for the new PyPI 
                 
                 
                     Hide SpatiaLite system tables. [Russ Garrett] 
                 
                 
                     Allow  explain select  /  explain query plan select   #201 
                 
                 
                     Datasette inspect now finds primary_keys  #195 
                 
                 
                     Ability to sort using form fields (for mobile portrait mode)  #199 
                     We now display sort options as a select box plus a descending checkbox, which
                        means you can apply sort orders even in portrait mode on a mobile phone where
                        the column headers are hidden.",345,
344,Binary values in JSON,"Binary data is represented in  .json  exports using Base64 encoding. Datasette uses this representation for every  BLOB  value, including binary values that could also be decoded as UTF-8 text. 
             https://latest.datasette.io/fixtures/binary_data.json?_shape=array 
             [
    {
        ""rowid"": 1,
        ""data"": {
            ""$base64"": true,
            ""encoded"": ""FRwCx60F/g==""
        }
    },
    {
        ""rowid"": 2,
        ""data"": {
            ""$base64"": true,
            ""encoded"": ""FRwDx60F/g==""
        }
    },
    {
        ""rowid"": 3,
        ""data"": null
    }
] 
             The same format can be used with the  JSON write API .
                If a column value in a  row ,  rows  or  update  object is a JSON object with exactly  ""$base64""  set to  true  and an  ""encoded""  string, Datasette will decode that Base64 string and store the resulting bytes: 
             {
    ""data"": {
        ""$base64"": true,
        ""encoded"": ""FRwCx60F/g==""
    }
} 
             This works for inserts, upserts and updates. It also works when creating a table from example  row  or  rows  data: Datasette decodes the value before inferring the schema, allowing that column to be created as a  BLOB  column. 
             To store a JSON object with that exact shape literally, wrap it in a  ""$raw""  object: 
             {
    ""data"": {
        ""$raw"": {
            ""$base64"": true,
            ""encoded"": ""FRwCx60F/g==""
        }
    }
} 
             ""$raw""  unwraps exactly one layer. To store a literal  ""$raw""  object containing a Base64 object, wrap it again: 
             {
    ""data"": {
        ""$raw"": {
            ""$raw"": {
                ""$base64"": true,
                ""encoded"": ""FRwCx60F/g==""
            }
        }
    }
}",345,
31,Running Black,"Black is installed as part of the development dependency group. To test that your code complies with Black, run the following in your root  datasette  repository checkout: 
                 uv run black . --check 
                 All done! ✨ 🍰 ✨
95 files would be left unchanged. 
                 If any of your code does not conform to Black you can run this to automatically fix those problems: 
                 uv run black . 
                 reformatted ../datasette/app.py
All done! ✨ 🍰 ✨
1 file reformatted, 94 files left unchanged.",345,
354,Special JSON arguments,"Boolean query string arguments - such as  ?_labels=  and
                 ?_json_infinity=  - accept  on ,  true  or  1  for true and
                 off ,  false  or  0  for false. 
             Every Datasette endpoint that can return JSON also accepts the following
                query string arguments: 
             
                 
                     ?_shape=SHAPE 
                     
                         The shape of the JSON to return, documented above. 
                     
                 
                 
                     ?_nl=on 
                     
                         When used with  ?_shape=array  produces newline-delimited JSON objects. 
                     
                 
                 
                     ?_json=COLUMN1&_json=COLUMN2 
                     
                         If any of your SQLite columns contain JSON values, you can use one or more
                             _json=  parameters to request that those columns be returned as regular
                            JSON. Without this argument those columns will be returned as JSON objects
                            that have been double-encoded into a JSON string value. 
                         Compare  this query without the argument  to  this query using the argument 
                     
                 
                 
                     ?_json_infinity=on 
                     
                         If your data contains infinity or -infinity values, Datasette will replace
                            them with None when returning them as JSON. If you pass  _json_infinity=1 
                            Datasette will instead return them as  Infinity  or  -Infinity  which is
                            invalid JSON but can be processed by some custom JSON parsers. 
                     
                 
                 
                     ?_timelimit=MS 
                     
                         Sets a custom time limit for the query in ms. You can use this for optimistic
                            queries where you would like Datasette to give up if the query takes too
                            long, for example if you want to implement autocomplete search but only if
                            it can be executed in less than 10ms. 
                     
                 
                 
                     ?_ttl=SECONDS 
                     
                         For how many seconds should this response be cached by HTTP proxies? Use
                             ?_ttl=0  to disable HTTP caching entirely for this request. 
                     
                 
                 
                     ?_trace=1 
                     
                         Turns on tracing for this page: SQL queries executed during the request will
                            be gathered and included in the response, either in a new  ""_traces""  key
                            for JSON responses or at the bottom of the page if the response is in HTML. 
                         The structure of the data returned here should be considered highly unstable
                            and very likely to change. 
                         Only available if the  trace_debug  setting is enabled.",345,
620,Signed values and secrets,"Both flash messages and user authentication needed a way to sign values and set signed cookies. Two new methods are now available for plugins to take advantage of this mechanism:  .sign(value, namespace=""default"")  and  .unsign(value, namespace=""default"") . 
                 Datasette will generate a secret automatically when it starts up, but to avoid resetting the secret (and hence invalidating any cookies) every time the server restarts you should set your own secret. You can pass a secret to Datasette using the new  --secret  option or with a  DATASETTE_SECRET  environment variable. See  Configuring the secret  for more details. 
                 You can also set a secret when you deploy Datasette using  datasette publish  or  datasette package  - see  Using secrets with datasette publish . 
                 Plugins can now sign values and verify their signatures using the  datasette.sign()  and  datasette.unsign()  methods.",345,
682,0.22.1 (2018-05-23),"Bugfix release, plus we now use  versioneer  for our version numbers. 
             
                 
                     Faceting no longer breaks pagination, fixes  #282 
                 
                 
                     Add  __version_info__  derived from  __version__  [Robert Gieseke] 
                     This might be tuple of more than two values (major and minor
                        version) if commits have been made after a release. 
                 
                 
                     Add version number support with Versioneer. [Robert Gieseke] 
                     Versioneer Licence:
                        Public Domain (CC0-1.0) 
                     Closes  #273 
                 
                 
                     Refactor inspect logic [Russ Garrett]",345,
716,"await .allowed_resources_sql(*, action, actor=None, parent=None, include_is_private=False)","Builds the SQL query that Datasette uses to determine which resources an actor may access for a specific action. Returns a  (sql: str, params: dict)  namedtuple that can be executed against the internal  catalog_*  database tables.  parent  can be used to limit results to a specific database, and  include_is_private  adds a column indicating whether anonymous users would be denied access to that resource. 
                 Plugins that need to execute custom analysis over the raw allow/deny rules can use this helper to run the same query that powers the  /-/allowed  debugging interface. 
                 The SQL query built by this method will return the following columns: 
                 
                     
                         parent : The parent resource identifier (or NULL) 
                     
                     
                         child : The child resource identifier (or NULL) 
                     
                     
                         reason : The reason from the rule that granted access 
                     
                     
                         is_private : (if  include_is_private ) 1 if anonymous users cannot access, 0 otherwise",345,
646,0.29.2 (2019-07-13),"Bumped  Uvicorn  to 0.8.4, fixing a bug where the query string was not included in the server logs. ( #559 ) 
                 
                 
                     Fixed bug where the navigation breadcrumbs were not displayed correctly on the page for a custom query. ( #558 ) 
                 
                 
                     Fixed bug where custom query names containing unicode characters caused errors.",345,
115,,"By default Datasette tables are sorted by primary key. You can set a default sort order for a specific table using the  sort  or  sort_desc  properties: 
                     [[[cog
from metadata_doc import config_example
import textwrap
config_example(cog, textwrap.dedent(
  """"""
    databases:
      mydatabase:
        tables:
          example_table:
            sort: created
  """""").strip()
) 
                     ]]] 
                     [[[end]]] 
                     Or use  sort_desc  to sort in descending order: 
                     [[[cog
config_example(cog, textwrap.dedent(
  """"""
    databases:
      mydatabase:
        tables:
          example_table:
            sort_desc: created
  """""").strip()
) 
                     ]]] 
                     [[[end]]]",345,
128,Denying all permissions by default,"By default, Datasette allows unauthenticated access to view databases, tables, and execute SQL queries. 
                 You may want to run Datasette in a mode where  all  access is denied by default, and you explicitly grant permissions only to authenticated users, either using the  --root mechanism  or through  configuration file rules  or plugins. 
                 Use the  --default-deny  command-line option to run Datasette in this mode: 
                 datasette --default-deny data.db --root 
                 With  --default-deny  enabled: 
                 
                     
                         Anonymous users are denied access to view the instance, databases, tables, and queries 
                     
                     
                         Authenticated users are also denied access unless they're explicitly granted permissions 
                     
                     
                         The root user (when using  --root ) still has access to everything 
                     
                     
                         You can grant permissions using  configuration file rules  or plugins 
                     
                 
                 For example, to allow only a specific user to access your instance: 
                 datasette --default-deny data.db --config datasette.yaml 
                 Where  datasette.yaml  contains: 
                 allow:
  id: alice 
                 This configuration will deny access to everyone except the user with  id  of  alice .",345,
7,Custom templates,"By default, Datasette uses default templates that ship with the package. 
                 You can over-ride these templates by specifying a custom  --template-dir  like
                    this: 
                 datasette mydb.db --template-dir=mytemplates/ 
                 Datasette will now first look for templates in that directory, and fall back on
                    the defaults if no matches are found. 
                 The variables made available to each template are documented on the
                     Template context  page. Variables documented there are a stable API:
                    custom templates that use them will keep working in future Datasette
                    releases, up until the next major version. 
                 It is also possible to over-ride templates on a per-database, per-row or per-
                    table basis. 
                 The lookup rules Datasette uses are as follows: 
                 Index page (/):
    index.html

Database page (/mydatabase):
    database-mydatabase.html
    database.html

Custom query page (/mydatabase?sql=...):
    query-mydatabase.html
    query.html

Stored query page (/mydatabase/query-name):
    query-mydatabase-query-name.html
    query-mydatabase.html
    query.html

Table page (/mydatabase/mytable):
    table-mydatabase-mytable.html
    table.html

Row page (/mydatabase/mytable/id):
    row-mydatabase-mytable.html
    row.html

Table of rows and columns include on table page:
    _table-table-mydatabase-mytable.html
    _table-mydatabase-mytable.html
    _table.html

Table of rows and columns include on row page:
    _table-row-mydatabase-mytable.html
    _table-mydatabase-mytable.html
    _table.html 
                 If a table name has spaces or other unexpected characters in it, the template
                    filename will follow the same rules as our custom  <body>  CSS classes - for
                    example, a table called ""Food Trucks"" will attempt to load the following
                    templates: 
                 table-mydatabase-Food-Trucks-399138.html
table.html 
                 You can find out which templates were considered for a specific page by viewing
                    source on that page and looking for an HTML comment at the bottom. The comment
                    will look something like this: 
                 <!-- Templates considered: *query-mydb-tz.html, query-mydb.html, query.html --> 
                 This example is from the stored query page for a query called ""tz"" in the
                    database called ""mydb"". The asterisk shows which template was selected - so in
                    this case, Datasette found a template file called  query-mydb-tz.html  and
                    used that - but if that template had not been found, it would have tried for
                     query-mydb.html  or the default  query.html . 
                 It is possible to extend the default templates using Jinja template
                    inheritance. If you want to customize EVERY row template with some additional
                    content you can do so by creating a  row.html  template like this: 
                 {% extends ""default:row.html"" %}

{% block content %}
<h1>EXTRA HTML AT THE TOP OF THE CONTENT BLOCK</h1>
<p>This line renders the original block:</p>
{{ super() }}
{% endblock %} 
                 Note the  default:row.html  template name, which ensures Jinja will inherit
                    from the default template. 
                 The  _table.html  template is included by both the row and the table pages,
                    and a list of rows. The default  _table.html  template renders them as an
                    HTML template and  can be seen here . 
                 You can provide a custom template that applies to all of your databases and
                    tables, or you can provide custom templates for specific tables using the
                    template naming scheme described above. 
                 If you want to present your data in a format other than an HTML table, you
                    can do so by looping through  display_rows  in your own  _table.html 
                    template. You can use  {{ row[""column_name""] }}  to output the raw value
                    of a specific column. 
                 If you want to output the rendered HTML version of a column, including any
                    links to foreign keys, you can use  {{ row.display(""column_name"") }} . 
                 Here is an example of a custom  _table.html  template: 
                 {% for row in display_rows %}
    <div data-row=""{{ row.row_path }}"">
        <h2>{{ row[""title""] }}</h2>
        <p>{{ row[""description""] }}<lp>
        <p>Category: {{ row.display(""category_id"") }}</p>
    </div>
{% endfor %} 
                 If your custom table template should support Datasette's row editing UI, include
                     data-row=""{{ row.row_path }}""  on the outer element that represents each row.
                    This does not need to be a  <tr> : it can be a  <div> ,  <li>  or any other
                    element that wraps the HTML for that row. Datasette uses this attribute to find
                    the element to remove after a delete, or replace after an edit. Any edit or
                    delete controls should be rendered inside that same element. 
                 The  _action_menu.html  template renders the action menus used by database,
                    table, query and row pages. Plugin-provided actions can be link dictionaries
                    with  href  and  label  keys, or button dictionaries using  {""type"":
""button"", ""label"": ""..."", ""attrs"": {...}}  for JavaScript-backed interactions.
                    Both shapes can include an optional  description  key. Custom
                     _action_menu.html  templates should preserve support for both link and button
                    action items.",345,
263,sql_time_limit_ms,"By default, queries have a time limit of one second. If a query takes longer than this to run Datasette will terminate the query and return an error. 
                 If this time limit is too short for you, you can customize it using the  sql_time_limit_ms  limit - for example, to increase it to 3.5 seconds: 
                 datasette mydatabase.db --setting sql_time_limit_ms 3500 
                 You can optionally set a lower time limit for an individual query using the  ?_timelimit=100  query string argument: 
                 /my-database/my-table?qSpecies=44&_timelimit=100 
                 This would set the time limit to 100ms for that specific query. This feature is useful if you are working with databases of unknown size and complexity - a query that might make perfect sense for a smaller table could take too long to execute on a table with millions of rows. By setting custom time limits you can execute queries ""optimistically"" - e.g. give me an exact count of rows matching this query but only if it takes less than 100ms to calculate.",345,
787,"call_with_supported_arguments(fn, **kwargs)","Call  fn , passing it only those keyword arguments that match its function signature. This implements a dependency injection pattern - the caller provides all available arguments, and the function receives only the ones it declares as parameters. 
                 This is useful in plugins that want to define callback functions that only declare the arguments they need. For example: 
                 from datasette.utils import call_with_supported_arguments


def my_callback(request, datasette): ...


# This will pass only request and datasette, ignoring other kwargs:
call_with_supported_arguments(
    my_callback,
    request=request,
    datasette=datasette,
    database=database,
    table=table,
) 
                 
                 
                     datasette.utils. call_with_supported_arguments fn ** kwargs 
                     
                         Call  fn  with the subset of  **kwargs  matching its signature. 
                         This implements dependency injection: the caller provides all available
                            keyword arguments and the function receives only the ones it declares
                            as parameters. 
                         
                             
                                 Parameters 
                                 
                                     
                                         
                                             fn  -- A callable (sync function) 
                                         
                                         
                                             kwargs  -- All available keyword arguments 
                                         
                                     
                                 
                             
                             
                                 Returns 
                                 
                                     The return value of  fn",345,
610,Magic parameters for canned queries,"Canned queries now support  Magic parameters , which can be used to insert or select automatically generated values. For example: 
                 insert into logs
  (user_id, timestamp)
values
  (:_actor_id, :_now_datetime_utc) 
                 This inserts the currently authenticated actor ID and the current datetime. ( #842 )",345,
614,Smaller changes,"Cascading view permissions - so if a user has  view-table  they can view the table page even if they do not have  view-database  or  view-instance . ( #832 ) 
                     
                     
                         CSRF protection no longer applies to  Authentication: Bearer token  requests or requests without cookies. ( #835 ) 
                     
                     
                         datasette.add_message()  now works inside plugins. ( #864 ) 
                     
                     
                         Workaround for ""Too many open files"" error in test runs. ( #846 ) 
                     
                     
                         Respect existing  scope[""actor""]  if already set by ASGI middleware. ( #854 ) 
                     
                     
                         New process for shipping  Alpha and beta releases . ( #807 ) 
                     
                     
                         {{ csrftoken() }}  now works when plugins render a template using  datasette.render_template(..., request=request) . ( #863 ) 
                     
                     
                         Datasette now creates a single  Request object  and uses it throughout the lifetime of the current HTTP request. ( #870 )",345,
58,"Metadata ""fallback"" has been removed","Certain keys in metadata like  license  used to ""fallback"" up the chain of ownership.
                        For example, if you set an  MIT  to a database and a table within that database did not have a specified license, then that table would inherit an  MIT  license. 
                     This behavior has been removed in Datasette 1.0. Now license fields must be placed on all items, including individual databases and tables.",345,
564,0.59.2 (2021-11-13),"Column names with a leading underscore now work correctly when used as a facet. ( #1506 ) 
                 
                 
                     Applying  ?_nocol=  to a column no longer removes that column from the filtering interface. ( #1503 ) 
                 
                 
                     Official Datasette Docker container now uses Debian Bullseye as the base image. ( #1497 ) 
                 
                 
                     Datasette is four years old today! Here's the  original release announcement  from 2017.",345,
740,Column types,Column types are stored in the  column_types  table in the  internal database . The following methods provide the API for reading and modifying column type assignments.,345,
566,0.59 (2021-10-14),"Columns can now have associated metadata descriptions in  metadata.json , see  Column descriptions . ( #942 ) 
                 
                 
                     New  register_commands()  plugin hook allows plugins to register additional Datasette CLI commands, e.g.  datasette mycommand file.db . ( #1449 ) 
                 
                 
                     Adding  ?_facet_size=max  to a table page now shows the number of unique values in each facet. ( #1423 ) 
                 
                 
                     Upgraded dependency  httpx 0.20  - the undocumented  allow_redirects=  parameter to  datasette.client  is now  follow_redirects= , and defaults to  False  where it previously defaulted to  True . ( #1488 ) 
                 
                 
                     The  --cors  option now causes Datasette to return the  Access-Control-Allow-Headers: Authorization  header, in addition to  Access-Control-Allow-Origin: * . ( #1467 ) 
                 
                 
                     Code that figures out which named parameters a SQL query takes in order to display form fields for them is no longer confused by strings that contain colon characters. ( #1421 ) 
                 
                 
                     Renamed  --help-config  option to  --help-settings . ( #1431 ) 
                 
                 
                     datasette.databases  property is now a documented API. ( #1443 ) 
                 
                 
                     The  base.html  template now wraps everything other than the  <footer>  in a  <div class=""not-footer"">  element, to help with advanced CSS customization. ( #1446 ) 
                 
                 
                     The  render_cell()  plugin hook can now return an awaitable function. This means the hook can execute SQL queries. ( #1425 ) 
                 
                 
                     register_routes(datasette)  plugin hook now accepts an optional  datasette  argument. ( #1404 ) 
                 
                 
                     New  hide_sql  canned query option for defaulting to hiding the SQL query used by a canned query, see  Additional query options . ( #1422 ) 
                 
                 
                     New  --cpu  option for  datasette publish cloudrun . ( #1420 ) 
                 
                 
                     If  Rich  is installed in the same virtual environment as Datasette, it will be used to provide enhanced display of error tracebacks on the console. ( #1416 ) 
                 
                 
                     datasette.utils   parse_metadata(content)  function, used by the new  datasette-remote-metadata plugin , is now a documented API. ( #1405 ) 
                 
                 
                     Fixed bug where  ?_next=x&_sort=rowid  could throw an error. ( #1470 ) 
                 
                 
                     Column cog menu no longer shows the option to facet by a column that is already selected by the default facets in metadata. ( #1469 )",345,
421,Default deny with an exception,"Combine a root-level deny with a specific table allow for trusted users.
                        The resolver will automatically apply the most specific rule. 
                     from datasette import hookimpl
from datasette.permissions import PermissionSQL

TRUSTED = {""alice"", ""bob""}


@hookimpl
def permission_resources_sql(datasette, actor, action):
    if action != ""view-table"":
        return None

    actor_id = (actor or {}).get(""id"")

    if actor_id not in TRUSTED:
        return PermissionSQL(
            sql=""""""
                SELECT NULL AS parent, NULL AS child, 0 AS allow,
                       'default deny view-table' AS reason
            """""",
        )

    return PermissionSQL(
        sql=""""""
            SELECT NULL AS parent, NULL AS child, 0 AS allow,
                   'default deny view-table' AS reason
            UNION ALL
            SELECT 'reports' AS parent, 'daily_metrics' AS child, 1 AS allow,
                   'trusted user access' AS reason
        """""",
        params={""actor_id"": actor_id},
    ) 
                     The  UNION ALL  ensures the deny rule is always present, while the second row
                        adds the exception for trusted users.",345,