metricflow 0.200.0.dev13__tar.gz → 0.200.0.dev14__tar.gz

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/Makefile

@@ -13,15 +13,6 @@ install-hatch:
 	pip3 install hatch
 
 # Testing and linting
-.PHONY: test-core
-test-core:
-	hatch -v run dev-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test --ignore metricflow/test/model/dbt_cloud_parsing/
-
-# Test that depend on dbt-related packages.
-.PHONY: test-dbt-associated
-test-dbt-associated:
-	hatch -v run dev-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/model/dbt_cloud_parsing/
-
 .PHONY: test
 test:
 	hatch -v run dev-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/
@@ -30,6 +21,20 @@ test:
 test-postgresql:
 	hatch -v run postgres-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/
 
+# Engine-specific test environments. In most cases you should run these with
+# `make -e ADDITIONAL_PYTEST_OPTIONS="--use-persistent-source-schema" test-<engine_type>`
+.PHONY: test-bigquery
+test-bigquery:
+	hatch -v run bigquery-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/
+
+.PHONY: test-databricks
+test-databricks:
+	hatch -v run databricks-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/
+
+.PHONY: test-redshift
+test-redshift:
+	hatch -v run redshift-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/
+
 .PHONY: test-snowflake
 test-snowflake:
 	hatch -v run snowflake-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: metricflow
-Version: 0.200.0.dev13
+Version: 0.200.0.dev14
 Summary: Translates a simple metric definition into reusable SQL and executes it against the SQL engine of your choice.
 Project-URL: Documentation, https://transform.co/metricflow
 Project-URL: Source Code, https://github.com/transform-data/metricflow
-Author-email: Transform <hello@transformdata.io>
+Author: dbt Labs
 License-Expression: BUSL-1.1
 License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
@@ -18,13 +18,8 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: <3.12,>=3.8
 Requires-Dist: click<8.1.4,>=7.1.2
 Requires-Dist: cryptography~=39.0.1
-Requires-Dist: databricks-sql-connector~=2.0
 Requires-Dist: dbt-core~=1.6.0rc1
 Requires-Dist: dbt-semantic-interfaces~=0.1.0rc1
-Requires-Dist: duckdb-engine~=0.9
-Requires-Dist: duckdb~=0.8
-Requires-Dist: google-auth~=2.13.0
-Requires-Dist: google-cloud-bigquery~=3.4.2
 Requires-Dist: graphviz==0.18.2
 Requires-Dist: halo~=0.0.31
 Requires-Dist: jinja2>=2.11.3
@@ -34,26 +29,26 @@ Requires-Dist: mo-sql-parsing~=9.328.23003
 Requires-Dist: more-itertools==8.10.0
 Requires-Dist: numpy>=1.22.2
 Requires-Dist: pandas~=1.3.0
-Requires-Dist: psycopg2-binary~=2.9.3
 Requires-Dist: pydantic~=1.10.0
 Requires-Dist: pyopenssl~=23.0.0
 Requires-Dist: python-dateutil==2.8.2
 Requires-Dist: pyyaml~=6.0
 Requires-Dist: rapidfuzz==3.0.0
-Requires-Dist: requests~=2.27.1
 Requires-Dist: ruamel-yaml~=0.17.21
 Requires-Dist: rudder-sdk-python~=1.0.3
-Requires-Dist: sqlalchemy-bigquery~=1.6.1
-Requires-Dist: sqlalchemy-redshift==0.8.1
-Requires-Dist: sqlalchemy2-stubs~=0.0.2a21
-Requires-Dist: sqlalchemy~=1.4.42
 Requires-Dist: tabulate~=0.8.9
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: update-checker~=0.18.0
+Provides-Extra: dbt-bigquery
+Requires-Dist: dbt-bigquery~=1.6.0rc1; extra == 'dbt-bigquery'
+Provides-Extra: dbt-databricks
+Requires-Dist: dbt-databricks==1.6.0rc2; extra == 'dbt-databricks'
 Provides-Extra: dbt-postgres
-Requires-Dist: dbt-postgres>=1.6.0.b6; extra == 'dbt-postgres'
+Requires-Dist: dbt-postgres~=1.6.0rc1; extra == 'dbt-postgres'
+Provides-Extra: dbt-redshift
+Requires-Dist: dbt-redshift~=1.6.0rc1; extra == 'dbt-redshift'
 Provides-Extra: dbt-snowflake
-Requires-Dist: dbt-snowflake>=1.6.0b3; extra == 'dbt-snowflake'
+Requires-Dist: dbt-snowflake~=1.6.0rc1; extra == 'dbt-snowflake'
 Provides-Extra: dev-packages
 Requires-Dist: mypy~=1.3.0; extra == 'dev-packages'
 Requires-Dist: pre-commit~=3.2.2; extra == 'dev-packages'
@@ -63,6 +58,11 @@ Requires-Dist: pytest~=7.1.1; extra == 'dev-packages'
 Requires-Dist: types-jsonschema; extra == 'dev-packages'
 Requires-Dist: types-python-dateutil; extra == 'dev-packages'
 Requires-Dist: types-pyyaml; extra == 'dev-packages'
+Provides-Extra: sql-client-packages
+Requires-Dist: duckdb-engine~=0.9; extra == 'sql-client-packages'
+Requires-Dist: duckdb~=0.8; extra == 'sql-client-packages'
+Requires-Dist: sqlalchemy2-stubs~=0.0.2a21; extra == 'sql-client-packages'
+Requires-Dist: sqlalchemy~=1.4.42; extra == 'sql-client-packages'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -128,7 +128,7 @@ MetricFlow is distributed under a Business Source License (BUSL-1.1). For detail
 MetricFlow can be installed from PyPi for use as a Python library with the following command:
 
 ```
-pip install metricflow
+pip install dbt-metricflow
 ```
 
 Once installed, MetricFlow can be setup and connected to a data warehouse by following the instructions after issuing the command:

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/README.md

@@ -61,7 +61,7 @@ MetricFlow is distributed under a Business Source License (BUSL-1.1). For detail
 MetricFlow can be installed from PyPi for use as a Python library with the following command:
 
 ```
-pip install metricflow
+pip install dbt-metricflow
 ```
 
 Once installed, MetricFlow can be setup and connected to a data warehouse by following the instructions after issuing the command:

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/dbt-metricflow/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dbt-metricflow"
-version = "0.0.2"
+version = "0.0.4"
 description = "Execute commands against the MetricFlow semantic layer with dbt."
 readme = "README.md"
-requires-python = ">=3.8,<3.10"
+requires-python = ">=3.8,<3.12"
 license = "BUSL-1.1"
 authors = [
   { name = "dbt Labs", email = "info@dbtlabs.com" },
@@ -18,14 +18,19 @@ classifiers = [
   "Programming Language :: Python",
   "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "dbt-core==1.6.0b6",
-  "metricflow==0.200.0.dev10"
+  "dbt-core~=1.6.0rc1",
+  "metricflow==0.200.0.dev13"
 ]
 
+[project.urls]
+"Source Code" = "https://github.com/dbt-labs/metricflow/tree/main/dbt-metricflow"
+
 [project.optional-dependencies]
 postgres = [
   "dbt-postgres>=1.6.0b6"

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/metricflow/cli/dbt_connectors/adapter_backed_client.py

@@ -2,41 +2,56 @@ from __future__ import annotations
 
 import enum
 import logging
-import textwrap
 import time
-from typing import Optional, Sequence
 
 import pandas as pd
 from dbt.adapters.base.impl import BaseAdapter
+from dbt.exceptions import DbtDatabaseError
 from dbt_semantic_interfaces.enum_extension import assert_values_exhausted
 from dbt_semantic_interfaces.pretty_print import pformat_big_objects
 
-from metricflow.dataflow.sql_table import SqlTable
 from metricflow.errors.errors import SqlBindParametersNotSupportedError
-from metricflow.logging.formatting import indent_log_line
+from metricflow.formatting import indent_log_line
 from metricflow.protocols.sql_client import SqlEngine
-from metricflow.protocols.sql_request import SqlJsonTag, SqlRequestId, SqlRequestTagSet
 from metricflow.random_id import random_id
+from metricflow.sql.render.big_query import BigQuerySqlQueryPlanRenderer
+from metricflow.sql.render.databricks import DatabricksSqlQueryPlanRenderer
 from metricflow.sql.render.postgres import PostgresSQLSqlQueryPlanRenderer
+from metricflow.sql.render.redshift import RedshiftSqlQueryPlanRenderer
 from metricflow.sql.render.snowflake import SnowflakeSqlQueryPlanRenderer
 from metricflow.sql.render.sql_plan_renderer import SqlQueryPlanRenderer
 from metricflow.sql.sql_bind_parameters import SqlBindParameters
-from metricflow.sql_clients.sql_statement_metadata import CombinedSqlTags, SqlStatementCommentMetadata
+from metricflow.sql_request.sql_request_attributes import SqlJsonTag, SqlRequestId, SqlRequestTagSet
+from metricflow.sql_request.sql_statement_metadata import CombinedSqlTags, SqlStatementCommentMetadata
 
 logger = logging.getLogger(__name__)
 
 
+# Discovered via trial and error from the original, and now defunct DatabricksSqlClient implementation
+DATABRICKS_SQL_WAREHOUSE_EXPLAIN_PLAN_ERROR_KEY = "Error occurred during query planning"
+DATABRICKS_CLUSTER_EXPLAIN_PLAN_ERROR_KEY = "org.apache.spark.sql.AnalysisException"
+
+
 class SupportedAdapterTypes(enum.Enum):
     """Enumeration of supported dbt adapter types."""
 
+    DATABRICKS = "databricks"
     POSTGRES = "postgres"
     SNOWFLAKE = "snowflake"
+    REDSHIFT = "redshift"
+    BIGQUERY = "bigquery"
 
     @property
     def sql_engine_type(self) -> SqlEngine:
         """Return the SqlEngine corresponding to the supported adapter type."""
-        if self is SupportedAdapterTypes.POSTGRES:
+        if self is SupportedAdapterTypes.BIGQUERY:
+            return SqlEngine.BIGQUERY
+        elif self is SupportedAdapterTypes.DATABRICKS:
+            return SqlEngine.DATABRICKS
+        elif self is SupportedAdapterTypes.POSTGRES:
             return SqlEngine.POSTGRES
+        elif self is SupportedAdapterTypes.REDSHIFT:
+            return SqlEngine.REDSHIFT
         elif self is SupportedAdapterTypes.SNOWFLAKE:
             return SqlEngine.SNOWFLAKE
         else:
@@ -45,8 +60,14 @@ class SupportedAdapterTypes(enum.Enum):
     @property
     def sql_query_plan_renderer(self) -> SqlQueryPlanRenderer:
         """Return the SqlQueryPlanRenderer corresponding to the supported adapter type."""
-        if self is SupportedAdapterTypes.POSTGRES:
+        if self is SupportedAdapterTypes.BIGQUERY:
+            return BigQuerySqlQueryPlanRenderer()
+        elif self is SupportedAdapterTypes.DATABRICKS:
+            return DatabricksSqlQueryPlanRenderer()
+        elif self is SupportedAdapterTypes.POSTGRES:
             return PostgresSQLSqlQueryPlanRenderer()
+        elif self is SupportedAdapterTypes.REDSHIFT:
+            return RedshiftSqlQueryPlanRenderer()
         elif self is SupportedAdapterTypes.SNOWFLAKE:
             return SnowflakeSqlQueryPlanRenderer()
         else:
@@ -183,139 +204,33 @@ class AdapterBackedSqlClient:
             f"\n\n{indent_log_line(stmt)}\n"
             + (f"\nwith parameters: {dict(sql_bind_parameters.param_dict)}" if sql_bind_parameters.param_dict else "")
         )
-        # TODO - rely on self._adapter.dry_run() when it is available so this will work for BigQuery.
-        self.execute(f"EXPLAIN {stmt}")
+        request_id = SqlRequestId(f"mf_rid__{random_id()}")
+        connection_name = f"MetricFlow_dry_run_request_{request_id}"
+        # TODO - consolidate to self._adapter.validate_sql() when all implementations will work from within MetricFlow
+        if self.sql_engine_type is SqlEngine.BIGQUERY:
+            with self._adapter.connection_named(connection_name):
+                self._adapter.validate_sql(stmt)
+        else:
+            is_databricks = self.sql_engine_type is SqlEngine.DATABRICKS
+            with self._adapter.connection_named(connection_name):
+                results = self._adapter.execute(f"EXPLAIN {stmt}", auto_begin=True, fetch=is_databricks)
+
+            if is_databricks:
+                # We have to parse the output results from adapter.execute, but only in Databricks. We should probably use
+                # a subclass for this and override things properly, but there's hopefully an upstream fix in our near
+                # future so let's just put this ugly bit in for now.
+                plan_output_str = "\n".join([",".join(row.values()) for row in results[1].rows])
+                has_error = (
+                    plan_output_str.find(DATABRICKS_CLUSTER_EXPLAIN_PLAN_ERROR_KEY) != -1
+                    or plan_output_str.find(DATABRICKS_SQL_WAREHOUSE_EXPLAIN_PLAN_ERROR_KEY) != -1
+                )
+                if has_error:
+                    raise DbtDatabaseError(f"Encountered error in Databricks dry run. Full output: {plan_output_str}")
+
         stop = time.time()
         logger.info(f"Finished running the dry_run in {stop - start:.2f}s")
         return
 
-    def create_table_from_dataframe(
-        self,
-        sql_table: SqlTable,
-        df: pd.DataFrame,
-        chunk_size: Optional[int] = None,
-    ) -> None:
-        """Create a table in the data warehouse containing the contents of the dataframe.
-
-        Only used in tutorials and tests.
-
-        Args:
-            sql_table: The SqlTable object representing the table location to use
-            df: The Pandas DataFrame object containing the column schema and data to load
-            chunk_size: The number of rows to insert per transaction
-        """
-        logger.info(f"Creating table '{sql_table.sql}' from a DataFrame with {df.shape[0]} row(s)")
-        start_time = time.time()
-        with self._adapter.connection_named("MetricFlow_create_from_dataframe"):
-            # Create table
-            # update dtypes to convert None to NA in boolean columns.
-            # This mirrors the SQLAlchemy schema detection logic in pandas.io.sql
-            df = df.convert_dtypes()
-            columns = df.columns
-            columns_to_insert = []
-            for i in range(len(df.columns)):
-                # Format as "column_name column_type"
-                columns_to_insert.append(
-                    f"{columns[i]} {self._get_type_from_pandas_dtype(str(df[columns[i]].dtype).lower())}"
-                )
-            self._adapter.execute(
-                f"CREATE TABLE IF NOT EXISTS {sql_table.sql} ({', '.join(columns_to_insert)})",
-                auto_begin=True,
-                fetch=False,
-            )
-            self._adapter.commit_if_has_connection()
-
-            # Insert rows
-            values = []
-            for row in df.itertuples(index=False, name=None):
-                cells = []
-                for cell in row:
-                    if pd.isnull(cell):
-                        # use null keyword instead of isNA/None/etc.
-                        cells.append("null")
-                    elif type(cell) in [str, pd.Timestamp]:
-                        # Wrap cell in quotes & escape existing single quotes
-                        escaped_cell = str(cell).replace("'", "''")
-                        cells.append(f"'{escaped_cell}'")
-                    else:
-                        cells.append(str(cell))
-
-                values.append(f"({', '.join(cells)})")
-                if chunk_size and len(values) == chunk_size:
-                    value_string = ",\n".join(values)
-                    self._adapter.execute(
-                        f"INSERT INTO {sql_table.sql} VALUES {value_string}", auto_begin=True, fetch=False
-                    )
-                    values = []
-            if values:
-                value_string = ",\n".join(values)
-                self._adapter.execute(
-                    f"INSERT INTO {sql_table.sql} VALUES {value_string}", auto_begin=True, fetch=False
-                )
-            # Commit all insert transaction at once
-            self._adapter.commit_if_has_connection()
-
-        logger.info(f"Created table '{sql_table.sql}' from a DataFrame in {time.time() - start_time:.2f}s")
-
-    def _get_type_from_pandas_dtype(self, dtype: str) -> str:
-        """Helper method to get the engine-specific type value.
-
-        The dtype dict here is non-exhaustive but should be adequate for our needs.
-        """
-        # TODO: add type handling for string/bool/bigint types for all engines
-        if dtype == "string" or dtype == "object":
-            return "text"
-        elif dtype == "boolean" or dtype == "bool":
-            return "boolean"
-        elif dtype == "int64":
-            return "bigint"
-        elif dtype == "float64":
-            return self._sql_query_plan_renderer.expr_renderer.double_data_type
-        elif dtype == "datetime64[ns]":
-            return self._sql_query_plan_renderer.expr_renderer.timestamp_data_type
-        else:
-            raise ValueError(f"Encountered unexpected Pandas dtype ({dtype})!")
-
-    def list_tables(self, schema_name: str) -> Sequence[str]:
-        """Get a list of the table names in a given schema. Only used in tutorials and tests."""
-        # TODO: Short term, make this work with as many engines as possible. Medium term, remove this altogether.
-        if self.sql_engine_type is SqlEngine.SNOWFLAKE:
-            # Snowflake likes capitalizing things, except when it doesn't. We can get away with this due to its
-            # limited scope of usage.
-            schema_name = schema_name.upper()
-
-        df = self.query(
-            textwrap.dedent(
-                f"""\
-                SELECT table_name FROM information_schema.tables
-                WHERE table_schema = '{schema_name}'
-                """
-            ),
-        )
-        if df.empty:
-            return []
-
-        # Lower casing table names and data frame names for consistency between Snowflake and other clients.
-        # As above, we can do this because it isn't used in any consequential situations.
-        df.columns = df.columns.str.lower()
-        return [t.lower() for t in df["table_name"]]
-
-    def table_exists(self, sql_table: SqlTable) -> bool:
-        """Check if a given table exists. Only used in tutorials and tests."""
-        return sql_table.table_name in self.list_tables(sql_table.schema_name)
-
-    def create_schema(self, schema_name: str) -> None:
-        """Create the given schema in a data warehouse. Only used in tutorials and tests."""
-        self.execute(f"CREATE SCHEMA IF NOT EXISTS {schema_name}")
-
-    def drop_schema(self, schema_name: str, cascade: bool = True) -> None:
-        """Drop the given schema from the data warehouse. Only used in tests."""
-        self.execute(f"DROP SCHEMA IF EXISTS {schema_name}{' CASCADE' if cascade else ''}")
-
-    def drop_table(self, sql_table: SqlTable) -> None:
-        """Drop the given table from the data warehouse. Only used in tutorials and tests."""
-        self.execute(f"DROP TABLE IF EXISTS {sql_table.sql}")
-
     def close(self) -> None:  # noqa: D
         self._adapter.cancel_open_connections()
 

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/metricflow/cli/dbt_connectors/dbt_config_accessor.py

@@ -105,7 +105,8 @@ class dbtArtifacts:
             raise ModelCreationException(
                 f"Unable to find {full_path_to_manifest}\n"
                 "Please ensure that you are running `mf` in the root directory of a dbt project "
-                "and that the semantic_manifest JSON exists."
+                "and that the semantic_manifest JSON exists. If this is your first time running "
+                "`mf`, run `dbt parse` to generate the semantic_manifest JSON."
             )
         try:
             with open(full_path_to_manifest, "r") as file:

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/metricflow/engine/metricflow_engine.py

@@ -5,11 +5,13 @@ import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, Optional, Sequence
+from typing import List, Optional, Sequence, Tuple
 
 import pandas as pd
+from dbt_semantic_interfaces.implementations.elements.dimension import PydanticDimensionTypeParams
 from dbt_semantic_interfaces.pretty_print import pformat_big_objects
-from dbt_semantic_interfaces.references import DimensionReference, EntityReference, MetricReference
+from dbt_semantic_interfaces.references import EntityReference, MetricReference
+from dbt_semantic_interfaces.type_enums import DimensionType
 
 from metricflow.dataflow.builder.dataflow_plan_builder import DataflowPlanBuilder
 from metricflow.dataflow.builder.node_data_set import (
@@ -22,6 +24,7 @@ from metricflow.dataflow.optimizer.source_scan.source_scan_optimizer import (
 )
 from metricflow.dataflow.sql_table import SqlTable
 from metricflow.dataset.convert_semantic_model import SemanticModelToDataSetConverter
+from metricflow.dataset.dataset import DataSet
 from metricflow.dataset.semantic_model_adapter import SemanticModelDataSet
 from metricflow.engine.models import Dimension, Entity, Metric
 from metricflow.engine.time_source import ServerTimeSource
@@ -29,12 +32,14 @@ from metricflow.errors.errors import ExecutionException
 from metricflow.execution.execution_plan import ExecutionPlan, SqlQuery
 from metricflow.execution.execution_plan_to_text import execution_plan_to_text
 from metricflow.execution.executor import SequentialPlanExecutor
-from metricflow.logging.formatting import indent_log_line
+from metricflow.formatting import indent_log_line
 from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
 from metricflow.model.semantics.linkable_element_properties import (
     LinkableElementProperties,
 )
+from metricflow.model.semantics.linkable_spec_resolver import LinkableDimension
 from metricflow.model.semantics.semantic_model_lookup import SemanticModelLookup
+from metricflow.naming.linkable_spec_name import StructuredLinkableSpecName
 from metricflow.plan_conversion.column_resolver import DunderColumnAssociationResolver
 from metricflow.plan_conversion.dataflow_to_execution import (
     DataflowToExecutionPlanConverter,
@@ -484,6 +489,7 @@ class MetricFlowEngine(AbstractMetricFlowEngine):
         ).path_key_to_linkable_dimensions
 
         dimensions: List[Dimension] = []
+        linkable_dimensions_tuple: Tuple[LinkableDimension, ...]
         for (
             path_key,
             linkable_dimensions_tuple,
@@ -493,16 +499,44 @@ class MetricFlowEngine(AbstractMetricFlowEngine):
                     linkable_dimension.semantic_model_origin
                 )
                 assert semantic_model
-                dimensions.append(
-                    Dimension.from_pydantic(
-                        pydantic_dimension=SemanticModelLookup.get_dimension_from_semantic_model(
-                            semantic_model=semantic_model,
-                            dimension_reference=DimensionReference(element_name=linkable_dimension.element_name),
-                        ),
-                        path_key=path_key,
+
+                if LinkableElementProperties.METRIC_TIME in linkable_dimension.properties:
+                    metric_time_name = DataSet.metric_time_dimension_name()
+                    assert linkable_dimension.element_name == metric_time_name, (
+                        f"{linkable_dimension} has the {LinkableElementProperties.METRIC_TIME}, but the name does not"
+                        f"match."
                     )
-                )
-        return dimensions
+
+                    dimensions.append(
+                        Dimension(
+                            name=metric_time_name,
+                            qualified_name=StructuredLinkableSpecName(
+                                element_name=metric_time_name,
+                                entity_link_names=linkable_dimension.entity_links,
+                                time_granularity=linkable_dimension.time_granularity,
+                            ).qualified_name,
+                            description="Event time for metrics.",
+                            metadata=None,
+                            type_params=PydanticDimensionTypeParams(
+                                time_granularity=linkable_dimension.time_granularity,
+                                validity_params=None,
+                            ),
+                            is_partition=False,
+                            type=DimensionType.TIME,
+                        )
+                    )
+                else:
+                    dimensions.append(
+                        Dimension.from_pydantic(
+                            pydantic_dimension=SemanticModelLookup.get_dimension_from_semantic_model(
+                                semantic_model=semantic_model,
+                                dimension_reference=linkable_dimension.reference,
+                            ),
+                            path_key=path_key,
+                        )
+                    )
+        logger.error(f"Dimensions is:\n{pformat_big_objects(dimensions)}")
+        return sorted(dimensions, key=lambda dimension: dimension.qualified_name)
 
     def entities_for_metrics(self, metric_names: List[str]) -> List[Entity]:  # noqa: D
         path_key_to_linkable_entities = (

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/metricflow/execution/execution_plan.py

@@ -14,8 +14,8 @@ from metricflow.dag.id_generation import EXEC_NODE_READ_SQL_QUERY, EXEC_NODE_WRI
 from metricflow.dag.mf_dag import DagNode, DisplayedProperty, MetricFlowDag, NodeId
 from metricflow.dataflow.sql_table import SqlTable
 from metricflow.protocols.sql_client import SqlClient
-from metricflow.protocols.sql_request import SqlJsonTag
 from metricflow.sql.sql_bind_parameters import SqlBindParameters
+from metricflow.sql_request.sql_request_attributes import SqlJsonTag
 from metricflow.visitor import Visitable
 
 logger = logging.getLogger(__name__)
@@ -185,7 +185,7 @@ class SelectSqlQueryToTableTask(ExecutionPlanTask):
     def execute(self) -> TaskExecutionResult:  # noqa: D
         start_time = time.time()
         logger.info(f"Dropping table {self._output_table} in case it already exists")
-        self._sql_client.drop_table(self._output_table)
+        self._sql_client.execute(f"DROP TABLE IF EXISTS {self._output_table.sql}")
         logger.info(f"Creating table {self._output_table} using a SELECT query")
         sql_query = self.sql_query
         assert sql_query

{metricflow-0.200.0.dev13 → metricflow-0.200.0.dev14}/metricflow/model/semantics/linkable_element_properties.py

@@ -23,6 +23,8 @@ class LinkableElementProperties(Enum):
     DERIVED_TIME_GRANULARITY = "derived_time_granularity"
     # Refers to an entity, not a dimension.
     ENTITY = "entity"
+    # See metric_time in DataSet
+    METRIC_TIME = "metric_time"
 
     @staticmethod
     def all_properties() -> FrozenSet[LinkableElementProperties]:  # noqa: D
@@ -33,5 +35,6 @@ class LinkableElementProperties(Enum):
                 LinkableElementProperties.JOINED,
                 LinkableElementProperties.MULTI_HOP,
                 LinkableElementProperties.DERIVED_TIME_GRANULARITY,
+                LinkableElementProperties.METRIC_TIME,
             }
         )