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

sqlspec/data_dictionary/sql/duckdb/columns.sql

@@ -0,0 +1,23 @@
+-- name: columns_by_table
+-- dialect: duckdb
+SELECT
+    column_name,
+    data_type,
+    is_nullable,
+    column_default
+FROM information_schema.columns
+WHERE table_name = :table_name
+  AND table_schema = COALESCE(:schema_name, current_schema())
+ORDER BY ordinal_position;
+
+-- name: columns_by_schema
+-- dialect: duckdb
+SELECT
+    table_name,
+    column_name,
+    data_type,
+    is_nullable,
+    column_default
+FROM information_schema.columns
+WHERE table_schema = COALESCE(:schema_name, current_schema())
+ORDER BY table_name, ordinal_position;

sqlspec/data_dictionary/sql/duckdb/foreign_keys.sql

@@ -0,0 +1,36 @@
+-- name: foreign_keys_by_table
+-- dialect: duckdb
+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 information_schema.key_column_usage kcu
+JOIN information_schema.referential_constraints rc
+  ON kcu.constraint_name = rc.constraint_name
+JOIN information_schema.key_column_usage pk_kcu
+  ON rc.unique_constraint_name = pk_kcu.constraint_name
+  AND kcu.ordinal_position = pk_kcu.ordinal_position
+WHERE kcu.table_schema = COALESCE(:schema_name, current_schema())
+  AND kcu.table_name = :table_name;
+
+-- name: foreign_keys_by_schema
+-- dialect: duckdb
+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 information_schema.key_column_usage kcu
+JOIN information_schema.referential_constraints rc
+  ON kcu.constraint_name = rc.constraint_name
+JOIN information_schema.key_column_usage pk_kcu
+  ON rc.unique_constraint_name = pk_kcu.constraint_name
+  AND kcu.ordinal_position = pk_kcu.ordinal_position
+WHERE kcu.table_schema = COALESCE(:schema_name, current_schema());

sqlspec/data_dictionary/sql/duckdb/indexes.sql

@@ -0,0 +1,19 @@
+-- name: indexes_by_table
+-- dialect: duckdb
+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: duckdb
+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/duckdb/tables.sql

@@ -0,0 +1,38 @@
+-- name: tables_by_schema
+-- dialect: duckdb
+WITH RECURSIVE dependency_tree AS (
+    SELECT
+        table_name,
+        0 AS level,
+        [table_name] AS path
+    FROM information_schema.tables t
+    WHERE t.table_type = 'BASE TABLE'
+      AND t.table_schema = COALESCE(:schema_name, current_schema())
+      AND NOT EXISTS (
+          SELECT 1
+          FROM information_schema.key_column_usage kcu
+          WHERE kcu.table_name = t.table_name
+            AND kcu.table_schema = t.table_schema
+            AND kcu.constraint_name IN (
+                SELECT constraint_name FROM information_schema.referential_constraints
+            )
+      )
+
+    UNION ALL
+
+    SELECT
+        kcu.table_name,
+        dt.level + 1,
+        list_append(dt.path, kcu.table_name)
+    FROM information_schema.key_column_usage kcu
+    JOIN information_schema.referential_constraints rc ON kcu.constraint_name = rc.constraint_name
+    JOIN information_schema.key_column_usage pk_kcu
+      ON rc.unique_constraint_name = pk_kcu.constraint_name
+      AND rc.unique_constraint_schema = pk_kcu.constraint_schema
+    JOIN dependency_tree dt ON dt.table_name = pk_kcu.table_name
+    WHERE kcu.table_schema = COALESCE(:schema_name, current_schema())
+      AND NOT list_contains(dt.path, kcu.table_name)
+)
+SELECT DISTINCT table_name, level
+FROM dependency_tree
+ORDER BY level, table_name;

sqlspec/data_dictionary/sql/duckdb/version.sql

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

sqlspec/data_dictionary/sql/mysql/columns.sql

@@ -0,0 +1,23 @@
+-- name: columns_by_table
+-- dialect: mysql
+SELECT
+    column_name,
+    data_type,
+    is_nullable,
+    column_default
+FROM information_schema.columns
+WHERE table_name = :table_name
+  AND table_schema = COALESCE(:schema_name, DATABASE())
+ORDER BY ordinal_position;
+
+-- name: columns_by_schema
+-- dialect: mysql
+SELECT
+    table_name,
+    column_name,
+    data_type,
+    is_nullable,
+    column_default
+FROM information_schema.columns
+WHERE table_schema = COALESCE(:schema_name, DATABASE())
+ORDER BY table_name, ordinal_position;

sqlspec/data_dictionary/sql/mysql/foreign_keys.sql

@@ -0,0 +1,28 @@
+-- name: foreign_keys_by_table
+-- dialect: mysql
+SELECT
+    table_name,
+    column_name,
+    referenced_table_name,
+    referenced_column_name,
+    constraint_name,
+    table_schema,
+    referenced_table_schema
+FROM information_schema.key_column_usage
+WHERE referenced_table_name IS NOT NULL
+  AND table_name = :table_name
+  AND table_schema = COALESCE(:schema_name, DATABASE());
+
+-- name: foreign_keys_by_schema
+-- dialect: mysql
+SELECT
+    table_name,
+    column_name,
+    referenced_table_name,
+    referenced_column_name,
+    constraint_name,
+    table_schema,
+    referenced_table_schema
+FROM information_schema.key_column_usage
+WHERE referenced_table_name IS NOT NULL
+  AND table_schema = COALESCE(:schema_name, DATABASE());

sqlspec/data_dictionary/sql/mysql/indexes.sql

@@ -0,0 +1,26 @@
+-- name: indexes_by_table
+-- dialect: mysql
+SELECT
+    s.index_name AS index_name,
+    s.table_name AS table_name,
+    CASE WHEN s.non_unique = 0 THEN 1 ELSE 0 END AS is_unique,
+    CASE WHEN s.index_name = 'PRIMARY' THEN 1 ELSE 0 END AS is_primary,
+    GROUP_CONCAT(s.column_name ORDER BY s.seq_in_index) AS columns
+FROM information_schema.statistics s
+WHERE s.table_schema = COALESCE(:schema_name, DATABASE())
+  AND s.table_name = :table_name
+GROUP BY s.index_name, s.table_name, s.non_unique
+ORDER BY s.index_name;
+
+-- name: indexes_by_schema
+-- dialect: mysql
+SELECT
+    s.index_name AS index_name,
+    s.table_name AS table_name,
+    CASE WHEN s.non_unique = 0 THEN 1 ELSE 0 END AS is_unique,
+    CASE WHEN s.index_name = 'PRIMARY' THEN 1 ELSE 0 END AS is_primary,
+    GROUP_CONCAT(s.column_name ORDER BY s.seq_in_index) AS columns
+FROM information_schema.statistics s
+WHERE s.table_schema = COALESCE(:schema_name, DATABASE())
+GROUP BY s.index_name, s.table_name, s.non_unique
+ORDER BY s.table_name, s.index_name;

sqlspec/data_dictionary/sql/mysql/tables.sql

@@ -0,0 +1,33 @@
+-- name: tables_by_schema
+-- dialect: mysql
+WITH RECURSIVE dependency_tree AS (
+    SELECT
+        table_name,
+        0 AS level,
+        CAST(table_name AS CHAR(4000)) AS path
+    FROM information_schema.tables t
+    WHERE t.table_type = 'BASE TABLE'
+      AND t.table_schema = COALESCE(:schema_name, DATABASE())
+      AND NOT EXISTS (
+          SELECT 1
+          FROM information_schema.key_column_usage kcu
+          WHERE kcu.table_name = t.table_name
+            AND kcu.table_schema = t.table_schema
+            AND kcu.referenced_table_name IS NOT NULL
+      )
+
+    UNION ALL
+
+    SELECT
+        kcu.table_name,
+        dt.level + 1,
+        CONCAT(dt.path, ',', kcu.table_name)
+    FROM information_schema.key_column_usage kcu
+    JOIN dependency_tree dt ON kcu.referenced_table_name = dt.table_name
+    WHERE kcu.table_schema = COALESCE(:schema_name, DATABASE())
+      AND kcu.referenced_table_name IS NOT NULL
+      AND NOT FIND_IN_SET(kcu.table_name, dt.path)
+)
+SELECT DISTINCT table_name
+FROM dependency_tree
+ORDER BY level, table_name;

sqlspec/data_dictionary/sql/mysql/version.sql

@@ -0,0 +1,3 @@
+-- name: version
+-- dialect: mysql
+SELECT VERSION() AS version;

sqlspec/data_dictionary/sql/oracle/columns.sql

@@ -0,0 +1,23 @@
+-- name: columns_by_table
+-- dialect: oracle
+SELECT
+    column_name AS column_name,
+    data_type AS data_type,
+    nullable AS is_nullable,
+    data_default AS column_default
+FROM all_tab_columns
+WHERE owner = COALESCE(:schema_name, USER)
+  AND table_name = UPPER(:table_name)
+ORDER BY column_id;
+
+-- name: columns_by_schema
+-- dialect: oracle
+SELECT
+    table_name,
+    column_name AS column_name,
+    data_type AS data_type,
+    nullable AS is_nullable,
+    data_default AS column_default
+FROM all_tab_columns
+WHERE owner = COALESCE(:schema_name, USER)
+ORDER BY table_name, column_id;

sqlspec/data_dictionary/sql/oracle/foreign_keys.sql

@@ -0,0 +1,48 @@
+-- name: foreign_keys_by_table
+-- dialect: oracle
+SELECT
+    c.table_name,
+    cc.column_name,
+    r.table_name AS referenced_table_name,
+    rcc.column_name AS referenced_column_name,
+    c.constraint_name,
+    c.owner AS table_schema,
+    r.owner AS referenced_table_schema
+FROM all_constraints c
+JOIN all_cons_columns cc
+  ON c.owner = cc.owner
+  AND c.constraint_name = cc.constraint_name
+JOIN all_constraints r
+  ON c.r_owner = r.owner
+  AND c.r_constraint_name = r.constraint_name
+JOIN all_cons_columns rcc
+  ON r.owner = rcc.owner
+  AND r.constraint_name = rcc.constraint_name
+  AND cc.position = rcc.position
+WHERE c.constraint_type = 'R'
+  AND c.owner = COALESCE(:schema_name, USER)
+  AND (:table_name IS NULL OR c.table_name = UPPER(:table_name));
+
+-- name: foreign_keys_by_schema
+-- dialect: oracle
+SELECT
+    c.table_name,
+    cc.column_name,
+    r.table_name AS referenced_table_name,
+    rcc.column_name AS referenced_column_name,
+    c.constraint_name,
+    c.owner AS table_schema,
+    r.owner AS referenced_table_schema
+FROM all_constraints c
+JOIN all_cons_columns cc
+  ON c.owner = cc.owner
+  AND c.constraint_name = cc.constraint_name
+JOIN all_constraints r
+  ON c.r_owner = r.owner
+  AND c.r_constraint_name = r.constraint_name
+JOIN all_cons_columns rcc
+  ON r.owner = rcc.owner
+  AND r.constraint_name = rcc.constraint_name
+  AND cc.position = rcc.position
+WHERE c.constraint_type = 'R'
+  AND c.owner = COALESCE(:schema_name, USER);

sqlspec/data_dictionary/sql/oracle/indexes.sql

@@ -0,0 +1,44 @@
+-- name: indexes_by_table
+-- dialect: oracle
+SELECT
+    i.index_name,
+    i.table_name AS table_name,
+    CASE WHEN i.uniqueness = 'UNIQUE' THEN 1 ELSE 0 END AS is_unique,
+    CASE
+        WHEN MAX(CASE WHEN c.constraint_type = 'P' THEN 1 ELSE 0 END) = 1 THEN 1
+        ELSE 0
+    END AS is_primary,
+    LISTAGG(ic.column_name, ',') WITHIN GROUP (ORDER BY ic.column_position) AS columns
+FROM all_indexes i
+JOIN all_ind_columns ic
+  ON i.owner = ic.index_owner
+  AND i.index_name = ic.index_name
+LEFT JOIN all_constraints c
+  ON c.owner = i.owner
+  AND c.index_name = i.index_name
+  AND c.constraint_type = 'P'
+WHERE i.table_name = UPPER(:table_name)
+  AND i.owner = COALESCE(:schema_name, USER)
+GROUP BY i.index_name, i.table_name, i.uniqueness;
+
+-- name: indexes_by_schema
+-- dialect: oracle
+SELECT
+    i.index_name,
+    i.table_name AS table_name,
+    CASE WHEN i.uniqueness = 'UNIQUE' THEN 1 ELSE 0 END AS is_unique,
+    CASE
+        WHEN MAX(CASE WHEN c.constraint_type = 'P' THEN 1 ELSE 0 END) = 1 THEN 1
+        ELSE 0
+    END AS is_primary,
+    LISTAGG(ic.column_name, ',') WITHIN GROUP (ORDER BY ic.column_position) AS columns
+FROM all_indexes i
+JOIN all_ind_columns ic
+  ON i.owner = ic.index_owner
+  AND i.index_name = ic.index_name
+LEFT JOIN all_constraints c
+  ON c.owner = i.owner
+  AND c.index_name = i.index_name
+  AND c.constraint_type = 'P'
+WHERE i.owner = COALESCE(:schema_name, USER)
+GROUP BY i.index_name, i.table_name, i.uniqueness;

sqlspec/data_dictionary/sql/oracle/tables.sql

@@ -0,0 +1,25 @@
+-- name: tables_by_schema
+-- dialect: oracle
+SELECT
+    table_name,
+    MAX(level) AS level
+FROM all_constraints
+WHERE owner = COALESCE(:schema_name, USER)
+START WITH table_name NOT IN (
+    SELECT table_name
+    FROM all_constraints
+    WHERE constraint_type = 'R'
+      AND owner = COALESCE(:schema_name, USER)
+)
+CONNECT BY NOCYCLE PRIOR constraint_name = r_constraint_name
+    AND PRIOR owner = owner
+GROUP BY table_name
+ORDER BY level, table_name;
+
+-- name: all_tables_by_schema
+-- dialect: oracle
+SELECT
+    table_name
+FROM all_tables
+WHERE owner = COALESCE(:schema_name, USER)
+ORDER BY table_name;

sqlspec/data_dictionary/sql/oracle/version.sql

@@ -0,0 +1,20 @@
+-- name: version
+-- dialect: oracle
+SELECT
+    product AS "product",
+    version AS "version",
+    status AS "status"
+FROM product_component_version
+WHERE product LIKE 'Oracle%'
+ORDER BY TO_NUMBER(REGEXP_SUBSTR(version, '^[0-9]+')) DESC, version DESC
+FETCH FIRST 1 ROWS ONLY;
+
+-- name: autonomous_service
+-- dialect: oracle
+SELECT sys_context('USERENV', 'CLOUD_SERVICE') AS "service" FROM dual;
+
+-- name: compatible
+-- dialect: oracle
+SELECT value AS compatible
+FROM v$parameter
+WHERE name = 'compatible';

sqlspec/data_dictionary/sql/postgres/columns.sql

@@ -0,0 +1,34 @@
+-- name: columns_by_table
+-- dialect: postgres
+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: postgres
+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/postgres/foreign_keys.sql

@@ -0,0 +1,40 @@
+-- name: foreign_keys_by_table
+-- dialect: postgres
+SELECT
+    kcu.table_name,
+    kcu.column_name,
+    ccu.table_name AS referenced_table_name,
+    ccu.column_name AS referenced_column_name,
+    tc.constraint_name,
+    tc.table_schema,
+    ccu.table_schema AS referenced_table_schema
+FROM information_schema.table_constraints AS tc
+JOIN information_schema.key_column_usage AS kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage AS ccu
+  ON ccu.constraint_name = tc.constraint_name
+  AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND (:schema_name::text IS NULL OR tc.table_schema = :schema_name)
+  AND (:table_name::text IS NULL OR tc.table_name = :table_name);
+
+-- name: foreign_keys_by_schema
+-- dialect: postgres
+SELECT
+    kcu.table_name,
+    kcu.column_name,
+    ccu.table_name AS referenced_table_name,
+    ccu.column_name AS referenced_column_name,
+    tc.constraint_name,
+    tc.table_schema,
+    ccu.table_schema AS referenced_table_schema
+FROM information_schema.table_constraints AS tc
+JOIN information_schema.key_column_usage AS kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN information_schema.constraint_column_usage AS ccu
+  ON ccu.constraint_name = tc.constraint_name
+  AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY'
+  AND (:schema_name::text IS NULL OR tc.table_schema = :schema_name);

sqlspec/data_dictionary/sql/postgres/indexes.sql

@@ -0,0 +1,56 @@
+-- name: indexes_by_table
+-- dialect: postgres
+SELECT
+    i.relname as index_name,
+    t.relname as table_name,
+    ix.indisunique as is_unique,
+    ix.indisprimary as is_primary,
+    array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) as columns
+FROM
+    pg_class t,
+    pg_class i,
+    pg_index ix,
+    pg_attribute a,
+    pg_namespace n
+WHERE
+    t.oid = ix.indrelid
+    AND i.oid = ix.indexrelid
+    AND a.attrelid = t.oid
+    AND a.attnum = ANY(ix.indkey)
+    AND t.relkind = 'r'
+    AND t.relnamespace = n.oid
+    AND n.nspname = :schema_name
+    AND t.relname = :table_name
+GROUP BY
+    t.relname,
+    i.relname,
+    ix.indisunique,
+    ix.indisprimary;
+
+-- name: indexes_by_schema
+-- dialect: postgres
+SELECT
+    i.relname as index_name,
+    t.relname as table_name,
+    ix.indisunique as is_unique,
+    ix.indisprimary as is_primary,
+    array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) as columns
+FROM
+    pg_class t,
+    pg_class i,
+    pg_index ix,
+    pg_attribute a,
+    pg_namespace n
+WHERE
+    t.oid = ix.indrelid
+    AND i.oid = ix.indexrelid
+    AND a.attrelid = t.oid
+    AND a.attnum = ANY(ix.indkey)
+    AND t.relkind = 'r'
+    AND t.relnamespace = n.oid
+    AND n.nspname = :schema_name
+GROUP BY
+    t.relname,
+    i.relname,
+    ix.indisunique,
+    ix.indisprimary;

sqlspec/data_dictionary/sql/postgres/tables.sql

@@ -0,0 +1,44 @@
+-- name: tables_by_schema
+-- dialect: postgres
+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/postgres/version.sql

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

sqlspec/data_dictionary/sql/spanner/columns.sql

@@ -0,0 +1,23 @@
+-- name: columns_by_table
+-- dialect: spanner
+SELECT
+    column_name,
+    spanner_type AS data_type,
+    is_nullable,
+    column_default
+FROM 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: spanner
+SELECT
+    table_name,
+    column_name,
+    spanner_type AS data_type,
+    is_nullable,
+    column_default
+FROM information_schema.columns
+WHERE (:schema_name IS NULL OR table_schema = :schema_name)
+ORDER BY table_name, ordinal_position;

sqlspec/data_dictionary/sql/spanner/foreign_keys.sql

@@ -0,0 +1,70 @@
+-- name: foreign_keys_by_table
+-- dialect: spanner
+WITH fk_constraints AS (
+    SELECT
+        constraint_name,
+        unique_constraint_name
+    FROM information_schema.referential_constraints
+    WHERE (:schema_name IS NULL OR constraint_schema = :schema_name)
+),
+fk_columns AS (
+    SELECT
+        constraint_name,
+        table_name,
+        column_name,
+        ordinal_position,
+        table_schema
+    FROM information_schema.key_column_usage
+    WHERE (:schema_name IS NULL OR constraint_schema = :schema_name)
+)
+SELECT
+    fk.table_name,
+    fk.column_name,
+    pk.table_name AS referenced_table_name,
+    pk.column_name AS referenced_column_name,
+    fk.constraint_name,
+    fk.table_schema AS table_schema,
+    pk.table_schema AS referenced_table_schema
+FROM fk_columns fk
+JOIN fk_constraints rc
+  ON fk.constraint_name = rc.constraint_name
+JOIN fk_columns pk
+  ON pk.constraint_name = rc.unique_constraint_name
+  AND pk.ordinal_position = fk.ordinal_position
+WHERE (:table_name IS NULL OR fk.table_name = :table_name)
+ORDER BY fk.table_name, fk.ordinal_position;
+
+-- name: foreign_keys_by_schema
+-- dialect: spanner
+WITH fk_constraints AS (
+    SELECT
+        constraint_name,
+        unique_constraint_name
+    FROM information_schema.referential_constraints
+    WHERE (:schema_name IS NULL OR constraint_schema = :schema_name)
+),
+fk_columns AS (
+    SELECT
+        constraint_name,
+        table_name,
+        column_name,
+        ordinal_position,
+        table_schema
+    FROM information_schema.key_column_usage
+    WHERE (:schema_name IS NULL OR constraint_schema = :schema_name)
+)
+SELECT
+    fk.table_name,
+    fk.column_name,
+    pk.table_name AS referenced_table_name,
+    pk.column_name AS referenced_column_name,
+    fk.constraint_name,
+    fk.table_schema AS table_schema,
+    pk.table_schema AS referenced_table_schema
+FROM fk_columns fk
+JOIN fk_constraints rc
+  ON fk.constraint_name = rc.constraint_name
+JOIN fk_columns pk
+  ON pk.constraint_name = rc.unique_constraint_name
+  AND pk.ordinal_position = fk.ordinal_position
+ORDER BY fk.table_name, fk.ordinal_position;