metricflow 0.204.0.dev5__tar.gz → 0.204.0.dev6__tar.gz

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: metricflow
-Version: 0.204.0.dev5
+Version: 0.204.0.dev6
 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

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/dag/id_generation.py

@@ -23,6 +23,7 @@ DATAFLOW_NODE_CONSTRAIN_TIME_RANGE_ID_PREFIX = "ctr"
 DATAFLOW_NODE_SET_MEASURE_AGGREGATION_TIME = "sma"
 DATAFLOW_NODE_SEMI_ADDITIVE_JOIN_ID_PREFIX = "saj"
 DATAFLOW_NODE_JOIN_TO_TIME_SPINE_ID_PREFIX = "jts"
+DATAFLOW_NODE_MIN_MAX_ID_PREFIX = "mm"
 DATAFLOW_NODE_ADD_UUID_COLUMN_PREFIX = "auid"
 DATAFLOW_NODE_JOIN_CONVERSION_EVENTS_PREFIX = "jce"
 

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/dataflow/builder/dataflow_plan_builder.py

@@ -45,6 +45,7 @@ from metricflow.dataflow.dataflow_plan import (
     JoinOverTimeRangeNode,
     JoinToBaseOutputNode,
     JoinToTimeSpineNode,
+    MinMaxNode,
     OrderByLimitNode,
     ReadSqlSourceNode,
     SemiAdditiveJoinNode,
@@ -630,8 +631,12 @@ class DataflowPlanBuilder:
             distinct=True,
         )
 
+        min_max_node: Optional[MinMaxNode] = None
+        if query_spec.min_max_only:
+            min_max_node = MinMaxNode(parent_node=distinct_values_node)
+
         sink_node = self.build_sink_node(
-            parent_node=distinct_values_node,
+            parent_node=min_max_node or distinct_values_node,
             order_by_specs=query_spec.order_by_specs,
             limit=query_spec.limit,
         )

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/dataflow/dataflow_plan.py

@@ -25,6 +25,7 @@ from metricflow.dag.id_generation import (
     DATAFLOW_NODE_JOIN_SELF_OVER_TIME_RANGE_ID_PREFIX,
     DATAFLOW_NODE_JOIN_TO_STANDARD_OUTPUT_ID_PREFIX,
     DATAFLOW_NODE_JOIN_TO_TIME_SPINE_ID_PREFIX,
+    DATAFLOW_NODE_MIN_MAX_ID_PREFIX,
     DATAFLOW_NODE_ORDER_BY_LIMIT_ID_PREFIX,
     DATAFLOW_NODE_PASS_FILTER_ELEMENTS_ID_PREFIX,
     DATAFLOW_NODE_READ_SQL_SOURCE_ID_PREFIX,
@@ -181,6 +182,10 @@ class DataflowPlanNodeVisitor(Generic[VisitorOutputT], ABC):
     def visit_join_to_time_spine_node(self, node: JoinToTimeSpineNode) -> VisitorOutputT:  # noqa: D
         pass
 
+    @abstractmethod
+    def visit_min_max_node(self, node: MinMaxNode) -> VisitorOutputT:  # noqa: D
+        pass
+
     @abstractmethod
     def visit_add_generated_uuid_column_node(self, node: AddGeneratedUuidColumnNode) -> VisitorOutputT:  # noqa: D
         pass
@@ -1262,6 +1267,36 @@ class ConstrainTimeRangeNode(AggregatedMeasuresOutput, BaseOutput):
         )
 
 
+class MinMaxNode(BaseOutput):
+    """Calculate the min and max of a single instance data set."""
+
+    def __init__(self, parent_node: BaseOutput) -> None:  # noqa: D
+        self._parent_node = parent_node
+        super().__init__(node_id=self.create_unique_id(), parent_nodes=[parent_node])
+
+    @classmethod
+    def id_prefix(cls) -> str:  # noqa: D
+        return DATAFLOW_NODE_MIN_MAX_ID_PREFIX
+
+    def accept(self, visitor: DataflowPlanNodeVisitor[VisitorOutputT]) -> VisitorOutputT:  # noqa: D
+        return visitor.visit_min_max_node(self)
+
+    @property
+    def description(self) -> str:  # noqa: D
+        return "Calculate min and max"
+
+    @property
+    def parent_node(self) -> BaseOutput:  # noqa: D
+        return self._parent_node
+
+    def functionally_identical(self, other_node: DataflowPlanNode) -> bool:  # noqa: D
+        return isinstance(other_node, self.__class__)
+
+    def with_new_parents(self, new_parent_nodes: Sequence[BaseOutput]) -> MinMaxNode:  # noqa: D
+        assert len(new_parent_nodes) == 1
+        return MinMaxNode(parent_node=new_parent_nodes[0])
+
+
 class AddGeneratedUuidColumnNode(BaseOutput):
     """Adds a UUID column."""
 

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/dataflow/optimizer/source_scan/cm_branch_combiner.py

@@ -19,6 +19,7 @@ from metricflow.dataflow.dataflow_plan import (
     JoinToBaseOutputNode,
     JoinToTimeSpineNode,
     MetricTimeDimensionTransformNode,
+    MinMaxNode,
     OrderByLimitNode,
     ReadSqlSourceNode,
     SemiAdditiveJoinNode,
@@ -424,3 +425,7 @@ class ComputeMetricsBranchCombiner(DataflowPlanNodeVisitor[ComputeMetricsBranchC
     ) -> ComputeMetricsBranchCombinerResult:
         self._log_visit_node_type(node)
         return self._default_handler(node)
+
+    def visit_min_max_node(self, node: MinMaxNode) -> ComputeMetricsBranchCombinerResult:  # noqa: D
+        self._log_visit_node_type(node)
+        return self._default_handler(node)

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/dataflow/optimizer/source_scan/source_scan_optimizer.py

@@ -21,6 +21,7 @@ from metricflow.dataflow.dataflow_plan import (
     JoinToBaseOutputNode,
     JoinToTimeSpineNode,
     MetricTimeDimensionTransformNode,
+    MinMaxNode,
     OrderByLimitNode,
     ReadSqlSourceNode,
     SemiAdditiveJoinNode,
@@ -341,3 +342,7 @@ class SourceScanOptimizer(
     def visit_join_conversion_events_node(self, node: JoinConversionEventsNode) -> OptimizeBranchResult:  # noqa: D
         self._log_visit_node_type(node)
         return self._default_base_output_handler(node)
+
+    def visit_min_max_node(self, node: MinMaxNode) -> OptimizeBranchResult:  # noqa: D
+        self._log_visit_node_type(node)
+        return self._default_base_output_handler(node)

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/engine/metricflow_engine.py

@@ -109,6 +109,7 @@ class MetricFlowQueryRequest:
     where_constraint: Optional[str] = None
     order_by_names: Optional[Sequence[str]] = None
     order_by: Optional[Sequence[OrderByQueryParameter]] = None
+    min_max_only: bool = False
     output_table: Optional[str] = None
     sql_optimization_level: SqlQueryOptimizationLevel = SqlQueryOptimizationLevel.O4
     query_type: MetricFlowQueryType = MetricFlowQueryType.METRIC
@@ -129,6 +130,7 @@ class MetricFlowQueryRequest:
         output_table: Optional[str] = None,
         sql_optimization_level: SqlQueryOptimizationLevel = SqlQueryOptimizationLevel.O4,
         query_type: MetricFlowQueryType = MetricFlowQueryType.METRIC,
+        min_max_only: bool = False,
     ) -> MetricFlowQueryRequest:
         return MetricFlowQueryRequest(
             request_id=MetricFlowRequestId(mf_rid=f"{random_id()}"),
@@ -146,6 +148,7 @@ class MetricFlowQueryRequest:
             output_table=output_table,
             sql_optimization_level=sql_optimization_level,
             query_type=query_type,
+            min_max_only=min_max_only,
         )
 
 
@@ -434,6 +437,7 @@ class MetricFlowEngine(AbstractMetricFlowEngine):
                 where_constraint_str=mf_query_request.where_constraint,
                 order_by_names=mf_query_request.order_by_names,
                 order_by=mf_query_request.order_by,
+                min_max_only=mf_query_request.min_max_only,
             )
         logger.info(f"Query spec is:\n{pformat_big_objects(query_spec)}")
 

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/engine/models.py

@@ -43,6 +43,7 @@ class Metric:
     filter: Optional[WhereFilterIntersection]
     metadata: Optional[Metadata]
     dimensions: List[Dimension]
+    label: Optional[str]
 
     @classmethod
     def from_pydantic(cls, pydantic_metric: SemanticManifestMetric, dimensions: List[Dimension]) -> Metric:
@@ -55,6 +56,7 @@ class Metric:
             filter=pydantic_metric.filter,
             metadata=pydantic_metric.metadata,
             dimensions=dimensions,
+            label=pydantic_metric.label,
         )
 
     @property
@@ -79,6 +81,7 @@ class Dimension:
     metadata: Optional[Metadata]
     is_partition: bool = False
     expr: Optional[str] = None
+    label: Optional[str] = None
 
     @classmethod
     def from_pydantic(cls, pydantic_dimension: SemanticManifestDimension, path_key: ElementPathKey) -> Dimension:
@@ -102,6 +105,7 @@ class Dimension:
             metadata=pydantic_dimension.metadata,
             is_partition=pydantic_dimension.is_partition,
             expr=pydantic_dimension.expr,
+            label=pydantic_dimension.label,
         )
 
     @property

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/plan_conversion/column_resolver.py

@@ -79,7 +79,7 @@ class DunderColumnAssociationResolverVisitor(InstanceSpecVisitor[ColumnAssociati
 
     def visit_metadata_spec(self, metadata_spec: MetadataSpec) -> ColumnAssociation:  # noqa: D
         return ColumnAssociation(
-            column_name=metadata_spec.element_name,
+            column_name=metadata_spec.qualified_name,
             single_column_correlation_key=SingleColumnCorrelationKey(),
         )
 

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/plan_conversion/dataflow_to_sql.py

@@ -7,6 +7,7 @@ from typing import List, Optional, Sequence, Tuple, Union
 from dbt_semantic_interfaces.enum_extension import assert_values_exhausted
 from dbt_semantic_interfaces.protocols.metric import MetricInputMeasure, MetricType
 from dbt_semantic_interfaces.references import MetricModelReference
+from dbt_semantic_interfaces.type_enums.aggregation_type import AggregationType
 from dbt_semantic_interfaces.type_enums.conversion_calculation_type import ConversionCalculationType
 from dbt_semantic_interfaces.validations.unique_valid_name import MetricFlowReservedKeywords
 
@@ -27,6 +28,7 @@ from metricflow.dataflow.dataflow_plan import (
     JoinToBaseOutputNode,
     JoinToTimeSpineNode,
     MetricTimeDimensionTransformNode,
+    MinMaxNode,
     OrderByLimitNode,
     ReadSqlSourceNode,
     SemiAdditiveJoinNode,
@@ -37,12 +39,7 @@ from metricflow.dataflow.dataflow_plan import (
 from metricflow.dataset.dataset import DataSet
 from metricflow.dataset.sql_dataset import SqlDataSet
 from metricflow.filters.time_constraint import TimeRangeConstraint
-from metricflow.instances import (
-    InstanceSet,
-    MetadataInstance,
-    MetricInstance,
-    TimeDimensionInstance,
-)
+from metricflow.instances import InstanceSet, MetadataInstance, MetricInstance, TimeDimensionInstance
 from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
 from metricflow.plan_conversion.instance_converters import (
     AddLinkToLinkableElements,
@@ -51,6 +48,7 @@ from metricflow.plan_conversion.instance_converters import (
     AliasAggregatedMeasures,
     ChangeAssociatedColumns,
     ChangeMeasureAggregationState,
+    ConvertToMetadata,
     CreateSelectColumnForCombineOutputNode,
     CreateSelectColumnsForInstances,
     CreateSelectColumnsWithMeasuresAggregated,
@@ -1367,6 +1365,47 @@ class DataflowToSqlQueryPlanConverter(DataflowPlanNodeVisitor[SqlDataSet]):
             ),
         )
 
+    def visit_min_max_node(self, node: MinMaxNode) -> SqlDataSet:  # noqa: D
+        parent_data_set = node.parent_node.accept(self)
+        parent_table_alias = self._next_unique_table_alias()
+        assert (
+            len(parent_data_set.sql_select_node.select_columns) == 1
+        ), "MinMaxNode supports exactly one parent select column."
+        parent_column_alias = parent_data_set.sql_select_node.select_columns[0].column_alias
+
+        select_columns: List[SqlSelectColumn] = []
+        metadata_instances: List[MetadataInstance] = []
+        for agg_type in (AggregationType.MIN, AggregationType.MAX):
+            metadata_spec = MetadataSpec.from_name(name=parent_column_alias, agg_type=agg_type)
+            output_column_association = self._column_association_resolver.resolve_spec(metadata_spec)
+            select_columns.append(
+                SqlSelectColumn(
+                    expr=SqlFunctionExpression.build_expression_from_aggregation_type(
+                        aggregation_type=agg_type,
+                        sql_column_expression=SqlColumnReferenceExpression(
+                            SqlColumnReference(table_alias=parent_table_alias, column_name=parent_column_alias)
+                        ),
+                    ),
+                    column_alias=output_column_association.column_name,
+                )
+            )
+            metadata_instances.append(
+                MetadataInstance(associated_columns=(output_column_association,), spec=metadata_spec)
+            )
+
+        return SqlDataSet(
+            instance_set=parent_data_set.instance_set.transform(ConvertToMetadata(metadata_instances)),
+            sql_select_node=SqlSelectStatementNode(
+                description=node.description,
+                select_columns=tuple(select_columns),
+                from_source=parent_data_set.sql_select_node,
+                from_source_alias=parent_table_alias,
+                joins_descs=(),
+                group_bys=(),
+                order_bys=(),
+            ),
+        )
+
     def visit_add_generated_uuid_column_node(self, node: AddGeneratedUuidColumnNode) -> SqlDataSet:
         """Implements the behaviour of AddGeneratedUuidColumnNode.
 

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/plan_conversion/instance_converters.py

@@ -950,6 +950,18 @@ class ChangeAssociatedColumns(InstanceSetTransform[InstanceSet]):
         )
 
 
+class ConvertToMetadata(InstanceSetTransform[InstanceSet]):
+    """Removes all instances from old instance set and replaces them with a set of metadata instances."""
+
+    def __init__(self, metadata_instances: Sequence[MetadataInstance]) -> None:  # noqa: D
+        self._metadata_instances = metadata_instances
+
+    def transform(self, instance_set: InstanceSet) -> InstanceSet:  # noqa: D
+        return InstanceSet(
+            metadata_instances=tuple(self._metadata_instances),
+        )
+
+
 def create_select_columns_for_instance_sets(
     column_resolver: ColumnAssociationResolver,
     table_alias_to_instance_set: OrderedDict[str, InstanceSet],

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/query/issues/group_by_item_resolver/no_common_items.py

@@ -69,9 +69,10 @@ class NoCommonItemsInParents(MetricFlowQueryResolutionIssue):
                 (spec_str if spec_str is not None else "None") for spec_str in spec_as_strs
             ]
         return (
-            f"{last_path_item.ui_description} is built from {last_path_item_parent_descriptions}. However, the "
-            f"given input does not match to a common item that is available to those parents:\n\n"
-            f"{indent_log_line(mf_pformat(parent_to_available_items))}\n\n"
+            f"{last_path_item.ui_description} is built from:\n\n"
+            f"{indent_log_line(last_path_item_parent_descriptions)}.\n"
+            f"However, the given input does not match to a common item that is available to those parents:\n\n"
+            f"{indent_log_line(mf_pformat(parent_to_available_items, max_line_length=80))}\n\n"
             f"For time dimension inputs, please specify a time grain as ambiguous resolution only allows "
             f"resolution when the parents have the same defined time gain."
         )

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/query/issues/group_by_item_resolver/no_matching_items_for_measure.py

@@ -43,18 +43,19 @@ class NoMatchingItemsForMeasure(MetricFlowQueryResolutionIssue):
     @override
     def ui_description(self, associated_input: MetricFlowQueryResolverInput) -> str:
         lines = [
-            f"The given input does not match any of the available group-by-items for "
+            f"The given input does not match any of the available group-by-items for\n"
             f"{self.query_resolution_path.last_item.ui_description}. Common issues are:\n",
             indent_log_line(
                 "* Incorrect names.\n"
-                "* No valid join paths exist from the measure to the group-by-item "
-                "(fan-out joins are not yet supported).\n"
-                "* There are multiple matching join paths (disambiguation support is pending)."
+                "* No valid join paths exist from the measure to the group-by-item.\n"
+                "  (fan-out join support is pending).\n"
+                "* There are multiple matching join paths.\n"
+                "  (disambiguation support is pending)."
             ),
         ]
 
         if len(self.suggestions) > 0:
-            lines.append(f"\nSuggestions:\n{indent_log_line(mf_pformat(list(self.suggestions)))}")
+            lines.append(f"\nSuggestions:\n{indent_log_line(mf_pformat(list(self.suggestions), max_line_length=80))}")
         return "\n".join(lines)
 
     @override

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/query/issues/group_by_item_resolver/no_matching_items_for_no_metrics_query.py

@@ -32,8 +32,8 @@ class NoMatchingItemsForNoMetricsQuery(MetricFlowQueryResolutionIssue):
     def ui_description(self, associated_input: MetricFlowQueryResolverInput) -> str:
         # Could be useful to list the candidates, but it makes the logs very long.
         return (
-            "The given input does not match any of the available group-by-items for a distinct values query without "
-            "metrics."
+            "The given input does not match any of the available group-by-items for a distinct\n"
+            "values query without metrics."
         )
 
     @override

metricflow-0.204.0.dev6/metricflow/query/issues/parsing/invalid_min_max_only.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from typing_extensions import override
+
+from metricflow.query.group_by_item.resolution_path import MetricFlowQueryResolutionPath
+from metricflow.query.issues.issues_base import (
+    MetricFlowQueryIssueType,
+    MetricFlowQueryResolutionIssue,
+)
+from metricflow.query.resolver_inputs.base_resolver_inputs import MetricFlowQueryResolverInput
+
+
+@dataclass(frozen=True)
+class InvalidMinMaxOnlyIssue(MetricFlowQueryResolutionIssue):
+    """Describes an issue with the query where the limit is invalid."""
+
+    min_max_only: bool
+
+    @staticmethod
+    def from_parameters(  # noqa: D
+        min_max_only: bool, query_resolution_path: MetricFlowQueryResolutionPath
+    ) -> InvalidMinMaxOnlyIssue:
+        return InvalidMinMaxOnlyIssue(
+            issue_type=MetricFlowQueryIssueType.ERROR,
+            parent_issues=(),
+            query_resolution_path=query_resolution_path,
+            min_max_only=min_max_only,
+        )
+
+    @override
+    def ui_description(self, associated_input: MetricFlowQueryResolverInput) -> str:
+        return "`min_max_only` must be used with exactly one `group_by`, and cannot be used with `metrics`, `order_by`, or `limit`."
+
+    @override
+    def with_path_prefix(self, path_prefix_node: MetricFlowQueryResolutionPath) -> InvalidMinMaxOnlyIssue:
+        return InvalidMinMaxOnlyIssue(
+            issue_type=self.issue_type,
+            parent_issues=tuple(issue.with_path_prefix(path_prefix_node) for issue in self.parent_issues),
+            query_resolution_path=self.query_resolution_path.with_path_prefix(path_prefix_node),
+            min_max_only=self.min_max_only,
+        )

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/query/query_parser.py

@@ -42,6 +42,7 @@ from metricflow.query.resolver_inputs.query_resolver_inputs import (
     ResolverInputForGroupByItem,
     ResolverInputForLimit,
     ResolverInputForMetric,
+    ResolverInputForMinMaxOnly,
     ResolverInputForOrderByItem,
     ResolverInputForQuery,
     ResolverInputForQueryLevelWhereFilterIntersection,
@@ -307,11 +308,13 @@ class MetricFlowQueryParser:
         where_constraint_str: Optional[str] = None,
         order_by_names: Optional[Sequence[str]] = None,
         order_by: Optional[Sequence[OrderByQueryParameter]] = None,
+        min_max_only: bool = False,
     ) -> MetricFlowQuerySpec:
         """Parse the query into spec objects, validating them in the process.
 
         e.g. make sure that the given metric is a valid metric name.
         """
+        # TODO: validate min_max_only - can only be called for non-metric queries
         assert_at_most_one_arg_set(metric_names=metric_names, metrics=metrics)
         assert_at_most_one_arg_set(group_by_names=group_by_names, group_by=group_by)
         assert_at_most_one_arg_set(order_by_names=order_by_names, order_by=order_by)
@@ -423,6 +426,7 @@ class MetricFlowQueryParser:
         resolver_inputs_for_order_by.extend(MetricFlowQueryParser._parse_order_by(order_by=order_by))
 
         resolver_input_for_limit = ResolverInputForLimit(limit=limit)
+        resolver_input_for_min_max_only = ResolverInputForMinMaxOnly(min_max_only=min_max_only)
 
         resolver_input_for_query = ResolverInputForQuery(
             metric_inputs=tuple(resolver_inputs_for_metrics),
@@ -430,6 +434,7 @@ class MetricFlowQueryParser:
             order_by_item_inputs=tuple(resolver_inputs_for_order_by),
             limit_input=resolver_input_for_limit,
             filter_input=resolver_input_for_filter,
+            min_max_only=resolver_input_for_min_max_only,
         )
 
         logger.info("Resolver input for query is:\n" + indent_log_line(mf_pformat(resolver_input_for_query)))

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/query/query_resolver.py

@@ -26,6 +26,7 @@ from metricflow.query.issues.issues_base import (
 )
 from metricflow.query.issues.parsing.invalid_limit import InvalidLimitIssue
 from metricflow.query.issues.parsing.invalid_metric import InvalidMetricIssue
+from metricflow.query.issues.parsing.invalid_min_max_only import InvalidMinMaxOnlyIssue
 from metricflow.query.issues.parsing.invalid_order import InvalidOrderByItemIssue
 from metricflow.query.query_resolution import (
     InputToIssueSetMapping,
@@ -36,6 +37,7 @@ from metricflow.query.resolver_inputs.query_resolver_inputs import (
     ResolverInputForGroupByItem,
     ResolverInputForLimit,
     ResolverInputForMetric,
+    ResolverInputForMinMaxOnly,
     ResolverInputForOrderByItem,
     ResolverInputForQuery,
     ResolverInputForQueryLevelWhereFilterIntersection,
@@ -80,6 +82,14 @@ class ResolveLimitResult:
     input_to_issue_set_mapping: InputToIssueSetMapping
 
 
+@dataclass(frozen=True)
+class ResolveMinMaxOnlyResult:
+    """Result of resolving a limit input."""
+
+    min_max_only: bool
+    input_to_issue_set_mapping: InputToIssueSetMapping
+
+
 @dataclass(frozen=True)
 class ResolveGroupByItemsResult:
     """Result of resolving group-by inputs to specs."""
@@ -266,6 +276,38 @@ class MetricFlowQueryResolver:
             )
         return ResolveLimitResult(limit=limit, input_to_issue_set_mapping=InputToIssueSetMapping.empty_instance())
 
+    @staticmethod
+    def _resolve_min_max_only_input(
+        min_max_only_input: ResolverInputForMinMaxOnly,
+        query_resolution_path: MetricFlowQueryResolutionPath,
+        metric_inputs: Tuple[ResolverInputForMetric, ...],
+        group_by_item_inputs: Tuple[ResolverInputForGroupByItem, ...],
+        order_by_item_inputs: Tuple[ResolverInputForOrderByItem, ...],
+        limit_input: ResolverInputForLimit,
+    ) -> ResolveMinMaxOnlyResult:
+        min_max_only = min_max_only_input.min_max_only
+        if min_max_only:
+            if (
+                metric_inputs
+                or order_by_item_inputs
+                or (limit_input.limit is not None)
+                or len(group_by_item_inputs) != 1
+            ):
+                return ResolveMinMaxOnlyResult(
+                    min_max_only=min_max_only,
+                    input_to_issue_set_mapping=InputToIssueSetMapping.from_one_item(
+                        resolver_input=min_max_only_input,
+                        issue_set=MetricFlowQueryResolutionIssueSet.from_issue(
+                            InvalidMinMaxOnlyIssue.from_parameters(
+                                min_max_only=min_max_only, query_resolution_path=query_resolution_path
+                            ),
+                        ),
+                    ),
+                )
+        return ResolveMinMaxOnlyResult(
+            min_max_only=min_max_only, input_to_issue_set_mapping=InputToIssueSetMapping.empty_instance()
+        )
+
     def _build_filter_spec_lookup(
         self,
         resolution_dag: GroupByItemResolutionDag,
@@ -284,6 +326,7 @@ class MetricFlowQueryResolver:
         order_by_item_inputs = resolver_input_for_query.order_by_item_inputs
         limit_input = resolver_input_for_query.limit_input
         query_level_filter_input = resolver_input_for_query.filter_input
+        min_max_only_input = resolver_input_for_query.min_max_only
 
         # Define a resolution path for issues where the input is considered to be the whole query.
         query_resolution_path = MetricFlowQueryResolutionPath.from_path_item(
@@ -308,6 +351,17 @@ class MetricFlowQueryResolver:
         )
         mappings_to_merge.append(resolve_limit_result.input_to_issue_set_mapping)
 
+        # Resolve min max only
+        resolve_min_max_only_result = self._resolve_min_max_only_input(
+            min_max_only_input=min_max_only_input,
+            query_resolution_path=query_resolution_path,
+            metric_inputs=metric_inputs,
+            group_by_item_inputs=group_by_item_inputs,
+            order_by_item_inputs=order_by_item_inputs,
+            limit_input=limit_input,
+        )
+        mappings_to_merge.append(resolve_min_max_only_result.input_to_issue_set_mapping)
+
         # Early stop before resolving further as with invalid metrics, the errors won't be as useful.
         issue_set_mapping_so_far = InputToIssueSetMapping.merge_iterable(mappings_to_merge)
         if issue_set_mapping_so_far.has_issues:
@@ -420,6 +474,7 @@ class MetricFlowQueryResolver:
                 limit=limit_input.limit,
                 filter_intersection=query_level_filter_input.where_filter_intersection,
                 filter_spec_resolution_lookup=filter_spec_lookup,
+                min_max_only=min_max_only_input.min_max_only,
             ),
             resolution_dag=resolution_dag,
             filter_spec_lookup=filter_spec_lookup,

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/query/resolver_inputs/query_resolver_inputs.py

@@ -118,6 +118,18 @@ class ResolverInputForLimit(MetricFlowQueryResolverInput):
         return str(self.limit)
 
 
+@dataclass(frozen=True)
+class ResolverInputForMinMaxOnly(MetricFlowQueryResolverInput):
+    """An input that describes if the query will be aggregated to only the min and max."""
+
+    min_max_only: bool = False
+
+    @property
+    @override
+    def ui_description(self) -> str:
+        return str(self.min_max_only)
+
+
 @dataclass(frozen=True)
 class ResolverInputForQueryLevelWhereFilterIntersection(MetricFlowQueryResolverInput):
     """An input that describes the where filter for the query."""
@@ -180,6 +192,7 @@ class ResolverInputForQuery(MetricFlowQueryResolverInput):
     filter_input: ResolverInputForQueryLevelWhereFilterIntersection
     order_by_item_inputs: Tuple[ResolverInputForOrderByItem, ...]
     limit_input: ResolverInputForLimit
+    min_max_only: ResolverInputForMinMaxOnly
 
     @property
     @override

{metricflow-0.204.0.dev5 → metricflow-0.204.0.dev6}/metricflow/specs/specs.py

@@ -21,7 +21,7 @@ from typing import TYPE_CHECKING, Any, Dict, Generic, List, Optional, Sequence,
 
 from dbt_semantic_interfaces.dataclass_serialization import SerializableDataclass
 from dbt_semantic_interfaces.implementations.metric import PydanticMetricTimeWindow
-from dbt_semantic_interfaces.naming.keywords import METRIC_TIME_ELEMENT_NAME
+from dbt_semantic_interfaces.naming.keywords import DUNDER, METRIC_TIME_ELEMENT_NAME
 from dbt_semantic_interfaces.protocols import MetricTimeWindow, WhereFilterIntersection
 from dbt_semantic_interfaces.references import (
     DimensionReference,
@@ -129,14 +129,15 @@ class MetadataSpec(InstanceSpec):
     """A specification for a specification that is built during the dataflow plan and not defined in config."""
 
     element_name: str
+    agg_type: Optional[AggregationType] = None
 
     @property
     def qualified_name(self) -> str:  # noqa: D
-        return self.element_name
+        return f"{self.element_name}{DUNDER}{self.agg_type.value}" if self.agg_type else self.element_name
 
     @staticmethod
-    def from_name(name: str) -> MetadataSpec:  # noqa: D
-        return MetadataSpec(element_name=name)
+    def from_name(name: str, agg_type: Optional[AggregationType] = None) -> MetadataSpec:  # noqa: D
+        return MetadataSpec(element_name=name, agg_type=agg_type)
 
     def accept(self, visitor: InstanceSpecVisitor[VisitorOutputT]) -> VisitorOutputT:  # noqa: D
         return visitor.visit_metadata_spec(self)
@@ -719,6 +720,7 @@ class MetricFlowQuerySpec(SerializableDataclass):
     limit: Optional[int] = None
     filter_intersection: Optional[WhereFilterIntersection] = None
     filter_spec_resolution_lookup: Optional[FilterSpecResolutionLookUp] = None
+    min_max_only: bool = False
 
     @property
     def linkable_specs(self) -> LinkableSpecSet:  # noqa: D