metricflow-sql 0.1.1__tar.gz

metricflow_sql-0.1.1/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

metricflow_sql-0.1.1/LICENSE

@@ -0,0 +1,29 @@
+Copyright (c) 2026 Fivetran, Inc.
+
+By accessing or using this software, you agree to the following terms:
+
+PERMITTED USE
+This software is made available for internal use and evaluation purposes
+only. You may install and use the software solely to access and interact
+with Fivetran's services.
+
+RESTRICTIONS
+You may not use this software to:
+- Build competing products or services
+- Redistribute, sublicense, or transfer the software
+
+INTELLECTUAL PROPERTY
+All rights, title, and interest in the software remain exclusively with
+Fivetran, Inc. No license to any intellectual property is granted
+except as expressly stated herein.
+
+NO WARRANTIES
+THE SOFTWARE IS PROVIDED "AS IS". FIVETRAN, INC. MAKES NO WARRANTIES,
+EXPRESS OR IMPLIED, AND HEREBY DISCLAIMS ALL IMPLIED WARRANTIES,
+INCLUDING ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE.
+
+LIMITATION OF LIABILITY
+FIVETRAN, INC. SHALL NOT BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING
+FROM USE OF THIS SOFTWARE, INCLUDING DIRECT, INDIRECT, INCIDENTAL,
+PUNITIVE, AND CONSEQUENTIAL DAMAGES.

metricflow_sql-0.1.1/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.5
+Name: metricflow-sql
+Version: 0.1.1
+Summary: MetricFlow's core semantic layer engine
+Project-URL: Documentation, https://congenial-bassoon-7zkjv8w.pages.github.io/
+License-Expression: LicenseRef-Fivetran
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: jinja2>=3.1
+Requires-Dist: msgspec>=0.19
+Requires-Dist: sqlglot[c]>=30.27.0
+Requires-Dist: wenmode>=0.15.2
+Provides-Extra: lookml
+Requires-Dist: lkml>=1.3.7; extra == 'lookml'
+Provides-Extra: server
+Requires-Dist: starlette>=0.47.0; extra == 'server'
+Requires-Dist: uvicorn>=0.34.0; extra == 'server'
+Provides-Extra: yaml
+Requires-Dist: ruamel-yaml>=0.18; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# metricflow-sql
+
+Something is cooking...
+
+[Documentation](https://congenial-bassoon-7zkjv8w.pages.github.io/), for design partners with access.

metricflow_sql-0.1.1/PYPI.md

@@ -0,0 +1,5 @@
+# metricflow-sql
+
+Something is cooking...
+
+[Documentation](https://congenial-bassoon-7zkjv8w.pages.github.io/), for design partners with access.

metricflow_sql-0.1.1/README.md

@@ -0,0 +1,3 @@
+# metricflow-sql
+
+Core SQL library for MetricFlow.

metricflow_sql-0.1.1/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "metricflow-sql"
+# A placeholder: a release sets its tag's version, with scripts/set_version.py.
+version = "0.1.1"
+description = "MetricFlow's core semantic layer engine"
+# Its PyPI page: README.md is for this repository.
+readme = "PYPI.md"
+# Fivetran's own, in LICENSE, which no SPDX identifier names.
+license = "LicenseRef-Fivetran"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "jinja2>=3.1",
+    "msgspec>=0.19",
+    "sqlglot[c]>=30.27.0",
+    "wenmode>=0.15.2",
+]
+
+[project.scripts]
+metricflow-serve = "metricflow_sql.server.serve:main"
+
+[project.optional-dependencies]
+lookml = [
+    "lkml>=1.3.7",
+]
+yaml = [
+    "ruamel-yaml>=0.18",
+]
+server = [
+    "starlette>=0.47.0",
+    "uvicorn>=0.34.0",
+]
+
+[project.urls]
+Documentation = "https://congenial-bassoon-7zkjv8w.pages.github.io/"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/metricflow_sql"]

metricflow_sql-0.1.1/src/metricflow_sql/__init__.py

@@ -0,0 +1,8 @@
+"""Core SQL library for MetricFlow."""
+
+from importlib import metadata
+
+__all__ = ["__version__"]
+
+# The installed package's, which a release sets from its tag.
+__version__ = metadata.version("metricflow-sql")

metricflow_sql-0.1.1/src/metricflow_sql/compiler/catalog/cluster.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, override
+
+from sqlglot import Dialect, Schema
+from sqlglot import expressions as exp
+from sqlglot.dialects.dialect import DialectType, NormalizationStrategy
+from sqlglot.errors import OptimizeError, SchemaError
+from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
+
+from metricflow_sql.compiler.catalog.protocols import CatalogLike, ColumnLike, TableLike
+from metricflow_sql.registry.registry import ConstellationProxy, DatasetProxy, Registry
+from metricflow_sql.utils.normalize import exact_identifier, normalizing_dialect
+
+if TYPE_CHECKING:
+    from sqlglot.schema import ColumnMapping
+
+
+class Cluster(Schema):
+    """
+    Collection of catalogs.
+
+    This serves as the database schema for the compiler and sqlglot optimizer.
+    """
+
+    def __init__(
+        self,
+        catalogs: dict[str, CatalogLike] | None = None,
+        dialect: DialectType = None,
+        fallback: Callable[[str], CatalogLike | None] | None = None,
+        normalization_strategy: NormalizationStrategy | None = None,
+    ):
+        """
+        `catalogs` maps names to catalogs. A name matches a query's once both are normalized with
+        `normalization_strategy`, e.g. `env_1` matches `ENV_1` if names are uppercase. Give it
+        the registry's strategy, as the compiler's.
+
+        `fallback` builds a catalog for any other name, e.g. a warehouse catalog.
+        """
+        self.catalogs = catalogs or {}
+        self._dialect = dialect
+        self._normalizing = (
+            normalizing_dialect(None, normalization_strategy) if normalization_strategy else None
+        )
+        self._fallback = fallback
+        self._fallen_back: dict[str, CatalogLike | None] = {}
+        self._normalized_names: dict[str, str] = {}
+
+    def get_catalog(self, name: str) -> CatalogLike | None:
+        """The catalog named `name`, which is normalized: one of `catalogs`, else the fallback's."""
+        catalog = next(
+            (own for key, own in self.catalogs.items() if self._normalized(key) == name), None
+        )
+        if catalog is not None or self._fallback is None or not name:
+            return catalog
+        # Built once, so it looks up each table once.
+        if name not in self._fallen_back:
+            self._fallen_back[name] = self._fallback(name)
+        return self._fallen_back[name]
+
+    def _normalized(self, name: str) -> str:
+        if name not in self._normalized_names:
+            identifier = exp.to_identifier(name)
+            self._normalized_names[name] = normalize_identifiers(
+                identifier, dialect=self._normalizing
+            ).name
+        return self._normalized_names[name]
+
+    def find_table(self, table: exp.Table | str) -> TableLike[ColumnLike] | None:
+        catalog, name = self._resolve(table)
+        return catalog.get_table(name)
+
+    def get_table(self, table: exp.Table | str) -> TableLike[ColumnLike]:
+        catalog, name = self._resolve(table)
+        table_obj = catalog.get_table(name)
+        if not table_obj:
+            catalog_name = exp.to_table(table, dialect=self._dialect, copy=False).args["catalog"]
+            name.set("catalog", catalog_name.copy())
+            raise SchemaError(f"Unknown table: {name.sql(self._dialect)}")
+        return table_obj
+
+    def get_dataset(self, table: exp.Table | str) -> tuple[Registry, DatasetProxy] | None:
+        catalog, name = self._resolve(table)
+        return catalog.get_dataset(name)
+
+    def get_constellation(
+        self, table: exp.Table | str
+    ) -> tuple[Registry, ConstellationProxy] | None:
+        catalog, name = self._resolve(table)
+        return catalog.get_constellation(name)
+
+    def _resolve(self, table: exp.Table | str) -> tuple[CatalogLike, exp.Table]:
+        """The table's catalog, and its name in it."""
+        table = exp.to_table(table, dialect=self._dialect, copy=False)
+        if not table.catalog:
+            raise OptimizeError(f"Expected table to have been qualified with catalog: {table}")
+        if not table.db:
+            raise OptimizeError(f"Expected table to have been qualified with db: {table}")
+        catalog = self.get_catalog(table.catalog)
+        if not catalog:
+            raise SchemaError(f"Unknown catalog: {table.sql(self._dialect)}")
+        # Not `exp.table_`, which a table function's name, e.g. `f('x')`, can't be passed to.
+        return catalog, exp.Table(this=table.this.copy(), db=table.args["db"].copy())
+
+    @property
+    @override
+    def empty(self) -> bool:
+        # Tables load lazily, so there's no mapping to show; to sqlglot, an empty schema knows no
+        # columns, and an alias shadows one, e.g. `b` in `SELECT CONCAT(a, b) AS b ... WHERE b = 1`.
+        return not self.catalogs
+
+    @property
+    @override
+    def dialect(self) -> Dialect | None:
+        return Dialect.get_or_raise(self._dialect)
+
+    @override
+    def add_table(
+        self,
+        table: exp.Table | str,
+        column_mapping: ColumnMapping | None = None,
+        dialect: DialectType = None,
+        normalize: bool | None = None,
+        match_depth: bool = True,
+    ) -> None:
+        raise NotImplementedError
+
+    @override
+    def column_names(
+        self,
+        table: exp.Table | str,
+        only_visible: bool = False,
+        dialect: DialectType = None,
+        normalize: bool | None = None,
+    ) -> Sequence[str]:
+        return [name.name for name in self.get_table(table).column_names()]
+
+    @override
+    def get_column_type(
+        self,
+        table: exp.Table | str,
+        column: exp.Column | str,
+        dialect: DialectType = None,
+        normalize: bool | None = None,
+    ) -> exp.DataType:
+        return self.get_table(table).get_column_type(exact_identifier(column))
+
+    @property
+    @override
+    def supported_table_args(self) -> tuple[str, ...]:
+        return "this", "db", "catalog"

metricflow_sql-0.1.1/src/metricflow_sql/compiler/catalog/information_schema.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import logging
+
+from sqlglot import exp
+
+from metricflow_sql.compiler.catalog.metadata import MetadataColumn, MetadataTable
+
+logger = logging.getLogger(__name__)
+
+# Trino's public information_schema.tables columns, all with SQL type VARCHAR.
+TABLE_COLUMNS = (
+    "table_catalog",
+    "table_schema",
+    "table_name",
+    "table_type",
+)
+
+# The information_schema.columns columns clients read, e.g. Looker, all VARCHAR.
+COLUMN_COLUMNS = (
+    "table_catalog",
+    "table_schema",
+    "table_name",
+    "column_name",
+    "data_type",
+)
+
+
+def table_metadata(source: exp.Query, *, engine: str) -> MetadataTable:
+    """information_schema.tables, whose rows `source` produces on `engine`."""
+    return _varchar_table("tables", TABLE_COLUMNS, source, engine)
+
+
+def column_metadata(source: exp.Query, *, engine: str) -> MetadataTable:
+    """information_schema.columns, whose rows `source` produces on `engine`."""
+    return _varchar_table("columns", COLUMN_COLUMNS, source, engine)
+
+
+def _varchar_table(
+    name: str, columns: tuple[str, ...], source: exp.Query, engine: str
+) -> MetadataTable:
+    return MetadataTable(
+        name=name,
+        columns={column: MetadataColumn(exp.DType.VARCHAR.into_expr()) for column in columns},
+        source=source,
+        engine=engine,
+    )

metricflow_sql-0.1.1/src/metricflow_sql/compiler/catalog/metadata.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable, Collection, Mapping, Sequence
+from dataclasses import dataclass
+
+from sqlglot import exp
+from sqlglot.errors import SchemaError
+
+from metricflow_sql.compiler.catalog.protocols import CatalogLike, ColumnLike, TableLike
+
+logger = logging.getLogger(__name__)
+
+# The db a semantic catalog serves its metadata tables under.
+INFORMATION_SCHEMA = "information_schema"
+
+
+@dataclass(frozen=True)
+class MetadataColumn:
+    datatype: exp.DataType
+    description: str | None = None
+
+
+@dataclass(frozen=True)
+class MetadataTable:
+    name: str
+    columns: dict[str, MetadataColumn]
+
+    # The query that replaces the table, or a function that builds it when it's read
+    source: exp.Query | Callable[[], exp.Query]
+
+    # The engine that runs queries over the table, e.g. "metadata"
+    engine: str
+
+    def query(self) -> exp.Query:
+        """A copy of the query that replaces the table."""
+        return self.source() if callable(self.source) else self.source.copy()
+
+    def column_names(self) -> Collection[exp.Identifier]:
+        return [exp.to_identifier(name) for name in self.columns]
+
+    # information_schema's names are case-insensitive.
+    def get_column(self, name: exp.Identifier) -> MetadataColumn | None:
+        return self.columns.get(name.name.lower())
+
+    def get_column_type(self, name: exp.Identifier) -> exp.DataType:
+        column = self.get_column(name)
+        if column is None:
+            raise SchemaError(f"Unknown column: {self.name}.{name.name}")
+        return column.datatype
+
+
+class MetadataCatalog(CatalogLike):
+    """A catalog of only metadata tables, e.g. a Trino client's `system.runtime.nodes`."""
+
+    def __init__(self, tables: Mapping[str, Sequence[MetadataTable]]) -> None:
+        """`tables` are the catalog's metadata tables, by db."""
+        self._tables = {
+            (db.lower(), table.name.lower()): table
+            for db, db_tables in tables.items()
+            for table in db_tables
+        }
+
+    def get_table(self, table: exp.Table) -> TableLike[ColumnLike] | None:
+        return self._tables.get((table.db.lower(), table.name.lower()))