sqlspec 0.47.0__cp314-cp314-win_amd64.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,81 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+
+__all__ = ("format_bigquery_information_schema_tables", "format_bigquery_schema_prefix")
+
+
+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)
+
+
+def format_bigquery_information_schema_tables(schema: "str | None") -> "tuple[str, str, str]":
+    """Format BigQuery INFORMATION_SCHEMA table identifiers for metadata queries.
+
+    Args:
+        schema: Optional BigQuery project.dataset schema qualifier.
+
+    Returns:
+        TABLES, KEY_COLUMN_USAGE, and REFERENTIAL_CONSTRAINTS identifiers.
+    """
+    if schema:
+        return (
+            f"`{schema}.INFORMATION_SCHEMA.TABLES`",
+            f"`{schema}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE`",
+            f"`{schema}.INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS`",
+        )
+    return (
+        "INFORMATION_SCHEMA.TABLES",
+        "INFORMATION_SCHEMA.KEY_COLUMN_USAGE",
+        "INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS",
+    )
+
+
+def format_bigquery_schema_prefix(schema: "str | None") -> str:
+    """Format a BigQuery schema prefix for INFORMATION_SCHEMA queries."""
+    if schema:
+        return f"`{schema}`."
+    return ""

sqlspec/data_dictionary/dialects/cockroachdb.py

@@ -0,0 +1,54 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+__all__ = ("resolve_cockroachdb_json_type",)
+
+
+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)
+
+
+def resolve_cockroachdb_json_type(version_info: "VersionInfo | None") -> str:
+    """Resolve the best CockroachDB JSON storage type for a database version."""
+    json_version = COCKROACHDB_CONFIG.get_feature_version("supports_json")
+    if version_info and json_version and version_info >= json_version:
+        return COCKROACHDB_CONFIG.get_optimal_type("json")
+    return "TEXT"

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,53 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+__all__ = ("resolve_mysql_json_type",)
+
+
+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)
+
+
+def resolve_mysql_json_type(version_info: "VersionInfo | None") -> str:
+    """Resolve the best MySQL JSON storage type for a database version."""
+    json_version = MYSQL_CONFIG.get_feature_version("supports_json")
+    if version_info and json_version and version_info >= json_version:
+        return "JSON"
+    return "TEXT"

sqlspec/data_dictionary/dialects/oracle.py

@@ -0,0 +1,197 @@
+import re
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Final
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+
+if TYPE_CHECKING:
+    from sqlspec.typing import TableMetadata, VersionInfo
+
+__all__ = (
+    "extract_oracle_version_value",
+    "list_oracle_available_features",
+    "merge_oracle_table_lists",
+    "oracle_supports_json_blob",
+    "oracle_supports_native_json",
+    "oracle_supports_oson_blob",
+    "parse_oracle_compatible_major",
+    "parse_oracle_version_components",
+    "resolve_oracle_feature_flag",
+    "resolve_oracle_json_type",
+)
+
+
+ORACLE_VERSION_PATTERN = re.compile(r"(\d+)")
+ORACLE_VERSION_PARTS_COUNT: Final[int] = 3
+ORACLE_MIN_JSON_NATIVE_VERSION: Final[int] = 21
+ORACLE_MIN_JSON_NATIVE_COMPATIBLE: Final[int] = 20
+ORACLE_MIN_JSON_BLOB_VERSION: Final[int] = 12
+ORACLE_MIN_OSON_VERSION: Final[int] = 19
+
+ORACLE_DYNAMIC_FEATURES: Final[tuple[str, ...]] = (
+    "is_autonomous",
+    "supports_native_json",
+    "supports_oson_blob",
+    "supports_json_blob",
+    "supports_json",
+)
+
+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)
+
+
+def parse_oracle_compatible_major(compatible: "str | None") -> "int | None":
+    """Parse the major version from an Oracle compatible parameter value.
+
+    Args:
+        compatible: Oracle compatible parameter value.
+
+    Returns:
+        Compatible major version or None when unavailable.
+    """
+    if not compatible:
+        return None
+    parts = compatible.split(".")
+    if not parts:
+        return None
+    return int(parts[0])
+
+
+def oracle_supports_native_json(major: int, compatible_major: "int | None") -> bool:
+    """Return whether an Oracle version supports the native JSON data type."""
+    return major >= ORACLE_MIN_JSON_NATIVE_VERSION and (compatible_major or 0) >= ORACLE_MIN_JSON_NATIVE_COMPATIBLE
+
+
+def oracle_supports_oson_blob(major: int, is_autonomous: bool) -> bool:
+    """Return whether an Oracle version supports BLOB with OSON format."""
+    if major >= ORACLE_MIN_JSON_NATIVE_VERSION:
+        return True
+    return major >= ORACLE_MIN_OSON_VERSION and is_autonomous
+
+
+def oracle_supports_json_blob(major: int) -> bool:
+    """Return whether an Oracle version supports BLOB with JSON validation."""
+    return major >= ORACLE_MIN_JSON_BLOB_VERSION
+
+
+def extract_oracle_version_value(row: object) -> "str | None":
+    """Extract an Oracle version string from a row-like object.
+
+    Args:
+        row: Row value returned by an Oracle version query.
+
+    Returns:
+        Version string when one can be found, otherwise None.
+    """
+    if isinstance(row, Mapping):
+        for key in ("version", "VERSION", "Version"):
+            value = row.get(key)
+            if value:
+                return str(value)
+    if isinstance(row, (list, tuple)) and row:
+        return str(row[0])
+    if row is not None:
+        return str(row)
+    return None
+
+
+def parse_oracle_version_components(version_str: str) -> "tuple[int, int, int] | None":
+    """Parse Oracle version text into major, minor, patch components."""
+    parts = [int(value) for value in ORACLE_VERSION_PATTERN.findall(version_str)]
+    if not parts:
+        return None
+    while len(parts) < ORACLE_VERSION_PARTS_COUNT:
+        parts.append(0)
+    return parts[0], parts[1], parts[2]
+
+
+def resolve_oracle_json_type(
+    version_info: "VersionInfo | None", *, compatible_major: "int | None", is_autonomous: bool
+) -> str:
+    """Resolve the best Oracle JSON storage type for a database version."""
+    if version_info is None:
+        return "CLOB"
+    if oracle_supports_native_json(version_info.major, compatible_major):
+        return "JSON"
+    if oracle_supports_oson_blob(version_info.major, is_autonomous):
+        return "BLOB"
+    if oracle_supports_json_blob(version_info.major):
+        return "BLOB"
+    return "CLOB"
+
+
+def resolve_oracle_feature_flag(
+    config: DialectConfig,
+    version_info: "VersionInfo | None",
+    feature: str,
+    *,
+    compatible_major: "int | None",
+    is_autonomous: bool,
+) -> bool:
+    """Resolve an Oracle feature flag from static config and version details."""
+    if feature == "is_autonomous":
+        return bool(version_info and is_autonomous)
+    if version_info is None:
+        return False
+    if feature == "supports_native_json":
+        return oracle_supports_native_json(version_info.major, compatible_major)
+    if feature == "supports_oson_blob":
+        return oracle_supports_oson_blob(version_info.major, is_autonomous)
+    if feature == "supports_json_blob":
+        return oracle_supports_json_blob(version_info.major)
+    if feature == "supports_json":
+        return oracle_supports_json_blob(version_info.major)
+
+    flag = config.get_feature_flag(feature)
+    if flag is not None:
+        return flag
+    required_version = config.get_feature_version(feature)
+    if required_version is None:
+        return False
+    return bool(version_info >= required_version)
+
+
+def list_oracle_available_features(config: DialectConfig) -> "list[str]":
+    """List static and dynamic Oracle data-dictionary feature flags."""
+    features: set[str] = set()
+    features.update(config.feature_flags.keys())
+    features.update(config.feature_versions.keys())
+    features.update(ORACLE_DYNAMIC_FEATURES)
+    return sorted(features)
+
+
+def merge_oracle_table_lists(
+    ordered: "list[TableMetadata]", all_tables: "list[TableMetadata]"
+) -> "list[TableMetadata]":
+    """Merge dependency-ordered Oracle tables with unordered remainder rows."""
+    if not ordered:
+        return sorted(all_tables, key=lambda item: item.get("table_name") or "")
+    ordered_names = {item.get("table_name") for item in ordered if item.get("table_name")}
+    remainder = [item for item in all_tables if item.get("table_name") not in ordered_names]
+    return ordered + remainder

sqlspec/data_dictionary/dialects/postgres.py

@@ -0,0 +1,69 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+__all__ = ("resolve_postgres_json_type",)
+
+
+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)
+
+
+def resolve_postgres_json_type(version_info: "VersionInfo | None") -> str:
+    """Resolve the best PostgreSQL JSON storage type for a database version.
+
+    Args:
+        version_info: Parsed PostgreSQL version, or None when version detection failed.
+
+    Returns:
+        JSONB when available, JSON before JSONB support, otherwise TEXT.
+    """
+    jsonb_version = POSTGRES_CONFIG.get_feature_version("supports_jsonb")
+    if version_info and jsonb_version and version_info >= jsonb_version:
+        return "JSONB"
+
+    json_version = POSTGRES_CONFIG.get_feature_version("supports_json")
+    if version_info and json_version and version_info >= json_version:
+        return "JSON"
+
+    return "TEXT"

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,59 @@
+import re
+
+from sqlspec.data_dictionary import DialectConfig, FeatureFlags, FeatureVersions, register_dialect
+from sqlspec.typing import VersionInfo
+
+__all__ = ("list_sqlite_available_features", "resolve_sqlite_json_type")
+
+
+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)
+
+
+def resolve_sqlite_json_type(version_info: "VersionInfo | None") -> str:
+    """Resolve the best SQLite JSON storage type for a database version."""
+    json_version = SQLITE_CONFIG.get_feature_version("supports_json")
+    if version_info and json_version and version_info >= json_version:
+        return "JSON"
+    return "TEXT"
+
+
+def list_sqlite_available_features() -> "list[str]":
+    """List SQLite data-dictionary feature flags."""
+    features = set(SQLITE_CONFIG.feature_flags.keys()) | set(SQLITE_CONFIG.feature_versions.keys())
+    return sorted(features)

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;