pytrilogy 0.3.142__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

trilogy/dialect/mock.py

@@ -0,0 +1,190 @@
+import random
+from datetime import date, datetime
+from typing import TYPE_CHECKING, Any, Iterable
+
+from trilogy.core.enums import Purpose
+from trilogy.core.models.author import Concept, ConceptRef
+from trilogy.core.models.core import CONCRETE_TYPES, ArrayType, DataType, TraitDataType
+from trilogy.core.models.datasource import Address, Datasource
+from trilogy.core.models.environment import Environment
+from trilogy.core.statements.execute import ProcessedMockStatement
+from trilogy.dialect.results import MockResult
+
+if TYPE_CHECKING:
+    from pyarrow import Table
+
+DEFAULT_SCALE_FACTOR = 100
+
+
+def safe_name(name: str) -> str:
+    return "".join(c if c.isalnum() or c == "_" else "_" for c in name)
+
+
+def mock_email(scale_factor: int, is_key: bool = False) -> list[str]:
+    providers = ["example.com", "test.com", "mock.com", "sample.org"]
+    if is_key:
+        return [
+            f"user{i}@{providers[i % len(providers)]}"
+            for i in range(1, scale_factor + 1)
+        ]
+    return [
+        f"user{random.randint(1, 999999)}@{random.choice(providers)}"
+        for _ in range(scale_factor)
+    ]
+
+
+def mock_hex_code(scale_factor: int, is_key: bool = False) -> list[str]:
+    if is_key:
+        return [f"#{i:06x}" for i in range(1, scale_factor + 1)]
+    return [f"#{random.randint(0, 0xFFFFFF):06x}" for _ in range(scale_factor)]
+
+
+def mock_datatype(
+    full_type: Any, datatype: CONCRETE_TYPES, scale_factor: int, is_key: bool = False
+) -> list[Any]:
+    if isinstance(full_type, TraitDataType):
+        if full_type.type == DataType.STRING:
+            # TODO: get stdlib inventory some other way?
+            if full_type.traits == ["email_address"]:
+                # email mock function
+                return mock_email(scale_factor, is_key)
+            elif full_type.traits == ["hex"]:
+                return mock_hex_code(scale_factor, is_key)
+        return mock_datatype(full_type.type, full_type.type, scale_factor, is_key)
+    elif datatype == DataType.INTEGER:
+        if is_key:
+            # unique integers for keys
+            return list(range(1, scale_factor + 1))
+        return [random.randint(0, 999_999) for _ in range(scale_factor)]
+    elif datatype == DataType.STRING:
+        if is_key:
+            # unique strings for keys
+            return [f"key_{i}" for i in range(1, scale_factor + 1)]
+        return [
+            f"mock_string_{random.randint(0, 999_999)}" for _ in range(scale_factor)
+        ]
+    elif datatype == DataType.FLOAT:
+        if is_key:
+            # unique floats for keys
+            return [float(i) for i in range(1, scale_factor + 1)]
+        return [random.uniform(0, 999_999) for _ in range(scale_factor)]
+    elif datatype == DataType.NUMERIC:
+        if is_key:
+            # unique numerics for keys
+            return [float(i) for i in range(1, scale_factor + 1)]
+        return [round(random.uniform(0, 999_999), 2) for _ in range(scale_factor)]
+    elif datatype == DataType.BOOL:
+        # booleans can only have 2 unique values, so keys don't make sense here
+        return [random.choice([True, False]) for _ in range(scale_factor)]
+    elif datatype == DataType.DATE:
+        if is_key:
+            # unique dates for keys - spread across multiple months/years if needed
+            base_date = date(2023, 1, 1)
+            return [
+                date.fromordinal(base_date.toordinal() + i) for i in range(scale_factor)
+            ]
+        return [date(2023, 1, random.randint(1, 28)) for _ in range(scale_factor)]
+    elif datatype in (DataType.DATETIME, DataType.TIMESTAMP):
+        if is_key:
+            # unique datetimes for keys - increment by seconds
+            base_dt = datetime(2023, 1, 1, 0, 0, 0)
+            return [
+                datetime.fromtimestamp(base_dt.timestamp() + i)
+                for i in range(scale_factor)
+            ]
+        return [
+            datetime(
+                2023,
+                1,
+                1,
+                random.randint(0, 23),
+                random.randint(0, 59),
+                random.randint(0, 59),
+            )
+            for _ in range(scale_factor)
+        ]
+    elif isinstance(datatype, ArrayType):
+        # arrays as keys don't typically make sense, but generate unique if requested
+        if is_key:
+            return [
+                [mock_datatype(datatype.type, datatype.value_data_type, 5, False)[0], i]
+                for i in range(scale_factor)
+            ]
+        return [
+            [mock_datatype(datatype.type, datatype.value_data_type, 5, False)]
+            for _ in range(scale_factor)
+        ]
+    raise NotImplementedError(f"Mocking not implemented for datatype {datatype}")
+
+
+class MockManager:
+
+    def __init__(
+        self, environment: Environment, scale_factor: int = DEFAULT_SCALE_FACTOR
+    ):
+        self.environment = environment
+        self.concept_mocks: dict[str, Any] = {}
+        self.scale_factor = scale_factor
+
+    def mock_concept(self, concept: Concept | ConceptRef):
+        if concept.address in self.concept_mocks:
+            return False
+        concrete = self.environment.concepts[concept.address]
+        self.concept_mocks[concept.address] = mock_datatype(
+            concept.datatype,
+            concept.output_datatype,
+            self.scale_factor,
+            True if concrete.purpose == Purpose.KEY else False,
+        )
+        return True
+
+    def create_mock_table(
+        self, concepts: Iterable[Concept | ConceptRef], headers: list[str]
+    ) -> "Table":
+        from pyarrow import table
+
+        data = {h: self.concept_mocks[c.address] for h, c in zip(headers, concepts)}
+        return table(data)
+
+
+def handle_processed_mock_statement(
+    query: ProcessedMockStatement, environment: Environment, executor
+) -> MockResult:
+    """Handle processed mock statements."""
+    # For mock statements, we can simulate some output based on targets
+    mock_manager = MockManager(environment)
+    output = []
+    for target in query.targets:
+        datasource = environment.datasources.get(target)
+        if not datasource:
+            raise ValueError(f"Datasource {target} not found in environment")
+        mock_datasource(datasource, mock_manager, executor)
+        output.append(
+            {
+                "target": target,
+                "status": "mocked",
+            }
+        )
+    return MockResult(output, ["target", "status"])
+
+
+def mock_datasource(datasource: Datasource, manager: MockManager, executor):
+    concrete: list[ConceptRef] = []
+    headers: list[str] = []
+    for k, col in datasource.concrete_columns.items():
+        manager.mock_concept(col.concept)
+        concrete.append(col.concept)
+        headers.append(k)
+
+    table = manager.create_mock_table(concrete, headers)
+
+    # duckdb load the pyarrow table
+    executor.execute_raw_sql(
+        "register(:name, :tbl)", {"name": "mock_tbl", "tbl": table}
+    )
+    address = safe_name(datasource.safe_address)
+    executor.execute_raw_sql(
+        f"""CREATE OR REPLACE TABLE {address} AS SELECT * FROM mock_tbl"""
+    )
+    # overwrite the address since we've mangled the name
+    datasource.address = Address(location=address)

trilogy/dialect/postgres.py

@@ -0,0 +1,117 @@
+from typing import Any, Callable, Mapping
+
+from jinja2 import Template
+
+from trilogy.core.enums import DatePart, FunctionType, WindowType
+from trilogy.dialect.base import BaseDialect
+
+
+def date_diff(first: str, second: str, grain: DatePart) -> str:
+    grain = DatePart(grain)
+    if grain == DatePart.YEAR:
+        return f"date_part('year', {second}) - date_part('year', {first})"
+    elif grain == DatePart.MONTH:
+        return f"12 * {date_diff(first, second, DatePart.YEAR)} + date_part('month', {second}) - date_part('month', {first})"
+    elif grain == DatePart.DAY:
+        return f"date_part('day', {second} - {first})"
+    elif grain == DatePart.HOUR:
+        return f"{date_diff(first, second, DatePart.DAY)} *24 + date_part('hour', {second} - {first})"
+    elif grain == DatePart.MINUTE:
+        return f"{date_diff(first, second, DatePart.HOUR)} *60 + date_part('minute', {second} - {first})"
+    elif grain == DatePart.SECOND:
+        return f"{date_diff(first, second, DatePart.MINUTE)} *60 + date_part('second', {second} - {first})"
+    else:
+        raise NotImplementedError(f"Date diff not implemented for grain {grain}")
+
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.SPLIT: lambda x, types: f"string_to_array({x[0]}, {x[1]})",
+    FunctionType.DATE_TRUNCATE: lambda x, types: f"date_trunc('{x[1]}', {x[0]})",
+    FunctionType.DATE_ADD: lambda x, types: f"({x[0]} + INTERVAL '{x[2]} {x[1]}')",
+    FunctionType.DATE_PART: lambda x, types: f"date_part('{x[1]}', {x[0]})",
+    FunctionType.DATE_DIFF: lambda x, types: date_diff(x[0], x[1], x[2]),
+    FunctionType.IS_NULL: lambda x, types: f"{x[0]} IS NULL",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT_DISTINCT: lambda args, types: f"CASE WHEN{args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.COUNT: lambda args, types: f"CASE WHEN {args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.SUM: lambda args, types: f"{args[0]}",
+    FunctionType.AVG: lambda args, types: f"{args[0]}",
+}
+
+PG_SQL_TEMPLATE = Template(
+    """{%- if output %}
+DROP TABLE IF EXISTS {{ output.address.location }};
+CREATE TABLE {{ output.address.location }} AS
+{% endif %}{%- if ctes %}
+WITH {% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if full_select -%}
+{{full_select}}
+{%- else -%}
+SELECT
+{%- for select in select_columns %}
+    {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
+{% if base %}FROM
+    {{ base }}{% endif %}{% if joins %}
+{% for join in joins %}
+{{ join }}
+{% endfor %}{% endif %}
+{% if where %}WHERE
+    {{ where }}
+{% endif %}
+{%- if group_by %}GROUP BY {% for group in group_by %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
+{%- if order_by %}
+ORDER BY {% for order in order_by %}
+    {{ order }}{% if not loop.last %},{% endif %}
+{% endfor %}{% endif %}
+{%- if limit is not none %}
+LIMIT {{ limit }}{% endif %}{% endif %}
+"""
+)
+
+MAX_IDENTIFIER_LENGTH = 50
+
+
+class PostgresDialect(BaseDialect):
+    WINDOW_FUNCTION_MAP = {**BaseDialect.WINDOW_FUNCTION_MAP, **WINDOW_FUNCTION_MAP}
+    FUNCTION_MAP = {**BaseDialect.FUNCTION_MAP, **FUNCTION_MAP}
+    FUNCTION_GRAIN_MATCH_MAP = {
+        **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
+        **FUNCTION_GRAIN_MATCH_MAP,
+    }
+    QUOTE_CHARACTER = '"'
+    SQL_TEMPLATE = PG_SQL_TEMPLATE
+
+    def get_table_primary_keys(
+        self, executor, table_name: str, schema: str | None = None
+    ) -> list[str]:
+        """Uses pg_catalog for more reliable constraint information than information_schema."""
+        if schema:
+            pk_query = f"""
+            SELECT a.attname
+            FROM pg_index i
+            JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+            WHERE i.indrelid = '{schema}.{table_name}'::regclass
+            AND i.indisprimary
+            ORDER BY a.attnum
+            """
+        else:
+            pk_query = f"""
+            SELECT a.attname
+            FROM pg_index i
+            JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+            WHERE i.indrelid = '{table_name}'::regclass
+            AND i.indisprimary
+            ORDER BY a.attnum
+            """
+
+        rows = executor.execute_raw_sql(pk_query).fetchall()
+        return [row[0] for row in rows]

trilogy/dialect/presto.py

@@ -0,0 +1,110 @@
+from typing import Any, Callable, Mapping
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, GroupMode, UnnestMode, WindowType
+from trilogy.core.models.core import DataType
+from trilogy.dialect.base import BaseDialect
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda x, types: f"count({x[0]})",
+    FunctionType.SUM: lambda x, types: f"sum({x[0]})",
+    FunctionType.LENGTH: lambda x, types: f"length({x[0]})",
+    FunctionType.AVG: lambda x, types: f"avg({x[0]})",
+    FunctionType.INDEX_ACCESS: lambda x, types: f"element_at({x[0]},{x[1]})",
+    FunctionType.MAP_ACCESS: lambda x, types: f"{x[0]}[{x[1]}]",
+    FunctionType.LIKE: lambda x, types: (
+        f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
+    ),
+    FunctionType.MINUTE: lambda x, types: f"EXTRACT(MINUTE from {x[0]})",
+    FunctionType.SECOND: lambda x, types: f"EXTRACT(SECOND from {x[0]})",
+    FunctionType.HOUR: lambda x, types: f"EXTRACT(HOUR from {x[0]})",
+    FunctionType.DAY_OF_WEEK: lambda x, types: f"EXTRACT(DAYOFWEEK from {x[0]})",
+    FunctionType.DAY: lambda x, types: f"EXTRACT(DAY from {x[0]})",
+    FunctionType.YEAR: lambda x, types: f"EXTRACT(YEAR from {x[0]})",
+    FunctionType.MONTH: lambda x, types: f"EXTRACT(MONTH from {x[0]})",
+    FunctionType.WEEK: lambda x, types: f"EXTRACT(WEEK from {x[0]})",
+    FunctionType.QUARTER: lambda x, types: f"EXTRACT(QUARTER from {x[0]})",
+    # math
+    FunctionType.DIVIDE: lambda x, types: f"{x[0]}/{x[1]}",
+    FunctionType.DATE_ADD: lambda x, types: f"DATE_ADD('{x[1]}', {x[2]}, {x[0]})",
+    FunctionType.CURRENT_DATE: lambda x, types: "CURRENT_DATE",
+    FunctionType.CURRENT_DATETIME: lambda x, types: "CURRENT_TIMESTAMP",
+    FunctionType.ARRAY: lambda x, types: f"ARRAY[{', '.join(x)}]",
+    # regex
+    FunctionType.REGEXP_CONTAINS: lambda x, types: f"REGEXP_LIKE({x[0]}, {x[1]})",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT_DISTINCT: lambda args, types: f"CASE WHEN{args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.COUNT: lambda args, types: f"CASE WHEN {args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.SUM: lambda args, types: f"{args[0]}",
+    FunctionType.AVG: lambda args, types: f"{args[0]}",
+}
+
+SQL_TEMPLATE = Template(
+    """{%- if output %}
+{{output}}
+{% endif %}{%- if ctes %}
+WITH {% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if full_select -%}
+{{full_select}}
+{%- else -%}
+SELECT
+{%- for select in select_columns %}
+    {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
+{% if base %}FROM
+    {{ base }}{% endif %}{% if joins %}
+{% for join in joins %}
+{{ join }}
+{% endfor %}{% endif %}
+{% if where %}WHERE
+    {{ where }}
+{% endif %}
+{%- if group_by %}GROUP BY {% for group in group_by %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
+{%- if order_by %}
+ORDER BY {% for order in order_by %}
+    {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if limit is not none %}
+LIMIT {{ limit }}{% endif %}{% endif %}
+"""
+)
+MAX_IDENTIFIER_LENGTH = 50
+
+
+class PrestoDialect(BaseDialect):
+    WINDOW_FUNCTION_MAP = {**BaseDialect.WINDOW_FUNCTION_MAP, **WINDOW_FUNCTION_MAP}
+    FUNCTION_MAP = {**BaseDialect.FUNCTION_MAP, **FUNCTION_MAP}
+    FUNCTION_GRAIN_MATCH_MAP = {
+        **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
+        **FUNCTION_GRAIN_MATCH_MAP,
+    }
+    QUOTE_CHARACTER = '"'
+    SQL_TEMPLATE = SQL_TEMPLATE
+    DATATYPE_MAP = {
+        **BaseDialect.DATATYPE_MAP,
+        DataType.NUMERIC: "DECIMAL",
+        DataType.STRING: "VARCHAR",
+    }
+    UNNEST_MODE = UnnestMode.PRESTO
+    GROUP_MODE = GroupMode.BY_INDEX
+    ALIAS_ORDER_REFERENCING_ALLOWED = (
+        False  # some complex presto functions don't support aliasing
+    )
+
+    def get_table_primary_keys(
+        self, executor, table_name: str, schema: str | None = None
+    ) -> list[str]:
+        """Presto/Trino don't enforce PKs; rely on data-driven grain detection."""
+        return []
+
+
+class TrinoDialect(PrestoDialect):
+    pass

trilogy/dialect/results.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from typing import Any, List
+
+from trilogy.core.models.author import ConceptRef
+from trilogy.engine import ResultProtocol
+
+
+@dataclass
+class MockResult(ResultProtocol):
+    values: list["MockResultRow"]
+    columns: list[str]
+
+    def __init__(self, values: list[Any], columns: list[str]):
+        processed: list[MockResultRow] = []
+        for x in values:
+            if isinstance(x, dict):
+                processed.append(MockResultRow(x))
+            elif isinstance(x, MockResultRow):
+                processed.append(x)
+            else:
+                raise ValueError(
+                    f"Cannot process value of type {type(x)} in MockResult"
+                )
+        self.columns = columns
+        self.values = processed
+
+    def __iter__(self):
+        while self.values:
+            yield self.values.pop(0)
+
+    def fetchall(self):
+        return self.values
+
+    def fetchone(self):
+        if self.values:
+            return self.values.pop(0)
+        return None
+
+    def fetchmany(self, size: int):
+        rval = self.values[:size]
+        self.values = self.values[size:]
+        return rval
+
+    def keys(self):
+        return self.columns
+
+    def as_dict(self):
+        return [x.as_dict() if isinstance(x, MockResultRow) else x for x in self.values]
+
+
+@dataclass
+class MockResultRow:
+    _values: dict[str, Any]
+
+    def as_dict(self):
+        return self._values
+
+    def __str__(self) -> str:
+        return str(self._values)
+
+    def __repr__(self) -> str:
+        return repr(self._values)
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self._values:
+            return self._values[name]
+        return super().__getattribute__(name)
+
+    def __getitem__(self, key: str) -> Any:
+        return self._values[key]
+
+    def __iter__(self):
+        return iter(self._values.values())
+
+    def values(self):
+        return self._values.values()
+
+    def keys(self):
+        return self._values.keys()
+
+
+def generate_result_set(
+    columns: List[ConceptRef], output_data: list[Any]
+) -> MockResult:
+    """Generate a mock result set from columns and output data."""
+    names = [x.address.replace(".", "_") for x in columns]
+    return MockResult(
+        values=[dict(zip(names, [row])) for row in output_data], columns=names
+    )

trilogy/dialect/snowflake.py

@@ -0,0 +1,129 @@
+from typing import Any, Callable, Mapping
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, UnnestMode, WindowType
+from trilogy.dialect.base import BaseDialect
+
+ENV_SNOWFLAKE_PW = "PREQL_SNOWFLAKE_PW"
+ENV_SNOWFLAKE_USER = "PREQL_SNOWFLAKE_USER"
+ENV_SNOWFLAKE_ACCOUNT = "PREQL_SNOWFLAKE_ACCOUNT"
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda x, types: f"count({x[0]})",
+    FunctionType.SUM: lambda x, types: f"sum({x[0]})",
+    FunctionType.LENGTH: lambda x, types: f"length({x[0]})",
+    FunctionType.AVG: lambda x, types: f"avg({x[0]})",
+    FunctionType.LIKE: lambda x, types: (
+        f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
+    ),
+    FunctionType.MINUTE: lambda x, types: f"EXTRACT(MINUTE from {x[0]})",
+    FunctionType.SECOND: lambda x, types: f"EXTRACT(SECOND from {x[0]})",
+    FunctionType.HOUR: lambda x, types: f"EXTRACT(HOUR from {x[0]})",
+    FunctionType.DAY_OF_WEEK: lambda x, types: f"EXTRACT(DAYOFWEEK from {x[0]})",
+    FunctionType.DAY: lambda x, types: f"EXTRACT(DAY from {x[0]})",
+    FunctionType.YEAR: lambda x, types: f"EXTRACT(YEAR from {x[0]})",
+    FunctionType.MONTH: lambda x, types: f"EXTRACT(MONTH from {x[0]})",
+    FunctionType.WEEK: lambda x, types: f"EXTRACT(WEEK from {x[0]})",
+    FunctionType.QUARTER: lambda x, types: f"EXTRACT(QUARTER from {x[0]})",
+    # math
+    FunctionType.POWER: lambda x, types: f"POWER({x[0]}, {x[1]})",
+    FunctionType.DIVIDE: lambda x, types: f"DIV0({x[0]},{x[1]})",
+    FunctionType.UNNEST: lambda x, types: f"table(flatten({x[0]}))",
+    FunctionType.ARRAY: lambda x, types: f"ARRAY_CONSTRUCT({', '.join(x)})",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT_DISTINCT: lambda args, types: f"CASE WHEN{args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.COUNT: lambda args, types: f"CASE WHEN {args[0]} IS NOT NULL THEN 1 ELSE 0 END",
+    FunctionType.SUM: lambda args, types: f"{args[0]}",
+    FunctionType.AVG: lambda args, types: f"{args[0]}",
+}
+
+
+SNOWFLAKE_SQL_TEMPLATE = Template(
+    """{%- if output %}
+{{output}}
+{% endif %}{%- if ctes %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
+"{{cte.name}}" as ({{cte.statement}}){% if not loop.last %},{% endif %}{% else %}
+{% endfor %}{% endif %}
+{%- if full_select -%}
+{{full_select}}
+{%- else -%}
+
+SELECT
+{%- for select in select_columns %}
+    {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
+{% if base %}FROM
+    {{ base }}{% endif %}{% if joins %}{% for join in joins %}
+    {{ join }}{% endfor %}{% endif %}
+{% if where %}WHERE
+    {{ where }}
+{% endif %}
+{%- if group_by %}GROUP BY {% for group in group_by %}
+    {{group}}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{% if having %}
+HAVING
+\t{{ having }}{% endif %}
+{%- if order_by %}
+ORDER BY {% for order in order_by %}
+    {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+{%- if limit is not none %}
+LIMIT {{ limit }}{% endif %}{% endif %}
+"""
+)
+MAX_IDENTIFIER_LENGTH = 50
+
+
+class SnowflakeDialect(BaseDialect):
+    WINDOW_FUNCTION_MAP = {**BaseDialect.WINDOW_FUNCTION_MAP, **WINDOW_FUNCTION_MAP}
+    FUNCTION_MAP = {**BaseDialect.FUNCTION_MAP, **FUNCTION_MAP}
+    FUNCTION_GRAIN_MATCH_MAP = {
+        **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
+        **FUNCTION_GRAIN_MATCH_MAP,
+    }
+    QUOTE_CHARACTER = '"'
+    SQL_TEMPLATE = SNOWFLAKE_SQL_TEMPLATE
+    UNNEST_MODE = UnnestMode.SNOWFLAKE
+
+    def get_table_schema(
+        self, executor, table_name: str, schema: str | None = None
+    ) -> list[tuple]:
+        """Snowflake requires uppercase identifiers unless quoted."""
+        table_name_upper = table_name.upper()
+
+        column_query = f"""
+        SELECT
+            column_name,
+            data_type,
+            is_nullable,
+            comment as column_comment
+        FROM information_schema.columns
+        WHERE table_name = '{table_name_upper}'
+        """
+        if schema:
+            schema_upper = schema.upper()
+            column_query += f" AND table_schema = '{schema_upper}'"
+        column_query += " ORDER BY ordinal_position"
+
+        rows = executor.execute_raw_sql(column_query).fetchall()
+        return rows
+
+    def get_table_primary_keys(
+        self, executor, table_name: str, schema: str | None = None
+    ) -> list[str]:
+        """Uses SHOW PRIMARY KEYS; note Snowflake PKs are not enforced."""
+        table_name_upper = table_name.upper()
+
+        # Use SHOW PRIMARY KEYS command (column_name is at index 4)
+        if schema:
+            schema_upper = schema.upper()
+            pk_query = f"SHOW PRIMARY KEYS IN {schema_upper}.{table_name_upper}"
+        else:
+            pk_query = f"SHOW PRIMARY KEYS IN {table_name_upper}"
+
+        rows = executor.execute_raw_sql(pk_query).fetchall()
+        return [row[4] for row in rows] if rows else []