pytrilogy 0.0.1.102__py3-none-any.whl

trilogy/dialect/bigquery.py

@@ -0,0 +1,80 @@
+from typing import Mapping, Callable, Any
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, WindowType, UnnestMode
+from trilogy.dialect.base import BaseDialect
+
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda x: f"count({x[0]})",
+    FunctionType.SUM: lambda x: f"sum({x[0]})",
+    FunctionType.LENGTH: lambda x: f"length({x[0]})",
+    FunctionType.AVG: lambda x: f"avg({x[0]})",
+    FunctionType.LIKE: lambda x: (
+        f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
+    ),
+    FunctionType.MINUTE: lambda x: f"EXTRACT(MINUTE from {x[0]})",
+    FunctionType.SECOND: lambda x: f"EXTRACT(SECOND from {x[0]})",
+    FunctionType.HOUR: lambda x: f"EXTRACT(HOUR from {x[0]})",
+    FunctionType.DAY_OF_WEEK: lambda x: f"EXTRACT(DAYOFWEEK from {x[0]})",
+    FunctionType.DAY: lambda x: f"EXTRACT(DAY from {x[0]})",
+    FunctionType.YEAR: lambda x: f"EXTRACT(YEAR from {x[0]})",
+    FunctionType.MONTH: lambda x: f"EXTRACT(MONTH from {x[0]})",
+    FunctionType.WEEK: lambda x: f"EXTRACT(WEEK from {x[0]})",
+    FunctionType.QUARTER: lambda x: f"EXTRACT(QUARTER from {x[0]})",
+    # math
+    FunctionType.DIVIDE: lambda x: f"COALESCE(SAFE_DIVIDE({x[0]},{x[1]}),0)",
+    FunctionType.DATE_ADD: lambda x: f"DATE_ADD({x[0]}, INTERVAL {x[2]} {x[1]})",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT: lambda args: f"{args[0]}",
+    FunctionType.SUM: lambda args: f"{args[0]}",
+    FunctionType.AVG: lambda args: f"{args[0]}",
+}
+
+BQ_SQL_TEMPLATE = Template(
+    """{%- if output %}
+CREATE OR REPLACE 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 %}
+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 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 %}
+"""
+)
+MAX_IDENTIFIER_LENGTH = 50
+
+
+class BigqueryDialect(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 = BQ_SQL_TEMPLATE
+    UNNEST_MODE = UnnestMode.CROSS_JOIN

trilogy/dialect/common.py

@@ -0,0 +1,43 @@
+from trilogy.core.models import Join, InstantiatedUnnestJoin, CTE, Concept
+from trilogy.core.enums import UnnestMode, Modifier
+from typing import Optional, Callable
+
+
+def null_wrapper(lval: str, rval: str, concept: Concept) -> str:
+    if concept.modifiers and Modifier.NULLABLE in concept.modifiers:
+        return f"(({lval} is null and {rval} is null) or ({lval} = {rval}))"
+    return f"{lval} = {rval}"
+
+
+def render_join(
+    join: Join | InstantiatedUnnestJoin,
+    quote_character: str,
+    render_func: Optional[Callable[[Concept, CTE, bool], str]] = None,
+    cte: Optional[CTE] = None,
+    unnest_mode: UnnestMode = UnnestMode.CROSS_APPLY,
+) -> str | None:
+    # {% for key in join.joinkeys %}{{ key.inner }} = {{ key.outer}}{% endfor %}
+    if isinstance(join, InstantiatedUnnestJoin):
+        if unnest_mode == UnnestMode.DIRECT:
+            return None
+        if not render_func:
+            raise ValueError("must provide a render func to build an unnest joins")
+        if not cte:
+            raise ValueError("must provide a cte to build an unnest joins")
+        if unnest_mode == UnnestMode.CROSS_JOIN:
+            return f"CROSS JOIN {render_func(join.concept, cte, False)} as {quote_character}{join.concept.safe_address}{quote_character}"
+
+        return f"FULL JOIN {render_func(join.concept, cte, False)} as unnest_wrapper({quote_character}{join.concept.safe_address}{quote_character})"
+
+    base_joinkeys = [
+        null_wrapper(
+            f"{join.left_cte.name}.{quote_character}{key.concept.safe_address}{quote_character}",
+            f"{join.right_cte.name}.{quote_character}{key.concept.safe_address}{quote_character}",
+            key.concept,
+        )
+        for key in join.joinkeys
+    ]
+    if not base_joinkeys:
+        base_joinkeys = ["1=1"]
+    joinkeys = " AND ".join(base_joinkeys)
+    return f"{join.jointype.value.upper()} JOIN {join.right_cte.name} on {joinkeys}"

trilogy/dialect/config.py

@@ -0,0 +1,55 @@
+class DialectConfig:
+    pass
+
+
+class DuckDBConfig(DialectConfig):
+    def __init__(self, path: str | None = None):
+        self.path = path
+
+    def connection_string(self) -> str:
+        if not self.path:
+            return "duckdb:///:memory:"
+        return f"duckdb:///{self.path}"
+
+
+class PostgresConfig(DialectConfig):
+    def __init__(
+        self, host: str, port: int, username: str, password: str, database: str
+    ):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.database = database
+
+    def connection_string(self) -> str:
+        return f"postgresql://{self.username}:{self.password}@{self.host}:{self.port}"
+
+
+class SQLServerConfig(DialectConfig):
+    def __init__(
+        self, host: str, port: int, username: str, password: str, database: str
+    ):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.database = database
+
+    def connection_string(self) -> str:
+        return f"sqlserver//{self.username}:{self.password}@{self.host}:{self.port}"
+
+
+class SnowflakeConfig(DialectConfig):
+    def __init__(
+        self,
+        account: str,
+        username: str,
+        password: str,
+    ):
+        self.account = account
+        self.username = username
+        self.password = password
+
+    def connection_string(self) -> str:
+        return f"snowflake://{self.username}:{self.password}@{self.account}"

trilogy/dialect/duckdb.py

@@ -0,0 +1,83 @@
+from typing import Mapping, Callable, Any
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, WindowType, UnnestMode
+from trilogy.dialect.base import BaseDialect
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda args: f"count({args[0]})",
+    FunctionType.SUM: lambda args: f"sum({args[0]})",
+    FunctionType.AVG: lambda args: f"avg({args[0]})",
+    FunctionType.LENGTH: lambda args: f"length({args[0]})",
+    FunctionType.LIKE: lambda args: (
+        f" CASE WHEN {args[0]} like {args[1]} THEN True ELSE False END"
+    ),
+    FunctionType.CONCAT: lambda args: (
+        f"CONCAT({','.join([f''' {str(a)} ''' for a in args])})"
+    ),
+    FunctionType.SPLIT: lambda args: (
+        f"STRING_SPLIT({','.join([f''' {str(a)} ''' for a in args])})"
+    ),
+    ## Duckdb indexes from 1, not 0
+    FunctionType.INDEX_ACCESS: lambda args: (f"{args[0]}[{args[1]}]"),
+    # datetime is aliased
+    FunctionType.CURRENT_DATETIME: lambda x: "cast(get_current_timestamp() as datetime)",
+    FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc('{x[1]}', {x[0]})",
+    FunctionType.DATE_ADD: lambda x: f"date_add({x[0]}, INTERVAL {x[2]} {x[1]})",
+    FunctionType.DATE_PART: lambda x: f"date_part('{x[1]}', {x[0]})",
+    FunctionType.DATE_DIFF: lambda x: f"date_diff('{x[2]}', {x[0]}, {x[1]})",
+    FunctionType.CONCAT: lambda x: f"({' || '.join(x)})",
+}
+
+# if an aggregate function is called on a source that is at the same grain as the aggregate
+# we may return a static value
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT: lambda args: "1",
+    FunctionType.SUM: lambda args: f"{args[0]}",
+    FunctionType.AVG: lambda args: f"{args[0]}",
+}
+
+DUCKDB_TEMPLATE = Template(
+    """{%- if output %}
+CREATE OR REPLACE 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 %}
+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 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 %}
+"""
+)
+
+
+class DuckDBDialect(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 = DUCKDB_TEMPLATE
+    UNNEST_MODE = UnnestMode.DIRECT

trilogy/dialect/enums.py

@@ -0,0 +1,95 @@
+from enum import Enum
+from typing import List, TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from trilogy.hooks.base_hook import BaseHook
+    from trilogy import Executor, Environment
+
+from trilogy.dialect.config import DialectConfig
+from trilogy.constants import logger
+
+
+class Dialects(Enum):
+    BIGQUERY = "bigquery"
+    SQL_SERVER = "sql_server"
+    DUCK_DB = "duck_db"
+    PRESTO = "presto"
+    TRINO = "trino"
+    POSTGRES = "postgres"
+    SNOWFLAKE = "snowflake"
+
+    @classmethod
+    def _missing_(cls, value):
+        if value == "duckdb":
+            return cls.DUCK_DB
+        return super()._missing_(value)
+
+    def default_engine(self, conf=None):
+        if self == Dialects.BIGQUERY:
+            from sqlalchemy import create_engine
+            from google.auth import default
+            from google.cloud import bigquery
+
+            credentials, project = default()
+            client = bigquery.Client(credentials=credentials, project=project)
+            return create_engine(
+                f"bigquery://{project}?user_supplied_client=True",
+                connect_args={"client": client},
+            )
+        elif self == Dialects.SQL_SERVER:
+            from sqlalchemy import create_engine
+
+            raise NotImplementedError()
+        elif self == Dialects.DUCK_DB:
+            from sqlalchemy import create_engine
+            from trilogy.dialect.config import DuckDBConfig
+
+            if not conf:
+                conf = DuckDBConfig()
+            if not isinstance(conf, DuckDBConfig):
+                raise TypeError("Invalid dialect configuration for type duck_db")
+            return create_engine(conf.connection_string(), future=True)
+        elif self == Dialects.SNOWFLAKE:
+            from sqlalchemy import create_engine
+            from trilogy.dialect.config import SnowflakeConfig
+
+            if not isinstance(conf, SnowflakeConfig):
+                raise TypeError("Invalid dialect configuration for type snowflake")
+            return create_engine(conf.connection_string(), future=True)
+        elif self == Dialects.POSTGRES:
+            logger.warn(
+                "WARN: Using experimental postgres dialect. Most functionality will not work."
+            )
+            import importlib
+
+            spec = importlib.util.find_spec("psycopg2")
+            if spec is None:
+                raise ImportError(
+                    "postgres driver not installed. python -m pip install pypreql[postgres]"
+                )
+            from sqlalchemy import create_engine
+            from trilogy.dialect.config import PostgresConfig
+
+            if not isinstance(conf, PostgresConfig):
+                raise TypeError("Invalid dialect configuration for type postgres")
+
+            return create_engine(conf.connection_string(), future=True)
+        else:
+            raise ValueError(
+                f"Unsupported dialect {self} for default engine creation; create one explicitly."
+            )
+
+    def default_executor(
+        self,
+        environment: Optional["Environment"] = None,
+        hooks: List["BaseHook"] | None = None,
+        conf: DialectConfig | None = None,
+    ) -> "Executor":
+        from trilogy import Executor, Environment
+
+        return Executor(
+            engine=self.default_engine(conf=conf),
+            environment=environment or Environment(),
+            dialect=self,
+            hooks=hooks,
+        )

trilogy/dialect/postgres.py

@@ -0,0 +1,86 @@
+from typing import Mapping, Callable, Any
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, WindowType, DatePart
+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: f"string_to_array({x[0]}, {x[1]})",
+    FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc('{x[1]}', {x[0]})",
+    FunctionType.DATE_ADD: lambda x: f"({x[0]} + INTERVAL '{x[2]} {x[1]}')",
+    FunctionType.DATE_PART: lambda x: f"date_part('{x[1]}', {x[0]})",
+    FunctionType.DATE_DIFF: lambda x: date_diff(x[0], x[1], x[2]),
+    FunctionType.IS_NULL: lambda x: f"{x[0]} IS NULL",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT: lambda args: f"{args[0]}",
+    FunctionType.SUM: lambda args: f"{args[0]}",
+    FunctionType.AVG: lambda args: 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 %}
+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 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 %}
+"""
+)
+
+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

trilogy/dialect/presto.py

@@ -0,0 +1,82 @@
+from typing import Mapping, Callable, Any
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, WindowType
+from trilogy.dialect.base import BaseDialect
+
+
+WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
+
+FUNCTION_MAP = {
+    FunctionType.COUNT: lambda x: f"count({x[0]})",
+    FunctionType.SUM: lambda x: f"sum({x[0]})",
+    FunctionType.LENGTH: lambda x: f"length({x[0]})",
+    FunctionType.AVG: lambda x: f"avg({x[0]})",
+    FunctionType.LIKE: lambda x: (
+        f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
+    ),
+    FunctionType.MINUTE: lambda x: f"EXTRACT(MINUTE from {x[0]})",
+    FunctionType.SECOND: lambda x: f"EXTRACT(SECOND from {x[0]})",
+    FunctionType.HOUR: lambda x: f"EXTRACT(HOUR from {x[0]})",
+    FunctionType.DAY_OF_WEEK: lambda x: f"EXTRACT(DAYOFWEEK from {x[0]})",
+    FunctionType.DAY: lambda x: f"EXTRACT(DAY from {x[0]})",
+    FunctionType.YEAR: lambda x: f"EXTRACT(YEAR from {x[0]})",
+    FunctionType.MONTH: lambda x: f"EXTRACT(MONTH from {x[0]})",
+    FunctionType.WEEK: lambda x: f"EXTRACT(WEEK from {x[0]})",
+    FunctionType.QUARTER: lambda x: f"EXTRACT(QUARTER from {x[0]})",
+    # math
+    FunctionType.DIVIDE: lambda x: f"SAFE_DIVIDE({x[0]},{x[1]})",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT: lambda args: f"{args[0]}",
+    FunctionType.SUM: lambda args: f"{args[0]}",
+    FunctionType.AVG: lambda args: f"{args[0]}",
+}
+
+SQL_TEMPLATE = Template(
+    """{%- if output %}
+CREATE OR REPLACE TABLE {{ output.address }} AS
+{% endif %}{%- if ctes %}
+WITH {% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+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 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 %}
+"""
+)
+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
+
+
+class TrinoDialect(PrestoDialect):
+    pass

trilogy/dialect/snowflake.py

@@ -0,0 +1,82 @@
+from typing import Mapping, Callable, Any
+
+from jinja2 import Template
+
+from trilogy.core.enums import FunctionType, WindowType, UnnestMode
+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: f"count({x[0]})",
+    FunctionType.SUM: lambda x: f"sum({x[0]})",
+    FunctionType.LENGTH: lambda x: f"length({x[0]})",
+    FunctionType.AVG: lambda x: f"avg({x[0]})",
+    FunctionType.LIKE: lambda x: (
+        f" CASE WHEN {x[0]} like {x[1]} THEN True ELSE False END"
+    ),
+    FunctionType.MINUTE: lambda x: f"EXTRACT(MINUTE from {x[0]})",
+    FunctionType.SECOND: lambda x: f"EXTRACT(SECOND from {x[0]})",
+    FunctionType.HOUR: lambda x: f"EXTRACT(HOUR from {x[0]})",
+    FunctionType.DAY_OF_WEEK: lambda x: f"EXTRACT(DAYOFWEEK from {x[0]})",
+    FunctionType.DAY: lambda x: f"EXTRACT(DAY from {x[0]})",
+    FunctionType.YEAR: lambda x: f"EXTRACT(YEAR from {x[0]})",
+    FunctionType.MONTH: lambda x: f"EXTRACT(MONTH from {x[0]})",
+    FunctionType.WEEK: lambda x: f"EXTRACT(WEEK from {x[0]})",
+    FunctionType.QUARTER: lambda x: f"EXTRACT(QUARTER from {x[0]})",
+    # math
+    FunctionType.DIVIDE: lambda x: f"DIV0({x[0]},{x[1]})",
+}
+
+FUNCTION_GRAIN_MATCH_MAP = {
+    **FUNCTION_MAP,
+    FunctionType.COUNT: lambda args: f"{args[0]}",
+    FunctionType.SUM: lambda args: f"{args[0]}",
+    FunctionType.AVG: lambda args: f"{args[0]}",
+}
+
+BQ_SQL_TEMPLATE = Template(
+    """{%- if output %}
+CREATE OR REPLACE 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 %}
+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 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 %}
+"""
+)
+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 = BQ_SQL_TEMPLATE
+    UNNEST_MODE = UnnestMode.CROSS_JOIN