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

# execute

> Executes a SQL statement and returns the results. Supports requests for both regular and streaming responses. 

With streaming, results return as they become available using the HTTP chunked transfer encoding. Each chunk contains a valid JSON object that you can parse independently.

For details on streaming, including large-response configuration, see the header parameters. 

You can specify the database in the request body. If you do not specify the database, the Ocient System defaults to the database specified in the authentication token or system settings. If you specify a database in the request, this value overrides any alternate database value specified as a body parameter.



## OpenAPI

````yaml /openapi/generated-api-methods.json POST /v1/execute/{database}
openapi: 3.1.0
info:
  title: Generated API methods
  version: 1.0.0
  description: Generated from imported ApiMethodV2 blocks.
servers:
  - url: https://{sql_node}
    variables:
      sql_node:
        default: sql_node
  - url: http://oc1-lts0:9090
security: []
paths:
  /v1/execute/{database}:
    post:
      tags:
        - Ocient HTTP Query API
      summary: execute
      description: >-
        Executes a SQL statement and returns the results. Supports requests for
        both regular and streaming responses. 


        With streaming, results return as they become available using the HTTP
        chunked transfer encoding. Each chunk contains a valid JSON object that
        you can parse independently.


        For details on streaming, including large-response configuration, see
        the header parameters. 


        You can specify the database in the request body. If you do not specify
        the database, the Ocient System defaults to the database specified in
        the authentication token or system settings. If you specify a database
        in the request, this value overrides any alternate database value
        specified as a body parameter.
      operationId: postOcientHttpQueryApiExecute
      parameters:
        - name: database
          in: path
          required: true
          description: >-
            The specific database in your system for the API call. 


            If you do not specify the database, the executed query defaults to
            the database from the authentication token or system settings.


            If you include a database in the path, this value overrides any
            alternate database value specified as a body parameter.
          schema:
            type: string
        - name: format
          in: query
          required: false
          description: >-
            Sets the format for the requested data. 


            Note: This parameter applies only when using Content-Type:
            text/plain. When using Content-Type: application/json, specify the
            format in the request body.


            Supported values are: 


            "array" — Returns schema and data as arrays (more efficient for
            large data sets). (default)

            "collection" — Returns data as JSON objects (more convenient for
            client processing).


            Example: format=collection
          schema:
            type: string
        - name: schema
          in: query
          required: false
          description: >-
            The schema to use for the SQL statement.


            Example: schema=mydata


            Note: This parameter applies only when using Content-Type:
            text/plain. When using Content-Type: application/json, specify the
            schema in the request body.
          schema:
            type: string
        - name: authorization
          in: header
          required: true
          description: >-
            An access token to connect to your Ocient System. 


            To receive an access token, you must provide your username and
            password using the login endpoint. 


            The system passes the credentials using the Authorization HTTP
            header using Base64-encoded Basic Authentication.
          schema:
            type: string
        - name: content-type
          in: header
          required: true
          description: >-
            Specifies the request body format. Options include: 


            application/json


            Description: The standard option for submitting queries and
            receiving responses as a single JSON object or array. Use when
            submitting queries with relatively small or moderate result sets or
            when you want the entire result set in one response.


            application/stream+json


            Description: Enables streaming of multiple JSON objects, allowing
            the API to send results as they become available. Use when querying
            large tables or expecting a large volume of results or when you want
            to process each row or result as soon as it is received, without
            waiting for the full response.
          schema:
            type: string
        - name: accept-encoding
          in: header
          required: false
          description: >-
            Supported compression algorithms for responses. You can specify
            multiple algorithms as a comma-separated list. 


            Supported values are: 

            "gzip" 

            "deflate" 

            "be" (Brotli)

            or combinations like: "gzip, be".


            Note: For large result sets, compression can impact performance.
            Without compression, the result sets can be chunks of rows processed
            in a streaming fashion. With compression, the entire result set must
            be compressed before it is returned to the client. The client side
            must decompress the entire result set before processing any rows.
          schema:
            type: string
        - name: accept
          in: header
          required: false
          description: >-
            Supported response media types. Regardless of the Accept header, the
            API returns large query results using chunked encoding. Also, see
            the note about compression in the accept-encoding parameter.


            Supported values are: 


            "application/json" (default)

            "application/stream+json"
          schema:
            type: string
        - name: preferred-encoding
          in: header
          required: false
          description: >-
            Indicates the preferred encoding type from those specified in the
            accept-encoding parameter. This header provides fine-grained control
            when the accept-encoding parameter contains multiple values,
            allowing the client to specify which encoding is preferred for this
            specific request explicitly.


            Supported values are: 


            "gzip" 

            "br"
          schema:
            type: string
        - name: preferred-compression-level
          in: header
          required: false
          description: >-
            Specifies the chosen compression level for the selected encoding
            algorithm. Values range from 1 (fastest, least compression) to 9
            (slowest, maximum compression). The exact behavior depends on the
            specific compression algorithm.
          schema:
            type: integer
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                statement:
                  type: string
                  description: >-
                    A valid SQL statement to execute. 


                    Example: statement=SELECT * FROM customers LIMIT 10;


                    You can include parameters to substitute in the SQL
                    statement by including them in the params body parameter.
                database:
                  type: string
                  description: >-
                    A specific database in your system for the API call. 


                    If you do not specify this parameter, the executed query
                    defaults to the database from the authentication token or
                    system settings.
                format:
                  type: string
                  description: >-
                    Sets the output format of the query result data. 


                    Supported values are: 


                    "array" — Returns the schema and data as arrays (more
                    efficient for large data sets). (default)

                    "collection" — Returns data as JSON objects (more convenient
                    for client processing).
                params:
                  type: object
                  description: >-
                    Parameters to substitute in the SQL statement for values
                    enclosed in braces. The keys should match the parameter
                    names in the statement (without the enclosing braces). Wrap
                    string values in single quotes. All other data types do not
                    use quotes. 


                    Example: If your SQL statement is SELECT * FROM orders WHERE
                    order_date > {start_date}, then your API request should
                    include values in the params body parameter, such as
                    {'start_date': '2023-01-01'}.
                fetch_size:
                  type: integer
                  description: >-
                    The number of rows to return in each chunk for streaming
                    responses. This value must be 0 or greater. A value of 0
                    (default) means the database determines how many rows to
                    return.  


                    Use smaller values for interactive applications (100-1000
                    rows). For batch processing, use larger values (5000-10000
                    rows).
                max_rows:
                  type: integer
                  description: >-
                    The maximum number of rows to return. The default value is
                    9223372036854776000.


                    Note: Adding a LIMIT clause to a SQL query is generally a
                    better method to restrict the number of rows, as the query
                    engine still generates the total number of rows, but only
                    returns this value to the client.
              required:
                - statement
      responses:
        '200':
          description: Response
          content:
            application/json:
              schema:
                type: object
                properties:
                  query_id:
                    type: string
                  status:
                    type: object
                    properties:
                      reason:
                        type: string
                      sql_state:
                        type: string
                      vendor_code:
                        type: integer
                  data:
                    type: array
                    items:
                      type: object
                      properties:
                        c1:
                          type: integer
              examples:
                response:
                  value:
                    query_id: ac4dd039-e385-400b-a428-fd1fdcd02e30
                    status:
                      reason: The operation completed successfully
                      sql_state: '00000'
                      vendor_code: 0
                    data:
                      - c1: 1
                      - c1: 2
      servers:
        - url: https://{sql_node}
          variables:
            sql_node:
              default: sql_node
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -u 'admin@system:admin'
            https://my_sql_node.com/v1/execute/system \
                -d '{"statement":"SELECT * FROM sys.dummy2", "format": "collection"}'

````