lexis-cli 0.4.2__py3-none-any.whl

lexis/transpilers/dbt_ossie.py

@@ -0,0 +1,67 @@
+"""Package an OssieDocument for dbt-core 1.12+'s native Ossie ingestion.
+
+dbt-core >=1.12 parses raw Ossie JSON files dropped in a project's `osi/` directory (or a
+configured `osi-paths` — dbt kept this config key and default directory name lowercase
+`osi` even after the upstream spec's Apache rename) directly into its manifest — no
+Ossie->dbt-YAML conversion needed. Per dbt's docs
+(docs.getdbt.com/docs/build/ossie-semantic-models, checked 2026-09-04), two hard
+constraints apply that our own Ossie documents don't satisfy by default, so this module
+adjusts/validates rather than passing the document through verbatim:
+
+1. dbt only accepts `version: "0.1.0"` or `"0.1.1"` — any other version string is a
+   parse error. Our vendored OssieDocument defaults to `"0.2.0.dev0"` (the current core
+   spec draft version), so the emitted copy's version is overridden to `"0.1.1"`; the
+   document shape (datasets/fields/relationships/metrics) is otherwise unchanged.
+2. Each dataset's `source` must be `database.schema.alias`, fully qualified to a dbt
+   model *in the target dbt project* (not a source/seed/snapshot/external table). We
+   can't verify this against a project we don't have, so we only check the shape
+   (three dot-separated parts) and surface a warning for anything that doesn't match.
+"""
+
+import json
+from dataclasses import dataclass
+
+from lexis._vendor.ossie import OssieDocument
+from lexis.transpilers.base import Artifact
+
+DBT_SUPPORTED_OSSIE_VERSIONS = ("0.1.0", "0.1.1")
+DBT_EMIT_VERSION = "0.1.1"
+
+
+@dataclass(frozen=True)
+class DbtOssieResult:
+    artifact: Artifact
+    warnings: list[str]
+
+
+def _source_shape_warnings(document: OssieDocument) -> list[str]:
+    warnings = []
+    for semantic_model in document.semantic_model:
+        for dataset in semantic_model.datasets:
+            parts = dataset.source.split(".")
+            if len(parts) != 3:
+                warnings.append(
+                    f"dataset {dataset.name!r} source {dataset.source!r} is not "
+                    "'database.schema.alias' — dbt requires it resolve to a dbt model "
+                    "in the target project; this dataset will likely fail to parse "
+                    "under dbt-core's Ossie ingestion until corrected."
+                )
+    return warnings
+
+
+def emit_dbt_ossie_document(document: OssieDocument, filename: str = "osi/lexis_model.json") -> DbtOssieResult:
+    """Render `document` as a dbt-core-1.12+-compatible Ossie JSON artifact."""
+    data = document.model_dump(by_alias=True, exclude_none=True, mode="json")
+    data["version"] = DBT_EMIT_VERSION
+
+    warnings = list(_source_shape_warnings(document))
+    if document.version not in DBT_SUPPORTED_OSSIE_VERSIONS:
+        warnings.append(
+            f"source document version {document.version!r} is not dbt-supported "
+            f"({DBT_SUPPORTED_OSSIE_VERSIONS!r}); emitted copy overrides version to "
+            f"{DBT_EMIT_VERSION!r} — verify the document's constructs are still valid "
+            "under the 0.1.x Ossie schema before relying on this in dbt."
+        )
+
+    content = json.dumps(data, indent=2) + "\n"
+    return DbtOssieResult(artifact=Artifact(filename=filename, content=content), warnings=warnings)

lexis/transpilers/mcp.py

@@ -0,0 +1,182 @@
+"""Ossie -> MCP tool manifest / LLM function-calling schema emitter.
+
+This is Lexis's differentiator: turn a metric's `ai_context` (instructions,
+synonyms, examples) into a grounded tool description, and constrain `group_by` to an
+explicit enum of real dataset.field refs — so an agent gets a governed query tool
+instead of having to guess joins/columns/synonyms from a bare warehouse schema.
+"""
+
+import json
+
+from lexis._vendor.ossie import OssieAIContextObject, OssieDataType, OssieDialect
+from lexis.resolved_model import ResolvedModel
+from lexis.transpilers.sql.base import SqlDialectEmitter
+
+#: Grains a `query_<metric>` tool call may bucket by (see `time_grain` below).
+#: Kept in sync with `SqlDialectEmitter.TIME_GRAINS`, ordered fine -> coarse for the
+#: tool schema (an agent picking "the smallest useful bucket" reads top-down).
+TIME_GRAINS = ["day", "week", "month", "quarter", "year"]
+assert set(TIME_GRAINS) == set(SqlDialectEmitter.TIME_GRAINS)
+
+_DATE_DATATYPES = frozenset(
+    {OssieDataType.DATE, OssieDataType.DATE_TIME, OssieDataType.DATE_TIME_TZ}
+)
+
+
+def time_axis_refs(model: ResolvedModel) -> list[str]:
+    """`dataset.field` refs usable as the time axis of a `DATE_TRUNC`-bucketed
+    query: fields whose Ossie `datatype` is a date/timestamp. Falls back to any
+    `is_time` dimension when the model declares no temporal datatypes at all, so
+    hand-written models that skip `datatype` still get weekly/monthly grains."""
+    dated: list[str] = []
+    is_time: list[str] = []
+    for dataset_name, dataset in model.datasets.items():
+        for f in dataset.fields or []:
+            ref = f"{dataset_name}.{f.name}"
+            if f.datatype in _DATE_DATATYPES:
+                dated.append(ref)
+            elif f.is_time_dimension():
+                is_time.append(ref)
+    return dated or is_time
+
+
+def resolve_time_axis(model: ResolvedModel, time_field: str | None) -> tuple[str, str]:
+    """`(time_dataset, time_field)` for a `time_grain` query. Uses `time_field` when
+    given (validated against `time_axis_refs`), otherwise the model's sole time axis.
+    Raises `ValueError` (a clean MCP tool error) when there's no time axis, more than
+    one and none was chosen, or an unknown one was passed."""
+    refs = time_axis_refs(model)
+    if not refs:
+        raise ValueError("this model has no date field to bucket by, so time_grain is not supported")
+    if time_field is None:
+        if len(refs) > 1:
+            raise ValueError(f"time_field is required when time_grain is set; choose one of {refs}")
+        time_field = refs[0]
+    elif time_field not in refs:
+        raise ValueError(f"unknown time_field {time_field!r}; choose one of {refs}")
+    dataset, _, column = time_field.partition(".")
+    return dataset, column
+
+
+def model_instructions(model: ResolvedModel) -> str:
+    """The model-level `ai_context` text (instructions / synonyms / examples), if any -
+    surfaced to MCP clients as the server's `instructions` and in `list_metrics`, so a
+    model can e.g. tell an agent its weeks are Sunday-Saturday retail weeks rather than
+    ISO Monday weeks. Returns "" when the model has no `ai_context` (the model
+    `description` is carried separately, by `list_models`)."""
+    return _describe_ai_context(None, model.semantic_model.ai_context)
+
+
+def _describe_ai_context(base_description: str | None, ai_context) -> str:
+    parts = [base_description] if base_description else []
+    if ai_context is None:
+        pass
+    elif isinstance(ai_context, str):
+        parts.append(ai_context)
+    elif isinstance(ai_context, OssieAIContextObject):
+        if ai_context.instructions:
+            parts.append(ai_context.instructions)
+        if ai_context.synonyms:
+            parts.append("Also known as: " + ", ".join(ai_context.synonyms) + ".")
+        if ai_context.examples:
+            parts.append("Example questions: " + " | ".join(ai_context.examples))
+    return " ".join(p.strip() for p in parts if p and p.strip())
+
+
+def _dimension_refs(model: ResolvedModel) -> list[str]:
+    refs = []
+    for dataset_name, dataset in model.datasets.items():
+        for f in dataset.fields or []:
+            refs.append(f"{dataset_name}.{f.name}")
+    return refs
+
+
+def _time_bucketing_properties(time_refs: list[str]) -> dict:
+    """The `time_grain` / `time_field` input-schema properties, added to every
+    `query_<metric>` tool when the model has at least one usable time axis."""
+    default_hint = (
+        f" Defaults to {time_refs[0]!r}." if len(time_refs) == 1
+        else " Required when time_grain is set (the model has more than one time field)."
+    )
+    return {
+        "time_grain": {
+            "type": "string",
+            "enum": TIME_GRAINS,
+            "description": (
+                "Return one row per consecutive time period instead of a single total - "
+                "e.g. 'week' for a week-by-week trend. Periods are ISO 8601 calendar "
+                "periods and weeks start Monday; if this model's instructions define a "
+                "fiscal or retail week, label the results accordingly. Cannot be combined "
+                "with group_by."
+            ),
+        },
+        "time_field": {
+            "type": "string",
+            "enum": time_refs,
+            "description": "Which date field to bucket by when time_grain is set." + default_hint,
+        },
+    }
+
+
+def build_metric_tool_specs(model: ResolvedModel) -> list[dict]:
+    """One `{"name", "description", "inputSchema"}` dict per Ossie metric — the bare MCP
+    tool schema, shared by the static manifest below and the live MCP server
+    (`lexis.mcp_server`), which additionally needs plain schema dicts it can turn
+    into `mcp.types.Tool` objects (no extra `_lexis`-style fields)."""
+    dimension_refs = _dimension_refs(model)
+    time_refs = time_axis_refs(model)
+    time_properties = _time_bucketing_properties(time_refs) if time_refs else {}
+    specs = []
+
+    for metric in model.metrics.values():
+        description = _describe_ai_context(metric.description, metric.ai_context)
+        specs.append(
+            {
+                "name": f"query_{metric.name}",
+                "description": description or f"Query the {metric.name!r} metric.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "group_by": {
+                            "type": "array",
+                            "items": {"type": "string", "enum": dimension_refs},
+                            "description": (
+                                "Zero or more dataset.field references to group results by."
+                            ),
+                        },
+                        **time_properties,
+                    },
+                    "additionalProperties": False,
+                },
+            }
+        )
+
+    return specs
+
+
+def build_mcp_tool_manifest(model: ResolvedModel) -> dict:
+    """Build an MCP-style `{"tools": [...]}` manifest, one tool per Ossie metric."""
+    tools = []
+
+    for metric, spec in zip(model.metrics.values(), build_metric_tool_specs(model), strict=True):
+        try:
+            expr = model.resolve_expression(metric.expression, OssieDialect.ANSI_SQL)
+        except Exception:
+            expr = None
+
+        tools.append({**spec, "_lexis": {"metric": metric.name, "expression": expr}})
+
+    return {
+        "model": {
+            "name": model.semantic_model.name,
+            "description": _describe_ai_context(
+                model.semantic_model.description, model.semantic_model.ai_context
+            ),
+        },
+        "tools": tools,
+    }
+
+
+def emit_mcp_tool_manifest(model: ResolvedModel) -> str:
+    """Render the MCP tool manifest as JSON text."""
+    return json.dumps(build_mcp_tool_manifest(model), indent=2) + "\n"

lexis/transpilers/snowflake_semantic_view.py

@@ -0,0 +1,126 @@
+"""Ossie -> Snowflake `CREATE SEMANTIC VIEW` DDL emitter.
+
+Snowflake's native semantic view (Cortex Analyst) DDL groups a model into five
+clauses - TABLES, RELATIONSHIPS, FACTS, DIMENSIONS, METRICS - which line up
+closely with Ossie's own datasets/relationships/fields/metrics:
+
+- Each OssieDataset becomes a TABLES entry (`<dataset> AS <source>`), carrying
+  over PRIMARY KEY, WITH SYNONYMS (from ai_context), and COMMENT (description).
+- Each OssieRelationship becomes a RELATIONSHIPS entry using Snowflake's
+  `<alias> AS <from>(<cols>) REFERENCES <to>(<cols>)` shape.
+- Ossie fields split into FACTS vs DIMENSIONS the same way the bundled TPC-DS
+  fixture models it: a field carrying a `dimension` block is a grouping/
+  filtering attribute (DIMENSIONS); a field with no `dimension` block is
+  treated as a row-level numeric fact (FACTS), since Snowflake facts are the
+  row-level building blocks aggregate METRICS are written against.
+- Ossie semantic-model-level metrics become METRICS entries. Snowflake requires
+  each metric to be qualified by a single table alias, so - as with the Cube
+  emitter - a metric expression is attached to the first dataset it
+  references (falling back to an arbitrary dataset if it references none).
+
+Expressions prefer the SNOWFLAKE dialect where the source model provides one,
+falling back to ANSI_SQL like every other target (`ResolvedModel.resolve_expression`).
+"""
+
+from lexis._vendor.ossie import OssieAIContext, OssieAIContextObject, OssieDialect
+from lexis.resolved_model import ResolvedModel
+
+
+def _quote_literal(text: str) -> str:
+    return text.replace("'", "''")
+
+
+def _synonyms_clause(ai_context: OssieAIContext | None) -> str:
+    if isinstance(ai_context, OssieAIContextObject) and ai_context.synonyms:
+        rendered = ", ".join(f"'{_quote_literal(s)}'" for s in ai_context.synonyms)
+        return f" WITH SYNONYMS ({rendered})"
+    return ""
+
+
+def _comment_clause(text: str | None) -> str:
+    return f" COMMENT = '{_quote_literal(text)}'" if text else ""
+
+
+def _table_entries(model: ResolvedModel) -> list[str]:
+    entries = []
+    for name, dataset in model.datasets.items():
+        entry = f"{name} AS {dataset.source}"
+        if dataset.primary_key:
+            entry += f" PRIMARY KEY ({', '.join(dataset.primary_key)})"
+        entry += _synonyms_clause(dataset.ai_context)
+        entry += _comment_clause(dataset.description)
+        entries.append(entry)
+    return entries
+
+
+def _relationship_entries(model: ResolvedModel) -> list[str]:
+    entries = []
+    for rel in model.relationships:
+        from_cols = ", ".join(rel.from_columns)
+        to_cols = ", ".join(rel.to_columns)
+        entries.append(
+            f"{rel.name} AS {rel.from_dataset}({from_cols}) REFERENCES {rel.to}({to_cols})"
+        )
+    return entries
+
+
+def _field_entries(model: ResolvedModel, *, dimensions: bool) -> list[str]:
+    entries = []
+    for dataset_name, dataset in model.datasets.items():
+        for f in dataset.fields or []:
+            if (f.dimension is not None) != dimensions:
+                continue
+            try:
+                expr = model.resolve_expression(f.expression, OssieDialect.SNOWFLAKE)
+            except Exception:
+                continue
+            entry = f"{dataset_name}.{f.name} AS {expr}"
+            entry += _synonyms_clause(f.ai_context)
+            entry += _comment_clause(f.description)
+            entries.append(entry)
+    return entries
+
+
+def _metric_entries(model: ResolvedModel) -> list[str]:
+    entries = []
+    for metric in model.metrics.values():
+        expr = model.resolve_expression(metric.expression, OssieDialect.SNOWFLAKE)
+        referenced = model.referenced_datasets(expr)
+        dataset_name = referenced[0] if referenced else next(iter(model.datasets))
+        entry = f"{dataset_name}.{metric.name} AS {expr}"
+        entry += _synonyms_clause(metric.ai_context)
+        entry += _comment_clause(metric.description)
+        entries.append(entry)
+    return entries
+
+
+def _clause(keyword: str, entries: list[str]) -> str:
+    body = ",\n".join(f"    {entry}" for entry in entries)
+    return f"  {keyword} (\n{body}\n  )"
+
+
+def emit_snowflake_semantic_view(model: ResolvedModel) -> str:
+    """Render `model` as a Snowflake `CREATE SEMANTIC VIEW` DDL statement."""
+    clauses = [_clause("TABLES", _table_entries(model))]
+
+    relationships = _relationship_entries(model)
+    if relationships:
+        clauses.append(_clause("RELATIONSHIPS", relationships))
+
+    facts = _field_entries(model, dimensions=False)
+    if facts:
+        clauses.append(_clause("FACTS", facts))
+
+    dims = _field_entries(model, dimensions=True)
+    if dims:
+        clauses.append(_clause("DIMENSIONS", dims))
+
+    metrics = _metric_entries(model)
+    if metrics:
+        clauses.append(_clause("METRICS", metrics))
+
+    lines = [f"CREATE OR REPLACE SEMANTIC VIEW {model.semantic_model.name}", *clauses]
+    comment = _comment_clause(model.semantic_model.description).strip()
+    if comment:
+        lines.append(f"  {comment}")
+    return "\n".join(lines) + ";\n"

lexis/transpilers/sql/__init__.py

@@ -0,0 +1,22 @@
+from .bigquery import BigQueryEmitter
+from .databricks import DatabricksEmitter
+from .duckdb import DuckDBEmitter
+from .postgres import PostgresEmitter
+from .snowflake import SnowflakeEmitter
+
+EMITTERS = {
+    "duckdb": DuckDBEmitter,
+    "postgres": PostgresEmitter,
+    "bigquery": BigQueryEmitter,
+    "databricks": DatabricksEmitter,
+    "snowflake": SnowflakeEmitter,
+}
+
+__all__ = [
+    "BigQueryEmitter",
+    "DatabricksEmitter",
+    "DuckDBEmitter",
+    "PostgresEmitter",
+    "SnowflakeEmitter",
+    "EMITTERS",
+]

lexis/transpilers/sql/base.py

@@ -0,0 +1,172 @@
+"""Shared SQL-dialect emitter: builds a metric query from a ResolvedModel.
+
+Per-dialect subclasses only need to set `dialect` and `quote_char` — the join-graph
+resolution, dialect-expression fallback, and SELECT/FROM/JOIN/GROUP BY assembly are
+identical across warehouses (per Ossie's converters/index.md mapping guidance).
+"""
+
+import re
+
+from lexis._vendor.ossie import OssieDialect
+from lexis.resolved_model import ResolvedModel
+
+_SIMPLE_IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_ISO_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+
+
+class SqlDialectEmitter:
+    dialect: OssieDialect
+    quote_char: str = '"'
+
+    #: Grains supported by `emit_timeseries_query`, coarsest first. `week` is an
+    #: ISO 8601 week (Monday start) - what `DATE_TRUNC('week', ...)` returns natively
+    #: on DuckDB / Postgres / Snowflake (default `WEEK_START`) / Spark. A model whose
+    #: business calendar uses a different week (e.g. US retail Sunday-Saturday) should
+    #: say so in its `ai_context` so consumers interpret weekly rows accordingly.
+    TIME_GRAINS = ("year", "quarter", "month", "week", "day")
+
+    def quote(self, identifier: str) -> str:
+        return f"{self.quote_char}{identifier}{self.quote_char}"
+
+    def _resolve_field_expr(self, model: ResolvedModel, dataset_name: str, field_name: str) -> str:
+        dataset = model.datasets[dataset_name]
+        matching = [f for f in (dataset.fields or []) if f.name == field_name]
+        if not matching:
+            raise ValueError(f"Unknown field {dataset_name}.{field_name!r}")
+        field_expr = model.resolve_expression(matching[0].expression, self.dialect)
+        # Field expressions (unlike metrics) are unqualified column refs/scalar
+        # expressions scoped to their own dataset. Qualify the common case (a bare
+        # column name) with the dataset alias; multi-column scalar expressions
+        # (e.g. `first_name || ' ' || last_name`) are left as-is and rely on SQL's
+        # automatic unambiguous-column resolution across the joined tables.
+        if _SIMPLE_IDENTIFIER_RE.match(field_expr):
+            field_expr = f"{self.quote(dataset_name)}.{field_expr}"
+        return field_expr
+
+    def _from_and_joins(self, model: ResolvedModel, all_datasets: list[str]) -> list[str]:
+        """FROM + JOIN lines connecting `all_datasets` (first element is the base
+        table); shared by `emit_metric_query` and `emit_timeseries_query` so the
+        join-path traversal/direction logic only lives in one place."""
+        joins = model.join_path(all_datasets)
+        base_name = all_datasets[0]
+        base_dataset = model.datasets[base_name]
+        lines = [f"FROM {base_dataset.source} AS {self.quote(base_name)}"]
+
+        joined = {base_name}
+        for rel in joins:
+            if rel.from_dataset in joined and rel.to not in joined:
+                left, right, left_cols, right_cols = (
+                    rel.from_dataset,
+                    rel.to,
+                    rel.from_columns,
+                    rel.to_columns,
+                )
+            else:
+                left, right, left_cols, right_cols = (
+                    rel.to,
+                    rel.from_dataset,
+                    rel.to_columns,
+                    rel.from_columns,
+                )
+
+            right_dataset = model.datasets[right]
+            on_clause = " AND ".join(
+                f"{self.quote(left)}.{lc} = {self.quote(right)}.{rc}"
+                for lc, rc in zip(left_cols, right_cols)
+            )
+            lines.append(
+                f"JOIN {right_dataset.source} AS {self.quote(right)} ON {on_clause}"
+            )
+            joined.add(right)
+
+        return lines
+
+    def emit_metric_query(
+        self,
+        model: ResolvedModel,
+        metric_name: str,
+        group_by: list[str] | None = None,
+    ) -> str:
+        """Render a runnable SELECT for `metric_name`, optionally grouped by field refs.
+
+        `group_by` entries are `"dataset.field"` references, e.g. `"item.i_category"`.
+        """
+        metric = model.metrics[metric_name]
+        metric_expr = model.resolve_expression(metric.expression, self.dialect)
+
+        group_exprs: list[str] = []
+        group_datasets: list[str] = []
+        for ref in group_by or []:
+            dataset_name, field_name = ref.split(".", 1)
+            field_expr = self._resolve_field_expr(model, dataset_name, field_name)
+            group_exprs.append(f"{field_expr} AS {self.quote(field_name)}")
+            group_datasets.append(dataset_name)
+
+        referenced = model.referenced_datasets(metric_expr)
+        all_datasets = list(dict.fromkeys(referenced + group_datasets))
+        if not all_datasets:
+            raise ValueError(
+                f"Metric {metric_name!r} expression references no known dataset"
+            )
+
+        select_list = [*group_exprs, f"{metric_expr} AS {self.quote(metric.name)}"]
+        lines = [
+            f"SELECT {', '.join(select_list)}",
+            *self._from_and_joins(model, all_datasets),
+        ]
+
+        if group_exprs:
+            positions = ", ".join(str(i + 1) for i in range(len(group_exprs)))
+            lines.append(f"GROUP BY {positions}")
+
+        return "\n".join(lines)
+
+    def emit_timeseries_query(
+        self,
+        model: ResolvedModel,
+        metric_name: str,
+        time_dataset: str,
+        time_field: str,
+        grain: str,
+        filter_grain: str | None = None,
+        filter_value: str | None = None,
+    ) -> str:
+        """Render a SELECT grouping `metric_name` by `DATE_TRUNC(grain, time_field)`,
+        optionally restricted to one coarser period (`filter_grain`/`filter_value`,
+        an ISO `YYYY-MM-DD` date) - the drill-down case, where `filter_value` is the
+        period boundary of the row the caller drilled into.
+
+        Only meaningful for dialects that share Postgres-style
+        `DATE_TRUNC('unit', expr)` syntax (DuckDB, Postgres, Databricks, Snowflake) -
+        not BigQuery, which takes `DATE_TRUNC(expr, UNIT)` with no quoting.
+        `grain`/`filter_grain` are validated against `TIME_GRAINS` and `filter_value`
+        against a strict date-shaped regex before being embedded, since they're
+        interpolated directly into the returned SQL text rather than bound as
+        parameters (this method returns a fully-formed, displayable query, matching
+        `emit_metric_query`'s contract).
+        """
+        if grain not in self.TIME_GRAINS:
+            raise ValueError(f"Unsupported time grain: {grain!r}")
+
+        metric = model.metrics[metric_name]
+        metric_expr = model.resolve_expression(metric.expression, self.dialect)
+        time_expr = self._resolve_field_expr(model, time_dataset, time_field)
+
+        all_datasets = list(dict.fromkeys([*model.referenced_datasets(metric_expr), time_dataset]))
+
+        period_expr = f"DATE_TRUNC('{grain}', {time_expr})"
+        lines = [
+            f"SELECT {period_expr} AS {self.quote('period')}, {metric_expr} AS {self.quote(metric.name)}",
+            *self._from_and_joins(model, all_datasets),
+        ]
+
+        if filter_grain is not None:
+            if filter_grain not in self.TIME_GRAINS:
+                raise ValueError(f"Unsupported time grain: {filter_grain!r}")
+            if not filter_value or not _ISO_DATE_RE.match(filter_value):
+                raise ValueError(f"filter_value must be an ISO date (YYYY-MM-DD): {filter_value!r}")
+            lines.append(f"WHERE DATE_TRUNC('{filter_grain}', {time_expr}) = DATE '{filter_value}'")
+
+        lines.append("GROUP BY 1")
+        lines.append("ORDER BY 1")
+        return "\n".join(lines)

lexis/transpilers/sql/bigquery.py

@@ -0,0 +1,8 @@
+from lexis._vendor.ossie import OssieDialect
+
+from .base import SqlDialectEmitter
+
+
+class BigQueryEmitter(SqlDialectEmitter):
+    dialect = OssieDialect.BIGQUERY
+    quote_char = "`"

lexis/transpilers/sql/databricks.py

@@ -0,0 +1,8 @@
+from lexis._vendor.ossie import OssieDialect
+
+from .base import SqlDialectEmitter
+
+
+class DatabricksEmitter(SqlDialectEmitter):
+    dialect = OssieDialect.DATABRICKS
+    quote_char = "`"

lexis/transpilers/sql/duckdb.py

@@ -0,0 +1,8 @@
+from lexis._vendor.ossie import OssieDialect
+
+from .base import SqlDialectEmitter
+
+
+class DuckDBEmitter(SqlDialectEmitter):
+    dialect = OssieDialect.ANSI_SQL
+    quote_char = '"'

lexis/transpilers/sql/postgres.py

@@ -0,0 +1,10 @@
+from lexis._vendor.ossie import OssieDialect
+
+from .base import SqlDialectEmitter
+
+
+class PostgresEmitter(SqlDialectEmitter):
+    # Ossie defines no dedicated POSTGRES dialect; Postgres is ANSI_SQL-compliant enough
+    # that the ANSI_SQL expression text is used directly.
+    dialect = OssieDialect.ANSI_SQL
+    quote_char = '"'

lexis/transpilers/sql/snowflake.py

@@ -0,0 +1,8 @@
+from lexis._vendor.ossie import OssieDialect
+
+from .base import SqlDialectEmitter
+
+
+class SnowflakeEmitter(SqlDialectEmitter):
+    dialect = OssieDialect.SNOWFLAKE
+    quote_char = '"'