dvt-core 0.58.6__cp311-cp311-macosx_10_9_x86_64.whl

dbt/graph/selector_spec.py

@@ -0,0 +1,222 @@
+import os
+import re
+from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Set, Tuple, Union
+
+from dbt.exceptions import InvalidSelectorError
+from dbt.flags import get_flags
+from dbt_common.dataclass_schema import StrEnum, dbtClassMixin
+from dbt_common.exceptions import DbtRuntimeError
+
+from .graph import UniqueId
+from .selector_methods import MethodName
+
+RAW_SELECTOR_PATTERN = re.compile(
+    r"\A"
+    r"(?P<childrens_parents>(\@))?"
+    r"(?P<parents>((?P<parents_depth>(\d*))\+))?"
+    r"((?P<method>([\w.]+)):)?(?P<value>(.*?))"
+    r"(?P<children>(\+(?P<children_depth>(\d*))))?"
+    r"\Z"
+)
+SELECTOR_METHOD_SEPARATOR = "."
+
+
+class IndirectSelection(StrEnum):
+    Eager = "eager"
+    Cautious = "cautious"
+    Buildable = "buildable"
+    Empty = "empty"
+
+
+def _probably_path(value: str):
+    """Decide if the value is probably a path. Windows has two path separators, so
+    we should check both sep ('\\') and altsep ('/') there.
+    """
+    if os.path.sep in value:
+        return True
+    elif os.path.altsep is not None and os.path.altsep in value:
+        return True
+    else:
+        return False
+
+
+def _match_to_int(match: Dict[str, str], key: str) -> Optional[int]:
+    raw = match.get(key)
+    # turn the empty string into None, too.
+    if not raw:
+        return None
+    try:
+        return int(raw)
+    except ValueError as exc:
+        raise DbtRuntimeError(f"Invalid node spec - could not handle parent depth {raw}") from exc
+
+
+SelectionSpec = Union[
+    "SelectionCriteria",
+    "SelectionIntersection",
+    "SelectionDifference",
+    "SelectionUnion",
+]
+
+
+@dataclass
+class SelectionCriteria:
+    raw: Any
+    method: MethodName
+    method_arguments: List[str]
+    value: Any
+    childrens_parents: bool
+    parents: bool
+    parents_depth: Optional[int]
+    children: bool
+    children_depth: Optional[int]
+    indirect_selection: IndirectSelection = IndirectSelection.Eager
+
+    def __post_init__(self):
+        if self.children and self.childrens_parents:
+            raise DbtRuntimeError(
+                f'Invalid node spec {self.raw} - "@" prefix and "+" suffix ' "are incompatible"
+            )
+
+    @classmethod
+    def default_method(cls, value: str) -> MethodName:
+        if _probably_path(value):
+            return MethodName.Path
+        elif value.lower().endswith((".sql", ".py", ".csv")):
+            return MethodName.File
+        else:
+            return MethodName.FQN
+
+    @classmethod
+    def parse_method(cls, groupdict: Dict[str, Any]) -> Tuple[MethodName, List[str]]:
+        raw_method = groupdict.get("method")
+        if raw_method is None:
+            return cls.default_method(groupdict["value"]), []
+
+        method_parts: List[str] = raw_method.split(SELECTOR_METHOD_SEPARATOR)
+        try:
+            method_name = MethodName(method_parts[0])
+        except ValueError as exc:
+            raise InvalidSelectorError(f"'{method_parts[0]}' is not a valid method name") from exc
+
+        # Following is for cases like config.severity and config.materialized
+        method_arguments: List[str] = method_parts[1:]
+
+        return method_name, method_arguments
+
+    @classmethod
+    def selection_criteria_from_dict(
+        cls,
+        raw: Any,
+        dct: Dict[str, Any],
+    ) -> "SelectionCriteria":
+        if "value" not in dct:
+            raise DbtRuntimeError(f'Invalid node spec "{raw}" - no search value!')
+        method_name, method_arguments = cls.parse_method(dct)
+
+        parents_depth = _match_to_int(dct, "parents_depth")
+        children_depth = _match_to_int(dct, "children_depth")
+
+        # If defined field in selector, override CLI flag
+        indirect_selection = IndirectSelection(
+            dct.get("indirect_selection", getattr(get_flags(), "INDIRECT_SELECTION", "eager"))
+        )
+
+        return cls(
+            raw=raw,
+            method=method_name,
+            method_arguments=method_arguments,
+            value=dct["value"],
+            childrens_parents=bool(dct.get("childrens_parents")),
+            parents=bool(dct.get("parents")),
+            parents_depth=parents_depth,
+            children=bool(dct.get("children")),
+            children_depth=children_depth,
+            indirect_selection=indirect_selection,
+        )
+
+    @classmethod
+    def dict_from_single_spec(cls, raw: str):
+        result = RAW_SELECTOR_PATTERN.match(raw)
+        if result is None:
+            return {"error": "Invalid selector spec"}
+        dct: Dict[str, Any] = result.groupdict()
+        method_name, method_arguments = cls.parse_method(dct)
+        meth_name = str(method_name)
+        if method_arguments:
+            meth_name += "." + ".".join(method_arguments)
+        dct["method"] = meth_name
+        dct = {k: v for k, v in dct.items() if (v is not None and v != "")}
+        if "childrens_parents" in dct:
+            dct["childrens_parents"] = bool(dct.get("childrens_parents"))
+        if "parents" in dct:
+            dct["parents"] = bool(dct.get("parents"))
+        if "children" in dct:
+            dct["children"] = bool(dct.get("children"))
+        return dct
+
+    @classmethod
+    def from_single_spec(cls, raw: str) -> "SelectionCriteria":
+        result = RAW_SELECTOR_PATTERN.match(raw)
+        if result is None:
+            # bad spec!
+            raise DbtRuntimeError(f'Invalid selector spec "{raw}"')
+
+        return cls.selection_criteria_from_dict(raw, result.groupdict())
+
+
+class BaseSelectionGroup(dbtClassMixin, Iterable[SelectionSpec], metaclass=ABCMeta):
+    def __init__(
+        self,
+        components: Iterable[SelectionSpec],
+        indirect_selection: IndirectSelection = IndirectSelection.Eager,
+        expect_exists: bool = False,
+        raw: Any = None,
+    ) -> None:
+        self.components: List[SelectionSpec] = list(components)
+        self.expect_exists = expect_exists
+        self.raw = raw
+        self.indirect_selection = indirect_selection
+
+    def __iter__(self) -> Iterator[SelectionSpec]:
+        for component in self.components:
+            yield component
+
+    @abstractmethod
+    def combine_selections(
+        self,
+        selections: List[Set[UniqueId]],
+    ) -> Set[UniqueId]:
+        raise NotImplementedError("_combine_selections not implemented!")
+
+    def combined(self, selections: List[Set[UniqueId]]) -> Set[UniqueId]:
+        if not selections:
+            return set()
+
+        return self.combine_selections(selections)
+
+
+class SelectionIntersection(BaseSelectionGroup):
+    def combine_selections(
+        self,
+        selections: List[Set[UniqueId]],
+    ) -> Set[UniqueId]:
+        return set.intersection(*selections)
+
+
+class SelectionDifference(BaseSelectionGroup):
+    def combine_selections(
+        self,
+        selections: List[Set[UniqueId]],
+    ) -> Set[UniqueId]:
+        return set.difference(*selections)
+
+
+class SelectionUnion(BaseSelectionGroup):
+    def combine_selections(
+        self,
+        selections: List[Set[UniqueId]],
+    ) -> Set[UniqueId]:
+        return set.union(*selections)

dbt/graph/thread_pool.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from multiprocessing.pool import ThreadPool
+
+
+class DbtThreadPool(ThreadPool):
+    """A ThreadPool that tracks whether or not it's been closed"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.closed = False
+
+    def close(self):
+        self.closed = True
+        super().close()
+
+    def is_closed(self):
+        return self.closed

dbt/hooks.py

@@ -0,0 +1,21 @@
+import json
+from typing import Any, Dict, Union
+
+from dbt_common.dataclass_schema import StrEnum
+
+
+class ModelHookType(StrEnum):
+    PreHook = "pre-hook"
+    PostHook = "post-hook"
+
+
+def get_hook_dict(source: Union[str, Dict[str, Any]]) -> Dict[str, Any]:
+    """From a source string-or-dict, get a dictionary that can be passed to
+    Hook.from_dict
+    """
+    if isinstance(source, dict):
+        return source
+    try:
+        return json.loads(source)
+    except ValueError:
+        return {"sql": source}

dbt/include/README.md

@@ -0,0 +1,49 @@
+# Include Module
+
+The Include module is responsible for the starter project scaffold.
+
+# Directories
+
+## `starter_project`
+Produces the default project after running the `dbt init` command for the CLI. `dbt-cloud` initializes the project by using [dbt-starter-project](https://github.com/dbt-labs/dbt-starter-project).
+
+# adapter.dispatch
+Packages (e.g. `include` directories of adapters, any [hub](https://hub.getdbt.com/)-hosted package) can be interpreted as namespaces of functions a.k.a macros. In `dbt`'s macrospace, we take advantage of the multiple dispatch programming language concept. In short, multiple dispatch supports dynamic searching for a function across several namespaces—usually in a manually specified manner/order.
+
+Adapters can have their own implementation of the same macro X. For example, a macro executed by `dbt-redshift` may need a specific implementation different from `dbt-snowflake`'s macro. We use multiple dispatch via `adapter.dispatch`, a Jinja function, which enables polymorphic macro invocations. The chosen implementation is selected according to what the `adapter` object is set to at runtime (it could be for redshift, postgres, and so on).
+
+For more on this object, check out the dbt docs [here](https://docs.getdbt.com/reference/dbt-jinja-functions/adapter).
+
+# dbt and database adapter python package interop
+
+Let’s say we have a fictional python app named `dbt-core` with this structure
+
+```
+dbt
+├── adapters
+│   └── base.py
+├── cli.py
+└── main.py
+```
+
+`pip install dbt-core` will install this application in my python environment, maintaining the same structure. Note that `dbt.adapters` only contains a `base.py`. In this example, we can assume that base.py includes an abstract class for creating connections. Let’s say we wanted to create an postgres adapter that this app could use, and can be installed independently. We can create a python package with the following structure called `dbt-postgres`
+```
+dbt
+└── adapters
+    └── postgres
+        └── impl.py
+```
+
+`pip install dbt-postgres` will install this package in the python environment, maintaining the same structure again. Let’s say `impl.py` imports `dbt.adapters.base` and implements a concrete class inheriting from the abstract class in `base.py` from the `dbt-core` package. Since our top level package is named the same in both packages, `pip` will put this in the same place. We end up with this installed in our python environment.
+
+```
+dbt
+├── adapters
+│   ├── base.py
+│   └── postgres
+│       └── impl.py
+├── cli.py
+└── main.py
+```
+
+`dbt.adapters` now has a postgres module that dbt can easily find and call directly. dbt and its adapters follows the same type of file structure convention. This is the magic that allows you to import `dbt.*` in database adapters, and using a factory pattern in dbt-core, we can create instances of concrete classes defined in the database adapter packages (for creating connections, defining database configuration, defining credentials, etc.)

dbt/include/__init__.py

@@ -0,0 +1,3 @@
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

dbt/include/data/build_registry.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""
+Build Script for DVT Adapters Registry
+
+This script reads CSV files from the csv/ directory and creates
+adapters_registry.duckdb with pre-populated type mappings, syntax rules,
+and adapter queries.
+
+Usage:
+    python build_registry.py
+
+The resulting adapters_registry.duckdb is shipped with the DVT package.
+"""
+
+import csv
+import os
+from pathlib import Path
+
+try:
+    import duckdb
+except ImportError:
+    print("Error: duckdb is required. Install with: pip install duckdb")
+    exit(1)
+
+
+def get_script_dir() -> Path:
+    """Get directory containing this script."""
+    return Path(__file__).parent
+
+
+def create_schema(conn: duckdb.DuckDBPyConnection) -> None:
+    """Create the database schema."""
+
+    # Table: datatype_mappings
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS datatype_mappings (
+            adapter_name VARCHAR NOT NULL,
+            adapter_type VARCHAR NOT NULL,
+            spark_type VARCHAR NOT NULL,
+            spark_version VARCHAR DEFAULT 'all',
+            is_complex BOOLEAN DEFAULT FALSE,
+            cast_expression VARCHAR,
+            notes VARCHAR,
+            UNIQUE (adapter_name, adapter_type, spark_version)
+        )
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_datatype_lookup
+        ON datatype_mappings(adapter_name, adapter_type)
+    """)
+
+    # Table: syntax_registry
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS syntax_registry (
+            adapter_name VARCHAR NOT NULL PRIMARY KEY,
+            quote_start VARCHAR NOT NULL,
+            quote_end VARCHAR NOT NULL,
+            case_sensitivity VARCHAR NOT NULL,
+            reserved_keywords VARCHAR
+        )
+    """)
+
+    # Table: adapter_queries
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS adapter_queries (
+            adapter_name VARCHAR NOT NULL,
+            query_type VARCHAR NOT NULL,
+            query_template VARCHAR NOT NULL,
+            notes VARCHAR,
+            PRIMARY KEY (adapter_name, query_type)
+        )
+    """)
+
+    print("Schema created successfully")
+
+
+def load_type_mappings(conn: duckdb.DuckDBPyConnection, csv_dir: Path) -> int:
+    """Load type mappings from CSV files."""
+    total_rows = 0
+
+    # Find all type_mappings_*.csv files
+    for csv_file in sorted(csv_dir.glob("type_mappings_*.csv")):
+        adapter_name = csv_file.stem.replace("type_mappings_", "")
+        rows_loaded = 0
+
+        with open(csv_file, 'r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                conn.execute("""
+                    INSERT OR REPLACE INTO datatype_mappings
+                    (adapter_name, adapter_type, spark_type, spark_version,
+                     is_complex, cast_expression, notes)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                """, [
+                    adapter_name,
+                    row['adapter_type'].strip(),
+                    row['spark_type'].strip(),
+                    row.get('spark_version', 'all').strip() or 'all',
+                    row.get('is_complex', 'false').strip().lower() == 'true',
+                    row.get('cast_expression', '').strip() or None,
+                    row.get('notes', '').strip() or None,
+                ])
+                rows_loaded += 1
+
+        print(f"  Loaded {rows_loaded} type mappings for {adapter_name}")
+        total_rows += rows_loaded
+
+    return total_rows
+
+
+def load_syntax_rules(conn: duckdb.DuckDBPyConnection, csv_dir: Path) -> int:
+    """Load syntax rules from CSV file."""
+    csv_file = csv_dir / "syntax_rules.csv"
+    if not csv_file.exists():
+        print("  Warning: syntax_rules.csv not found")
+        return 0
+
+    rows_loaded = 0
+    with open(csv_file, 'r', encoding='utf-8') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            conn.execute("""
+                INSERT OR REPLACE INTO syntax_registry
+                (adapter_name, quote_start, quote_end, case_sensitivity, reserved_keywords)
+                VALUES (?, ?, ?, ?, ?)
+            """, [
+                row['adapter_name'].strip(),
+                row['quote_start'].strip(),
+                row['quote_end'].strip(),
+                row['case_sensitivity'].strip(),
+                row.get('reserved_keywords', '').strip() or None,
+            ])
+            rows_loaded += 1
+
+    print(f"  Loaded {rows_loaded} syntax rules")
+    return rows_loaded
+
+
+def load_adapter_queries(conn: duckdb.DuckDBPyConnection, csv_dir: Path) -> int:
+    """Load adapter queries from CSV file."""
+    csv_file = csv_dir / "adapter_queries.csv"
+    if not csv_file.exists():
+        print("  Warning: adapter_queries.csv not found")
+        return 0
+
+    rows_loaded = 0
+    with open(csv_file, 'r', encoding='utf-8') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            conn.execute("""
+                INSERT OR REPLACE INTO adapter_queries
+                (adapter_name, query_type, query_template, notes)
+                VALUES (?, ?, ?, ?)
+            """, [
+                row['adapter_name'].strip(),
+                row['query_type'].strip(),
+                row['query_template'].strip(),
+                row.get('notes', '').strip() or None,
+            ])
+            rows_loaded += 1
+
+    print(f"  Loaded {rows_loaded} adapter queries")
+    return rows_loaded
+
+
+def print_stats(conn: duckdb.DuckDBPyConnection) -> None:
+    """Print statistics about the loaded data."""
+    print("\n=== Registry Statistics ===")
+
+    # Type mappings by adapter
+    result = conn.execute("""
+        SELECT adapter_name, COUNT(*) as count
+        FROM datatype_mappings
+        GROUP BY adapter_name
+        ORDER BY adapter_name
+    """).fetchall()
+    print("\nType mappings per adapter:")
+    for row in result:
+        print(f"  {row[0]}: {row[1]}")
+
+    # Syntax rules
+    result = conn.execute("SELECT COUNT(*) FROM syntax_registry").fetchone()
+    print(f"\nSyntax rules: {result[0]} adapters")
+
+    # Adapter queries
+    result = conn.execute("""
+        SELECT adapter_name, COUNT(*) as count
+        FROM adapter_queries
+        GROUP BY adapter_name
+        ORDER BY adapter_name
+    """).fetchall()
+    print("\nAdapter queries:")
+    for row in result:
+        print(f"  {row[0]}: {row[1]} queries")
+
+
+def main():
+    script_dir = get_script_dir()
+    csv_dir = script_dir / "csv"
+    db_path = script_dir / "adapters_registry.duckdb"
+
+    print(f"Building adapters_registry.duckdb")
+    print(f"CSV directory: {csv_dir}")
+    print(f"Output: {db_path}")
+    print()
+
+    # Remove existing database
+    if db_path.exists():
+        os.remove(db_path)
+        print("Removed existing database")
+
+    # Create new database
+    conn = duckdb.connect(str(db_path))
+
+    try:
+        # Create schema
+        print("\nCreating schema...")
+        create_schema(conn)
+
+        # Load data
+        print("\nLoading type mappings...")
+        type_count = load_type_mappings(conn, csv_dir)
+
+        print("\nLoading syntax rules...")
+        syntax_count = load_syntax_rules(conn, csv_dir)
+
+        print("\nLoading adapter queries...")
+        query_count = load_adapter_queries(conn, csv_dir)
+
+        # Print stats
+        print_stats(conn)
+
+        print(f"\n=== Build Complete ===")
+        print(f"Total: {type_count} type mappings, {syntax_count} syntax rules, {query_count} queries")
+        print(f"Database size: {db_path.stat().st_size / 1024:.1f} KB")
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    main()

dbt/include/data/csv/adapter_queries.csv

@@ -0,0 +1,33 @@
+adapter_name,query_type,query_template,notes
+postgres,columns,"SELECT column_name, data_type, is_nullable, ordinal_position FROM information_schema.columns WHERE table_schema = '{schema}' AND table_name = '{table}' ORDER BY ordinal_position",Get column metadata
+postgres,tables,"SELECT table_name FROM information_schema.tables WHERE table_schema = '{schema}' AND table_type = 'BASE TABLE'",List tables in schema
+postgres,row_count,"SELECT COUNT(*) FROM ""{schema}"".""{table}""",Count rows in table
+postgres,primary_key,"SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name WHERE tc.table_schema = '{schema}' AND tc.table_name = '{table}' AND tc.constraint_type = 'PRIMARY KEY'",Get primary key columns
+snowflake,columns,"SELECT column_name, data_type, is_nullable, ordinal_position FROM information_schema.columns WHERE table_schema = '{schema}' AND table_name = '{table}' ORDER BY ordinal_position",Get column metadata
+snowflake,tables,"SELECT table_name FROM information_schema.tables WHERE table_schema = '{schema}' AND table_type = 'BASE TABLE'",List tables in schema
+snowflake,row_count,"SELECT COUNT(*) FROM ""{schema}"".""{table}""",Count rows in table
+snowflake,primary_key,"SELECT column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name WHERE tc.table_schema = '{schema}' AND tc.table_name = '{table}' AND tc.constraint_type = 'PRIMARY KEY'",Get primary key columns
+mysql,columns,"SELECT column_name, data_type, is_nullable, ordinal_position FROM information_schema.columns WHERE table_schema = '{schema}' AND table_name = '{table}' ORDER BY ordinal_position",Get column metadata
+mysql,tables,"SELECT table_name FROM information_schema.tables WHERE table_schema = '{schema}' AND table_type = 'BASE TABLE'",List tables in schema
+mysql,row_count,"SELECT COUNT(*) FROM `{schema}`.`{table}`",Count rows in table
+mysql,primary_key,"SELECT column_name FROM information_schema.key_column_usage WHERE table_schema = '{schema}' AND table_name = '{table}' AND constraint_name = 'PRIMARY'",Get primary key columns
+bigquery,columns,"SELECT column_name, data_type, is_nullable, ordinal_position FROM `{project}`.`{schema}`.INFORMATION_SCHEMA.COLUMNS WHERE table_name = '{table}' ORDER BY ordinal_position",Get column metadata
+bigquery,tables,"SELECT table_name FROM `{project}`.`{schema}`.INFORMATION_SCHEMA.TABLES WHERE table_type = 'BASE TABLE'",List tables in dataset
+bigquery,row_count,"SELECT COUNT(*) FROM `{project}`.`{schema}`.`{table}`",Count rows in table
+bigquery,primary_key,"SELECT column_name FROM `{project}`.`{schema}`.INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE table_name = '{table}' AND constraint_name LIKE 'pk_%'",Get primary key columns
+redshift,columns,"SELECT column_name, data_type, is_nullable, ordinal_position FROM information_schema.columns WHERE table_schema = '{schema}' AND table_name = '{table}' ORDER BY ordinal_position",Get column metadata
+redshift,tables,"SELECT table_name FROM information_schema.tables WHERE table_schema = '{schema}' AND table_type = 'BASE TABLE'",List tables in schema
+redshift,row_count,"SELECT COUNT(*) FROM ""{schema}"".""{table}""",Count rows in table
+redshift,primary_key,"SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name WHERE tc.table_schema = '{schema}' AND tc.table_name = '{table}' AND tc.constraint_type = 'PRIMARY KEY'",Get primary key columns
+oracle,columns,"SELECT column_name, data_type, nullable as is_nullable, column_id as ordinal_position FROM all_tab_columns WHERE owner = UPPER('{schema}') AND table_name = UPPER('{table}') ORDER BY column_id",Get column metadata
+oracle,tables,"SELECT table_name FROM all_tables WHERE owner = UPPER('{schema}')",List tables in schema
+oracle,row_count,"SELECT COUNT(*) FROM ""{schema}"".""{table}""",Count rows in table
+oracle,primary_key,"SELECT cols.column_name FROM all_constraints cons JOIN all_cons_columns cols ON cons.constraint_name = cols.constraint_name WHERE cons.owner = UPPER('{schema}') AND cons.table_name = UPPER('{table}') AND cons.constraint_type = 'P'",Get primary key columns
+sqlserver,columns,"SELECT column_name, data_type, is_nullable, ordinal_position FROM information_schema.columns WHERE table_schema = '{schema}' AND table_name = '{table}' ORDER BY ordinal_position",Get column metadata
+sqlserver,tables,"SELECT table_name FROM information_schema.tables WHERE table_schema = '{schema}' AND table_type = 'BASE TABLE'",List tables in schema
+sqlserver,row_count,"SELECT COUNT(*) FROM [{schema}].[{table}]",Count rows in table
+sqlserver,primary_key,"SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name WHERE tc.table_schema = '{schema}' AND tc.table_name = '{table}' AND tc.constraint_type = 'PRIMARY KEY'",Get primary key columns
+databricks,columns,"SELECT column_name, data_type, is_nullable, ordinal_position FROM information_schema.columns WHERE table_schema = '{schema}' AND table_name = '{table}' ORDER BY ordinal_position",Get column metadata
+databricks,tables,"SELECT table_name FROM information_schema.tables WHERE table_schema = '{schema}' AND table_type IN ('BASE TABLE', 'MANAGED', 'EXTERNAL')",List tables in schema
+databricks,row_count,"SELECT COUNT(*) FROM `{schema}`.`{table}`",Count rows in table
+databricks,primary_key,"SELECT column_name FROM system.information_schema.table_constraints tc JOIN system.information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name WHERE tc.table_schema = '{schema}' AND tc.table_name = '{table}' AND tc.constraint_type = 'PRIMARY KEY'",Get primary key columns

dbt/include/data/csv/syntax_rules.csv

@@ -0,0 +1,9 @@
+adapter_name,quote_start,quote_end,case_sensitivity,reserved_keywords
+postgres,"""","""",lowercase,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,INDEX,VIEW,SCHEMA,DATABASE,USER,GRANT,REVOKE,AND,OR,NOT,NULL,TRUE,FALSE,IN,BETWEEN,LIKE,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,FULL,CROSS,UNION,EXCEPT,INTERSECT,ORDER,BY,GROUP,HAVING,LIMIT,OFFSET,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF"
+snowflake,"""","""",uppercase,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,INDEX,VIEW,SCHEMA,DATABASE,USER,GRANT,REVOKE,AND,OR,NOT,NULL,TRUE,FALSE,IN,BETWEEN,LIKE,ILIKE,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,FULL,CROSS,UNION,EXCEPT,INTERSECT,MINUS,ORDER,BY,GROUP,HAVING,LIMIT,OFFSET,FETCH,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF,IFF,QUALIFY,PIVOT,UNPIVOT,LATERAL,FLATTEN,VARIANT,OBJECT,ARRAY"
+mysql,`,`,lowercase,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,INDEX,VIEW,SCHEMA,DATABASE,USER,GRANT,REVOKE,AND,OR,NOT,NULL,TRUE,FALSE,IN,BETWEEN,LIKE,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,CROSS,UNION,ORDER,BY,GROUP,HAVING,LIMIT,OFFSET,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF,IF,IFNULL,DIV,MOD,XOR,REGEXP,RLIKE"
+bigquery,`,`,lowercase,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,VIEW,SCHEMA,DATASET,PROJECT,AND,OR,NOT,NULL,TRUE,FALSE,IN,BETWEEN,LIKE,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,FULL,CROSS,UNION,EXCEPT,INTERSECT,ORDER,BY,GROUP,HAVING,LIMIT,OFFSET,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF,IF,IFNULL,STRUCT,ARRAY,UNNEST,PARTITION,CLUSTER,TABLESAMPLE"
+redshift,"""","""",lowercase,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,INDEX,VIEW,SCHEMA,DATABASE,USER,GRANT,REVOKE,AND,OR,NOT,NULL,TRUE,FALSE,IN,BETWEEN,LIKE,ILIKE,SIMILAR,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,FULL,CROSS,UNION,EXCEPT,INTERSECT,ORDER,BY,GROUP,HAVING,LIMIT,OFFSET,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF,NVL,NVL2,DECODE,DISTKEY,SORTKEY,DISTSTYLE"
+oracle,"""","""",uppercase,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,INDEX,VIEW,SCHEMA,USER,GRANT,REVOKE,AND,OR,NOT,NULL,IN,BETWEEN,LIKE,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,FULL,CROSS,UNION,EXCEPT,INTERSECT,MINUS,ORDER,BY,GROUP,HAVING,FETCH,FIRST,NEXT,ROWS,ONLY,OFFSET,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF,NVL,NVL2,DECODE,CONNECT,START,WITH,PRIOR,LEVEL,ROWNUM,ROWID,SYSDATE,SYSTIMESTAMP,DUAL"
+sqlserver,[,],case_insensitive,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,INDEX,VIEW,SCHEMA,DATABASE,USER,GRANT,REVOKE,AND,OR,NOT,NULL,IN,BETWEEN,LIKE,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,FULL,CROSS,UNION,EXCEPT,INTERSECT,ORDER,BY,GROUP,HAVING,TOP,OFFSET,FETCH,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF,ISNULL,IIF,CHOOSE,PIVOT,UNPIVOT,APPLY,CROSS,OUTER,GO,USE,EXEC,EXECUTE,PRINT,DECLARE,SET,BEGIN,COMMIT,ROLLBACK"
+databricks,`,`,case_insensitive,"SELECT,FROM,WHERE,INSERT,UPDATE,DELETE,CREATE,DROP,ALTER,TABLE,INDEX,VIEW,SCHEMA,DATABASE,CATALOG,AND,OR,NOT,NULL,TRUE,FALSE,IN,BETWEEN,LIKE,ILIKE,RLIKE,IS,AS,ON,JOIN,LEFT,RIGHT,INNER,OUTER,FULL,CROSS,SEMI,ANTI,UNION,EXCEPT,INTERSECT,ORDER,BY,GROUP,HAVING,LIMIT,OFFSET,DISTINCT,ALL,ANY,EXISTS,CASE,WHEN,THEN,ELSE,END,CAST,COALESCE,NULLIF,IF,IFNULL,NVL,STRUCT,ARRAY,MAP,LATERAL,EXPLODE,POSEXPLODE,INLINE,STACK,TABLESAMPLE,PIVOT,UNPIVOT,DISTRIBUTE,CLUSTER,SORT"

dbt/include/data/csv/type_mappings_bigquery.csv

@@ -0,0 +1,28 @@
+adapter_type,spark_type,spark_version,is_complex,cast_expression,notes
+STRING,StringType,all,false,,Variable-length Unicode string
+BYTES,BinaryType,all,false,,Variable-length binary
+INT64,LongType,all,false,,64-bit signed integer
+INTEGER,LongType,all,false,,Alias for INT64
+INT,LongType,all,false,,Alias for INT64
+SMALLINT,LongType,all,false,,Alias for INT64
+BIGINT,LongType,all,false,,Alias for INT64
+TINYINT,LongType,all,false,,Alias for INT64
+BYTEINT,LongType,all,false,,Alias for INT64
+FLOAT64,DoubleType,all,false,,64-bit floating point
+FLOAT,DoubleType,all,false,,Alias for FLOAT64
+NUMERIC,DecimalType,all,false,,Exact numeric (precision 38 scale 9)
+DECIMAL,DecimalType,all,false,,Alias for NUMERIC
+BIGNUMERIC,DecimalType,all,false,,High precision numeric (76.76)
+BIGDECIMAL,DecimalType,all,false,,Alias for BIGNUMERIC
+BOOL,BooleanType,all,false,,Boolean true/false
+BOOLEAN,BooleanType,all,false,,Alias for BOOL
+DATE,DateType,all,false,,Calendar date
+TIME,StringType,all,false,,Time of day
+DATETIME,TimestampType,all,false,,Date and time without timezone
+TIMESTAMP,TimestampType,all,false,,Date and time with timezone
+INTERVAL,StringType,all,false,,Time interval
+GEOGRAPHY,StringType,all,false,,Geographic data (GeoJSON)
+JSON,StringType,all,true,TO_JSON_STRING({}),JSON document
+STRUCT,StringType,all,true,TO_JSON_STRING({}),Structured record
+RECORD,StringType,all,true,TO_JSON_STRING({}),Alias for STRUCT
+ARRAY,ArrayType,all,true,,Array of values

dbt/include/data/csv/type_mappings_databricks.csv

@@ -0,0 +1,30 @@
+adapter_type,spark_type,spark_version,is_complex,cast_expression,notes
+STRING,StringType,all,false,,Variable-length string
+VARCHAR,StringType,all,false,,Variable-length string (alias)
+CHAR,StringType,all,false,,Fixed-length string
+BINARY,BinaryType,all,false,,Binary data
+TINYINT,ByteType,all,false,,8-bit signed integer
+BYTE,ByteType,all,false,,Alias for TINYINT
+SMALLINT,ShortType,all,false,,16-bit signed integer
+SHORT,ShortType,all,false,,Alias for SMALLINT
+INT,IntegerType,all,false,,32-bit signed integer
+INTEGER,IntegerType,all,false,,Alias for INT
+BIGINT,LongType,all,false,,64-bit signed integer
+LONG,LongType,all,false,,Alias for BIGINT
+FLOAT,FloatType,all,false,,32-bit floating point
+REAL,FloatType,all,false,,Alias for FLOAT
+DOUBLE,DoubleType,all,false,,64-bit floating point
+DECIMAL,DecimalType,all,false,,Exact numeric with precision
+DEC,DecimalType,all,false,,Alias for DECIMAL
+NUMERIC,DecimalType,all,false,,Alias for DECIMAL
+BOOLEAN,BooleanType,all,false,,True/false value
+DATE,DateType,all,false,,Calendar date
+TIMESTAMP,TimestampType,all,false,,Timestamp without timezone
+TIMESTAMP_NTZ,TimestampType,all,false,,Timestamp no timezone (explicit)
+TIMESTAMP_LTZ,TimestampType,all,false,,Timestamp with local timezone
+INTERVAL,StringType,all,false,,Time interval
+ARRAY,ArrayType,all,true,,Array of elements
+MAP,MapType,all,true,TO_JSON({}),Key-value pairs
+STRUCT,StringType,all,true,TO_JSON({}),Structured record
+VARIANT,StringType,all,true,TO_JSON({}),Semi-structured (Unity Catalog)
+OBJECT,StringType,all,true,TO_JSON({}),Object type (Unity Catalog)