curl --request GET \
--url https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview \
--header 'Authorization: Bearer <token>'import requests
url = "https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview"
headers = {"Authorization": "Bearer <token>"}
response = requests.get(url, headers=headers)
print(response.text)const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};
fetch('https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));<?php
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer <token>"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("Authorization", "Bearer <token>")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(string(body))
}HttpResponse<String> response = Unirest.get("https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview")
.header("Authorization", "Bearer <token>")
.asString();require 'uri'
require 'net/http'
url = URI("https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
response = http.request(request)
puts response.read_body{
"overview": {
"testsToCreate": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"testsToUpdate": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"testsToDelete": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"testsToKeep": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"skippedTables": [
{
"tablePath": "<string>",
"reason": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED"
}
],
"skippedTests": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reason": "<string>",
"ownerRuleId": "<string>",
"ownerRuleTitle": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
],
"referencedTablePath": "<string>"
}
],
"summary": {
"tablesMatched": 123,
"testsToCreate": 123,
"testsToUpdate": 123,
"testsToDelete": 123,
"testsToKeep": 123,
"testsSkipped": 123,
"skippedByReason": {},
"missingColumnsHistogram": {}
}
}
}GetSqlTestDeployOverview
Preview the effect of deploying a rule (which have not yet been saved), without deploying it.
curl --request GET \
--url https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview \
--header 'Authorization: Bearer <token>'import requests
url = "https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview"
headers = {"Authorization": "Bearer <token>"}
response = requests.get(url, headers=headers)
print(response.text)const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};
fetch('https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));<?php
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: Bearer <token>"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("Authorization", "Bearer <token>")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(string(body))
}HttpResponse<String> response = Unirest.get("https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview")
.header("Authorization", "Bearer <token>")
.asString();require 'uri'
require 'net/http'
url = URI("https://developer.synq.io/api/datachecks/sql-test-deployment-rules/v1/overview")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
response = http.request(request)
puts response.read_body{
"overview": {
"testsToCreate": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"testsToUpdate": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"testsToDelete": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"testsToKeep": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
]
}
],
"skippedTables": [
{
"tablePath": "<string>",
"reason": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED"
}
],
"skippedTests": [
{
"tablePath": "<string>",
"sqlTestPath": "<string>",
"testName": "<string>",
"reason": "<string>",
"ownerRuleId": "<string>",
"ownerRuleTitle": "<string>",
"reasonCode": "SQL_TEST_SKIP_REASON_UNSPECIFIED",
"missingColumns": [
"<string>"
],
"referencedTablePath": "<string>"
}
],
"summary": {
"tablesMatched": 123,
"testsToCreate": 123,
"testsToUpdate": 123,
"testsToDelete": 123,
"testsToKeep": 123,
"testsSkipped": 123,
"skippedByReason": {},
"missingColumnsHistogram": {}
}
}
}Authorizations
Bearer authentication header of the form Bearer <token>, where <token> is your auth token.
Query Parameters
Unique identifier for this rule.
Human friendly name for this rule.
1 - 100Opaque id of the entity, set on every identifier the API returns. Round-trip it verbatim; the format is not part of this contract and may change, and it is never constructed by hand.
OUTPUT ONLY. On a request this field is ignored — the structured variant is
what resolves. That is what lets you hand an identifier straight back
unchanged, or edit its structured fields, without the two disagreeing about
which entity you meant. To name an entity BY opaque id on a request, set the
synq_path variant to that id: it carries exactly this string, and it is
also how an entity whose platform has no structured variant is named.
1024Opaque identifier of the dbt Core project. Usually the Coalesce Quality integration id (a UUID), but may also be the dbt project name from manifest.json when the integration is configured to identify assets by project name. Treat it as an opaque string, not a UUID.
Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)
Your dbt Cloud project id
Your dbt Cloud account id
Dbt node_id that identifies one of dbt DAG nodes (model, test, etc)
BigQuery project
BigQuery dataset id
BigQuery table name
Snowflake account
Snowflake database
Snowflake schema
Snowflake table
Redshift cluster
Redshift database
Redshift schema
Redshift table
Postgres hostname without port
Postgres database
Postgres schema
Postgres table
Mysql hostname without port
Mysql database
Mysql table
Clickhouse hostname without port
Clickhouse database
Clickhouse table
Coalesce Quality integration_id that identifies the Airflow instance
Airflow dag_id that identifies the DAG
Coalesce Quality integration_id that identifies the Airflow instance
Airflow dag_id that identifies the DAG
Airflow task_id that identifies the task within the DAG
Id that identifies the custom entity The Id should be unique within the custom entity Identifier.
Dataproduct id that identifies the Dataproduct
Coalesce Quality path that identifies the Coalesce Quality entity, needs to be one of supported paths
URL of Databricks workspace
Databricks catalog
Databricks schema
Databricks table or view
Hostname of the Trino instance
Trino catalog
Trino schema
Trino table or view
Coalesce Quality integration_id that identifies the dbt Core project
SQLMesh model fully qualified name
Coalesce Quality integration_id that identifies the dbt Core project
SQLMesh model fully qualified name
Identifier of the audit
Hostname of the SQL Server instance
SQL Server database
SQL Server schema (e.g. "dbo")
SQL Server table or view
Hostname of the Oracle instance
Oracle service name (PDB)
Oracle schema (= owning user)
Oracle table or view
AWS account and region the Athena workgroup runs in, formatted as "." (e.g. "123456789012.eu-west-1"). Auto-derived from sts:GetCallerIdentity at integration setup time.
Glue Data Catalog name. Almost always "AwsDataCatalog" — the default catalog for Athena unless the customer registered a federated catalog.
Glue database (the namespace users typically filter on).
Glue table or view name.
Saved view id (client-supplied UUID) that identifies the saved view
Workspace SQL analytics endpoint host, e.g. ".datawarehouse.fabric.microsoft.com".
Fabric warehouse / lakehouse (database).
Schema within the database.
Table or view name.
Fabric workspace GUID, decoded from the endpoint host in instance.
Optional and informational: the table is addressed by
instance/database/schema/table, so leave it empty if you don't have it —
it does not affect how the identifier resolves.
Entra (Azure AD) tenant GUID, decoded from the endpoint host in instance.
Optional and informational, like workspace_id.
Host name of the Db2 server
Database name or alias, as in CONNECT TO <database>
Db2 schema (e.g. "DB2INST1")
Db2 table or view
Identifier of the monitor
Optional monitor segmentation identifier
Coalesce Quality integration_id of the monitored identifier
Default Coalesce Quality types
ENTITY_TYPE_UNSPECIFIED, ENTITY_TYPE_BQ_TABLE, ENTITY_TYPE_BQ_VIEW, ENTITY_TYPE_LOOKER_LOOK, ENTITY_TYPE_LOOKER_EXPLORE, ENTITY_TYPE_LOOKER_VIEW, ENTITY_TYPE_LOOKER_DASHBOARD, ENTITY_TYPE_LOOKER_INSTANCE, ENTITY_TYPE_DBT_MODEL, ENTITY_TYPE_DBT_TEST, ENTITY_TYPE_DBT_SOURCE, ENTITY_TYPE_DBT_PROJECT, ENTITY_TYPE_DBT_METRIC, ENTITY_TYPE_DBT_SNAPSHOT, ENTITY_TYPE_DBT_SEED, ENTITY_TYPE_DBT_ANALYSIS, ENTITY_TYPE_DBT_EXPOSURE, ENTITY_TYPE_DBT_GROUP, ENTITY_TYPE_DBT_SEMANTIC_MODEL, ENTITY_TYPE_DBT_CLOUD_PROJECT, ENTITY_TYPE_DBT_CLOUD_JOB, ENTITY_TYPE_SNOWFLAKE_TABLE, ENTITY_TYPE_SNOWFLAKE_VIEW, ENTITY_TYPE_SNOWFLAKE_STREAM, ENTITY_TYPE_SNOWFLAKE_DYNAMIC_TABLE, ENTITY_TYPE_SNOWFLAKE_TASK, ENTITY_TYPE_SNOWFLAKE_EXTERNAL_TABLE, ENTITY_TYPE_SNOWFLAKE_MATERIALIZED_VIEW, ENTITY_TYPE_SNOWFLAKE_PROCEDURE, ENTITY_TYPE_SNOWFLAKE_FUNCTION, ENTITY_TYPE_SNOWFLAKE_SEMANTIC_VIEW, ENTITY_TYPE_REDSHIFT_TABLE, ENTITY_TYPE_REDSHIFT_VIEW, ENTITY_TYPE_REDSHIFT_PROCEDURE, ENTITY_TYPE_REDSHIFT_FUNCTION, ENTITY_TYPE_TABLEAU_EMBEDDED, ENTITY_TYPE_TABLEAU_PUBLISHED, ENTITY_TYPE_TABLEAU_CUSTOM_SQL, ENTITY_TYPE_TABLEAU_TABLE, ENTITY_TYPE_TABLEAU_SHEET, ENTITY_TYPE_TABLEAU_DASHBOARD, ENTITY_TYPE_TABLEAU_WORKBOOK, ENTITY_TYPE_TABLEAU_SITE, ENTITY_TYPE_AIRFLOW_DAG, ENTITY_TYPE_AIRFLOW_TASK, ENTITY_TYPE_CLICKHOUSE_TABLE, ENTITY_TYPE_CLICKHOUSE_VIEW, ENTITY_TYPE_ANOMALY_MONITOR, ENTITY_TYPE_ANOMALY_MONITOR_SEGMENT, ENTITY_TYPE_SQLTEST_TEST, ENTITY_TYPE_RECON_SUITE, ENTITY_TYPE_RECON_CASE, ENTITY_TYPE_POSTGRES_TABLE, ENTITY_TYPE_POSTGRES_VIEW, ENTITY_TYPE_MYSQL_TABLE, ENTITY_TYPE_MYSQL_VIEW, ENTITY_TYPE_DATABRICKS_WAREHOUSE, ENTITY_TYPE_DATABRICKS_TABLE, ENTITY_TYPE_DATABRICKS_VIEW, ENTITY_TYPE_DATABRICKS_JOB, ENTITY_TYPE_DATABRICKS_JOB_TASK, ENTITY_TYPE_DATABRICKS_NOTEBOOK, ENTITY_TYPE_DATABRICKS_QUERY, ENTITY_TYPE_DATABRICKS_DASHBOARD, ENTITY_TYPE_SQLMESH_PROJECT, ENTITY_TYPE_SQLMESH_SQL_MODEL, ENTITY_TYPE_SQLMESH_PYTHON_MODEL, ENTITY_TYPE_SQLMESH_EXTERNAL, ENTITY_TYPE_SQLMESH_SEED, ENTITY_TYPE_SQLMESH_AUDIT, ENTITY_TYPE_SQLMESH_UNIT_TEST, ENTITY_TYPE_SQLMESH_ENVIRONMENT, ENTITY_TYPE_SQLMESH_SNAPSHOT, ENTITY_TYPE_DUCKDB_TABLE, ENTITY_TYPE_DUCKDB_VIEW, ENTITY_TYPE_TRINO_TABLE, ENTITY_TYPE_TRINO_VIEW, ENTITY_TYPE_ATLAN_ASSET, ENTITY_TYPE_ATLAN_INTEGRATION, ENTITY_TYPE_COALESCE_PROJECT, ENTITY_TYPE_COALESCE_ENVIRONMENT, ENTITY_TYPE_COALESCE_NODE, ENTITY_TYPE_COALESCE_NODE_TEST, ENTITY_TYPE_COALESCE_JOB, ENTITY_TYPE_CASTORDOC_TABLE, ENTITY_TYPE_CASTORDOC_DASHBOARD, ENTITY_TYPE_CASTORDOC_VIEW, ENTITY_TYPE_CASTORDOC_TILE, ENTITY_TYPE_CASTORDOC_VIZ_MODEL, ENTITY_TYPE_POWERBI_REPORT, ENTITY_TYPE_POWERBI_TILE, ENTITY_TYPE_POWERBI_DATASET, ENTITY_TYPE_POWERBI_DASHBOARD, ENTITY_TYPE_POWERBI_TENANT, ENTITY_TYPE_THOUGHTSPOT_LIVEBOARD, ENTITY_TYPE_THOUGHTSPOT_WORKSHEET, ENTITY_TYPE_SIGMA_WORKBOOK, ENTITY_TYPE_SIGMA_DATA_MODEL, ENTITY_TYPE_SIGMA_ORGANIZATION, ENTITY_TYPE_DOMO_PAGE, ENTITY_TYPE_DOMO_DATASET, ENTITY_TYPE_MSSQL_TABLE, ENTITY_TYPE_MSSQL_VIEW, ENTITY_TYPE_ORACLE_TABLE, ENTITY_TYPE_ORACLE_VIEW, ENTITY_TYPE_ATHENA_TABLE, ENTITY_TYPE_ATHENA_VIEW, ENTITY_TYPE_FABRIC_TABLE, ENTITY_TYPE_FABRIC_VIEW, ENTITY_TYPE_DB2_TABLE, ENTITY_TYPE_DB2_VIEW, ENTITY_TYPE_CUSTOM_ENTITY_GENERIC, ENTITY_TYPE_CUSTOM_ENTITY_CUSTOM_TYPE_MIN, ENTITY_TYPE_CUSTOM_ENTITY_CUSTOM_TYPE_MAX Custom types as defined through synq.entities.custom.v1.TypesService
Traits to select by, instead of — or alongside — naming types.
A trait is a property a type has, so is_monitorable means "everything a
monitor can run on" without listing the forty-odd types that satisfy it
today. The list it stands for is worked out each time the selection runs,
so a selection saved this way covers a new platform's tables as soon as we
support them, and you never have to revisit it.
Entities carrying any of the traits match. When types is also set the two
narrow each other: the entity must be one of the named types AND carry one
of the traits.
Accepted values, and what each one means, come from the selection-query
grammar the API publishes (describe_resolver_ql, or the query editor's
reference). A name that is not in it selects nothing rather than being
ignored, so a typo narrows the result to empty instead of widening it —
check a trait against the grammar before storing a selection. In a query
written as text this is with_type(traits="is_monitorable"), and there a
name outside the grammar is rejected outright.
A trait may also be a type alias, spelled alias:<name> where <name> is
one of the aliases the grammar lists among the entity types, e.g.
alias:table. It selects every type the alias stands for, worked out each
time the selection runs like any other trait. A selection written as
with_type("table") is stored this way and reads back with
traits: ["alias:table"]; writing that back keeps the same selection. In a
query written as text an alias is always with_type("table"), never
traits="alias:table".
Opaque folder identifiers (a folder's own entity id). folders is the
structured, human-authorable alternative. When path is the only source
set and deep is unset, deep defaults to true for back-compat with
queries authored before deep existed.
Opaque id of the entity the folder hierarchy hangs under — an integration
root or container (for example a warehouse instance, a database, or a
transformation project). Take it verbatim from FolderRef.root_entity_id
of a folder you already read, or from an entity id returned elsewhere.
Ordered folder names from the root down to this folder (root first, leaf last), for example ["staging", "sales"]. Empty means the ref points at the root entity itself. Folder names are kept as separate segments (not joined with "/") because some platforms allow "/" inside a single folder name.
Simplified source: the assets named directly by opaque entity id. Use this for the common "same folder as these specific assets" case; equivalent to an input_query that lists the same ids.
BigQuery project
Clickhouse host inclusive of port
Clickhouse database
Snowflake account
Snowflake database
Redshift cluster
Redshift database
Postgres host inclusive of port
Postgres database
Mysql host inclusive of port
URL of the databricks workspace
API endpoint for Dbt Cloud
Account ID
Project ID
Default database instance for SQL Mesh
SQL Server host
Database name
Oracle host
Oracle service name (PDB)
AWS account and region the Athena workgroup runs in, formatted as "." (e.g. "123456789012.eu-west-1"). Auto-derived by SYNQ from sts:GetCallerIdentity at integration setup time.
Glue Data Catalog name. Almost always "AwsDataCatalog" — the default catalog for Athena unless the customer registered a federated catalog.
Workspace SQL analytics endpoint host, e.g. ".datawarehouse.fabric.microsoft.com". Identifies the Fabric workspace the integration connects to. Fabric is workspace-scoped with cross-database queries, so the workspace host alone identifies the platform (like Databricks' workspace URL); a specific warehouse/table is addressed by FabricTableIdentifier.
Fabric workspace GUID — the identifier used by the Fabric REST API for
workspace-scoped resources. The Fabric endpoint host in instance encodes
the tenant and workspace GUIDs; this is the decoded workspace GUID, provided
so you don't have to decode it yourself. instance remains the identifying
value. Optional: empty when the host isn't a standard Fabric endpoint.
Entra (Azure AD) tenant GUID, decoded from the endpoint host in instance
alongside workspace_id. Optional: empty when the host isn't a standard
Fabric endpoint.
Host name of the Db2 server
Database name or alias, as in CONNECT TO <database>
Coalesce Quality integration ID maps to the created integration on the Coalesce Quality platform.
DATA_PLATFORM_TYPE_UNSPECIFIED, DATA_PLATFORM_TYPE_BIGQUERY, DATA_PLATFORM_TYPE_LOOKER, DATA_PLATFORM_TYPE_DBT, DATA_PLATFORM_TYPE_DBT_CLOUD, DATA_PLATFORM_TYPE_DBT_SELF_HOSTED, DATA_PLATFORM_TYPE_SNOWFLAKE, DATA_PLATFORM_TYPE_GCP, DATA_PLATFORM_TYPE_GIT, DATA_PLATFORM_TYPE_GITHUB, DATA_PLATFORM_TYPE_REDSHIFT, DATA_PLATFORM_TYPE_TABLEAU, DATA_PLATFORM_TYPE_AIRFLOW, DATA_PLATFORM_TYPE_CLICKHOUSE, DATA_PLATFORM_TYPE_POSTGRES, DATA_PLATFORM_TYPE_MYSQL, DATA_PLATFORM_TYPE_DATABRICKS, DATA_PLATFORM_TYPE_SQLMESH, DATA_PLATFORM_TYPE_DUCKDB, DATA_PLATFORM_TYPE_TRINO, DATA_PLATFORM_TYPE_ATLAN, DATA_PLATFORM_TYPE_COALESCE, DATA_PLATFORM_TYPE_CASTORDOC, DATA_PLATFORM_TYPE_POWERBI, DATA_PLATFORM_TYPE_THOUGHTSPOT, DATA_PLATFORM_TYPE_SIGMA, DATA_PLATFORM_TYPE_DOMO, DATA_PLATFORM_TYPE_MSSQL, DATA_PLATFORM_TYPE_ORACLE, DATA_PLATFORM_TYPE_ATHENA, DATA_PLATFORM_TYPE_FABRIC, DATA_PLATFORM_TYPE_DB2, DATA_PLATFORM_TYPE_SYNQ When false or unset, matches only the direct members of the folder(s). When true, matches the entire recursive subtree (members of subfolders too).
Exception: when only the legacy path source is set and deep is unset,
it defaults to true (preserves the behaviour of queries authored before this
flag existed). With folders or folder_of, unset means false (shallow).
Defaults to AND if not specified.
QUERY_OPERAND_UNSPECIFIED, QUERY_OPERAND_AND, QUERY_OPERAND_OR, QUERY_OPERAND_EXCEPT, QUERY_OPERAND_UPSTREAM, QUERY_OPERAND_DOWNSTREAM The entities to select. An id may not be blank.
An empty list selects no entities, exactly as an empty identifier_list
does. Be deliberate about it, because it is not the same as leaving the part
out: a part that selects nothing still counts, so it empties an AND, adds
nothing to an OR, and removes nothing from an EXCEPT. If what you mean is
"do not restrict on specific entities", omit the part instead of sending it
empty.
Ids may be up to 1024 characters — the same limit as Identifier.entity_id,
where you read them from, so any id the API returned is accepted here.
1 - 1024When false (default): only each asset's immediate parent folder. When true:
every ancestor folder up the hierarchy, so InFolder then also matches
assets in those ancestor folders.
QueryOperand defines how multiple QueryParts within a Query are combined.
QUERY_OPERAND_UNSPECIFIED, QUERY_OPERAND_AND, QUERY_OPERAND_OR, QUERY_OPERAND_EXCEPT, QUERY_OPERAND_UPSTREAM, QUERY_OPERAND_DOWNSTREAM ResolverQL selection string — an advanced, more expressive alternative to
query. ResolverQL is a superset of the structured query: use it for
selections query cannot express (e.g. lineage walks, column predicates).
When set (non-empty) on write, resolver_ql is the source of truth and the
structured query is ignored. The selection is compiled when it is written
and stored in that form, so the text itself is not kept: two spellings of the
same selection store the same rule, and a type alias such as "table" is
expanded to the types it names at the time of the write. On read this field
carries the canonical rendering of the stored selection, equal to
rendered_resolver_ql, whichever way the rule was written, and is empty when
the selection has no ResolverQL representation. Writing a read response back
unchanged stores the same selection. query is always populated.
Canonical ResolverQL rendering of this rule's selection, populated for every
rule regardless of how it was authored. OUTPUT ONLY — it is ignored on
write; set resolver_ql to author a selection in ResolverQL. Compare
selections by this field rather than by the text a rule was written with,
which may be spelled differently.
Human friendly name for this test. Required (non-empty) for business_rule_test and business_query_test — for those two kinds, name is the test's identity key across rule redeployments, so a renamed test is treated as a different test. Optional for every other kind: leave it unset and a name is generated.
Description of purpose and motivation, copied onto every test this rule deploys.
Overrides the rule's config-level severity for this test only. Leave unset to use the config-level severity.
SEVERITY_UNSPECIFIED, SEVERITY_WARNING, SEVERITY_ERROR, SEVERITY_INFO List of column names to check for NULL values
1Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
List of column names to check for empty values
1Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Name of the column to validate
Literal value that should be quoted in SQL (e.g., '2025-05-12', 'active')
SQL expression, numbers to be used as plain text (e.g., NOW(), COUNT(*), true, 1.1)
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Name of the column to validate
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
List of columns that should form a unique combination
1If provided, the check will be applied to the time window of the time partition column If not provided, the check will be applied to all rows
Time window for uniqueness check (in seconds)
Name of the timestamp column used for freshness check
Time window for freshness check (in seconds)
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Name of the numeric column to validate
If true, bounds are exclusive
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Name of the first time column to compare
Name of the second time column that should be later than the first
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Boolean SQL predicate evaluated per row of the anchor table (Template.identifier); rows where the predicate is TRUE are reported as failures.
Format: a single boolean expression — no SELECT, WITH, or semicolons.
References columns on the anchor table. The engine executes it as
SELECT * FROM <anchor_table> WHERE <sql_expression>.
Example: "total_amount != subtotal + tax" reports rows where totals disagree. Use BusinessQueryTest for SELECT / GROUP BY / multi-table logic.
Placeholder: {{ table }} is substituted with the anchor table's fully
qualified name, quoted for the warehouse — the matched table when the test
is deployed by a deployment rule. It is the only supported placeholder;
any other {{ name }} token is rejected. It renders a table name, so it
belongs where a table name goes — the FROM clause of a subquery of your own:
"total > (SELECT max(total) FROM {{ table }})".
It is not a column qualifier. The generated FROM clause carries no alias, and on BigQuery the fully qualified name is a single quoted identifier, so "{{ table }}.id" does not resolve. To name the anchor's columns, use BusinessQueryTest, where you write the FROM clause and can alias it.
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Name of the numeric column to validate
If true, the minimum value is exclusive
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Name of the numeric column to validate
If true, the maximum value is exclusive
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Column name in the source table
Column name in the reference table
If true, source rows where all join columns are NULL are excluded from results
Column name used to filter source rows by time (e.g., "created_at")
Time window in seconds - only check source rows within this window
Optional list of columns to include in the SELECT clause of the generated SQL. When empty (default), SELECT * is used — all columns are returned.
Full SELECT statement. Result rows are reported as failures.
Format: a single SELECT (CTEs allowed); no semicolon. May read any tables
the integration has access to. The engine wraps it as
WITH raw_query AS (<sql_query>) SELECT * FROM raw_query.
Use this when the failure set requires GROUP BY, JOINs, window functions, or other shape that a per-row predicate (BusinessRuleTest) cannot express.
Example: SELECT customer_id, SUM(amount) AS total FROM orders WHERE status = 'paid' GROUP BY customer_id HAVING SUM(amount) < 0
Template.identifier still anchors the test to a primary table for ownership, alerts, and UI grouping.
Placeholder: {{ table }} is substituted with the anchor table's fully
qualified name, quoted for the warehouse — the matched table when the test
is deployed by a deployment rule, which is how one query covers every table
the rule matches instead of being copied onto each of them. It is the only
supported placeholder; any other {{ name }} token is rejected.
Note: this test does not expose a select_columns option. The author
controls the SELECT shape directly in sql_query.
Recurrence rule
for the execution schedule applied to every test this rule deploys. Empty
means on-demand — deployed tests are never scheduled to run automatically.
When set, it must carry an inline DTSTART: naming the first occurrence, e.g.
"DTSTART:20260101T000000Z\nRRULE:FREQ=DAILY".
IANA timezone name (e.g., "Europe/Prague", "America/New_York") used to interpret recurrence_rule. Empty defaults to UTC.
Severity applied to every test this rule deploys, unless a RuleTest overrides it. Required — must be set to a value other than unspecified.
SEVERITY_UNSPECIFIED, SEVERITY_WARNING, SEVERITY_ERROR, SEVERITY_INFO Applied to every test this rule deploys. Toggles saving of failure runs.
When a previously matched table or view stops matching this rule's selection, its deployed tests are deleted by default. Set true to keep them as-is instead — they remain rule-managed but are no longer resynced.
ResolverQL selection string for the exclusion set. Same semantics as
SqlTestsQueryConfig.resolver_ql: when set on write it takes precedence over
query and is stored compiled; on read it carries the canonical rendering
of the stored selection, equal to rendered_resolver_ql. query is always
populated.
Canonical ResolverQL rendering of the exclusion selection. OUTPUT ONLY, populated for every rule, ignored on write.
Synq path of the table or view this rule deploys tests onto.
1Recurrence rule
for the execution schedule applied to every test this rule deploys. Empty
means on-demand. When set, it must carry an inline DTSTART: naming the first
occurrence, e.g. "DTSTART:20260101T000000Z\nRRULE:FREQ=DAILY".
IANA timezone name used to interpret recurrence_rule. Empty defaults to UTC.
Severity applied to every test this rule deploys, unless a RuleTest overrides it. Required — must be set to a value other than unspecified.
SEVERITY_UNSPECIFIED, SEVERITY_WARNING, SEVERITY_ERROR, SEVERITY_INFO Applied to every test this rule deploys. Toggles saving of failure runs.
Synq path of the table or view this rule exclusively owns.
1SOURCE_APP, SOURCE_API Config ID this rule was authored from, when deployed via configuration as code. Unset for rules authored directly through this API.
On a write this field is only ever set, never unset: omitting it keeps the stored value, so a full-replace update cannot detach the rule from the config that owns it. An empty string is a real config id — the one a deploy that declares no namespace uses — so sending it attaches the rule to that config rather than clearing the field. No value detaches a rule; recreating it is the only way to hand it back to the app.
Response
Success
SqlTestsDeploymentOverview previews or reports the effect of deploying a SqlTestDeploymentRule, per test rather than per table — a table with three tests deployed appears as three entries, one for each test.
Show child attributes
Show child attributes