metricflow-sql 0.2.0__tar.gz → 0.3.1__tar.gz

{metricflow_sql-0.2.0 → metricflow_sql-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metricflow-sql
-Version: 0.2.0
+Version: 0.3.1
 Summary: MetricFlow's core semantic layer engine
 Project-URL: Documentation, https://congenial-bassoon-7zkjv8w.pages.github.io/
 License-Expression: LicenseRef-Fivetran

{metricflow_sql-0.2.0 → metricflow_sql-0.3.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "metricflow-sql"
 # A placeholder: a release sets its tag's version, with scripts/set_version.py.
-version = "0.2.0"
+version = "0.3.1"
 description = "MetricFlow's core semantic layer engine"
 # Its PyPI page: README.md is for this repository.
 readme = "PYPI.md"

{metricflow_sql-0.2.0 → metricflow_sql-0.3.1}/src/metricflow_sql/compiler/compiler.py

@@ -28,6 +28,7 @@ from metricflow_sql.compiler.rules.expand_metadata import ENGINE, ExpandMetadata
 from metricflow_sql.compiler.rules.isolate_fragments import isolate_fragments
 from metricflow_sql.compiler.rules.passthrough_tables import name_passthrough_tables
 from metricflow_sql.compiler.table_arguments import bind_table_arguments
+from metricflow_sql.utils.normalize import normalizing_dialect
 
 
 def qualify_tables(
@@ -97,8 +98,8 @@ class Compiler:
         planner_rules: Sequence[OptimizerFn] = PLANNER_RULES,
         catalog: str | None = None,
         db: str | None = None,
-        input_dialect: str = "",
-        output_dialect: str = "",
+        input_dialect: DialectType = None,
+        output_dialect: DialectType = None,
         engine_dialects: Mapping[str, str] | None = None,
         normalization_strategy: NormalizationStrategy | None = None,
     ) -> None:
@@ -122,8 +123,8 @@ class Compiler:
         sql: str,
         *,
         read_only: bool = False,
-        input_dialect: str | None = None,
-        output_dialect: str | None = None,
+        input_dialect: DialectType = None,
+        output_dialect: DialectType = None,
         positional_columns: bool = False,
         with_tables: bool = False,
         db: str | None = None,
@@ -150,10 +151,7 @@ class Compiler:
         # dialect and normalization strategy.
         default_db = self.db if db is None else exp.to_identifier(db).sql(dialect=input_dialect)
         if self.normalization_strategy is not None:
-            input_dialect = (
-                f"{input_dialect}, normalization_strategy = "
-                f"{self.normalization_strategy.value.lower()}"
-            )
+            input_dialect = normalizing_dialect(input_dialect, self.normalization_strategy)
         expressions = parse(sql, read=input_dialect)
         explain = False
         match expressions:
@@ -211,7 +209,7 @@ class Compiler:
             tables=tuple(tables) if with_tables else None,
         )
 
-    def _apply_rules(self, expression: exp.Expr, dialect: str, db: str | None) -> exp.Expr:
+    def _apply_rules(self, expression: exp.Expr, dialect: DialectType, db: str | None) -> exp.Expr:
         arguments = {
             "schema": self.cluster,
             "cluster": self.cluster,
@@ -226,7 +224,7 @@ class Compiler:
                 break
         return expression
 
-    def _dialect(self, engine: str | None, output_dialect: str) -> str:
+    def _dialect(self, engine: str | None, output_dialect: DialectType) -> DialectType:
         if engine is None:
             return output_dialect
         if engine not in self.engine_dialects:
@@ -234,7 +232,7 @@ class Compiler:
         return self.engine_dialects[engine]
 
     def _prepare(
-        self, expression: exp.Expr, dialect: str, db: str | None, *, read_only: bool
+        self, expression: exp.Expr, dialect: DialectType, db: str | None, *, read_only: bool
     ) -> None:
         for node in expression.walk():
             match node:
@@ -243,7 +241,7 @@ class Compiler:
                 case exp.Into() if read_only:
                     raise ValueError("Only one query statement is supported")
 
-    def _is_dataset(self, table: exp.Table, dialect: str, db: str | None) -> bool:
+    def _is_dataset(self, table: exp.Table, dialect: DialectType, db: str | None) -> bool:
         """Nothing is loaded yet, so a constellation counts too."""
         # Not normalized yet, so normalize as `qualify` will. `normalize_identifiers` changes its
         # argument, so the query's own catalog is copied.

{metricflow_sql-0.2.0 → metricflow_sql-0.3.1}/src/metricflow_sql/compiler/rules/expand_constellations.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass, field
 from typing import NoReturn
 
 from sqlglot import exp
+from sqlglot.dialects.dialect import DialectType
 from sqlglot.helper import find_new_name
 from sqlglot.optimizer.qualify import qualify
 from sqlglot.optimizer.qualify_columns import quote_identifiers
@@ -104,7 +105,7 @@ class ConstellationContext:
     # Whether the query has no GROUP BY or AGG, so it reads the datasets' rows, stacked.
     stack: bool = False
     # The query's dialect, used to qualify branches, normalize metrics and print errors.
-    dialect: str | None = None
+    dialect: DialectType = None
 
 
 class ExpandConstellationsRule:
@@ -148,7 +149,7 @@ class ExpandConstellationsRule:
         raise ValueError(message)
 
     def __call__(
-        self, expression: exp.Expr, cluster: Cluster, dialect: str | None = None
+        self, expression: exp.Expr, cluster: Cluster, dialect: DialectType = None
     ) -> exp.Expr:
         for scope, select, table in table_scopes(expression):
             if not (registry_and_constellation := cluster.get_constellation(table)):

{metricflow_sql-0.2.0 → metricflow_sql-0.3.1}/src/metricflow_sql/compiler/rules/expand_datasets.py

@@ -7,6 +7,7 @@ from itertools import count
 from typing import NoReturn
 
 from sqlglot import Expr, exp
+from sqlglot.dialects.dialect import DialectType
 from sqlglot.errors import SchemaError
 from sqlglot.helper import find_new_name
 from sqlglot.optimizer.helpers import projection_has_aggregate
@@ -76,7 +77,7 @@ class ExpandContext:
     # One-to-many joins, keyed by alias, mapped to the alias of the join they fan out from.
     fanout_parents: dict[str, str] = field(default_factory=dict)
     aggregate_grains: dict[int, str] = field(default_factory=dict)
-    dialect: str | None = None
+    dialect: DialectType = None
     # The root table's table function arguments, passed to every dataset its relationships reach.
     arguments: dict[str, exp.Expr] = field(default_factory=dict)
 
@@ -95,7 +96,7 @@ class ExpandDatasetsRule:
             message = f"{message}: {expr.sql(dialect=ctx.dialect)}"
         raise ValueError(message)
 
-    def __call__(self, expression: Expr, cluster: Cluster, dialect: str | None = None) -> Expr:
+    def __call__(self, expression: Expr, cluster: Cluster, dialect: DialectType = None) -> Expr:
         for scope, select, table in table_scopes(expression):
             registry_and_dataset = cluster.get_dataset(table)
             if not registry_and_dataset:
@@ -274,7 +275,7 @@ class ExpandDatasetsRule:
             add_generated(alias)
         return ordered
 
-    def _join_terms(self, expression: exp.Expr, dialect: str | None) -> set[exp.Expr]:
+    def _join_terms(self, expression: exp.Expr, dialect: DialectType) -> set[exp.Expr]:
         normalized = simplify(expression, dialect=dialect).unnest()
         if isinstance(normalized, exp.And):
             return set(normalized.flatten())

{metricflow_sql-0.2.0 → metricflow_sql-0.3.1}/src/metricflow_sql/server/compile.py

@@ -25,6 +25,7 @@ import logging
 from collections.abc import Awaitable, Callable
 from typing import Protocol
 
+from sqlglot.dialects.dialect import Dialect
 from sqlglot.errors import SqlglotError
 from starlette.requests import Request
 from starlette.responses import JSONResponse
@@ -57,6 +58,12 @@ def compile_routes(compile_for: CompileFor) -> list[BaseRoute]:
     async def post_compile(request: Request) -> JSONResponse:
         compile_sql = compile_for(request)
         body = await request.json()
+        for key in ("input_dialect", "output_dialect"):
+            try:
+                # Checked as sqlglot reads it, then passed on as text.
+                Dialect.get_or_raise(body.get(key))
+            except ValueError as e:
+                return JSONResponse({"error": f"Invalid `{key}`: {e}"}, status_code=400)
         try:
             plan = await compile_sql(
                 body["sql"],

{metricflow_sql-0.2.0 → metricflow_sql-0.3.1}/src/metricflow_sql/utils/normalize.py

@@ -7,11 +7,12 @@ way.
 
 from __future__ import annotations
 
+import copy
 import logging
 from collections.abc import Iterable
 
 from sqlglot import exp
-from sqlglot.dialects.dialect import Dialect, NormalizationStrategy
+from sqlglot.dialects.dialect import Dialect, DialectType, NormalizationStrategy
 from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 from sqlglot.optimizer.qualify_columns import quote_identifiers
 
@@ -25,9 +26,14 @@ def strategy_of(dialect: str | None) -> NormalizationStrategy:
     return Dialect.get_or_raise(dialect).normalization_strategy
 
 
-def normalizing_dialect(dialect: str | None, strategy: NormalizationStrategy) -> str:
-    """`dialect`, reading names as `strategy` normalizes them, e.g. for sqlglot's `dialect=`."""
-    return f"{dialect or ''}, normalization_strategy = {strategy.value.lower()}"
+def normalizing_dialect(dialect: DialectType, strategy: NormalizationStrategy) -> Dialect:
+    """
+    `dialect`, reading names as `strategy` normalizes them, e.g. for sqlglot's `dialect=`. Its
+    other settings, e.g. its version, carry over; a `Dialect` given is copied, not changed.
+    """
+    normalizing = copy.copy(Dialect.get_or_raise(dialect))
+    normalizing.normalization_strategy = strategy
+    return normalizing
 
 
 def canonical[E: exp.Expr](