sqlspec 0.36.0__cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

sqlspec/data_dictionary/dialects/__init__.py

@@ -0,0 +1,21 @@
+"""Dialect configuration registrations."""
+
+from sqlspec.data_dictionary.dialects.bigquery import BIGQUERY_CONFIG
+from sqlspec.data_dictionary.dialects.cockroachdb import COCKROACHDB_CONFIG
+from sqlspec.data_dictionary.dialects.duckdb import DUCKDB_CONFIG
+from sqlspec.data_dictionary.dialects.mysql import MYSQL_CONFIG
+from sqlspec.data_dictionary.dialects.oracle import ORACLE_CONFIG
+from sqlspec.data_dictionary.dialects.postgres import POSTGRES_CONFIG
+from sqlspec.data_dictionary.dialects.spanner import SPANNER_CONFIG
+from sqlspec.data_dictionary.dialects.sqlite import SQLITE_CONFIG
+
+__all__ = (
+    "BIGQUERY_CONFIG",
+    "COCKROACHDB_CONFIG",
+    "DUCKDB_CONFIG",
+    "MYSQL_CONFIG",
+    "ORACLE_CONFIG",
+    "POSTGRES_CONFIG",
+    "SPANNER_CONFIG",
+    "SQLITE_CONFIG",
+)

sqlspec/data_dictionary/dialects/bigquery.py

@@ -0,0 +1,49 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+
+BIGQUERY_VERSION_PATTERN = re.compile(r".*")
+
+BIGQUERY_FEATURE_VERSIONS: "FeatureVersions" = {}
+
+BIGQUERY_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_json": True,
+    "supports_arrays": True,
+    "supports_structs": True,
+    "supports_geography": True,
+    "supports_returning": False,
+    "supports_upsert": True,
+    "supports_window_functions": True,
+    "supports_cte": True,
+    "supports_transactions": True,
+    "supports_prepared_statements": True,
+    "supports_schemas": True,
+    "supports_partitioning": True,
+    "supports_clustering": True,
+    "supports_uuid": False,
+}
+
+BIGQUERY_TYPE_MAPPINGS: dict[str, str] = {
+    "json": "JSON",
+    "uuid": "STRING",
+    "boolean": "BOOL",
+    "timestamp": "TIMESTAMP",
+    "text": "STRING",
+    "blob": "BYTES",
+    "array": "ARRAY",
+    "struct": "STRUCT",
+    "geography": "GEOGRAPHY",
+    "numeric": "NUMERIC",
+    "bignumeric": "BIGNUMERIC",
+}
+
+
+BIGQUERY_CONFIG = DialectConfig(
+    name="bigquery",
+    feature_versions=BIGQUERY_FEATURE_VERSIONS,
+    feature_flags=BIGQUERY_FEATURE_FLAGS,
+    type_mappings=BIGQUERY_TYPE_MAPPINGS,
+    version_pattern=BIGQUERY_VERSION_PATTERN,
+)
+
+register_dialect(BIGQUERY_CONFIG)

sqlspec/data_dictionary/dialects/cockroachdb.py

@@ -0,0 +1,43 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+COCKROACHDB_VERSION_PATTERN = re.compile(r"CockroachDB (?:CCL )?v(\d+)\.(\d+)\.(\d+)")
+
+COCKROACHDB_FEATURE_VERSIONS: "FeatureVersions" = {
+    "supports_json": VersionInfo(20, 1, 0),
+    "supports_returning": VersionInfo(20, 1, 0),
+    "supports_upsert": VersionInfo(19, 2, 0),
+    "supports_window_functions": VersionInfo(19, 1, 0),
+    "supports_cte": VersionInfo(19, 1, 0),
+}
+
+COCKROACHDB_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_uuid": True,
+    "supports_arrays": True,
+    "supports_transactions": True,
+    "supports_prepared_statements": True,
+    "supports_schemas": True,
+}
+
+COCKROACHDB_TYPE_MAPPINGS: dict[str, str] = {
+    "uuid": "UUID",
+    "boolean": "BOOL",
+    "timestamp": "TIMESTAMPTZ",
+    "text": "STRING",
+    "blob": "BYTES",
+    "array": "ARRAY",
+    "json": "JSONB",
+}
+
+COCKROACHDB_CONFIG = DialectConfig(
+    name="cockroachdb",
+    feature_versions=COCKROACHDB_FEATURE_VERSIONS,
+    feature_flags=COCKROACHDB_FEATURE_FLAGS,
+    type_mappings=COCKROACHDB_TYPE_MAPPINGS,
+    version_pattern=COCKROACHDB_VERSION_PATTERN,
+    default_schema="public",
+)
+
+register_dialect(COCKROACHDB_CONFIG)

sqlspec/data_dictionary/dialects/duckdb.py

@@ -0,0 +1,47 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+DUCKDB_VERSION_PATTERN = re.compile(r"v?(\d+)\.(\d+)\.(\d+)")
+
+DUCKDB_FEATURE_VERSIONS: "FeatureVersions" = {
+    "supports_returning": VersionInfo(0, 8, 0),
+    "supports_upsert": VersionInfo(0, 8, 0),
+}
+
+DUCKDB_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_json": True,
+    "supports_arrays": True,
+    "supports_maps": True,
+    "supports_structs": True,
+    "supports_window_functions": True,
+    "supports_cte": True,
+    "supports_transactions": True,
+    "supports_prepared_statements": True,
+    "supports_schemas": True,
+    "supports_uuid": True,
+}
+
+DUCKDB_TYPE_MAPPINGS: dict[str, str] = {
+    "json": "JSON",
+    "uuid": "UUID",
+    "boolean": "BOOLEAN",
+    "timestamp": "TIMESTAMP",
+    "text": "TEXT",
+    "blob": "BLOB",
+    "array": "LIST",
+    "map": "MAP",
+    "struct": "STRUCT",
+}
+
+
+DUCKDB_CONFIG = DialectConfig(
+    name="duckdb",
+    feature_versions=DUCKDB_FEATURE_VERSIONS,
+    feature_flags=DUCKDB_FEATURE_FLAGS,
+    type_mappings=DUCKDB_TYPE_MAPPINGS,
+    version_pattern=DUCKDB_VERSION_PATTERN,
+)
+
+register_dialect(DUCKDB_CONFIG)

sqlspec/data_dictionary/dialects/mysql.py

@@ -0,0 +1,42 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+MYSQL_VERSION_PATTERN = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+MYSQL_FEATURE_VERSIONS: "FeatureVersions" = {
+    "supports_json": VersionInfo(5, 7, 8),
+    "supports_cte": VersionInfo(8, 0, 1),
+    "supports_window_functions": VersionInfo(8, 0, 2),
+}
+
+MYSQL_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_returning": False,
+    "supports_upsert": True,
+    "supports_transactions": True,
+    "supports_prepared_statements": True,
+    "supports_schemas": True,
+    "supports_arrays": False,
+    "supports_uuid": False,
+}
+
+MYSQL_TYPE_MAPPINGS: dict[str, str] = {
+    "uuid": "VARCHAR(36)",
+    "boolean": "TINYINT(1)",
+    "timestamp": "TIMESTAMP",
+    "text": "TEXT",
+    "blob": "BLOB",
+    "json": "JSON",
+}
+
+
+MYSQL_CONFIG = DialectConfig(
+    name="mysql",
+    feature_versions=MYSQL_FEATURE_VERSIONS,
+    feature_flags=MYSQL_FEATURE_FLAGS,
+    type_mappings=MYSQL_TYPE_MAPPINGS,
+    version_pattern=MYSQL_VERSION_PATTERN,
+)
+
+register_dialect(MYSQL_CONFIG)

sqlspec/data_dictionary/dialects/oracle.py

@@ -0,0 +1,34 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+
+ORACLE_VERSION_PATTERN = re.compile(r"(\d+)")
+
+ORACLE_FEATURE_VERSIONS: "FeatureVersions" = {}
+
+ORACLE_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_transactions": True,
+    "supports_prepared_statements": True,
+    "supports_schemas": True,
+    "supports_in_memory": True,
+}
+
+ORACLE_TYPE_MAPPINGS: dict[str, str] = {
+    "uuid": "RAW(16)",
+    "boolean": "NUMBER(1)",
+    "timestamp": "TIMESTAMP",
+    "text": "CLOB",
+    "blob": "BLOB",
+    "json": "JSON",
+}
+
+
+ORACLE_CONFIG = DialectConfig(
+    name="oracle",
+    feature_versions=ORACLE_FEATURE_VERSIONS,
+    feature_flags=ORACLE_FEATURE_FLAGS,
+    type_mappings=ORACLE_TYPE_MAPPINGS,
+    version_pattern=ORACLE_VERSION_PATTERN,
+)
+
+register_dialect(ORACLE_CONFIG)

sqlspec/data_dictionary/dialects/postgres.py

@@ -0,0 +1,46 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+POSTGRES_VERSION_PATTERN = re.compile(r"PostgreSQL (\d+)\.(\d+)(?:\.(\d+))?")
+
+POSTGRES_FEATURE_VERSIONS: "FeatureVersions" = {
+    "supports_json": VersionInfo(9, 2, 0),
+    "supports_jsonb": VersionInfo(9, 4, 0),
+    "supports_returning": VersionInfo(8, 2, 0),
+    "supports_upsert": VersionInfo(9, 5, 0),
+    "supports_window_functions": VersionInfo(8, 4, 0),
+    "supports_cte": VersionInfo(8, 4, 0),
+    "supports_partitioning": VersionInfo(10, 0, 0),
+}
+
+POSTGRES_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_uuid": True,
+    "supports_arrays": True,
+    "supports_transactions": True,
+    "supports_prepared_statements": True,
+    "supports_schemas": True,
+}
+
+POSTGRES_TYPE_MAPPINGS: dict[str, str] = {
+    "uuid": "UUID",
+    "boolean": "BOOLEAN",
+    "timestamp": "TIMESTAMP WITH TIME ZONE",
+    "text": "TEXT",
+    "blob": "BYTEA",
+    "array": "ARRAY",
+    "json": "JSONB",
+}
+
+
+POSTGRES_CONFIG = DialectConfig(
+    name="postgres",
+    feature_versions=POSTGRES_FEATURE_VERSIONS,
+    feature_flags=POSTGRES_FEATURE_FLAGS,
+    type_mappings=POSTGRES_TYPE_MAPPINGS,
+    version_pattern=POSTGRES_VERSION_PATTERN,
+    default_schema="public",
+)
+
+register_dialect(POSTGRES_CONFIG)

sqlspec/data_dictionary/dialects/spanner.py

@@ -0,0 +1,37 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+
+SPANNER_VERSION_PATTERN = re.compile(r".*")
+
+SPANNER_FEATURE_VERSIONS: "FeatureVersions" = {}
+
+SPANNER_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_json": True,
+    "supports_generators": False,
+    "supports_index_clustering": True,
+    "supports_interleaved_tables": True,
+}
+
+SPANNER_TYPE_MAPPINGS: dict[str, str] = {
+    "json": "JSON",
+    "uuid": "BYTES(16)",
+    "boolean": "BOOL",
+    "timestamp": "TIMESTAMP",
+    "text": "STRING(MAX)",
+    "blob": "BYTES(MAX)",
+    "numeric": "NUMERIC",
+    "bignumeric": "NUMERIC",
+    "array": "ARRAY",
+}
+
+
+SPANNER_CONFIG = DialectConfig(
+    name="spanner",
+    feature_versions=SPANNER_FEATURE_VERSIONS,
+    feature_flags=SPANNER_FEATURE_FLAGS,
+    type_mappings=SPANNER_TYPE_MAPPINGS,
+    version_pattern=SPANNER_VERSION_PATTERN,
+)
+
+register_dialect(SPANNER_CONFIG)

sqlspec/data_dictionary/dialects/sqlite.py

@@ -0,0 +1,42 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+SQLITE_VERSION_PATTERN = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+SQLITE_FEATURE_VERSIONS: "FeatureVersions" = {
+    "supports_json": VersionInfo(3, 38, 0),
+    "supports_returning": VersionInfo(3, 35, 0),
+    "supports_upsert": VersionInfo(3, 24, 0),
+    "supports_window_functions": VersionInfo(3, 25, 0),
+    "supports_cte": VersionInfo(3, 8, 3),
+}
+
+SQLITE_FEATURE_FLAGS: "FeatureFlags" = {
+    "supports_transactions": True,
+    "supports_prepared_statements": True,
+    "supports_schemas": False,
+    "supports_arrays": False,
+    "supports_uuid": False,
+}
+
+SQLITE_TYPE_MAPPINGS: dict[str, str] = {
+    "uuid": "TEXT",
+    "boolean": "INTEGER",
+    "timestamp": "TIMESTAMP",
+    "text": "TEXT",
+    "blob": "BLOB",
+    "json": "JSON",
+}
+
+
+SQLITE_CONFIG = DialectConfig(
+    name="sqlite",
+    feature_versions=SQLITE_FEATURE_VERSIONS,
+    feature_flags=SQLITE_FEATURE_FLAGS,
+    type_mappings=SQLITE_TYPE_MAPPINGS,
+    version_pattern=SQLITE_VERSION_PATTERN,
+)
+
+register_dialect(SQLITE_CONFIG)

sqlspec/data_dictionary/sql/bigquery/columns.sql

@@ -0,0 +1,23 @@
+-- name: columns_by_table
+-- dialect: bigquery
+SELECT
+    column_name,
+    data_type,
+    is_nullable,
+    column_default
+FROM {schema_prefix}INFORMATION_SCHEMA.COLUMNS
+WHERE table_name = :table_name
+  AND (:schema_name IS NULL OR table_schema = :schema_name)
+ORDER BY ordinal_position;
+
+-- name: columns_by_schema
+-- dialect: bigquery
+SELECT
+    table_name,
+    column_name,
+    data_type,
+    is_nullable,
+    column_default
+FROM {schema_prefix}INFORMATION_SCHEMA.COLUMNS
+WHERE (:schema_name IS NULL OR table_schema = :schema_name)
+ORDER BY table_name, ordinal_position;

sqlspec/data_dictionary/sql/bigquery/foreign_keys.sql

@@ -0,0 +1,34 @@
+-- name: foreign_keys_by_table
+-- dialect: bigquery
+SELECT
+    kcu.table_name,
+    kcu.column_name,
+    pk_kcu.table_name AS referenced_table_name,
+    pk_kcu.column_name AS referenced_column_name,
+    kcu.constraint_name,
+    kcu.table_schema,
+    pk_kcu.table_schema AS referenced_table_schema
+FROM {kcu_table} kcu
+JOIN {rc_table} rc ON kcu.constraint_name = rc.constraint_name
+JOIN {kcu_table} pk_kcu
+  ON rc.unique_constraint_name = pk_kcu.constraint_name
+  AND kcu.ordinal_position = pk_kcu.ordinal_position
+WHERE kcu.table_name = :table_name
+  AND (:schema_name IS NULL OR kcu.table_schema = :schema_name);
+
+-- name: foreign_keys_by_schema
+-- dialect: bigquery
+SELECT
+    kcu.table_name,
+    kcu.column_name,
+    pk_kcu.table_name AS referenced_table_name,
+    pk_kcu.column_name AS referenced_column_name,
+    kcu.constraint_name,
+    kcu.table_schema,
+    pk_kcu.table_schema AS referenced_table_schema
+FROM {kcu_table} kcu
+JOIN {rc_table} rc ON kcu.constraint_name = rc.constraint_name
+JOIN {kcu_table} pk_kcu
+  ON rc.unique_constraint_name = pk_kcu.constraint_name
+  AND kcu.ordinal_position = pk_kcu.ordinal_position
+WHERE (:schema_name IS NULL OR kcu.table_schema = :schema_name);

sqlspec/data_dictionary/sql/bigquery/indexes.sql

@@ -0,0 +1,19 @@
+-- name: indexes_by_table
+-- dialect: bigquery
+SELECT
+    NULL AS index_name,
+    NULL AS table_name,
+    NULL AS is_unique,
+    NULL AS is_primary,
+    NULL AS columns
+WHERE FALSE;
+
+-- name: indexes_by_schema
+-- dialect: bigquery
+SELECT
+    NULL AS index_name,
+    NULL AS table_name,
+    NULL AS is_unique,
+    NULL AS is_primary,
+    NULL AS columns
+WHERE FALSE;

sqlspec/data_dictionary/sql/bigquery/tables.sql

@@ -0,0 +1,33 @@
+-- name: tables_by_schema
+-- dialect: bigquery
+WITH RECURSIVE dependency_tree AS (
+    SELECT
+        t.table_name,
+        0 AS level,
+        [t.table_name] AS path
+    FROM {tables_table} t
+    WHERE t.table_type = 'BASE TABLE'
+      AND NOT EXISTS (
+          SELECT 1
+          FROM {kcu_table} kcu
+          JOIN {rc_table} rc ON kcu.constraint_name = rc.constraint_name
+          WHERE kcu.table_name = t.table_name
+      )
+
+    UNION ALL
+
+    SELECT
+        kcu.table_name,
+        dt.level + 1,
+        ARRAY_CONCAT(dt.path, [kcu.table_name])
+    FROM {kcu_table} kcu
+    JOIN {rc_table} rc ON kcu.constraint_name = rc.constraint_name
+    JOIN {kcu_table} pk_kcu
+      ON rc.unique_constraint_name = pk_kcu.constraint_name
+      AND kcu.ordinal_position = pk_kcu.ordinal_position
+    JOIN dependency_tree dt ON pk_kcu.table_name = dt.table_name
+    WHERE kcu.table_name NOT IN UNNEST(dt.path)
+)
+SELECT DISTINCT table_name
+FROM dependency_tree
+ORDER BY level, table_name;

sqlspec/data_dictionary/sql/bigquery/version.sql

@@ -0,0 +1,3 @@
+-- name: version
+-- dialect: bigquery
+SELECT NULL AS version;

sqlspec/data_dictionary/sql/cockroachdb/columns.sql

@@ -0,0 +1,34 @@
+-- name: columns_by_table
+-- dialect: cockroachdb
+SELECT
+    a.attname::text AS column_name,
+    pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+    CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+    pg_catalog.pg_get_expr(d.adbin, d.adrelid)::text AS column_default
+FROM pg_catalog.pg_attribute a
+JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+LEFT JOIN pg_catalog.pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+WHERE c.relname = :table_name
+  AND n.nspname = :schema_name
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+ORDER BY a.attnum;
+
+-- name: columns_by_schema
+-- dialect: cockroachdb
+SELECT
+    n.nspname::text AS schema_name,
+    c.relname::text AS table_name,
+    a.attname::text AS column_name,
+    pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+    CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+    pg_catalog.pg_get_expr(d.adbin, d.adrelid)::text AS column_default
+FROM pg_catalog.pg_attribute a
+JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+LEFT JOIN pg_catalog.pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+WHERE n.nspname = :schema_name
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+ORDER BY c.relname, a.attnum;

sqlspec/data_dictionary/sql/cockroachdb/foreign_keys.sql

@@ -0,0 +1,40 @@
+-- name: foreign_keys_by_table
+-- dialect: cockroachdb
+SELECT
+    tc.constraint_name::text AS constraint_name,
+    kcu.column_name::text AS column_name,
+    ccu.table_name::text AS referenced_table,
+    ccu.column_name::text AS referenced_column,
+    tc.table_name::text AS table_name,
+    tc.table_schema::text AS table_schema
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage ccu
+  ON ccu.constraint_name = tc.constraint_name
+  AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND tc.table_schema = :schema_name
+  AND tc.table_name = :table_name
+ORDER BY tc.constraint_name, kcu.column_name;
+
+-- name: foreign_keys_by_schema
+-- dialect: cockroachdb
+SELECT
+    tc.constraint_name::text AS constraint_name,
+    kcu.column_name::text AS column_name,
+    ccu.table_name::text AS referenced_table,
+    ccu.column_name::text AS referenced_column,
+    tc.table_name::text AS table_name,
+    tc.table_schema::text AS table_schema
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage ccu
+  ON ccu.constraint_name = tc.constraint_name
+  AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND tc.table_schema = :schema_name
+ORDER BY tc.table_name, tc.constraint_name, kcu.column_name;

sqlspec/data_dictionary/sql/cockroachdb/indexes.sql

@@ -0,0 +1,32 @@
+-- name: indexes_by_table
+-- dialect: cockroachdb
+SELECT
+    i.relname::text AS index_name,
+    a.attname::text AS column_name,
+    ix.indisunique AS is_unique,
+    ix.indisprimary AS is_primary
+FROM pg_catalog.pg_class t
+JOIN pg_catalog.pg_namespace n ON t.relnamespace = n.oid
+JOIN pg_catalog.pg_index ix ON t.oid = ix.indrelid
+JOIN pg_catalog.pg_class i ON i.oid = ix.indexrelid
+JOIN pg_catalog.pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+WHERE t.relname = :table_name
+  AND n.nspname = :schema_name
+ORDER BY i.relname, a.attnum;
+
+-- name: indexes_by_schema
+-- dialect: cockroachdb
+SELECT
+    n.nspname::text AS schema_name,
+    t.relname::text AS table_name,
+    i.relname::text AS index_name,
+    a.attname::text AS column_name,
+    ix.indisunique AS is_unique,
+    ix.indisprimary AS is_primary
+FROM pg_catalog.pg_class t
+JOIN pg_catalog.pg_namespace n ON t.relnamespace = n.oid
+JOIN pg_catalog.pg_index ix ON t.oid = ix.indrelid
+JOIN pg_catalog.pg_class i ON i.oid = ix.indexrelid
+JOIN pg_catalog.pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+WHERE n.nspname = :schema_name
+ORDER BY t.relname, i.relname, a.attnum;

sqlspec/data_dictionary/sql/cockroachdb/tables.sql

@@ -0,0 +1,44 @@
+-- name: tables_by_schema
+-- dialect: cockroachdb
+WITH RECURSIVE dependency_tree AS (
+    SELECT
+        t.table_name::text,
+        0 AS level,
+        ARRAY[t.table_name::text] AS path
+    FROM information_schema.tables t
+    WHERE t.table_type = 'BASE TABLE'
+      AND t.table_schema = :schema_name
+      AND NOT EXISTS (
+          SELECT 1
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND tc.table_name = t.table_name
+            AND tc.table_schema = t.table_schema
+      )
+
+    UNION ALL
+
+    SELECT
+        tc.table_name::text,
+        dt.level + 1,
+        dt.path || tc.table_name::text
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name
+      AND tc.table_schema = kcu.table_schema
+    JOIN information_schema.constraint_column_usage ccu
+      ON ccu.constraint_name = tc.constraint_name
+      AND ccu.table_schema = tc.table_schema
+    JOIN dependency_tree dt
+      ON ccu.table_name = dt.table_name
+    WHERE tc.constraint_type = 'FOREIGN KEY'
+      AND tc.table_schema = :schema_name
+      AND ccu.table_schema = :schema_name
+      AND NOT (tc.table_name = ANY(dt.path))
+)
+SELECT DISTINCT table_name, level
+FROM dependency_tree
+ORDER BY level, table_name;

sqlspec/data_dictionary/sql/cockroachdb/version.sql

@@ -0,0 +1,3 @@
+-- name: version
+-- dialect: cockroachdb
+SELECT version();