> ## Documentation Index
> Fetch the complete documentation index at: https://docs.narrative.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Validate an NQL query

> The validate endpoint in the NQL API allows users to verify the syntax and structure
of their NQL queries before executing them. This ensures that the queries are correctly
formatted and will not cause errors when passing through the /run endpoint.
The primary goal of using the validate endpoint is to receive a 200 OK status code,
which indicates that the query is valid.



## OpenAPI

````yaml https://docs-cdn.narrative.io/api-reference/main/openapi.json post /nql/validate
openapi: 3.1.1
info:
  contact:
    email: support@narrative.io
    name: Narrative Support
    url: https://www.narrative.io
  termsOfService: https://www.narrative.io/legal/terms-of-service
  x-logo:
    url: >-
      https://cdn.narrative.io/images/company-logos/prod/narrative-logo-text-white.svg
    backgroundColor: rgb(9, 34, 166)
    altText: Narrative Logo
  description: >-
    The [Narrative Data Collaboration Platform](https://app.narrative.io) API is
    organized around REST. Our API has predictable resource-oriented URLs,
    accepts form-encoded request bodies, returns JSON-encoded responses, and
    uses standard HTTP response codes, authentication, and verbs.



    The current version is a pre-release beta.  It may result in unexpected
    behavior and there may be breaking changes in future releases up to the 1.0
    release.
  title: Narrative Data Collaboration Platform API
  version: 2.4.x
servers:
  - url: https://api-dev.narrative.io
  - url: https://api.narrative.io
security: []
tags:
  - name: Access Rules
    description: >-
      Access rules let data providers control who can purchase their data and
      the terms of purchase.


      The `access-rules` API allows you to manage access rules for your
      datasets.


      Related guides:
        - [What is an access rule?](https://kb.narrative.io/access-rules)
  - name: Agent Conversations
    description: >-
      Build LLM-driven workflows that can call MCP tools, ask the caller for
      input, and return structured answers.


      A conversation pins a model, a system prompt, and a tool catalog. Each run
      sends the model a user message (or

      a batch of tool outputs from a previously-paused run); the model decides
      whether to answer directly, call a

      server-side tool (resolved by the platform via Model Context Protocol), or
      call a client-side tool (which pauses

      the run with `requires_action` and waits for the caller to reply).


      Related guides:
        - [Agent Conversations Reference](https://docs.narrative.io/reference/architecture/agent-conversations)
        - [Error catalog](https://docs.narrative.io/reference/architecture/agent-conversations/errors/conversation-not-found)
  - name: MCP Connections
    description: >-
      Connect external (non-Narrative) MCP servers so agent runs can call their
      tools with the

      calling user's own OAuth authorization.


      A connection is created interactively: `POST /mcp-connections` runs OAuth
      discovery and

      Dynamic Client Registration against the server and returns a consent URL;
      the user authorizes

      in a browser; the authorization server redirects to `GET
      /mcp-connections/callback`, which

      finishes the token exchange and marks the connection `connected`. Tokens
      are stored encrypted

      and used server-side — they are never returned by the API. Once connected,
      reference the

      connection by id from an agent run's `mcp_servers[].connection_id`.
  - name: App Invites
    description: >-
      App invites allow applications to create one-time, shareable links on
      behalf of their users. These links

      enable users to invite third parties who do not have a Narrative account
      to perform actions within the

      application.


      For example, a Narrative user can send an invite link to a third party who
      then completes a Pinterest

      OAuth flow and creates a connector profile in the inviter's account,
      allowing the inviter to deliver

      audience data to the third party's Pinterest account without the third
      party needing a Narrative account.


      This API is intended to be used by applications (via app client
      credentials) to create and manage invites

      on behalf of their users, which can then be shared with invitees.
  - name: Apps
    description: >-
      Apps are applications bundled with a UI that can perform various actions
      on behalf of a user utilizing the Narrative API.

      Related guides:
        - [Building a Narrative Native App](https://www.narrative.io/knowledge-base/how-to-guides/building-a-narrative-native-app)
  - name: Access Tokens
    description: API Access Token management
  - name: Attributes
    description: >-
      An attribute models a standardized data point available for sale on the
      Narrative marketplace.


      Narrative automatically turns data points from provider datasets into
      attributes so that buyers can purchase well-formed, standardized data from
      any supplier on the marketplace.
  - name: Auth
    description: >-
      API token is a crucial step for developers to securely authenticate
      requests to the Narrative API

      Related guides:
        - [How to Create an API Token](https://www.narrative.io/knowledge-base/how-to-guides/understanding-narratives-apis/create-an-api-token)
  - name: Authentication
    description: User login and registration
  - name: Billings
    description: Used by Narrative internally to bill customers
  - name: Companies
    description: A collection of employees
  - name: Company Marketing Information
    description: Useful information related to companies
  - name: Compute Pools
    description: >-
      Compute pools represent compute resources (e.g. Snowflake warehouses)
      provisioned within a data plane.

      Companies can manage and share compute pools, assign them to jobs, and set
      a default compute pool on data planes.
  - name: Connections
    description: Associations between connectors and datasets
  - name: Data Shops
    description: |-
      Self-hosted website to sell your data
      Related guides:
        - [Setting up your datashop](https://www.narrative.io/knowledge-base/how-to-guides/shop-builder/settting-up-your-data-shop)
  - name: Data Streams
    description: >-
      The `data-stream` API endpoints allows one to create and update
      data-streams. Additionally the endpoints allow

      finding data-streams using free text search. A few of the endpoints are
      behind authorization.


      Update endpoint allows a client to post an edited data-stream document as
      is, without having to change its shape.

      The API ensures that only certain fields are allowed to be modified.
      Attempts to modify fields not up for client

      modifications are ignored.


      Related guides:
        - [What is a data stream?](https://kb.narrative.io/what-is-a-data-stream)
  - name: Contracts
    description: Contracts related APIs
  - name: Datasets
    description: >-
      Any kind of data, in any schema, can be pushed into the Narrative Data
      Collaboration Platform as a dataset exactly as it is stored in your own
      system.


      The `datasets` API allows you to manage your datasets.
  - name: Destinations
    description: >-
      Destinations associate a subscription to a profile. Optionally, ad-hoc
      quick settings can be configured to a destination.

      Those quick settings have to match the format defined on the app manifest.
  - name: Installations
    description: Installations of Applications for a profile
  - name: Jobs
    description: >-
      Jobs represent an operation done on a given data plane. All jobs today are
      tied to a query that represents a forecast or a materialized view.


      The jobs API provides an interface for interacting with the jobs table,
      which stores various operations involving reading or writing data. This
      API allows users to retrieve detailed information about specific jobs,
      including cost forecasts, data forecasts, NQL forecasts and materialized
      views.
  - name: Mappings
    description: >-
      A mapping is a transformation from a dataset to an attribute. Defining a
      mapping between a dataset and an attribute makes the dataset eligible to
      participate in subscriptions where a buyer is purchasing the target
      attribute.
  - name: Model Inference
    description: Model Inference
  - name: Models
    description: >-
      Machine learning models for training and inference.


      Models can be stored in HuggingFace or Narrative repositories and have
      configurable

      collaborator permissions for training and inference access.


      The `models` API allows you to list, retrieve, and update models
      accessible to your company.
  - name: NQL
    description: >-
      Narrative Query Language (NQL) is a specialized, SQL-inspired language
      designed to query and manipulate data within the Narrative platform. While
      it looks and feels much like standard SQL, it offers extended
      functionality and syntax that let you leverage platform-specific
      features—such as referencing datasets by their IDs, creating materialized
      views, or generating forecasts—without having to manage the complexities
      of different query engines behind the scenes. NQL queries can ultimately
      compile down to multiple underlying engines (e.g., Snowflake, Spark) to
      execute your requests efficiently in the Narrative ecosystem.
  - name: Payment Methods
    description: Payment methods used to purchase data
  - name: Products
    description: Internal routes used to offer datastream as products
  - name: Profiles
    description: >-
      App profiles are associated with an installation. They represent a
      reference to a configuration that the app can use to save confidential
      information outside of Narrative's control.

      Profiles are currently used to configure settings for connector apps.
  - name: Resources
    description: >-
      Narrative gives you access to managed resources, like your own AWS S3
      bucket, so that you can effortlessly buy and sell data on the platform.


      The `resources` API allows you to manage your resources.
  - name: Schema Inference
    description: >-
      The `schema-inference` API analyzes submitted files to automatically infer
      and return their structure as a dataset schema.
  - name: Schema Presets
    description: >-
      The `schema-presets` API allows you to list the available schema presets,
      get detailed information about a specific one and manage its life cycle.


      You can create a schema preset from scratch or create one based on an
      existing one, administrators can create platform wide available (public)
      schema preset.
  - name: Subscriptions
    description: >-
      In the Narrative Data Collaboration Platform a subscription represents a
      set of rules dictating the commercial terms related to the licensing of
      data.


      The `subscriptions` API allows you to set and get information about
      `subscription` objects owned by the authenticated account.
  - name: Uploads
    description: >-
      The `uploads` API allows you to send files to Narrative and use them to
      perform tasks like creating a list or adding data to a dataset.
  - name: Usage
    description: >-
      The `usage` API enables the recording of usage events associated with a
      product.
  - name: Workflows
    description: >-
      The `workflows` API allows you to create, schedule, trigger, and archive
      workflows.

      Workflows are defined using a serverlessworkflow YAML specification.
paths:
  /nql/validate:
    post:
      tags:
        - NQL
      summary: Validate an NQL query
      description: >-
        The validate endpoint in the NQL API allows users to verify the syntax
        and structure

        of their NQL queries before executing them. This ensures that the
        queries are correctly

        formatted and will not cause errors when passing through the /run
        endpoint.

        The primary goal of using the validate endpoint is to receive a 200 OK
        status code,

        which indicates that the query is valid.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - nql
              properties:
                nql:
                  $ref: '#/components/schemas/NQL'
                data_plane_id:
                  $ref: '#/components/schemas/DataPlaneId'
            example:
              nql: >-
                CREATE MATERIALIZED VIEW "dataset_name" AS SELECT
                "company_data"."1".x AS xx, "company_data"."1".y AS yy,
                "company_data"."1".z AS zz, "company_data"."1".x +
                "company_data"."1".y + "company_data"."1".z AS xyz_sum FROM
                "company_data"."1"
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Ast'
              examples:
                create_materialized_view:
                  summary: create materialized view
                  description: |-
                    NQL Query:

                    ```sql
                    CREATE MATERIALIZED VIEW  "dataset_name" AS
                    SELECT
                      "company_data"."1".x AS xx,
                      "company_data"."1".y AS yy,
                      "company_data"."1".z AS zz,
                      "company_data"."1".x +  "company_data"."1".y +  "company_data"."1".z AS xyz_sum
                    FROM  "company_data"."1""
                    ```
                  value:
                    type: create_materialized_view
                    nql: >-
                      CREATE MATERIALIZED VIEW "dataset_name" AS SELECT
                      "company_data"."1".x AS xx, "company_data"."1".y AS yy,
                      "company_data"."1".z AS zz, "company_data"."1".x +
                      "company_data"."1".y + "company_data"."1".z AS xyz_sum
                      FROM "company_data"."1"
                    name: dataset_name
                    select:
                      type: select
                      nql: >-
                        SELECT "company_data"."1".x AS xx, "company_data"."1".y
                        AS yy, "company_data"."1".z AS zz, "company_data"."1".x
                        + "company_data"."1".y + "company_data"."1".z AS xyz_sum
                        FROM "company_data"."1"
                      columns:
                        - as: xx
                          nql: '"company_data"."1".x AS xx'
                          type: column
                          db: null
                          schema: company_data
                          table: '1'
                          column: x
                          metadata:
                            column_type: column
                        - as: yy
                          nql: '"company_data"."1".y AS yy'
                          type: column
                          db: null
                          schema: company_data
                          table: '1'
                          column: 'y'
                          metadata:
                            column_type: column
                        - as: zz
                          nql: '"company_data"."1".z AS zz'
                          type: column
                          db: null
                          schema: company_data
                          table: '1'
                          column: z
                          metadata:
                            column_type: column
                        - as: xyz_sum
                          nql: >-
                            "company_data"."1".x + "company_data"."1".y +
                            "company_data"."1".z AS xyz_sum
                          type: binary_op
                          name: +
                          left:
                            type: binary_op
                            nql: '"company_data"."1".x + "company_data"."1".y'
                            name: +
                            left:
                              type: column
                              nql: '"company_data"."1".x'
                              db: null
                              schema: company_data
                              table: '1'
                              column: x
                              metadata:
                                column_type: column
                            right:
                              type: column
                              nql: '"company_data"."1".y'
                              db: null
                              schema: company_data
                              table: '1'
                              column: 'y'
                              metadata:
                                column_type: column
                          right:
                            type: column
                            nql: '"company_data"."1".z'
                            db: null
                            schema: company_data
                            table: '1'
                            column: z
                            metadata:
                              column_type: column
                      from:
                        type: table
                        nql: '"company_data"."1"'
                        db: null
                        schema: company_data
                        table: '1'
                        metadata:
                          id: 1
                          name: dataset_name_1
                          table_type: dataset
                      group_by: []
                      having: null
                      is_distinct: false
                      limit: null
                      order_by: []
                      qualify: null
                      where: null
                      windows: []
                      with: []
                explain:
                  summary: explain
                  description: |-
                    ```sql
                    explain
                    select
                      "company_data"."1".s,
                      "company_data"."1".arr
                    from "company_data"."1"
                    where "company_data"."1".x > -10.0
                    ```
                  value:
                    type: explain
                    nql: >-
                      EXPLAIN SELECT "company_data"."1".s,
                      "company_data"."1".arr FROM "company_data"."1" WHERE "1".x
                      > CAST(-10.0 AS DOUBLE)
                    query:
                      type: select
                      nql: >-
                        SELECT "company_data"."1".s, "company_data"."1".arr FROM
                        "company_data"."1" WHERE "1".x > CAST(-10.0 AS DOUBLE)
                      columns:
                        - type: column
                          nql: '"company_data"."1".s'
                          db: null
                          schema: company_data
                          table: '1'
                          column: s
                          metadata:
                            column_type: column
                        - type: column
                          nql: '"company_data"."1".arr'
                          db: null
                          schema: company_data
                          table: '1'
                          column: arr
                          metadata:
                            column_type: column
                      from:
                        type: table
                        nql: '"company_data"."1"'
                        db: null
                        schema: company_data
                        table: '1'
                        metadata:
                          id: 1
                          name: dataset_name_1
                          table_type: dataset
                      group_by: []
                      having: null
                      is_distinct: false
                      limit: null
                      order_by: []
                      qualify: null
                      where:
                        type: binary_op
                        nql: '"1".x > CAST(-10.0 AS DOUBLE)'
                        name: '>'
                        left:
                          type: column
                          nql: '"1".x'
                          db: null
                          schema: company_data
                          table: '1'
                          column: x
                          metadata:
                            column_type: column
                        right:
                          type: literal
                          nql: '-10.0'
                          value_type:
                            type: double
                          value: '-10.0'
                      windows: []
                      with: []
        '400':
          description: >-
            Bad Request

            visit
            https://www.narrative.io/knowledge-base/support-troubleshooting/nql
            for more details
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Response'
        '422':
          description: >-
            Unprocessable Entity — the query parsed but is semantically invalid,
            for example a materialized

            view output column whose type is not supported (such as DECIMAL), or
            a query that produces no

            output columns.

            visit
            https://www.narrative.io/knowledge-base/support-troubleshooting/nql
            for more details
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Response'
              examples:
                unsupported_output_type:
                  summary: unsupported output column type
                  value:
                    title: 'Unsupported Type Error: DECIMAL'
                    status: 422
                    detail: >-
                      Column 'decimal_value' has type DECIMAL, which is not
                      supported as an output column of a materialized view. CAST
                      the column to a supported type such as DOUBLE, BIGINT,
                      VARCHAR, BOOLEAN, or TIMESTAMP.
                    instance: /nql/validate
                    log_id: c904b703-d41e-4372-9276-9f4bdc8ad031
                    debug:
                      column: decimal_value
                      type_name: DECIMAL
      security:
        - BearerAuth: []
components:
  schemas:
    NQL:
      type: string
      description: A NQL query.
    DataPlaneId:
      type: string
      format: uuid
      description: >-
        A dataplane represent where you would run the query. Your query get
        compiled

        to the SQL dialect that your data engine understands. If you leave it
        blank,

        your query will target Narrative's dataplane on AWS using Apache Spark.
        We

        currently support Snowflake and we plan to support other dataplanes in
        the

        future. See https://next.narrative.io/products/narrative-anywhere for
        more

        details.
    Ast:
      oneOf:
        - $ref: '#/components/schemas/AggFunction'
        - $ref: '#/components/schemas/AstList'
        - $ref: '#/components/schemas/As'
        - $ref: '#/components/schemas/BinaryOp'
        - $ref: '#/components/schemas/Case'
        - $ref: '#/components/schemas/CreateMaterializedView'
        - $ref: '#/components/schemas/Explain'
        - $ref: '#/components/schemas/Function'
        - $ref: '#/components/schemas/Lit'
        - $ref: '#/components/schemas/Ident'
        - $ref: '#/components/schemas/Join'
        - $ref: '#/components/schemas/Select'
        - $ref: '#/components/schemas/Op'
        - $ref: '#/components/schemas/TypeSpec'
        - $ref: '#/components/schemas/Window'
        - $ref: '#/components/schemas/Unknown'
    Response:
      type: object
      required:
        - title
        - status
        - detail
        - instance
        - log_id
      properties:
        type:
          type: string
        title:
          type: string
          description: a summary of the error
        status:
          type: number
          description: http status code
        detail:
          type: string
          description: a longer description of the error
        instance:
          type: string
          description: path of the query
        log_id:
          type: string
          format: uuid
          description: an internal logging id, Narrative can use to help debug a problem.
      example:
        type: null
        title: Failed to Parse Query
        status: 400
        detail: Invalid query format.
        instance: /nql/validate
        log_id: c06fea02-0950-45c6-aaff-07ab07c0d04c
        debug: null
    AggFunction:
      title: aggregate
      type: object
      required:
        - type
        - nql
        - args
      properties:
        type:
          type: string
          const: agg_function
        nql:
          type: string
        args:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        quantifier:
          type: string
          enum:
            - all
            - distinct
    AstList:
      title: list
      type: array
      items:
        $ref: '#/components/schemas/Ast'
    As:
      title: as
      type: object
      required:
        - type
        - nql
        - name
        - value
      properties:
        type:
          type: string
          const: as
        nql:
          $ref: '#/components/schemas/Nql'
        name:
          type: string
        value:
          $ref: '#/components/schemas/Ast'
    BinaryOp:
      title: binary operator
      type: object
      required:
        - type
        - nql
        - name
        - left
        - right
      properties:
        type:
          type: string
          const: binary_op
        nql:
          $ref: '#/components/schemas/Nql'
        name:
          type: string
        left:
          $ref: '#/components/schemas/Ast'
        right:
          $ref: '#/components/schemas/Ast'
    Case:
      title: case
      type: object
      required:
        - type
        - nql
        - args
      properties:
        type:
          type: string
          const: case
        nql:
          $ref: '#/components/schemas/Nql'
        args:
          type: array
          items:
            $ref: '#/components/schemas/CaseArg'
    CreateMaterializedView:
      title: create materialized view
      type: object
      required:
        - type
        - nql
        - name
        - select
      properties:
        type:
          type: string
          const: create_materialized_view
        nql:
          $ref: '#/components/schemas/Nql'
        name:
          type: string
        select:
          $ref: '#/components/schemas/Select'
    Explain:
      title: explain
      type: object
      required:
        - type
        - nql
        - query
      properties:
        type:
          type: string
          const: explain
        nql:
          $ref: '#/components/schemas/Nql'
        query:
          $ref: '#/components/schemas/Ast'
    Function:
      title: function
      type: object
      required:
        - type
        - nql
        - args
        - name
      properties:
        type:
          type: string
          const: function
        nql:
          $ref: '#/components/schemas/Nql'
        args:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        name:
          type: string
    Lit:
      title: literal
      type: object
      required:
        - type
        - nql
        - value_type
      properties:
        type:
          type: string
          const: literal
        nql:
          $ref: '#/components/schemas/Nql'
        value_type:
          $ref: '#/components/schemas/SimpleType'
        value:
          type: string
    Ident:
      title: identifier
      type: object
      required:
        - type
        - nql
      properties:
        type:
          type: string
        nql:
          $ref: '#/components/schemas/Nql'
      oneOf:
        - $ref: '#/components/schemas/IdentAmbiguous'
        - $ref: '#/components/schemas/IdentTable'
        - $ref: '#/components/schemas/IdentColumn'
    Join:
      title: join
      type: object
      required:
        - type
        - condition_type
        - left
        - join_type
        - right
      properties:
        type:
          type: string
          const: join
        condition:
          $ref: '#/components/schemas/Ast'
        condition_type:
          type: string
          enum:
            - none
            - 'on'
            - using
        left:
          $ref: '#/components/schemas/Ast'
        join_type:
          type: string
          enum:
            - as_of
            - comma
            - cross
            - full
            - inner
            - left
            - left_as_of
            - left_anti
            - left_semi
            - right
        right:
          $ref: '#/components/schemas/Ast'
    Select:
      title: select
      type: object
      required:
        - type
        - nql
        - columns
        - group_by
        - is_distinct
        - order_by
        - windows
        - with
      properties:
        type:
          type: string
          const: select
        nql:
          $ref: '#/components/schemas/Nql'
        columns:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        from:
          $ref: '#/components/schemas/Ast'
        group_by:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        having:
          $ref: '#/components/schemas/Ast'
        is_distinct:
          type: boolean
        limit:
          $ref: '#/components/schemas/Ast'
        order_by:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        qualify:
          $ref: '#/components/schemas/Ast'
        where:
          $ref: '#/components/schemas/Ast'
        windows:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        with:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
    Op:
      title: operator
      type: object
      required:
        - type
        - nql
        - args
        - name
      properties:
        type:
          type: string
          const: operator
        nql:
          $ref: '#/components/schemas/Nql'
        args:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        name:
          type: string
    TypeSpec:
      title: type specification
      type: object
      required:
        - type
        - nql
        - value
      properties:
        type:
          type: string
          const: type_spec
        nql:
          $ref: '#/components/schemas/Nql'
        value:
          type: string
    Window:
      title: window
      type: object
      required:
        - type
        - nql
        - order_by
        - partitions
      properties:
        type:
          type: string
          const: window
        nql:
          $ref: '#/components/schemas/Nql'
        lower_bound:
          $ref: '#/components/schemas/Ast'
        name:
          $ref: '#/components/schemas/Ident'
        order_by:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        partitions:
          type: array
          items:
            $ref: '#/components/schemas/Ast'
        upper_bound:
          $ref: '#/components/schemas/Ast'
    Unknown:
      title: unknown
      type: object
      required:
        - type
        - nql
      properties:
        type:
          type: string
          const: unknown
        nql:
          $ref: '#/components/schemas/Nql'
    Nql:
      type: string
    CaseArg:
      oneOf:
        - $ref: '#/components/schemas/CaseArgWhen'
        - $ref: '#/components/schemas/CaseArgElse'
    SimpleType:
      title: a simple type
      type: object
      oneOf:
        - $ref: '#/components/schemas/BinaryType'
        - $ref: '#/components/schemas/AstTypes_BooleanType'
        - $ref: '#/components/schemas/AstTypes_DoubleType'
        - $ref: '#/components/schemas/AstTypes_LongType'
        - $ref: '#/components/schemas/AstTypes_IntervalType'
        - $ref: '#/components/schemas/AstTypes_ObjectType'
        - $ref: '#/components/schemas/OtherType'
        - $ref: '#/components/schemas/AstTypes_StringType'
        - $ref: '#/components/schemas/TimestampType'
    IdentAmbiguous:
      title: ambiguous
      type: object
      required:
        - parts
      properties:
        type:
          const: ambiguous
        parts:
          type: array
          items:
            type: string
    IdentTable:
      title: table
      type: object
      required:
        - table
        - metadata
      properties:
        type:
          const: table
        db:
          type: string
        schema:
          type: string
        table:
          type: string
        metadata:
          $ref: '#/components/schemas/TableMetadata'
    IdentColumn:
      title: column
      type: object
      required:
        - table
        - column
        - metadata
      properties:
        type:
          const: column
        db:
          type: string
        schema:
          type: string
        table:
          type: string
        column:
          type: string
        metadata:
          $ref: '#/components/schemas/ColumnMetadata'
    CaseArgWhen:
      type: object
      required:
        - type
        - nql
        - condition
        - value
      properties:
        type:
          type: string
          const: when
        nql:
          $ref: '#/components/schemas/Nql'
        condition:
          $ref: '#/components/schemas/Ast'
        value:
          $ref: '#/components/schemas/Ast'
    CaseArgElse:
      type: object
      required:
        - type
        - nql
        - value
      properties:
        type:
          type: string
          const: when
        nql:
          $ref: '#/components/schemas/Nql'
        value:
          $ref: '#/components/schemas/Ast'
    BinaryType:
      title: binary
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: binary
        format:
          type: string
          enum:
            - geometry
    AstTypes_BooleanType:
      title: boolean
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: boolean
    AstTypes_DoubleType:
      title: double
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: double
    AstTypes_LongType:
      title: long
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: boolean
    AstTypes_IntervalType:
      title: interval
      type: object
      required:
        - type
        - period
      properties:
        type:
          type: string
          const: interval
        period:
          type: string
          enum:
            - day
            - day_hour
            - day_minute
            - day_second
            - hour
            - hour_minute
            - hour_second
            - minute
            - minute_second
            - month
            - second
            - year
            - year_month
    AstTypes_ObjectType:
      title: object
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: object
        properties:
          type: array
          items:
            $ref: '#/components/schemas/SimpleType'
    OtherType:
      title: other
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: other
    AstTypes_StringType:
      title: string
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: string
    TimestampType:
      title: timestamp
      type: object
      required:
        - type
      properties:
        type:
          type: string
          const: timestamp
    TableMetadata:
      type: object
      required:
        - table_type
      properties:
        table_type:
          type: string
      oneOf:
        - $ref: '#/components/schemas/DatasetTable'
        - $ref: '#/components/schemas/AccessRulesTable'
        - $ref: '#/components/schemas/MaterializedViewTable'
        - $ref: '#/components/schemas/RosettaStoneTable'
        - $ref: '#/components/schemas/ReferenceTable'
        - $ref: '#/components/schemas/ViewTable'
    ColumnMetadata:
      type: object
      required:
        - column_type
      properties:
        column_type:
          type: string
      oneOf:
        - $ref: '#/components/schemas/RegularColumn'
        - $ref: '#/components/schemas/AttributeColumn'
        - $ref: '#/components/schemas/ReferenceColumn'
    DatasetTable:
      title: dataset
      type: object
      required:
        - id
        - name
      properties:
        table_type:
          const: dataset
        id:
          $ref: '#/components/schemas/DatasetId'
        name:
          $ref: '#/components/schemas/DatasetName'
    AccessRulesTable:
      title: access_rule
      type: object
      required:
        - id
      properties:
        table_type:
          const: access_rule
        id:
          $ref: '#/components/schemas/AccessRuleId'
        name:
          $ref: '#/components/schemas/AccessRuleName'
    MaterializedViewTable:
      title: materialized_view
      type: object
      required:
        - id
        - name
      properties:
        table_type:
          const: materialized_view
        id:
          $ref: '#/components/schemas/DatasetId'
        name:
          $ref: '#/components/schemas/DatasetName'
    RosettaStoneTable:
      title: rosetta_stone
      type: object
      properties:
        table_type:
          const: rosetta_stone
    ReferenceTable:
      title: reference
      type: object
      properties:
        table_type:
          const: reference
    ViewTable:
      title: view
      type: object
      required:
        - id
        - name
      properties:
        table_type:
          const: view
        id:
          $ref: '#/components/schemas/ViewId'
        name:
          $ref: '#/components/schemas/ViewName'
    RegularColumn:
      title: column
      type: object
      properties:
        column_type:
          const: column
    AttributeColumn:
      title: attribute
      type: object
      required:
        - id
        - name
      properties:
        column_type:
          const: attribute
        id:
          type: integer
        name:
          type: string
    ReferenceColumn:
      title: reference
      type: object
      properties:
        column_type:
          const: reference
    DatasetId:
      type: integer
      description: Unique identifier for the dataset.
    DatasetName:
      type: string
      description: >-
        The Dataset's name. Should be unique, contain only alpanum chars and
        underscores. Max length is 256.
    AccessRuleId:
      type: integer
      description: Unique identifier for the access rule.
    AccessRuleName:
      type: string
      description: >-
        It should be unique.

        Also should not intersect with Dataset names.

        Must be <= 256 characters and consist of only alphanumeric characters
        and underscores.
    ViewId:
      type: string
      format: uuid
    ViewName:
      type: string
      description: >-
        It should be unique.

        Must be <= 256 characters and consist of only alphanumeric characters
        and underscores.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer

````