id,page,ref,title,content,breadcrumbs,references
json_api:expand-foreign-keys,json_api,expand-foreign-keys,Expanding foreign key references,"Datasette can detect foreign key relationships and resolve those references into
                labels. The HTML interface does this by default for every detected foreign key
                column - you can turn that off using  ?_labels=off . 
             You can request foreign keys be expanded in JSON using the  _labels=on  or
                 _label=COLUMN  special query string parameters. Here's what an expanded row
                looks like: 
             [
    {
        ""rowid"": 1,
        ""TreeID"": 141565,
        ""qLegalStatus"": {
            ""value"": 1,
            ""label"": ""Permitted Site""
        },
        ""qSpecies"": {
            ""value"": 1,
            ""label"": ""Myoporum laetum :: Myoporum""
        },
        ""qAddress"": ""501X Baker St"",
        ""SiteOrder"": 1
    }
] 
             The column in the foreign key table that is used for the label can be specified
                in  metadata.json  - see  Specifying the label column for a table .","[""JSON API""]",[]
json_api:id2,json_api,id2,Table arguments,The Datasette table view takes a number of special query string arguments.,"[""JSON API""]",[]
json_api:json-api-discover-alternate,json_api,json-api-discover-alternate,Discovering the JSON for a page,"Most of the HTML pages served by Datasette provide a mechanism for discovering their JSON equivalents using the HTML  link  mechanism. 
             You can find this near the top of the source code of those pages, looking like this: 
             <link rel=""alternate""
  type=""application/json+datasette""
  href=""https://latest.datasette.io/fixtures/sortable.json""> 
             The JSON URL is also made available in a  Link  HTTP header for the page: 
             Link: https://latest.datasette.io/fixtures/sortable.json; rel=""alternate""; type=""application/json+datasette""","[""JSON API""]",[]
json_api:json-api-shapes,json_api,json-api-shapes,Different shapes,"The default JSON representation of data from a SQLite table or custom query
                looks like this: 
             {
    ""database"": ""sf-trees"",
    ""table"": ""qSpecies"",
    ""columns"": [
        ""id"",
        ""value""
    ],
    ""rows"": [
        [
            1,
            ""Myoporum laetum :: Myoporum""
        ],
        [
            2,
            ""Metrosideros excelsa :: New Zealand Xmas Tree""
        ],
        [
            3,
            ""Pinus radiata :: Monterey Pine""
        ]
    ],
    ""truncated"": false,
    ""next"": ""100"",
    ""next_url"": ""http://127.0.0.1:8001/sf-trees-02c8ef1/qSpecies.json?_next=100"",
    ""query_ms"": 1.9571781158447266
} 
             The  columns  key lists the columns that are being returned, and the  rows 
                key then returns a list of lists, each one representing a row. The order of the
                values in each row corresponds to the columns. 
             The  _shape  parameter can be used to access alternative formats for the
                 rows  key which may be more convenient for your application. There are three
                options: 
             
                 
                     ?_shape=arrays  -  ""rows""  is the default option, shown above 
                 
                 
                     ?_shape=objects  -  ""rows""  is a list of JSON key/value objects 
                 
                 
                     ?_shape=array  - an JSON array of objects 
                 
                 
                     ?_shape=array&_nl=on  - a newline-separated list of JSON objects 
                 
                 
                     ?_shape=arrayfirst  - a flat JSON array containing just the first value from each row 
                 
                 
                     ?_shape=object  - a JSON object keyed using the primary keys of the rows 
                 
             
             _shape=objects  looks like this: 
             {
    ""database"": ""sf-trees"",
    ...
    ""rows"": [
        {
            ""id"": 1,
            ""value"": ""Myoporum laetum :: Myoporum""
        },
        {
            ""id"": 2,
            ""value"": ""Metrosideros excelsa :: New Zealand Xmas Tree""
        },
        {
            ""id"": 3,
            ""value"": ""Pinus radiata :: Monterey Pine""
        }
    ]
} 
             _shape=array  looks like this: 
             [
    {
        ""id"": 1,
        ""value"": ""Myoporum laetum :: Myoporum""
    },
    {
        ""id"": 2,
        ""value"": ""Metrosideros excelsa :: New Zealand Xmas Tree""
    },
    {
        ""id"": 3,
        ""value"": ""Pinus radiata :: Monterey Pine""
    }
] 
             _shape=array&_nl=on  looks like this: 
             {""id"": 1, ""value"": ""Myoporum laetum :: Myoporum""}
{""id"": 2, ""value"": ""Metrosideros excelsa :: New Zealand Xmas Tree""}
{""id"": 3, ""value"": ""Pinus radiata :: Monterey Pine""} 
             _shape=arrayfirst  looks like this: 
             [1, 2, 3] 
             _shape=object  looks like this: 
             {
    ""1"": {
        ""id"": 1,
        ""value"": ""Myoporum laetum :: Myoporum""
    },
    ""2"": {
        ""id"": 2,
        ""value"": ""Metrosideros excelsa :: New Zealand Xmas Tree""
    },
    ""3"": {
        ""id"": 3,
        ""value"": ""Pinus radiata :: Monterey Pine""
    }
] 
             The  object  shape is only available for queries against tables - custom SQL
                queries and views do not have an obvious primary key so cannot be returned using
                this format. 
             The  object  keys are always strings. If your table has a compound primary
                key, the  object  keys will be a comma-separated string.","[""JSON API""]",[]