lexis-cli 0.4.2__py3-none-any.whl

lexis/sml/_common.py

@@ -0,0 +1,224 @@
+"""Shared helpers for the Ossie <-> SML converter.
+
+Mirrors the conventions Apache Ossie's other bidirectional converters already
+established (third_party/ossie/converters/{omni,orionbelt,databricks}/src/*/_common.py):
+a `custom_extensions` stash protocol keyed by vendor name, a `ConversionError` for
+clean error messages, and a dialect-preference table. See SML_OSSIE_CONVERTER_PLAN.md
+at the repo root for the full data-model mapping this implements.
+"""
+
+import json
+import re
+from typing import Any, NamedTuple, Optional
+
+from lexis._vendor.ossie import OssieCustomExtension, OssieDataType, OssieDialect
+
+VENDOR = "SML"
+
+# Bump when the shape of a stashed `data` blob changes.
+STASH_VERSION = 1
+
+# SML SQL dialects this converter maps to/from a corresponding Ossie dialect.
+# Postgresql and Iris have no Ossie enum slot (see SML_OSSIE_CONVERTER_PLAN.md,
+# Edge Case #9): never emitted on Ossie -> SML; preserved via stash on SML -> Ossie
+# (parse.py, phase 2).
+SML_TO_OSSIE_DIALECT = {
+    "Snowflake": OssieDialect.SNOWFLAKE,
+    "DatabricksSQL": OssieDialect.DATABRICKS,
+    "BigQuery": OssieDialect.BIGQUERY,
+}
+OSSIE_TO_SML_DIALECT = {v: k for k, v in SML_TO_OSSIE_DIALECT.items()}
+
+# OssieDataType -> a plausible SML `data_type` string. SML's docs show free-form
+# examples (e.g. "decimal(7,2)") rather than a strict enum, so this is a
+# reasonable default, not a spec-mandated mapping.
+OSSIE_TO_SML_DATATYPE = {
+    OssieDataType.STRING: "string",
+    OssieDataType.INTEGER: "int",
+    OssieDataType.DECIMAL: "decimal(18,2)",
+    OssieDataType.FLOAT: "double",
+    OssieDataType.BOOLEAN: "boolean",
+    OssieDataType.DATE: "date",
+    OssieDataType.TIME: "time",
+    OssieDataType.DATE_TIME: "datetime",
+    OssieDataType.DATE_TIME_TZ: "datetime",
+    OssieDataType.OPAQUE: "string",
+}
+
+
+def sml_datatype_to_ossie(data_type: Optional[str]) -> Optional[OssieDataType]:
+    """Best-effort reverse of OSSIE_TO_SML_DATATYPE. SML's `data_type` is
+    free-form (e.g. "decimal(7,2)", "varchar(50)") rather than a strict enum, so
+    this matches on a lowercased prefix rather than exact equality. Returns None
+    (rather than guessing) for anything unrecognized - the Ossie field is simply
+    emitted with no `datatype`."""
+    if not data_type:
+        return None
+    lowered = data_type.strip().lower()
+    if lowered.startswith(("decimal", "numeric")):
+        return OssieDataType.DECIMAL
+    if lowered.startswith(("double", "float", "real")):
+        return OssieDataType.FLOAT
+    if lowered.startswith(("int", "bigint", "smallint", "tinyint")):
+        return OssieDataType.INTEGER
+    if lowered.startswith(("bool",)):
+        return OssieDataType.BOOLEAN
+    if lowered.startswith("datetime") or lowered.startswith("timestamp"):
+        return OssieDataType.DATE_TIME
+    if lowered.startswith("date"):
+        return OssieDataType.DATE
+    if lowered.startswith("time"):
+        return OssieDataType.TIME
+    if lowered.startswith(("string", "varchar", "char", "text")):
+        return OssieDataType.STRING
+    return None
+
+
+class ConversionError(Exception):
+    """Raised when an input cannot be converted."""
+
+
+def require(obj: dict, key: str, what: str) -> Any:
+    """Return `obj[key]`, or raise a clean ConversionError if it's missing/empty."""
+    if not isinstance(obj, dict) or key not in obj or obj[key] is None:
+        raise ConversionError(f"{what} is missing required {key!r}")
+    value = obj[key]
+    if isinstance(value, str) and not value.strip():
+        raise ConversionError(f"{what} has an empty {key!r}")
+    return value
+
+
+def read_stash(obj: Any) -> dict:
+    """Return the SML `custom_extensions` stash dict on an Ossie object (anything
+    with a `custom_extensions` attribute - Dataset/Field/Relationship/Metric/
+    SemanticModel), or {} if absent. Strips the `_v` version marker.
+
+    Phase 1 (Ossie -> SML) never encounters real stash data yet, since nothing has
+    written an SML stash - this exists so Phase 2's SML -> Ossie -> SML round trip
+    can reconstruct richer SML shapes once `parse.py` starts writing one.
+    """
+    for ext in getattr(obj, "custom_extensions", None) or []:
+        if ext.vendor_name == VENDOR:
+            try:
+                data = json.loads(ext.data)
+            except json.JSONDecodeError as e:
+                raise ConversionError(f"SML custom_extensions data is not valid JSON: {e}") from e
+            data.pop("_v", None)
+            return data
+    return {}
+
+
+def make_stash_extension(data: dict) -> OssieCustomExtension:
+    """Build an OssieCustomExtension carrying `data` under the SML vendor tag."""
+    payload = {"_v": STASH_VERSION, **data}
+    return OssieCustomExtension(vendor_name=VENDOR, data=json.dumps(payload))
+
+
+# calculation_method (SML) <-> SQL aggregate function name. Extends the same
+# pattern already used for the Cube.js emitter (transpilers/cube.py's
+# _SIMPLE_AGGREGATE_RE) with SML's fuller calculation_method vocabulary.
+# `sum distinct` and `estimated count distinct` have no single ANSI function and
+# are intentionally left unmapped (see SML_OSSIE_CONVERTER_PLAN.md Edge Cases).
+CALC_METHOD_TO_SQL_FUNC = {
+    "sum": "SUM",
+    "average": "AVG",
+    "count non-null": "COUNT",
+    "maximum": "MAX",
+    "minimum": "MIN",
+    "stddev_pop": "STDDEV_POP",
+    "stddev_samp": "STDDEV_SAMP",
+    "var_pop": "VAR_POP",
+    "var_samp": "VAR_SAMP",
+    "percentile": "PERCENTILE_CONT",
+    "count_if": "COUNT_IF",
+}
+_SQL_FUNC_TO_CALC_METHOD = {v: k for k, v in CALC_METHOD_TO_SQL_FUNC.items()}
+
+_SIMPLE_AGGREGATE_RE = re.compile(
+    r"^(SUM|AVG|COUNT|MIN|MAX|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|COUNT_IF)"
+    r"\s*\(\s*(DISTINCT\s+)?([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\s*\)$",
+    re.IGNORECASE,
+)
+
+
+def decompose_simple_aggregate(expr: str) -> Optional[tuple[str, str, str]]:
+    """Match `FUNC([DISTINCT] dataset.column)` and return
+    `(calculation_method, dataset, column)`, or None if `expr` isn't that shape."""
+    match = _SIMPLE_AGGREGATE_RE.match(expr.strip())
+    if not match:
+        return None
+    func, distinct, dataset, column = match.groups()
+    func = func.upper()
+    if distinct:
+        if func != "COUNT":
+            return None  # DISTINCT on a non-COUNT aggregate has no SML calculation_method
+        method = "count distinct"
+    else:
+        method = _SQL_FUNC_TO_CALC_METHOD.get(func)
+        if method is None:
+            return None
+    return method, dataset, column
+
+
+def synthesize_aggregate_sql(calculation_method: str, dataset: str, column: str) -> Optional[str]:
+    """Reverse of decompose_simple_aggregate: build `FUNC(dataset.column)` ANSI SQL
+    for a calculation_method. Returns None for methods with no single ANSI function."""
+    if calculation_method == "count distinct":
+        return f"COUNT(DISTINCT {dataset}.{column})"
+    func = CALC_METHOD_TO_SQL_FUNC.get(calculation_method)
+    return f"{func}({dataset}.{column})" if func else None
+
+
+class RatioAggregate(NamedTuple):
+    """A `numerator / denominator` metric where both sides are simple
+    `FUNC(dataset.column)` aggregates - the exact shape SML's own metric_calc docs
+    use for ratio metrics (`"[Measures].[a]/[Measures].[b]"`)."""
+
+    numerator: tuple[str, str, str]  # (calculation_method, dataset, column)
+    denominator: tuple[str, str, str]
+    denominator_nullif_guard_dropped: bool
+
+
+_NULLIF_ZERO_RE = re.compile(r"^NULLIF\s*\(\s*(.+?)\s*,\s*0\s*\)$", re.IGNORECASE)
+
+
+def _split_top_level_slash(expr: str) -> Optional[tuple[str, str]]:
+    """Split `expr` on the first `/` that isn't nested inside parentheses.
+    Returns None if there's no such split point (so `A / B / C` correctly fails to
+    decompose here rather than silently dropping the third term)."""
+    depth = 0
+    for i, ch in enumerate(expr):
+        if ch == "(":
+            depth += 1
+        elif ch == ")":
+            depth -= 1
+        elif ch == "/" and depth == 0:
+            return expr[:i], expr[i + 1 :]
+    return None
+
+
+def decompose_ratio_aggregate(expr: str) -> Optional[RatioAggregate]:
+    """Match `AGG(dataset.column) / AGG(dataset.column)`, optionally with a
+    `NULLIF(..., 0)` divide-by-zero guard around the denominator (a common SQL
+    idiom with no MDX equivalent - MDX division already returns blank/error on
+    divide-by-zero). Returns None if `expr` isn't that shape."""
+    split = _split_top_level_slash(expr.strip())
+    if split is None:
+        return None
+    left, right = split[0].strip(), split[1].strip()
+
+    numerator = decompose_simple_aggregate(left)
+    if numerator is None:
+        return None
+
+    nullif_guard = False
+    nullif_match = _NULLIF_ZERO_RE.match(right)
+    if nullif_match:
+        right = nullif_match.group(1)
+        nullif_guard = True
+
+    denominator = decompose_simple_aggregate(right)
+    if denominator is None:
+        return None
+
+    return RatioAggregate(numerator=numerator, denominator=denominator, denominator_nullif_guard_dropped=nullif_guard)

lexis/sml/emit.py

@@ -0,0 +1,403 @@
+"""Ossie -> SML (Semantic Modeling Language) emitter.
+
+SML (github.com/semanticdatalayer/SML) models a semantic layer as many small
+YAML files (one per object) discriminated by `object_type`, resolved through a
+global `unique_name` registry - not a single document. This emitter produces
+that file set from one OssieDocument.
+
+v1 is the "documented supported subset" (see SML_OSSIE_CONVERTER_PLAN.md at the
+repo root): datasets, a synthesized single-level dimension per relationship
+target, relationships, and metrics that decompose into a plain
+`AGG(dataset.column)` shape. A metric that is a ratio of two such aggregates
+(`AGG(a.b) / AGG(c.d)`, optionally with a `NULLIF(..., 0)` divide-by-zero guard
+on the denominator) becomes an SML `metric_calc` with a synthesized MDX division
+expression - the exact shape SML's own docs use for ratio metrics - referencing
+two plain `metric` objects (reusing an existing one with the same aggregate
+shape when available, e.g. a `total_sales` metric doubling as a ratio's
+numerator, rather than duplicating it). A metric that doesn't decompose either
+way is preserved verbatim (never faked as arbitrary MDX) under a small
+`x_lexis_unconverted_metrics` escape hatch on the emitted `model.yml` - SML
+itself has no vendor-extension slot for an object it can't represent at all -
+so a later `parse_sml_repo()` call restores it exactly rather than losing it
+silently, mirroring the "no silent loss" convention Ossie's other bidirectional
+converters use (see `SML_OSSIE_CONVERTER_PLAN.md`'s Phase 3 section).
+
+If `document` was itself produced by `parse_sml_repo()`, this emitter is
+stash-aware: a dimension whose full original shape (hierarchies, levels,
+calculation_groups, ...) was stashed under `custom_extensions` on the way in is
+re-emitted verbatim instead of re-flattened into a fresh single-level
+synthesis, so an SML -> Ossie -> SML round trip doesn't lose hierarchy
+structure it never needed to lose.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+import yaml
+
+from lexis._vendor.ossie import OssieDataset, OssieDialect, OssieDocument
+from lexis.resolved_model import MissingExpressionError, ResolvedModel
+from lexis.sml._common import (
+    OSSIE_TO_SML_DATATYPE,
+    decompose_ratio_aggregate,
+    decompose_simple_aggregate,
+    read_stash,
+)
+from lexis.sml.models import (
+    SmlCatalog,
+    SmlConnection,
+    SmlDataset,
+    SmlDatasetColumn,
+    SmlDimension,
+    SmlHierarchy,
+    SmlLevel,
+    SmlLevelAttribute,
+    SmlMetric,
+    SmlMetricCalc,
+    SmlModel,
+    SmlModelMetricRef,
+    SmlModelRelationship,
+    SmlRelationshipEnd,
+)
+
+
+@dataclass(frozen=True)
+class SmlEmitResult:
+    files: dict[str, str]
+    warnings: list[str]
+
+
+def _dump(obj) -> str:
+    data = obj.model_dump(by_alias=True, exclude_none=True, mode="json")
+    return yaml.dump(data, sort_keys=False, default_flow_style=False, allow_unicode=True)
+
+
+def _split_source(dataset: OssieDataset, warnings: list[str]) -> tuple[str, str, str] | None:
+    """Split `database.schema.table`; warn and return None if source isn't 3-part
+    (mirrors dbt_ossie.py's `_source_shape_warnings` check on the same convention)."""
+    parts = dataset.source.split(".")
+    if len(parts) != 3 or not all(parts):
+        warnings.append(
+            f"LOSSY: dataset {dataset.name!r} source {dataset.source!r} is not "
+            "'database.schema.table' - SML requires a connection + table name; "
+            "this dataset was excluded from the SML output."
+        )
+        return None
+    return parts[0], parts[1], parts[2]
+
+
+def _emit_dimension(
+    dataset: OssieDataset, warnings: list[str]
+) -> tuple[dict[str, str], str | None]:
+    """Synthesize a single-level SML dimension for `dataset`.
+
+    v1 flattens every Ossie field into one level's key/secondary attributes
+    rather than attempting to infer a natural multi-level hierarchy - Ossie has
+    no data (level order, grouping) that would justify one. Hand-edit the
+    emitted SML if a richer hierarchy is wanted. See SML_OSSIE_CONVERTER_PLAN.md.
+    """
+    dim_name = f"{dataset.name} Dimension"
+    fields = dataset.fields or []
+    if not fields:
+        warnings.append(f"LOSSY: dataset {dataset.name!r} has no fields; dimension skipped.")
+        return {}, None
+
+    key_field = dataset.primary_key[0] if dataset.primary_key else fields[0].name
+    is_time = any(f.is_time_dimension() for f in fields)
+
+    # Per SML's dimension.md spec, dimension-level `level_attributes` holds only
+    # the one joinable key attribute per level ("Only level attributes can be
+    # used to define relationships between datasets and other dimensions") -
+    # our single synthesized level has exactly one. Every other field is a
+    # non-joinable secondary attribute, inlined directly under the level rather
+    # than duplicated at the dimension level.
+    key_attribute = SmlLevelAttribute(
+        unique_name=dim_name,
+        dataset=dataset.name,
+        name_column=key_field,
+        key_columns=[key_field],
+        is_unique_key=True,
+    )
+    secondary_attributes = [
+        SmlLevelAttribute(
+            unique_name=f"{dataset.name} {f.name}",
+            dataset=dataset.name,
+            name_column=f.name,
+            key_columns=[f.name],
+        )
+        for f in fields
+        if f.name != key_field
+    ]
+
+    hierarchy = SmlHierarchy(
+        unique_name=dim_name,
+        levels=[SmlLevel(unique_name=dim_name, secondary_attributes=secondary_attributes or None)],
+    )
+    dimension = SmlDimension(
+        unique_name=dim_name,
+        type="time" if is_time else "standard",
+        hierarchies=[hierarchy],
+        level_attributes=[key_attribute],
+    )
+    return {f"dimensions/{dim_name}.yml": _dump(dimension)}, dim_name
+
+
+def _dump_raw(data: dict) -> str:
+    return yaml.dump(data, sort_keys=False, default_flow_style=False, allow_unicode=True)
+
+
+def _leaf_level_of(raw_dimension: dict) -> str:
+    """The dimension's grain-key level unique_name - what a relationship's
+    `to.level` must reference. Falls back to the dimension's own unique_name,
+    matching `_emit_dimension`'s own single-level synthesis convention, if no
+    `level_attributes` entry is marked `is_unique_key`."""
+    for attr in raw_dimension.get("level_attributes") or []:
+        if attr.get("is_unique_key"):
+            return attr["unique_name"]
+    return raw_dimension.get("unique_name")
+
+
+def _stashed_dimensions_by_dataset(stashed_dimensions: dict[str, dict]) -> dict[str, str]:
+    """Reverse-index the stash: physical dataset name -> the (first) stashed
+    dimension unique_name whose `level_attributes` names it. A snowflaked
+    dimension spanning multiple datasets is looked up by whichever of its
+    datasets a relationship or degenerate-dimension pass asks about."""
+    by_dataset: dict[str, str] = {}
+    for dim_name, raw_dim in stashed_dimensions.items():
+        for attr in raw_dim.get("level_attributes") or []:
+            ds = attr.get("dataset")
+            if ds:
+                by_dataset.setdefault(ds, dim_name)
+    return by_dataset
+
+
+def _metric_ref_for_aggregate(
+    aggregate: tuple[str, str, str],
+    aggregate_index: dict[tuple[str, str, str], str],
+    files: dict[str, str],
+    metric_refs: list[SmlModelMetricRef],
+) -> str:
+    """Return the unique_name of an SML metric matching `aggregate`
+    (calculation_method, dataset, column) - reusing an existing metric with that
+    exact shape (from `aggregate_index`, populated from every metric that already
+    decomposes to a plain aggregate) if one exists, else synthesizing and emitting
+    a new helper metric for it. Used to build a ratio metric_calc's MDX operands."""
+    if aggregate in aggregate_index:
+        return aggregate_index[aggregate]
+    calc_method, ds_name, column = aggregate
+    name = f"{ds_name}.{column} {calc_method}"
+    files[f"metrics/{name}.yml"] = _dump(
+        SmlMetric(unique_name=name, label=name, calculation_method=calc_method, dataset=ds_name, column=column)
+    )
+    metric_refs.append(SmlModelMetricRef(unique_name=name))
+    aggregate_index[aggregate] = name
+    return name
+
+
+def emit_sml_files(document: OssieDocument) -> SmlEmitResult:
+    """Render `document`'s first semantic model as an SML file set."""
+    semantic_model = document.semantic_model[0]
+    model = ResolvedModel.build(semantic_model)
+    warnings: list[str] = []
+    files: dict[str, str] = {}
+
+    stash = read_stash(semantic_model)
+    stashed_dimensions: dict[str, dict] = stash.get("dimensions", {})
+    stashed_dim_by_dataset = _stashed_dimensions_by_dataset(stashed_dimensions)
+    emitted_dimension_names: set[str] = set()
+
+    # --- connections: one per unique (database, schema) pair ---
+    dataset_parts: dict[str, tuple[str, str, str]] = {}
+    connection_names: dict[tuple[str, str], str] = {}
+    for dataset in semantic_model.datasets:
+        parts = _split_source(dataset, warnings)
+        if parts is None:
+            continue
+        dataset_parts[dataset.name] = parts
+        db, schema, _table = parts
+        key = (db, schema)
+        if key not in connection_names:
+            conn_name = f"Connection - {db}.{schema}"
+            connection_names[key] = conn_name
+            conn = SmlConnection(unique_name=conn_name, database=db, schema_name=schema)
+            files[f"connections/{conn_name}.yml"] = _dump(conn)
+
+    # --- datasets (+ a dimension for every relationship target: re-emitted
+    # verbatim from the stash if this dataset was originally parsed from one,
+    # else freshly synthesized as a single flat level) ---
+    dimension_targets = {rel.to for rel in model.relationships}
+    dimension_key: dict[str, tuple[str, str]] = {}  # dataset -> (dimension unique_name, leaf level unique_name)
+    for dataset in semantic_model.datasets:
+        if dataset.name not in dataset_parts:
+            continue
+        db, schema, table = dataset_parts[dataset.name]
+
+        columns = []
+        for f in dataset.fields or []:
+            try:
+                sql = model.resolve_expression(f.expression, OssieDialect.ANSI_SQL)
+            except MissingExpressionError:
+                warnings.append(
+                    f"LOSSY: field {dataset.name}.{f.name!r} has no ANSI_SQL expression; "
+                    "column excluded from the SML dataset."
+                )
+                continue
+            data_type = OSSIE_TO_SML_DATATYPE.get(f.datatype) if f.datatype else None
+            columns.append(
+                SmlDatasetColumn(name=f.name, data_type=data_type, sql=None if sql == f.name else sql)
+            )
+
+        sml_dataset = SmlDataset(
+            unique_name=dataset.name,
+            label=dataset.name,
+            description=dataset.description,
+            connection_id=connection_names[(db, schema)],
+            table=table,
+            columns=columns,
+        )
+        files[f"datasets/{dataset.name}.yml"] = _dump(sml_dataset)
+
+        if dataset.name in dimension_targets:
+            stashed_name = stashed_dim_by_dataset.get(dataset.name)
+            if stashed_name:
+                raw_dim = stashed_dimensions[stashed_name]
+                if stashed_name not in emitted_dimension_names:
+                    files[f"dimensions/{stashed_name}.yml"] = _dump_raw(raw_dim)
+                    emitted_dimension_names.add(stashed_name)
+                dimension_key[dataset.name] = (stashed_name, _leaf_level_of(raw_dim))
+            else:
+                dim_files, dim_name = _emit_dimension(dataset, warnings)
+                files.update(dim_files)
+                if dim_name:
+                    dimension_key[dataset.name] = (dim_name, dim_name)
+
+    # A degenerate/shared-degenerate dimension (keyed on a fact dataset's own
+    # column) has no relationship pointing at it - `dimension_targets` above
+    # never catches it - so re-emit any stashed dimension not already handled,
+    # as long as its backing dataset(s) are still part of this document.
+    for dim_name, raw_dim in stashed_dimensions.items():
+        if dim_name in emitted_dimension_names:
+            continue
+        backing_datasets = {a.get("dataset") for a in raw_dim.get("level_attributes") or []}
+        if backing_datasets & dataset_parts.keys():
+            files[f"dimensions/{dim_name}.yml"] = _dump_raw(raw_dim)
+            emitted_dimension_names.add(dim_name)
+
+    # --- metrics ---
+    # First pass: resolve every metric's expression and record which ones decompose
+    # to a plain aggregate, so a ratio metric processed below can reuse one as an
+    # operand (e.g. `total_sales`) regardless of the two metrics' declaration order.
+    resolved: list[tuple] = []
+    aggregate_index: dict[tuple[str, str, str], str] = {}
+    unconverted_metrics: list[dict[str, Any]] = []
+    for metric in semantic_model.metrics or []:
+        try:
+            expr = model.resolve_expression(metric.expression, OssieDialect.ANSI_SQL)
+        except MissingExpressionError:
+            warnings.append(
+                f"LOSSY: metric {metric.name!r} has no ANSI_SQL expression; preserved verbatim "
+                "(not a queryable SML metric/metric_calc, but round-trips back to Ossie)."
+            )
+            unconverted_metrics.append(metric.model_dump(exclude_none=True, mode="json"))
+            resolved.append((metric, None))
+            continue
+        resolved.append((metric, expr))
+        decomposed = decompose_simple_aggregate(expr)
+        if decomposed is not None and decomposed not in aggregate_index:
+            # First declaration wins if two metrics share the same aggregate shape,
+            # so which one a later ratio metric_calc references is deterministic
+            # and follows document order rather than depending on dict overwrite order.
+            aggregate_index[decomposed] = metric.name
+
+    metric_refs = []
+    for metric, expr in resolved:
+        if expr is None:
+            continue
+
+        decomposed = decompose_simple_aggregate(expr)
+        if decomposed is not None:
+            calc_method, ds_name, column = decomposed
+            sml_metric = SmlMetric(
+                unique_name=metric.name,
+                label=metric.name,
+                description=metric.description,
+                calculation_method=calc_method,
+                dataset=ds_name,
+                column=column,
+            )
+            files[f"metrics/{metric.name}.yml"] = _dump(sml_metric)
+            metric_refs.append(SmlModelMetricRef(unique_name=metric.name))
+            continue
+
+        ratio = decompose_ratio_aggregate(expr)
+        if ratio is not None:
+            numerator_ref = _metric_ref_for_aggregate(ratio.numerator, aggregate_index, files, metric_refs)
+            denominator_ref = _metric_ref_for_aggregate(ratio.denominator, aggregate_index, files, metric_refs)
+            metric_calc = SmlMetricCalc(
+                unique_name=metric.name,
+                label=metric.name,
+                description=metric.description,
+                expression=f"[Measures].[{numerator_ref}]/[Measures].[{denominator_ref}]",
+            )
+            files[f"metrics/{metric.name}.yml"] = _dump(metric_calc)
+            metric_refs.append(SmlModelMetricRef(unique_name=metric.name))
+            if ratio.denominator_nullif_guard_dropped:
+                warnings.append(
+                    f"metric {metric.name!r}: the SQL denominator's NULLIF(..., 0) divide-by-zero "
+                    "guard has no MDX equivalent (MDX division already returns blank/error on "
+                    "divide-by-zero) and was dropped from the emitted metric_calc; behavior at a "
+                    "zero denominator may differ."
+                )
+            continue
+
+        warnings.append(
+            f"LOSSY: metric {metric.name!r} expression {expr!r} is not a simple AGG(dataset.column) "
+            "aggregate or a ratio of two such aggregates - preserved verbatim (not a queryable SML "
+            "metric/metric_calc, but round-trips back to Ossie) rather than faked as arbitrary MDX."
+        )
+        unconverted_metrics.append(metric.model_dump(exclude_none=True, mode="json"))
+
+    # --- model-level relationships (fact -> dimension) ---
+    relationships = []
+    for rel in model.relationships:
+        target = dimension_key.get(rel.to)
+        if target is None:
+            warnings.append(
+                f"LOSSY: relationship {rel.name!r} targets dataset {rel.to!r}, which has "
+                "no synthesized dimension; relationship excluded from SML output."
+            )
+            continue
+        dim_name, leaf_level = target
+        relationships.append(
+            SmlModelRelationship(
+                unique_name=rel.name,
+                from_end=SmlRelationshipEnd(dataset=rel.from_dataset, join_columns=rel.from_columns),
+                to=SmlRelationshipEnd(dimension=dim_name, level=leaf_level),
+            )
+        )
+
+    sml_model_data: dict[str, Any] = dict(
+        unique_name=semantic_model.name,
+        label=semantic_model.name,
+        description=semantic_model.description,
+        relationships=relationships,
+        metrics=metric_refs,
+    )
+    if unconverted_metrics:
+        # No SML object has a vendor-extension slot to stash an unconvertible
+        # metric on, unlike Ossie's own `custom_extensions` - this small,
+        # clearly-namespaced escape hatch on `model.yml` is this converter's
+        # own, restored by `parse.py`'s matching `x_lexis_unconverted_metrics` read.
+        sml_model_data["x_lexis_unconverted_metrics"] = unconverted_metrics
+    sml_model = SmlModel(**sml_model_data)
+    files[f"models/{semantic_model.name}.yml"] = _dump(sml_model)
+
+    # --- catalog ---
+    catalog = SmlCatalog(
+        unique_name=semantic_model.name,
+        label=semantic_model.name,
+        description=semantic_model.description,
+    )
+    files["catalog.yml"] = _dump(catalog)
+
+    return SmlEmitResult(files=files, warnings=warnings)