Flight SQL - Parable

Arrow Flight SQL is the protocol Parable’s SQL endpoint speaks. Parable authenticates and authorizes each gRPC call, then streams the Arrow results back unchanged. To connect DBeaver or Python step by step, start with Query Provider Pools with SQL. For language clients, see Query with SDKs. Use this page when you configure an ADBC, JDBC, or custom Flight SQL client.

Connection contract

Setting	Value
Endpoint	`sql.parable.work:443`, with TLS: `grpc+tls://sql.parable.work:443` for ADBC
Service path	`/arrow.flight.protocol.FlightService/*`
Authentication metadata	`authorization: Bearer <token>`
Workspace metadata	`x-tenant: <workspace-slug>`; for ADBC, the option `adbc.flight.sql.rpc.call_header.x-tenant`
Workspace permission	`tenant.data.query.providers` (the Provider Pools Reader role) to query the Provider Pools; `tenant.data.query` (the Data Access role) to query every pool. `tenant.view` alone, as in the Viewer role, is refused.

x-tenant-slug is accepted as an alias for x-tenant. Send the authorization metadata on every call. The Flight Handshake RPC is accepted and does nothing, so a client cannot authenticate through it.

Pools each role reaches

Role	Permission	Pools
Provider Pools Reader	`tenant.data.query.providers`	`providers`, `providers_quarantine`, `providers_quality`
Data Access	`tenant.data.query`	Every pool
Workspace Administrator	`tenant`	Every pool

A query that names a pool the caller’s role does not reach fails with INVALID_ARGUMENT, the message

FROM or JOIN names a source this Workspace cannot read. Choose an available source, or ask a Workspace Administrator to check your data access.

, and error code QL-PL-002. Catalog discovery leaves that pool out. Inside the pools a role reaches, the Workspace’s Provider Policies decide which rows of each Provider table it reads. Table metadata leaves out the row count and validation rates of a table they narrow for the caller. A caller whose Workspace roles hold All data access (tenant.data.unrestricted), as Workspace Administrator does, reads every row of every Provider table, and each such call is recorded in the Workspace’s audit events.

Tokens

A SQL tool authenticates with a pat_ token (API tokens). A SQL token a member creates in Protection → Access Tokens reaches that Workspace only and queries with its owner’s Workspace roles at the time of each query; a staff role never counts. A Parable token queries any Workspace its owner can, with the owner’s roles, staff roles included, at the time of each query. Flight SQL refuses a call with:

Status	Message	Cause
`UNAUTHENTICATED`	`authentication required`	The call carries no `authorization` metadata.
`UNAUTHENTICATED`	`invalid token`	The token is unknown, for example incomplete or from another environment.
`UNAUTHENTICATED`	`token has been revoked`, `token expired`, `user not found`	The token was revoked, expired, or its owner was deactivated.
`INVALID_ARGUMENT`	`X-Tenant header required`	The call names no Workspace.
`NOT_FOUND`	`tenant not found`	No Workspace has that slug.
`PERMISSION_DENIED`	`personal access tokens are turned off for this Workspace`	The Workspace turned tokens off.
`PERMISSION_DENIED`	`tenant not in token scope`	A SQL token names a Workspace other than the one it was created in.
`PERMISSION_DENIED`	`this personal access token does not work with SQL over Flight; create a SQL token`	The token is an MCP token, which works on the Workspace API and the MCP endpoint only.
`PERMISSION_DENIED`	`insufficient permissions`	The owner’s roles in the Workspace cannot query: their role changed or they left it.

Connect with ADBC

import os

import adbc_driver_flightsql.dbapi
from adbc_driver_flightsql import DatabaseOptions

connection = adbc_driver_flightsql.dbapi.connect(
    os.environ["PARABLE_FLIGHT_URL"],
    db_kwargs={
        DatabaseOptions.AUTHORIZATION_HEADER.value:
            f"Bearer {os.environ['PARABLE_API_TOKEN']}",
        f"{DatabaseOptions.RPC_CALL_HEADER_PREFIX.value}x-tenant":
            os.environ["PARABLE_WORKSPACE"],
    },
)

cursor = connection.cursor()
cursor.execute("SELECT * FROM providers.google.users LIMIT 10")
print(cursor.fetch_arrow_table())

Set PARABLE_FLIGHT_URL to grpc+tls://sql.parable.work:443. The public endpoints use TLS.

Request lifecycle

For a statement query:

GetFlightInfo validates and plans the SQL, then returns an opaque ticket.
DoGet executes from that ticket and streams Arrow record batches.
The client releases the result stream when it has consumed or abandoned it.

Prepared statements follow the same read path with a server-issued handle. See supported operations for the complete command matrix.

Limits

A query may run for up to one hour. The clock starts when Parable admits the query and covers planning and the whole result stream, including the time your client spends reading it. A query that runs longer fails with DEADLINE_EXCEEDED, Parable error code QL-TO-002 (QUERY_TIMEOUT), and the message query <id> exceeded timeout of 3600s. The server sets this limit. A longer deadline on your client does not extend it, and a shorter one ends the call early, so set your driver’s timeout to at least an hour before running a long query.

Row limit

A query may return up to 2,000,000 rows. DoGet streams them batch by batch, without collecting the result first. A query whose result has more rows fails. Nothing is truncated: the stream ends with RESOURCE_EXHAUSTED, Parable error code QL-SQ-005 (RESULT_ROW_CAP_EXCEEDED), and this message:

Query result has more than 2,000,000 rows, the most one query can return. Add a LIMIT clause, or narrow the query with a WHERE filter or an aggregation.

The error can arrive after some record batches. Your driver raises it when you read past them, so discard the rows it returned before the error: they are not the result. To stay under the limit, add LIMIT, filter with WHERE, or aggregate in SQL. To read more rows than the limit, run one query per range of a column, such as one month at a time.

AI call limits

ponder(), embed() and the Jev functions (ask, noul, choice and score) send paid calls to an AI Provider. By default, one query may send up to 1,000,000 of these calls and spend up to $1,000 on them. What counts as one call:

ponder() and a Jev function send one call for each row.
embed() sends up to 32 rows in one call.
A Jev call that TypeSafe or a decision model throttles and Parable sends again counts again. A decision model answers one Jev call with one chat request for each question, and the call counts once. The cost limit counts each question that still has no answer.

Parable checks the limits before each call. When the next call would pass a limit, Parable does not send it, and the stream ends with RESOURCE_EXHAUSTED and one of these error codes:

QL-SQ-010 (AI_CALL_LIMIT_EXCEEDED): the query would send more calls than the limit.
QL-SQ-011 (AI_COST_LIMIT_EXCEEDED): the query’s calls would cost more than the limit. Parable knows the cost of a call only after the call answers, so the calls already sent can pass the limit by a small amount.

A call to a model that Parable has no price for yet is refused, because the cost limit could not count it. The stream ends with FAILED_PRECONDITION and QL-SQ-012 (AI_MODEL_UNPRICED). The message names the function, the model and its processor. Most refusals come before any call. On OpenRouter, and for a Jev alias, the price shows in the answer, so the call is refused after that answer and no further call is sent. Do not retry: name a model that has a price. The message names the limit and the function. The error can arrive after some record batches: discard them, because they are not the result. Do not retry the same query. Call the function over fewer rows: filter with WHERE, sample or LIMIT the rows before the function, or aggregate fewer rows. To call a function over every row of a large table, publish the SQL as a Plot. A Refresh keeps each answer and runs under its own limits. Each IP address may send 600 calls a minute. A query takes at least two calls, GetFlightInfo and DoGet. Calls over the limit are refused with HTTP status 429 at Parable’s edge, which gRPC clients report as UNAVAILABLE.

Metadata discovery

Flight SQL supports catalog, schema, table, table-type, SQL capability, and logical key discovery. GetTables can include an Arrow IPC schema for every matching table, including optional Parable semantic metadata. Discover tables and columns shows how to use those operations.

Semantic types in comparisons

A column can carry a semantic scalar, such as Contact.Email or Contact.PhoneNumber, in its parable.scalar.canonical_name field metadata. Parable uses it when a query plans:

Two columns with different scalars can be compared only when scalar-lib declares them comparable, such as Temporal.Date and Temporal.DateTime. contacts.email = people.phone fails with INVALID_ARGUMENT and error code QL-PL-007 (INCOMPARABLE_SCALARS). The message names both columns and both scalars. The check covers comparison operators, BETWEEN, IN, subquery comparisons, join keys, and UNION, INTERSECT and EXCEPT columns.
To compare across scalars on purpose, cast one side where it is compared: CAST(contacts.email AS VARCHAR) = people.phone. A column without a scalar compares with any column.
A value you supply is never refused and needs no cast. A string literal or bound parameter compared with an Identity.UUID or Contact.Email column is converted to that scalar’s canonical form, so email = 'Jane@Example.com' matches the stored jane@example.com. A value that is not valid for the scalar is compared as written: email = '' returns no rows, and email <> '' returns every row with an email.

Embedding vectors in comparisons

embed() stamps its model identity (provider, name, variant, version, dimensions, normalization) in its output field’s parable.model_* metadata. Vectors are comparable only within one identity, so array_distance over two vectors stamped with different identities fails with INVALID_ARGUMENT and error code QL-PL-008 (INCOMPARABLE_EMBEDDING_MODELS), even when their dimensions match. The message names the function and both models. A Plot’s embed() column carries the identity of the model that wrote it. A vector without an identity, such as a literal vector, is compared on its dimensions alone; see Embed.

Recursive queries

WITH RECURSIVE walks a hierarchy, such as everyone below each manager at any depth. Join its two terms with UNION: it stops when an iteration adds no new row, so a loop in the data, such as a person listed as their own manager, ends. UNION ALL fails with INVALID_ARGUMENT and error code QL-PL-014 (RECURSIVE_UNION_ALL), because nothing else would stop it.

WITH RECURSIVE chain (manager_email, member_email) AS (
  SELECT manager_email, email FROM people WHERE manager_email IS NOT NULL
  UNION
  SELECT chain.manager_email, people.email
  FROM chain JOIN people ON people.manager_email = chain.member_email
)
SELECT manager_email, member_email FROM chain

A recursive query works the same way in SQL over Flight, in a Plot, in a Pipeline and in SQL over a Parable’s Plots. A large hierarchy is cheaper as a Pipeline: it is computed once per Refresh, and readers read its stored rows.

Errors and retries

Unsupported commands return gRPC UNIMPLEMENTED. Invalid authentication and Workspace selection return gRPC authentication, permission, or argument statuses rather than HTTP JSON errors. A Parable error code, such as QL-PL-002, arrives in the parable-error-code response metadata beside the gRPC status. Facts a refusal names for you, when it names any, arrive as a JSON object of strings in the binary parable-error-details-bin metadata. When query concurrency is saturated, Parable returns RESOURCE_EXHAUSTED with error code QL-IN-008. A client can retry a read-only query with bounded exponential backoff. Do not retry invalid SQL, authentication failures, or permission failures without changing the request. QL-PL-007 (INCOMPARABLE_SCALARS) is deterministic: change the comparison or add a CAST rather than retrying. QL-PL-008 (INCOMPARABLE_EMBEDDING_MODELS) is too: embed both sides with the same model. So is QL-PL-015 (FILTER_POLICY_COLUMN_MISSING, FAILED_PRECONDITION): a Plot that reads Provider data lacks a column a Parable filter Policy that binds you reads, usually identity_account_id; the Plot’s author adds the column. QL-TN-009 (SOURCE_PERMISSIONS_UNAVAILABLE) arrives with FAILED_PRECONDITION. Source permissions decide which rows of a table you read, and Parable can’t tell who may open its rows. Nothing is read: Parable never returns every row instead. The message says why, and the table detail names the table. When the message says that the access projection has not been built for its Provider, Parable has not read that Provider’s sharing yet. Parable reads a Provider’s sharing after each sync of it, so run the query again after the Provider’s next sync. SQL the query engine cannot run is the query’s to fix. It returns INVALID_ARGUMENT with one of these codes, unless a row names another status. The message names at most the columns, functions and types involved, never the rest of the SQL or its values. Change the query rather than retrying:

Code	Cause	Message
`QL-PL-001` (`UNKNOWN_COLUMN`)	A column that no table in the query has	`Query references an unknown column "…"`, naming the column as the query wrote it, with its qualifier, such as `"i.missing_column"`. Unquoted names are lowercased, so the name shows as the engine looked it up.
`QL-PL-009` (`UNSUPPORTED_CAST`)	A `CAST` between types that do not convert, such as a struct or a list of structs to `VARCHAR`	Names both Arrow types (`VARCHAR` is `Utf8View`). For a struct it suggests selecting a field, `column['field']`; for a list, `cardinality(column)` for the element count or `unnest(column)` for one row per element.
`QL-PL-010` (`UNKNOWN_FUNCTION`)	A function that does not exist	Names the function and, when there is one, a function with a similar name.
`QL-PL-011` (`DUPLICATE_EXPRESSION_NAME`)	Two output expressions with the same name, such as `SELECT count(), count()`	Asks for an alias with `AS` on each duplicate.
`QL-PL-012` (`UNSUPPORTED_SQL`)	Other SQL the engine does not implement, such as `IN (SELECT ...)` inside a select-list expression, an aggregate with its own `ORDER BY` used as a window function, such as `array_agg(DISTINCT x ORDER BY x) OVER ()`, a `LATERAL` subquery that reads an outer column outside its `WHERE` clause, `LATERAL` in a `RIGHT` or `FULL` join, or an inner `LATERAL` join whose subquery’s own `SELECT` has an aggregate and `HAVING` but no `GROUP BY` (see LATERAL subqueries)	`This SQL uses an unsupported expression. Rewrite it with supported SQL functions.` The message omits the engine’s description, because it can quote the query’s values. For a window aggregate’s own `ORDER BY`, the message names the construct and asks you to sort the result with `array_sort`, as in `array_sort(array_agg(DISTINCT x) OVER ())`. For a `LATERAL` subquery, the message says that outer columns work only in comparisons in the subquery’s own `WHERE` clause, that `LATERAL` works only in an inner or `LEFT` join, or that a `HAVING` condition moves into the join’s `ON` clause.
`QL-PL-013` (`INVALID_FUNCTION_ARGUMENT`)	An AI function argument that `ask`, `noul`, `choice`, `score`, `ponder`, `model` or `embed` refuses while the query is planned, such as Jev criteria that are not valid JSON, `ask` questions read from a column, or an unknown `ponder` output type. Also a Jev call directly in a position that a query cannot run it in, such as `ORDER BY`, `GROUP BY`, `DISTINCT ON`, a window, or an outer join condition. Also constant Jev criteria or questions with more Choice options or Score levels than the decision model the call runs on takes	The function’s own refusal, such as `Jev criteria must be valid JSON without duplicate keys`, or `choice asks 256 Choice options, but the Vertex decision model deepseek-v4.1-flash-decide-1 takes at most 255`. It names the function, the argument and what the argument must be, never the value you gave. A position refusal names the position and asks you to compute the call in a subquery and use its column alias.
`QL-PL-014` (`RECURSIVE_UNION_ALL`)	A `WITH RECURSIVE` query whose two terms are joined with `UNION ALL`	Names the recursive query and asks for `UNION`, which stops when an iteration adds no new row.
`QL-PL-019` (`INCOMPATIBLE_TYPES`)	An operation on types the engine cannot make common, such as `CAST($1 AS BIGINT) * INTERVAL '1 day'`, or a function given an argument of a type it does not take, such as `unnest` over text, `json_get_array` over a list, or `bool_or` over text	`Query combines types that do not coerce:` followed by the engine’s reason, which names the operation and the Arrow types, as in `Cannot coerce arithmetic expression Int64 * Interval(MonthDayNano) to valid types`, or a function whose arguments fit none of its signatures, as in `Failed to coerce arguments to satisfy a call to 'bool_or' function: coercion from Utf8 …`. Function signature failures use a fixed sentence that names the function and a correction. For example, `TRIM takes text, but its argument is a timestamp. Remove TRIM, or CAST the argument to VARCHAR first.` Wrong argument counts state the accepted count. Change an operand to a type the operation accepts. An interval cannot be multiplied by a number, so for that case the message suggests building the interval from text, as in `CAST(CAST(n AS VARCHAR) \|\| ' days' AS INTERVAL)`.
`QL-PL-020` (`UNGROUPED_COLUMN`)	A column outside `GROUP BY` and outside every aggregate function, in `SELECT`, `HAVING`, `QUALIFY` or `ORDER BY`, such as `title` in `SELECT state, title, count(*) FROM t GROUP BY state`; or a `HAVING` in a query with no `GROUP BY` and no aggregate	The engine’s reason, naming the column and the clause, as in `Column "github.issues.title" in SELECT must be in GROUP BY or an aggregate function`, and asking you to add it to `GROUP BY` or aggregate it. A column a subquery computed without an alias is not named, because its name is the expression with its values; the message asks you to name the expression with `AS`. A `HAVING` with nothing to group asks for `WHERE`.
`QL-PL-021` (`PROVIDER_POOLS_OFF`)	A Parable whose Pools permission is off reads a table of `providers`, `providers_quarantine` or `providers_quality`, directly or through a Plot view, wherever that view is read	`This Parable cannot read Provider data because its Pools permission is off.`, or, for a Plot view, the same sentence that names the view. Staff turn Pools on in the Parable’s Staff Settings. A table that does not exist is still `QL-PL-002`.
`QL-PL-022` (`FILTER_POLICY_STORAGE_UNPROVEN`, `FAILED_PRECONDITION`)	A query reads a stored Plot output, and Parable cannot prove that the output keeps each column that a filter Policy needs to narrow it for you. Three causes are common: a Refresh stored before Parable recorded this proof that read a Platform Parable’s Plot or that does not show what stood behind the stored outputs it read, a Plot that drops a filter column, and a Plot table that no Refresh stands behind. The output can be the Plot you read, or a Plot that its SQL reads, in this Parable or in a Platform Parable	When the stored Refresh that fails belongs to a Plot that your own SQL names, the message names that Plot as your SQL does: `The stored Refresh of … cannot prove that it keeps the keys that upstream filter Policies need:`, then the reason, then `Refresh …, then read again.` The details name it too: `parableId`, its Parable’s id as Ponder’s `?parable=` takes it, `plotKey`, its key, and `plot`, its name in your SQL. A Plot that only a view reads is never named, in the message or the details, because the view’s source can be closed to you. Otherwise the message says `The filter Policy '…' needs column '…', but this Plot cannot prove that it retains that key.`, then the reason, then `Refresh this Plot after its own inputs, or change it to keep that key, then try again.` That message says `Upstream View Filter` and `the required source key` when the cause is a missing record and not one filter or column. Parable reads nothing and never returns rows it cannot narrow. A Flight SQL query gets this refusal and does not retry. Refresh the Plot the message names, after its own inputs, or change a Plot to keep the column, then query again. Only a Pane’s read of current data in Parable retries once, as the Plot’s saved SQL run live under your filters (Reports). A Flight SQL query starts no Refresh. When the cause is a stored Refresh from before the record and a Page or a Plot read in Parable meets it, Parable refreshes that Parable itself, and while that Refresh runs a Pane on Latest shows it in progress instead of this refusal (Refresh by Parable).
`QL-PL-023` (`UNSUPPORTED_SEARCH_FILTER`)	A `search_everything` query filters `updated_at` alone in a form the search cannot apply inside the search, such as `date_trunc('day', updated_at) = …`, `updated_at <> …` or two ranges joined by `OR`. Applied after the search, the filter would see only the records the search chose	Starts with `search_everything: the filter`, names the filter as the engine planned it, and ends with the forms to use: `updated_at` compared with a time, `BETWEEN`, `IS NULL` or `IS NOT NULL`, joined by `AND` (Search Everything).
`QL-SQ-008` (`EXPLAIN_ANALYZE_REJECTED`)	`EXPLAIN ANALYZE`, which would run the query and its AI calls	`EXPLAIN ANALYZE runs the query, so it is not supported. Use EXPLAIN.` Remove `ANALYZE` to get the plan without running the query (Show the plan of a query).
`QL-SQ-009` (`EXPLAIN_FORM_REJECTED`)	A form of `EXPLAIN` other than plain `EXPLAIN` followed by a query, such as `EXPLAIN VERBOSE`, a `FORMAT` option, `EXPLAIN QUERY PLAN` or `DESCRIBE` of a query	`Only plain EXPLAIN followed by a query is supported`. Write `EXPLAIN` and the query, with no other option.

GetFlightInfo and GetSchema run the engine’s type checks on the statement they plan, so QL-PL-019 arrives there, and a DoGet of the same statement answers it too. A prepared statement is checked at the GetFlightInfo after its parameters are bound, not at CreatePreparedStatement. Casts and some unsupported expressions are checked when the result is read, so QL-PL-009 and QL-PL-012 can arrive from DoGet after GetFlightInfo succeeded. Other engine failures keep INTERNAL with QL-IN-001 (DATAFUSION_ERROR) and the message Query execution failed. That includes an error raised by a row while the query runs, such as a string value that does not cast to a number, because its description carries the value. A Jev argument read from a column, rather than written in the query, is checked on each row, so a row it refuses fails this way under the default on_error = fail, unless its request is too large to send (QL-SQ-006, below). A row a Plot returns that its declared contract does not allow, read through parables.*, fails with FAILED_PRECONDITION and error code PA-AU-047. The message names the Plot, the column that holds the value and what is wrong with it, never the value. A Jev function’s request (ask, noul, choice or score) that gets no answer fails the query with the limit it hit. The request goes to TypeSafe, or, when the Workspace’s AI policy resolves the call to one, to a decision model that Google Vertex AI serves. A Workspace that switches TypeSafe off runs its Jev calls on the decision model. The message names the function, the service, and the limit or the service’s HTTP status, never the state or the questions. They can arrive from DoGet, after GetFlightInfo succeeded:

Code	Status	Cause	What to do
`QL-SQ-006` (`JEV_REQUEST_TOO_LARGE`)	`INVALID_ARGUMENT`	The state and questions pass the 1 MiB of JSON Parable sends, or TypeSafe or the decision model refused the request as too large (HTTP 413).	Shorten or split the text the function judges.
`QL-SQ-007` (`JEV_REQUEST_REFUSED`)	`INVALID_ARGUMENT`	TypeSafe refused the request for its own content with HTTP 400 or 422, or the decision model with HTTP 422. The message names the service, the status and the request’s size in bytes. For a decision model it also names the most input tokens one decision may hold, such as 1,048,576 for DeepSeek V4.1 Flash.	Change the state, the questions or the arguments. The same request fails the same way again, so do not retry it.
`QL-TO-003` (`JEV_REQUEST_TIMEOUT`)	`DEADLINE_EXCEEDED`	TypeSafe or the decision model did not answer within the request’s 60 second deadline, retries included.	Run the query again. If it fails again, judge fewer or shorter texts per query.
`QL-IN-010` (`JEV_PROVIDER_FAILED`)	`UNAVAILABLE`	TypeSafe or the decision model failed (HTTP 5xx), throttled the request (HTTP 429 or 529) past its retries, refused Parable’s key or Google identity (HTTP 401 or 403), refused Parable’s endpoint (a redirect or another 4xx, such as 402, 404 or 405), or could not be reached. For a decision model, HTTP 404 means that the Vertex project does not serve the model: the project did not enable it in Model Garden, or Google withdrew it. The message names the model to enable. HTTP 400 means the model refuses a field of the request Parable wrote. A decision model’s HTTP 500, 502, 503 and 504 are retried like throttling. The message names the service and the status.	Retry HTTP 429, 529 and 5xx, and no answer, after a backoff. A refused key or endpoint fails the same way again until an operator fixes it.

Under on_error = null, a row whose request fails with QL-SQ-006 or QL-SQ-007 reads NULL instead, as a row with an invalid argument or an unusable answer does. That failure belongs to the row. A QL-TO-003 or QL-IN-010 failure belongs to the endpoint, so it always fails the query, including under on_error = null. When a workspace table is briefly unavailable, Parable returns UNAVAILABLE with error code QL-IN-005 (UPSTREAM_UNAVAILABLE), and the message names the table. Retry the query with the same backoff. Five error codes arrive with RESOURCE_EXHAUSTED, and each one needs a different response. Read the error code before you retry:

Error code	What happened	What to do
`QL-IN-008` (`QUERY_CONCURRENCY_REJECTED`)	Too many queries were running at once, so Parable did not run this one.	Retry with bounded exponential backoff.
`QL-IN-009` (`QUERY_RESOURCES_EXHAUSTED`)	The query ran out of memory or temporary disk space while it ran. Queries running at the same time share both, so other queries can be the cause, not only the size of yours.	Retry once after a backoff. If it fails again, narrow the query: add `LIMIT`, filter with `WHERE`, or sort, join, and group fewer rows at once.
`QL-SQ-005` (`RESULT_ROW_CAP_EXCEEDED`)	The result has more rows than the row limit.	Do not retry: the query fails the same way again. Add `LIMIT` or narrow the query.
`QL-SQ-010` (`AI_CALL_LIMIT_EXCEEDED`)	The query would send more paid AI calls than the AI call limits allow.	Do not retry. Call the AI function over fewer rows.
`QL-SQ-011` (`AI_COST_LIMIT_EXCEEDED`)	The query’s paid AI calls would cost more than the AI call limits allow.	Do not retry. Call the AI function over fewer rows, or name a cheaper model.

RESOURCE_EXHAUSTED can also arrive with no error code, for example when a workspace table returns more rows than one query may read: do not retry it, because the message says why the query was refused. Like QL-SQ-005, QL-IN-009, QL-SQ-010 and QL-SQ-011 can arrive after some record batches. Discard the rows your driver returned before the error: they are not the result. QL-TO-002 (QUERY_TIMEOUT) is a query past the time limit. Filter, aggregate, or split it before running it again. QL-TO-004 (ROW_SEARCH_REREAD_TIMEOUT) arrives with DEADLINE_EXCEEDED when search_everything could not read its matching records again from any source table in time. The message names the time limit. Run the search again. If it fails again, narrow its scope to fewer tables.

Admin

​Connection contract

​Pools each role reaches

​Tokens

​Connect with ADBC

​Request lifecycle

​Limits

​Row limit

​AI call limits

​Metadata discovery

​Semantic types in comparisons

​Embedding vectors in comparisons

​Recursive queries

​Errors and retries