fix(dbt): read OSSIE_SQL_2026 expressions instead of picking by position

OSSIE_SQL_2026 (#439, #440) was not recognised anywhere in converters/dbt.
_get_expression() matched only self._dialect -- always ANSI_SQL, since the
constructor argument is never passed -- and otherwise returned dialects[0].
Expression.dialects carries no ordering constraint, so an expression written
in OSSIE_SQL_2026 alongside a vendor dialect resolved by array position: with
the vendor entry first a Snowflake-only column reference was written into the
MetricFlow output as portable SQL, with no warning and no ConverterIssue.
expression_language.md asks implementations to always support the Ossie
dialect and to choose deterministically between dialects; this did neither.

Add OSSIE_SQL_2026 to the chain as an ANSI_SQL equivalent (self._dialect >
OSSIE_SQL_2026 > dialects[0]), mirroring #443/#446/#447 for orionbelt,
databricks and snowflake. The change is additive: expressions carrying
ANSI_SQL keep their current behaviour.

Add regression tests for the metric and field paths in either dialect order,
for ANSI_SQL keeping precedence over OSSIE_SQL_2026, and for the positional
fallback when no portable dialect is present. tests/helpers.py only builds
single-dialect expressions, so this is the first multi-dialect coverage in
the Ossie -> dbt direction.

Partial fix for #461 (_get_expression only); the positional read at
ossie_to_msi.py:401 is left for a follow-up.

Author: RyutoYoda

converters/dbt/src/ossie_dbt/ossie_to_msi.py

@@ -405,10 +405,23 @@ def _find_dataset_for_col(
         return datasets[0].name if datasets else ""
 
     def _get_expression(self, ossie_expr: OssieExpression) -> str:
-        """Return the expression string for the preferred dialect (fallback: first available)."""
+        """Return the expression string for the preferred dialect.
+
+        Preference order: the converter's dialect, then OSSIE_SQL_2026, then the
+        first entry available. OSSIE_SQL_2026 is Ossie's portable expression
+        language, based on ANSI SQL:2003 Core, so it is treated as an ANSI_SQL
+        equivalent rather than left to the positional fallback.
+        """
+        ossie_sql_expr: Optional[str] = None
+
         for dialect_expr in ossie_expr.dialects:
             if dialect_expr.dialect is self._dialect:
                 return dialect_expr.expression
+            if dialect_expr.dialect is OssieDialect.OSSIE_SQL_2026:
+                ossie_sql_expr = dialect_expr.expression
+
+        if ossie_sql_expr is not None:
+            return ossie_sql_expr
         return ossie_expr.dialects[0].expression if ossie_expr.dialects else ""
 
     @staticmethod

converters/dbt/tests/test_ossie_to_msi.py

@@ -20,7 +20,16 @@
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from ossie import OssieDataType, OssieDimension
+from ossie import (
+    OssieDataType,
+    OssieDialect,
+    OssieDialectExpression,
+    OssieDimension,
+    OssieDocument,
+    OssieExpression,
+    OssieField,
+    OssieMetric,
+)
 from ossie_dbt.msi_to_ossie import MSIToOssieConverter
 from ossie_dbt.ossie_to_msi import OssieToMSIConverter
 from metricflow_semantic_interfaces.implementations.elements.measure import (
@@ -456,6 +465,95 @@ def test_percentile_cont_non_median_carries_percentile_param(self) -> None:
         assert m.type_params.expr == "amount"
 
 
+def _multi_dialect_expr(*pairs: tuple[OssieDialect, str]) -> OssieExpression:
+    """Build an expression carrying more than one dialect, in the given order."""
+    return OssieExpression(
+        dialects=[OssieDialectExpression(dialect=dialect, expression=expr) for dialect, expr in pairs]
+    )
+
+
+_SNOWFLAKE_METRIC = (OssieDialect.SNOWFLAKE, "SUM(orders.amt_snowflake_only)")
+_OSSIE_SQL_METRIC = (OssieDialect.OSSIE_SQL_2026, "SUM(orders.amount)")
+_ANSI_METRIC = (OssieDialect.ANSI_SQL, "SUM(orders.amount_ansi)")
+
+
+def _doc_with_metric_expression(expression: OssieExpression) -> OssieDocument:
+    return _ossie_doc(
+        datasets=[_ossie_dataset("orders", fields=[_ossie_field("amount")])],
+        metrics=[OssieMetric(name="revenue", expression=expression)],
+    )
+
+
+class TestOssieToMSIDialectSelection:
+    @pytest.mark.parametrize(
+        "order",
+        [
+            (_OSSIE_SQL_METRIC, _SNOWFLAKE_METRIC),
+            (_SNOWFLAKE_METRIC, _OSSIE_SQL_METRIC),
+        ],
+        ids=["ossie_sql_first", "vendor_first"],
+    )
+    def test_ossie_sql_2026_wins_over_a_vendor_dialect_in_either_order(
+        self, order: tuple[tuple[OssieDialect, str], ...]
+    ) -> None:
+        doc = _doc_with_metric_expression(_multi_dialect_expr(*order))
+
+        result = OssieToMSIConverter().convert(doc).output
+
+        assert result.metrics[0].type_params.expr == "amount"
+
+    @pytest.mark.parametrize(
+        "order",
+        [
+            (_ANSI_METRIC, _OSSIE_SQL_METRIC),
+            (_OSSIE_SQL_METRIC, _ANSI_METRIC),
+        ],
+        ids=["ansi_first", "ossie_sql_first"],
+    )
+    def test_ansi_sql_still_takes_precedence_over_ossie_sql_2026(
+        self, order: tuple[tuple[OssieDialect, str], ...]
+    ) -> None:
+        doc = _doc_with_metric_expression(_multi_dialect_expr(*order))
+
+        result = OssieToMSIConverter().convert(doc).output
+
+        assert result.metrics[0].type_params.expr == "amount_ansi"
+
+    def test_field_expression_prefers_ossie_sql_2026_over_a_vendor_dialect(self) -> None:
+        doc = _ossie_doc(
+            datasets=[
+                _ossie_dataset(
+                    "orders",
+                    fields=[
+                        OssieField(
+                            name="region",
+                            expression=_multi_dialect_expr(
+                                (OssieDialect.SNOWFLAKE, "region_snowflake_only"),
+                                (OssieDialect.OSSIE_SQL_2026, "region_portable"),
+                            ),
+                        )
+                    ],
+                )
+            ]
+        )
+
+        sm = OssieToMSIConverter().convert(doc).output.semantic_models[0]
+
+        assert [(d.name, d.expr) for d in sm.dimensions] == [("region", "region_portable")]
+
+    def test_first_entry_is_still_used_when_no_portable_dialect_is_present(self) -> None:
+        doc = _doc_with_metric_expression(
+            _multi_dialect_expr(
+                (OssieDialect.SNOWFLAKE, "SUM(orders.amt_snowflake_only)"),
+                (OssieDialect.DAX, "SUM(orders.amt_dax_only)"),
+            )
+        )
+
+        result = OssieToMSIConverter().convert(doc).output
+
+        assert result.metrics[0].type_params.expr == "amt_snowflake_only"
+
+
 class TestOssieToMSIRoundTrip:
     def test_ossie_to_msi_to_ossie_preserves_structure(self, snapshot: SnapshotAssertion) -> None:
         """Ossie → MSI → Ossie preserves dataset names, fields, and metric expressions."""