Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

support expr with multiple instances of same metric (#71930)

John Swansonc49a43c8fe69
diff --git a/frontend/src/metabase-lib/metric/core.ts b/frontend/src/metabase-lib/metric/core.ts
index 5de1c2789c3..7bd46a2e736 100644
--- a/frontend/src/metabase-lib/metric/core.ts
+++ b/frontend/src/metabase-lib/metric/core.ts
@@ -365,14 +365,17 @@ export function filterParts(
export function projections(definition: MetricDefinition): ProjectionClause[];
export function projections(
definition: MetricDefinition,
- sourceMeta: MetricMetadata | MeasureMetadata,
+ sourceInstance: SourceInstance,
): ProjectionClause[];
export function projections(
definition: MetricDefinition,
- sourceMeta?: MetricMetadata | MeasureMetadata,
+ sourceInstance?: SourceInstance,
): ProjectionClause[] {
- if (sourceMeta !== undefined) {
- return LibMetric.projections(definition, sourceMeta) as ProjectionClause[];
+ if (sourceInstance !== undefined) {
+ return LibMetric.projections(
+ definition,
+ sourceInstance,
+ ) as ProjectionClause[];
}
return LibMetric.projections(definition) as ProjectionClause[];
}
@@ -388,16 +391,16 @@ export function projectionableDimensions(
): DimensionMetadata[];
export function projectionableDimensions(
definition: MetricDefinition,
- sourceMeta: MetricMetadata | MeasureMetadata,
+ sourceInstance: SourceInstance,
): DimensionMetadata[];
export function projectionableDimensions(
definition: MetricDefinition,
- sourceMeta?: MetricMetadata | MeasureMetadata,
+ sourceInstance?: SourceInstance,
): DimensionMetadata[] {
- if (sourceMeta !== undefined) {
+ if (sourceInstance !== undefined) {
return LibMetric.projectionableDimensions(
definition,
- sourceMeta,
+ sourceInstance,
) as DimensionMetadata[];
}
return LibMetric.projectionableDimensions(definition) as DimensionMetadata[];
@@ -416,18 +419,18 @@ export function project(
export function project(
definition: MetricDefinition,
dimensionRef: ProjectionClause,
- sourceMeta: MetricMetadata | MeasureMetadata,
+ sourceInstance: SourceInstance,
): MetricDefinition;
export function project(
definition: MetricDefinition,
dimensionRef: ProjectionClause,
- sourceMeta?: MetricMetadata | MeasureMetadata,
+ sourceInstance?: SourceInstance,
): MetricDefinition {
- if (sourceMeta !== undefined) {
+ if (sourceInstance !== undefined) {
return LibMetric.project(
definition,
dimensionRef,
- sourceMeta,
+ sourceInstance,
) as MetricDefinition;
}
return LibMetric.project(definition, dimensionRef) as MetricDefinition;
diff --git a/frontend/src/metabase-types/api/metric.ts b/frontend/src/metabase-types/api/metric.ts
index 43f90863585..745fc47ba4c 100644
--- a/frontend/src/metabase-types/api/metric.ts
+++ b/frontend/src/metabase-types/api/metric.ts
@@ -35,6 +35,7 @@ export type InstanceFilter = {
export type TypedProjection = {
type: "metric" | "measure";
id: number;
+ "lib/uuid": string;
projection: unknown[];
};
diff --git a/src/metabase/lib_metric/ast/build.cljc b/src/metabase/lib_metric/ast/build.cljc
index a0349cf4a9f..1212a948e2e 100644
--- a/src/metabase/lib_metric/ast/build.cljc
+++ b/src/metabase/lib_metric/ast/build.cljc
@@ -386,8 +386,8 @@
(comp (filter #(= leaf-uuid (:lib/uuid %)))
(map :filter))
(or filters []))
- ;; Extract flat projections for this leaf's type/id
- leaf-projections (perf/some #(when (and (= leaf-type (:type %)) (= leaf-id (:id %)))
+ ;; Extract flat projections for this leaf's :lib/uuid
+ leaf-projections (perf/some #(when (= leaf-uuid (:lib/uuid %))
(:projection %))
(or projections []))
;; Convert filters and projections to AST nodes
diff --git a/src/metabase/lib_metric/definition.cljc b/src/metabase/lib_metric/definition.cljc
index 01f6b34edf1..69749caa442 100644
--- a/src/metabase/lib_metric/definition.cljc
+++ b/src/metabase/lib_metric/definition.cljc
@@ -52,7 +52,7 @@
(defn flat-projections
"Extract flat dimension-reference vectors from typed projections.
- [{:type :metric :id 42 :projection [dim-ref-1 dim-ref-2]} ...]
+ [{:type :metric :id 42 :lib/uuid \"a\" :projection [dim-ref-1 dim-ref-2]} ...]
=> [dim-ref-1 dim-ref-2 ...]"
[typed-projections]
(into [] (mapcat :projection) typed-projections))
diff --git a/src/metabase/lib_metric/js.cljs b/src/metabase/lib_metric/js.cljs
index 39274d23f2d..246ea3a9bca 100644
--- a/src/metabase/lib_metric/js.cljs
+++ b/src/metabase/lib_metric/js.cljs
@@ -239,14 +239,17 @@
(defn ^:export projections
"Get the projection clauses from a metric definition.
1-arity: returns flat dimension-ref projections (single-source only).
- 2-arity: returns projections scoped to a specific source metadata."
+ 2-arity: returns projections scoped to a specific source instance."
([definition]
(assert-single-source! definition)
(to-array (lib-metric.definition/flat-projections
(lib-metric.definition/projections definition))))
- ([definition source-metadata]
- (let [dims (lib-metric.projection/projectable-dimensions-for-source definition source-metadata)]
- (to-array (filterv :projection-positions dims)))))
+ ([definition source-instance]
+ (let [inst (->source-instance source-instance)
+ uuid (lib-metric.definition/expression-leaf-uuid inst)
+ typed-proj (some #(when (= uuid (:lib/uuid %)) %)
+ (or (:projections definition) []))]
+ (to-array (or (:projection typed-proj) [])))))
(defn ^:export fromJsMetricDefinition
"Convert a JS metric definition (from JSON) to a MetricDefinition.
@@ -278,6 +281,7 @@
norm-projections (mapv (fn [tp]
{:type (keyword (:type tp))
:id (:id tp)
+ :lib/uuid (:lib/uuid tp)
:projection (into [] (keep lib-metric.schema/normalize-dimension-ref) (:projection tp))})
raw-projections)]
{:lib/type :metric/definition
@@ -329,10 +333,11 @@
(defn- typed-projection->js
"Convert a typed-projection map to JS."
- [{:keys [type id projection]}]
+ [{:keys [type id lib/uuid projection]}]
(let [obj #js {}]
(gobject/set obj "type" (name type))
(gobject/set obj "id" id)
+ (gobject/set obj "lib/uuid" uuid)
(gobject/set obj "projection" (to-array (map expression->js projection)))
obj))
@@ -589,13 +594,13 @@
(defn ^:export projectionableDimensions
"Get dimensions that can be used for projections.
1-arity: returns dimensions for single-source definition.
- 2-arity: returns dimensions scoped to a specific source metadata."
+ 2-arity: returns dimensions scoped to a specific source instance."
([definition]
(assert-single-source! definition)
(to-array (lib-metric.projection/projectable-dimensions definition)))
- ([definition source-metadata]
+ ([definition source-instance]
(to-array (lib-metric.projection/projectable-dimensions-for-source
- definition source-metadata))))
+ definition (->source-instance source-instance)))))
(defn ^:export defaultBreakoutDimensions
"Get dimensions corresponding to the source metric's default breakout columns."
@@ -613,12 +618,12 @@
The dimension-ref must be a dimension reference (from dimensionReference,
withTemporalBucket, or withBinning).
2-arity: adds projection to single-source definition.
- 3-arity: adds projection scoped to a specific source metadata."
+ 3-arity: adds projection scoped to a specific source instance."
([definition dimension-ref]
(assert-single-source! definition)
(lib-metric.projection/project definition dimension-ref))
- ([definition dimension source-metadata]
- (lib-metric.projection/project-for-source definition dimension source-metadata)))
+ ([definition dimension-ref source-instance]
+ (lib-metric.projection/project-for-source definition dimension-ref (->source-instance source-instance))))
(defn ^:export projectionDimension
"Get the dimension metadata for a projection clause.
diff --git a/src/metabase/lib_metric/projection.cljc b/src/metabase/lib_metric/projection.cljc
index a4f4085a7bc..e5446430689 100644
--- a/src/metabase/lib_metric/projection.cljc
+++ b/src/metabase/lib_metric/projection.cljc
@@ -41,68 +41,74 @@
(mu/defn projectable-dimensions :- [:sequential ::lib-metric.schema/metadata-dimension]
"Get dimensions that can be used for projections.
- Returns dimensions with :projection-positions indicating which are already used."
+ Returns dimensions with :projection-positions indicating which are already used.
+ For single-source definitions; uses the expression leaf's :lib/uuid to scope projections."
[definition :- ::lib-metric.schema/metric-definition]
(let [{:keys [expression projections metadata-provider]} definition
- leaf-type (lib-metric.definition/expression-leaf-type expression)
- leaf-id (lib-metric.definition/expression-leaf-id expression)
+ leaf-type (lib-metric.definition/expression-leaf-type expression)
+ leaf-id (lib-metric.definition/expression-leaf-id expression)
+ leaf-uuid (lib-metric.definition/expression-leaf-uuid expression)
dimensions (case leaf-type
:metric (lib-metric.dimension/dimensions-for-metric metadata-provider leaf-id)
:measure (lib-metric.dimension/dimensions-for-measure metadata-provider leaf-id))
- flat-projs (lib-metric.definition/flat-projections (or projections []))]
+ typed-proj (perf/some #(when (= leaf-uuid (:lib/uuid %)) %)
+ (or projections []))
+ flat-projs (if typed-proj (:projection typed-proj) [])]
(add-projection-positions dimensions flat-projs)))
(defn projectable-dimensions-for-source
- "Get projectable dimensions for a specific source (MetricMetadata or MeasureMetadata).
+ "Get projectable dimensions for a specific source instance.
+ source-instance is an expression leaf vector [:metric {:lib/uuid \"...\"} id]
+ or [:measure {:lib/uuid \"...\"} id].
Returns dimensions with :projection-positions scoped to that source's typed-projection."
- [definition source-metadata]
+ [definition source-instance]
(let [{:keys [projections metadata-provider]} definition
- leaf-type (case (:lib/type source-metadata)
- :metadata/metric :metric
- :metadata/measure :measure)
- source-id (:id source-metadata)
- dimensions (case leaf-type
- :metric (lib-metric.dimension/dimensions-for-metric metadata-provider source-id)
- :measure (lib-metric.dimension/dimensions-for-measure metadata-provider source-id))
- typed-proj (perf/some #(when (and (= (:type %) leaf-type) (= (:id %) source-id)) %)
- (or projections []))
- flat-projs (if typed-proj (:projection typed-proj) [])]
+ leaf-type (lib-metric.definition/expression-leaf-type source-instance)
+ source-id (lib-metric.definition/expression-leaf-id source-instance)
+ source-uuid (lib-metric.definition/expression-leaf-uuid source-instance)
+ dimensions (case leaf-type
+ :metric (lib-metric.dimension/dimensions-for-metric metadata-provider source-id)
+ :measure (lib-metric.dimension/dimensions-for-measure metadata-provider source-id))
+ typed-proj (perf/some #(when (= source-uuid (:lib/uuid %)) %)
+ (or projections []))
+ flat-projs (if typed-proj (:projection typed-proj) [])]
(add-projection-positions dimensions flat-projs)))
(defn project-for-source
- "Add a projection for a dimension to a specific source.
- source-metadata is MetricMetadata or MeasureMetadata."
- [definition dimension source-metadata]
- (let [leaf-type (case (:lib/type source-metadata)
- :metadata/metric :metric
- :metadata/measure :measure)
- source-id (:id source-metadata)
- dimension-ref (lib/ensure-uuid [:dimension {} (:id dimension)])
+ "Add a projection for a dimension-ref to a specific source instance.
+ source-instance is an expression leaf vector [:metric {:lib/uuid \"...\"} id]
+ or [:measure {:lib/uuid \"...\"} id]."
+ [definition dimension-ref source-instance]
+ (let [leaf-type (lib-metric.definition/expression-leaf-type source-instance)
+ source-id (lib-metric.definition/expression-leaf-id source-instance)
+ source-uuid (lib-metric.definition/expression-leaf-uuid source-instance)
+ dimension-ref (lib/ensure-uuid dimension-ref)
projections (or (:projections definition) [])
existing-idx (perf/some (fn [[idx tp]]
- (when (and (= (:type tp) leaf-type) (= (:id tp) source-id))
+ (when (= source-uuid (:lib/uuid tp))
idx))
(map-indexed vector projections))]
(if existing-idx
(update-in definition [:projections existing-idx :projection] conj dimension-ref)
(update definition :projections (fnil conj [])
- {:type leaf-type :id source-id :projection [dimension-ref]}))))
+ {:type leaf-type :id source-id :lib/uuid source-uuid :projection [dimension-ref]}))))
(mu/defn project :- ::lib-metric.schema/metric-definition
"Add a projection for a dimension reference to a metric definition.
The dimension-ref must be a dimension reference vector [:dimension opts uuid],
e.g. from `dimensionReference`, `withTemporalBucket`, or `withBinning`.
- Creates/reuses the typed-projection entry for the current source."
+ Creates/reuses the typed-projection entry keyed by the expression leaf's :lib/uuid."
[definition :- ::lib-metric.schema/metric-definition
dimension-ref :- ::lib-metric.schema/dimension-reference]
(let [expression (:expression definition)
leaf-type (lib-metric.definition/expression-leaf-type expression)
leaf-id (lib-metric.definition/expression-leaf-id expression)
+ leaf-uuid (lib-metric.definition/expression-leaf-uuid expression)
dimension-ref (lib/ensure-uuid dimension-ref)
projections (or (:projections definition) [])
- ;; Find existing typed-projection entry for this source
+ ;; Find existing typed-projection entry by :lib/uuid
existing-idx (perf/some (fn [[idx tp]]
- (when (and (= leaf-type (:type tp)) (= leaf-id (:id tp)))
+ (when (= leaf-uuid (:lib/uuid tp))
idx))
(map-indexed vector projections))]
(if existing-idx
@@ -110,7 +116,7 @@
(update-in definition [:projections existing-idx :projection] conj dimension-ref)
;; Create new typed-projection entry
(update definition :projections (fnil conj [])
- {:type leaf-type :id leaf-id :projection [dimension-ref]}))))
+ {:type leaf-type :id leaf-id :lib/uuid leaf-uuid :projection [dimension-ref]}))))
(mu/defn projection-dimension :- [:maybe ::lib-metric.schema/metadata-dimension]
"Get the dimension metadata for a projection clause.
diff --git a/src/metabase/lib_metric/schema.cljc b/src/metabase/lib_metric/schema.cljc
index c1b911e8e31..a71bf2b122a 100644
--- a/src/metabase/lib_metric/schema.cljc
+++ b/src/metabase/lib_metric/schema.cljc
@@ -279,14 +279,17 @@
[:sequential ::instance-filter])
;;; ------------------------------------------------- Typed Projections -------------------------------------------------
-;;; Projections keyed by source type and ID.
+;;; Projections keyed by :lib/uuid from the expression leaf, with type and ID for metadata resolution.
(mr/def ::typed-projection
- "A projection associated with a specific source type and ID."
+ "A projection associated with a specific expression leaf instance via :lib/uuid.
+ The :type and :id identify the source metric/measure for metadata resolution.
+ The :lib/uuid disambiguates multiple references to the same metric/measure in an expression."
[:map
{:decode/normalize lib.schema.common/normalize-map}
[:type [:enum {:decode/normalize lib.schema.common/normalize-keyword} :metric :measure]]
[:id pos-int?]
+ [:lib/uuid ::lib.schema.common/non-blank-string]
[:projection [:sequential ::dimension-reference]]])
(mr/def ::typed-projections
diff --git a/src/metabase/metrics/api.clj b/src/metabase/metrics/api.clj
index 1e629fb2c3e..44009909ff1 100644
--- a/src/metabase/metrics/api.clj
+++ b/src/metabase/metrics/api.clj
@@ -129,10 +129,10 @@
(fn [{:keys [expression filters]}]
(let [expr-uuids (set (collect-expression-uuids expression))]
(every? #(contains? expr-uuids (:lib/uuid %)) (or filters []))))]
- [:fn {:error/message "Projection type/id pairs must correspond to expression leaves"}
+ [:fn {:error/message "Projection :lib/uuid values must reference UUIDs from expression"}
(fn [{:keys [expression projections]}]
- (let [leaves (set (collect-expression-leaves expression))]
- (every? #(contains? leaves [(:type %) (:id %)]) (or projections []))))]])
+ (let [expr-uuids (set (collect-expression-uuids expression))]
+ (every? #(contains? expr-uuids (:lib/uuid %)) (or projections []))))]])
(mr/def ::DatasetRequest
"Schema for POST /dataset request body."
diff --git a/test/metabase/lib_metric/ast/build_test.cljc b/test/metabase/lib_metric/ast/build_test.cljc
index c9bd0aeb81e..2867723d505 100644
--- a/test/metabase/lib_metric/ast/build_test.cljc
+++ b/test/metabase/lib_metric/ast/build_test.cljc
@@ -391,6 +391,7 @@
(let [definition-with-projections (assoc (sample-definition)
:projections [{:type :metric
:id 42
+ :lib/uuid expr-uuid
:projection [[:dimension {} uuid-1]
[:dimension {"temporal-unit" "year"} uuid-2]]}])
ast (ast.build/from-definition definition-with-projections)]
diff --git a/test/metabase/lib_metric/binning_test.cljc b/test/metabase/lib_metric/binning_test.cljc
index 4b34120d8e3..5a7d167c571 100644
--- a/test/metabase/lib_metric/binning_test.cljc
+++ b/test/metabase/lib_metric/binning_test.cljc
@@ -154,7 +154,7 @@
(testing "Selected binning is marked when projection has binning"
(let [binning {:strategy :num-bins :num-bins 10}
projection [:dimension {:binning binning} uuid-numeric]
- def-with-proj (assoc definition :projections [{:type :metric :id 1 :projection [projection]}])
+ def-with-proj (assoc definition :projections [{:type :metric :id 1 :lib/uuid "550e8400-e29b-41d4-a716-446655440099" :projection [projection]}])
strategies (lib-metric.projection/available-binning-strategies def-with-proj numeric-dimension)]
;; The matching strategy should be marked as selected
(is (some #(and (= 10 (get-in % [:mbql :num-bins])) (:selected %)) strategies)))))
diff --git a/test/metabase/lib_metric/clause_test.cljc b/test/metabase/lib_metric/clause_test.cljc
index 6aff0897b63..5ecdd593c43 100644
--- a/test/metabase/lib_metric/clause_test.cljc
+++ b/test/metabase/lib_metric/clause_test.cljc
@@ -43,7 +43,7 @@
(deftest ^:parallel replace-clause-projection-test
(testing "replace-clause replaces a projection by UUID match"
- (let [definition (assoc base-definition :projections [{:type :metric :id 1 :projection [projection-1 projection-2]}])
+ (let [definition (assoc base-definition :projections [{:type :metric :id 1 :lib/uuid expr-uuid :projection [projection-1 projection-2]}])
new-projection [:dimension {:lib/uuid uuid-1 :temporal-unit :month} "dim-a"]
result (lib-metric.clause/replace-clause definition projection-1 new-projection)]
(is (= new-projection (get-in result [:projections 0 :projection 0])))
@@ -81,7 +81,7 @@
(deftest ^:parallel remove-clause-projection-test
(testing "remove-clause removes a projection by UUID match"
- (let [definition (assoc base-definition :projections [{:type :metric :id 1 :projection [projection-1 projection-2]}])
+ (let [definition (assoc base-definition :projections [{:type :metric :id 1 :lib/uuid expr-uuid :projection [projection-1 projection-2]}])
result (lib-metric.clause/remove-clause definition projection-1)]
(is (= [projection-2] (get-in result [:projections 0 :projection]))))))
@@ -111,13 +111,13 @@
(deftest ^:parallel remove-clause-first-of-many-test
(testing "remove-clause removes first projection element of many"
- (let [definition (assoc base-definition :projections [{:type :metric :id 1 :projection [projection-1 projection-2 projection-3]}])
+ (let [definition (assoc base-definition :projections [{:type :metric :id 1 :lib/uuid expr-uuid :projection [projection-1 projection-2 projection-3]}])
result (lib-metric.clause/remove-clause definition projection-1)]
(is (= [projection-2 projection-3] (get-in result [:projections 0 :projection]))))))
(deftest ^:parallel remove-clause-last-of-many-test
(testing "remove-clause removes last projection element of many"
- (let [definition (assoc base-definition :projections [{:type :metric :id 1 :projection [projection-1 projection-2 projection-3]}])
+ (let [definition (assoc base-definition :projections [{:type :metric :id 1 :lib/uuid expr-uuid :projection [projection-1 projection-2 projection-3]}])
result (lib-metric.clause/remove-clause definition projection-3)]
(is (= [projection-1 projection-2] (get-in result [:projections 0 :projection]))))))
@@ -133,7 +133,7 @@
(deftest ^:parallel swap-clauses-within-projections-test
(testing "swap-clauses swaps two projections"
- (let [definition (assoc base-definition :projections [{:type :metric :id 1 :projection [projection-1 projection-2 projection-3]}])
+ (let [definition (assoc base-definition :projections [{:type :metric :id 1 :lib/uuid expr-uuid :projection [projection-1 projection-2 projection-3]}])
result (lib-metric.clause/swap-clauses definition projection-1 projection-2)]
(is (= [projection-2 projection-1 projection-3]
(get-in result [:projections 0 :projection]))))))
@@ -142,7 +142,7 @@
(testing "swap-clauses swaps filter with projection"
(let [definition (assoc base-definition
:filters [inst-filter-1 inst-filter-2]
- :projections [{:type :metric :id 1 :projection [projection-3]}])
+ :projections [{:type :metric :id 1 :lib/uuid expr-uuid :projection [projection-3]}])
result (lib-metric.clause/swap-clauses definition filter-1 projection-3)]
;; filter-1's spot now has projection-3
(is (= projection-3 (get-in result [:filters 0 :filter])))
diff --git a/test/metabase/lib_metric/definition_test.cljc b/test/metabase/lib_metric/definition_test.cljc
index 3e84ec98e8c..664e76cd8a5 100644
--- a/test/metabase/lib_metric/definition_test.cljc
+++ b/test/metabase/lib_metric/definition_test.cljc
@@ -159,15 +159,15 @@
(deftest ^:parallel projections-returns-projections-from-definition-test
(let [projection [:dimension {} uuid-1]
definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)
- (assoc :projections [{:type :metric :id 42 :projection [projection]}]))]
- (is (= [{:type :metric :id 42 :projection [projection]}]
+ (assoc :projections [{:type :metric :id 42 :lib/uuid "tp-uuid" :projection [projection]}]))]
+ (is (= [{:type :metric :id 42 :lib/uuid "tp-uuid" :projection [projection]}]
(lib-metric.definition/projections definition)))))
(deftest ^:parallel projections-returns-multiple-projections-test
(let [projection-1 [:dimension {} uuid-1]
projection-2 [:dimension {:temporal-unit :month} uuid-2]
definition (-> (lib-metric.definition/from-metric-metadata mock-provider sample-metric-metadata)
- (assoc :projections [{:type :metric :id 42 :projection [projection-1 projection-2]}]))]
+ (assoc :projections [{:type :metric :id 42 :lib/uuid "tp-uuid" :projection [projection-1 projection-2]}]))]
(is (= [projection-1 projection-2]
(lib-metric.definition/flat-projections (lib-metric.definition/projections definition))))))
@@ -204,13 +204,13 @@
(let [dr1 [:dimension {} "d1"]
dr2 [:dimension {} "d2"]]
(is (= [dr1 dr2]
- (lib-metric.definition/flat-projections [{:type :metric :id 1 :projection [dr1 dr2]}])))))
+ (lib-metric.definition/flat-projections [{:type :metric :id 1 :lib/uuid "a" :projection [dr1 dr2]}])))))
(testing "multiple entries"
(let [dr1 [:dimension {} "d1"]
dr2 [:dimension {} "d2"]]
(is (= [dr1 dr2]
- (lib-metric.definition/flat-projections [{:type :metric :id 1 :projection [dr1]}
- {:type :measure :id 2 :projection [dr2]}]))))))
+ (lib-metric.definition/flat-projections [{:type :metric :id 1 :lib/uuid "a" :projection [dr1]}
+ {:type :measure :id 2 :lib/uuid "b" :projection [dr2]}]))))))
;;; -------------------------------------------------- expression-leaves --------------------------------------------------
@@ -279,5 +279,5 @@
(testing "definition with typed projections"
(is (nil? (me/humanize (mr/explain ::lib-metric.schema/metric-definition
(assoc valid-definition
- :projections [{:type :metric :id 1
+ :projections [{:type :metric :id 1 :lib/uuid uuid-1
:projection [[:dimension {} uuid-1]]}]))))))))
diff --git a/test/metabase/lib_metric/js_test.cljs b/test/metabase/lib_metric/js_test.cljs
index 53c96127202..f710261e002 100644
--- a/test/metabase/lib_metric/js_test.cljs
+++ b/test/metabase/lib_metric/js_test.cljs
@@ -74,7 +74,7 @@
(deftest ^:parallel toJsMetricDefinition-with-filters-and-projections-test
(let [inst-filter {:lib/uuid "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
:filter [:= {} [:dimension {} "uuid-1"] "Electronics"]}
- typed-proj {:type :metric :id 42 :projection [[:dimension {} "uuid-2"]]}
+ typed-proj {:type :metric :id 42 :lib/uuid "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" :projection [[:dimension {} "uuid-2"]]}
definition {:lib/type :metric/definition
:expression [:metric {:lib/uuid "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"} 42]
:filters [inst-filter]
@@ -198,7 +198,7 @@
(testing "definition with filters/projections round-trips correctly"
(let [inst-filter {:lib/uuid "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
:filter [:= {} [:dimension {} "dimension-uuid"] "value"]}
- typed-proj {:type :metric :id 42 :projection [[:dimension {} "uuid-2"]]}
+ typed-proj {:type :metric :id 42 :lib/uuid "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" :projection [[:dimension {} "uuid-2"]]}
original {:lib/type :metric/definition
:expression [:metric {:lib/uuid "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"} 42]
:filters [inst-filter]
@@ -208,7 +208,8 @@
round-trip (lib-metric.js/fromJsMetricDefinition mock-provider js-def)]
;; After round-trip, check structure is preserved
(is (= 1 (count (:filters round-trip))))
- (is (= 1 (count (:projections round-trip)))))))
+ (is (= 1 (count (:projections round-trip))))
+ (is (= "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" (:lib/uuid (first (:projections round-trip))))))))
;;; -------------------------------------------------- MetadataProviderable Tests --------------------------------------------------
diff --git a/test/metabase/lib_metric/projection_test.cljc b/test/metabase/lib_metric/projection_test.cljc
index 1fee0a41e36..0e1615974b6 100644
--- a/test/metabase/lib_metric/projection_test.cljc
+++ b/test/metabase/lib_metric/projection_test.cljc
@@ -172,13 +172,14 @@
(is (= 1 (count (:projections result))))
(is (= :metric (:type typed-proj)))
(is (= 1 (:id typed-proj)))
+ (is (= uuid-1 (:lib/uuid typed-proj)))
(is (= :dimension (first dim-ref)))
(is (= uuid-1 (nth dim-ref 2))))))
(deftest ^:parallel project-appends-to-existing-projections-test
(testing "project appends new projection to existing typed projection"
(let [definition (assoc valid-definition
- :projections [{:type :metric :id 1 :projection [dim-ref-1]}])
+ :projections [{:type :metric :id 1 :lib/uuid uuid-1 :projection [dim-ref-1]}])
result (lib-metric.projection/project definition (lib-metric.dimension/reference dimension-2))
dim-refs (get-in result [:projections 0 :projection])]
(is (= 1 (count (:projections result))))
@@ -213,7 +214,7 @@
;; we can't fully test projection-dimension without integration tests.
;; This test verifies the function exists and handles errors appropriately.
(let [definition (assoc valid-definition
- :projections [{:type :metric :id 1 :projection [dim-ref-1]}])]
+ :projections [{:type :metric :id 1 :lib/uuid uuid-1 :projection [dim-ref-1]}])]
(is (thrown? #?(:clj Exception :cljs js/Error)
(lib-metric.projection/projection-dimension definition dim-ref-1))))))
@@ -300,16 +301,17 @@
;;; -------------------------------------------------- projectable-dimensions-for-source --------------------------------------------------
-(def ^:private source-metric-metadata
- {:lib/type :metadata/metric :id 1 :name "Test Metric"})
+(def ^:private source-instance
+ "A source instance expression leaf for testing."
+ [:metric {:lib/uuid uuid-1} 1])
(deftest ^:parallel projectable-dimensions-for-source-test
(testing "returns dims scoped to source with projection-positions"
(let [definition (assoc definition-with-provider
- :projections [{:type :metric :id 1
+ :projections [{:type :metric :id 1 :lib/uuid uuid-1
:projection [dim-ref-1]}])
dims (lib-metric.projection/projectable-dimensions-for-source
- definition source-metric-metadata)]
+ definition source-instance)]
(is (seq dims))
(let [dim-with-pos (some #(when (= uuid-1 (:id %)) %) dims)]
(is (some? dim-with-pos))
@@ -318,7 +320,7 @@
(deftest ^:parallel projectable-dimensions-for-source-no-projections-test
(testing "returns dims without positions when no projections for source"
(let [dims (lib-metric.projection/projectable-dimensions-for-source
- definition-with-provider source-metric-metadata)]
+ definition-with-provider source-instance)]
(is (seq dims))
(doseq [dim dims]
(is (nil? (:projection-positions dim)))))))
@@ -327,21 +329,24 @@
(deftest ^:parallel project-for-source-creates-new-typed-projection-test
(testing "project-for-source creates a new typed-projection entry"
- (let [result (lib-metric.projection/project-for-source
- definition-with-provider dimension-1 source-metric-metadata)
+ (let [dim-ref (lib-metric.dimension/reference dimension-1)
+ result (lib-metric.projection/project-for-source
+ definition-with-provider dim-ref source-instance)
typed-proj (first (:projections result))]
(is (= 1 (count (:projections result))))
(is (= :metric (:type typed-proj)))
(is (= 1 (:id typed-proj)))
+ (is (= uuid-1 (:lib/uuid typed-proj)))
(is (= 1 (count (:projection typed-proj)))))))
(deftest ^:parallel project-for-source-appends-to-existing-test
(testing "project-for-source appends to existing typed-projection"
(let [definition (assoc definition-with-provider
- :projections [{:type :metric :id 1
+ :projections [{:type :metric :id 1 :lib/uuid uuid-1
:projection [dim-ref-1]}])
+ dim-ref (lib-metric.dimension/reference dimension-2)
result (lib-metric.projection/project-for-source
- definition dimension-2 source-metric-metadata)
+ definition dim-ref source-instance)
dim-refs (get-in result [:projections 0 :projection])]
(is (= 1 (count (:projections result))))
(is (= 2 (count dim-refs))))))
diff --git a/test/metabase/lib_metric/temporal_bucket_test.cljc b/test/metabase/lib_metric/temporal_bucket_test.cljc
index 246f0eed7b7..6b113afe975 100644
--- a/test/metabase/lib_metric/temporal_bucket_test.cljc
+++ b/test/metabase/lib_metric/temporal_bucket_test.cljc
@@ -125,7 +125,7 @@
(deftest ^:parallel available-temporal-buckets-marks-selected-test
(testing "Selected unit is marked when projection has temporal-unit"
(let [projection [:dimension {:temporal-unit :month} uuid-datetime]
- def-with-proj (assoc definition :projections [{:type :metric :id 1 :projection [projection]}])
+ def-with-proj (assoc definition :projections [{:type :metric :id 1 :lib/uuid "550e8400-e29b-41d4-a716-446655440099" :projection [projection]}])
buckets (lib-metric.projection/available-temporal-buckets def-with-proj datetime-dimension)]
(is (some #(and (= :month (:unit %)) (:selected %)) buckets)))))
diff --git a/test/metabase/metrics/api_dataset_test.clj b/test/metabase/metrics/api_dataset_test.clj
index ece8e1a3681..ed3f42111ce 100644
--- a/test/metabase/metrics/api_dataset_test.clj
+++ b/test/metabase/metrics/api_dataset_test.clj
@@ -466,7 +466,7 @@
price-dim (find-dimension-by-name hydrated "PRICE")]
(is (some? price-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {} (:id price-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {} (:id price-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 4 (:row_count response))))))))
@@ -481,8 +481,8 @@
(is (some? price-dim))
(is (some? cat-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {} (:id price-dim)]
- [:dimension {} (:id cat-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {} (:id price-dim)]
+ [:dimension {} (:id cat-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 4 (:row_count response))
"should have more than 4 rows for price/category combinations"))))))
@@ -497,7 +497,7 @@
(is (some? price-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
:filters [{:lib/uuid "a" :filter [:>= {} [:dimension {} (:id price-dim)] 2]}]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {} (:id price-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {} (:id price-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 3 (:row_count response)) "prices 2, 3, 4")
(let [rows (result-rows response)]
@@ -516,7 +516,7 @@
date-dim (find-dimension-by-name hydrated "DATE")]
(is (some? date-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :day} (:id date-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :day} (:id date-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 1 (:row_count response)) "should have multiple rows grouped by day"))))))
@@ -529,9 +529,9 @@
date-dim (find-dimension-by-name hydrated "DATE")]
(is (some? date-dim))
(let [day-count (:row_count (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :day} (:id date-dim)]]}]}))
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :day} (:id date-dim)]]}]}))
week-count (:row_count (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :week} (:id date-dim)]]}]}))]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :week} (:id date-dim)]]}]}))]
(is (< week-count day-count) "week grouping should have fewer rows than day grouping"))))))
(deftest dataset-projection-month-bucket-test
@@ -543,7 +543,7 @@
date-dim (find-dimension-by-name hydrated "DATE")]
(is (some? date-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 1 (:row_count response)) "should have multiple rows grouped by month"))))))
@@ -556,9 +556,9 @@
date-dim (find-dimension-by-name hydrated "DATE")]
(is (some? date-dim))
(let [month-count (:row_count (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]}))
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]}))
quarter-count (:row_count (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :quarter} (:id date-dim)]]}]}))]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :quarter} (:id date-dim)]]}]}))]
(is (<= quarter-count month-count) "quarter grouping should have fewer or equal rows than month grouping"))))))
(deftest dataset-projection-year-bucket-test
@@ -570,7 +570,7 @@
date-dim (find-dimension-by-name hydrated "DATE")]
(is (some? date-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :year} (:id date-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :year} (:id date-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 0 (:row_count response)) "should have at least one row grouped by year"))))))
@@ -583,7 +583,7 @@
date-dim (find-dimension-by-name hydrated "DATE")]
(is (some? date-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :day-of-week} (:id date-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :day-of-week} (:id date-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 7 (:row_count response))))))))
@@ -600,7 +600,7 @@
lat-dim (find-dimension-by-name hydrated "LATITUDE")]
(is (some? lat-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:binning {:strategy :default}} (:id lat-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:binning {:strategy :default}} (:id lat-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 1 (:row_count response)) "should have multiple bins"))))))
@@ -613,7 +613,7 @@
lat-dim (find-dimension-by-name hydrated "LATITUDE")]
(is (some? lat-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:binning {:strategy :num-bins :num-bins 5}} (:id lat-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:binning {:strategy :num-bins :num-bins 5}} (:id lat-dim)]]}]})]
(is (= "completed" (:status response)))
(is (<= (:row_count response) 6) "should have at most 5+1 bins"))))))
@@ -626,7 +626,7 @@
lat-dim (find-dimension-by-name hydrated "LATITUDE")]
(is (some? lat-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:binning {:strategy :bin-width :bin-width 10}} (:id lat-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:binning {:strategy :bin-width :bin-width 10}} (:id lat-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 0 (:row_count response)) "should have at least one bin"))))))
@@ -639,7 +639,7 @@
lat-dim (find-dimension-by-name hydrated "LATITUDE")]
(is (some? lat-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:binning {:strategy :default}} (:id lat-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:binning {:strategy :default}} (:id lat-dim)]]}]})]
(is (= "completed" (:status response))))))))
;;; +----------------------------------------------------------------------------------------------------------------+
@@ -738,7 +738,7 @@
price-dim (find-measure-dimension-by-name hydrated "PRICE")]
(is (some? price-dim))
(let [response (dataset-request {:expression [:measure {:lib/uuid "a"} (:id measure)]
- :projections [{:type :measure :id (:id measure) :projection [[:dimension {} (:id price-dim)]]}]})]
+ :projections [{:type :measure :id (:id measure) :lib/uuid "a" :projection [[:dimension {} (:id price-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 4 (:row_count response))))))))))
@@ -756,7 +756,7 @@
date-dim (find-measure-dimension-by-name hydrated "DATE")]
(is (some? date-dim))
(let [response (dataset-request {:expression [:measure {:lib/uuid "a"} (:id measure)]
- :projections [{:type :measure :id (:id measure) :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]})]
+ :projections [{:type :measure :id (:id measure) :lib/uuid "a" :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 1 (:row_count response)) "should have multiple rows grouped by month"))))))))
@@ -774,7 +774,7 @@
lat-dim (find-measure-dimension-by-name hydrated "LATITUDE")]
(is (some? lat-dim))
(let [response (dataset-request {:expression [:measure {:lib/uuid "a"} (:id measure)]
- :projections [{:type :measure :id (:id measure) :projection [[:dimension {:binning {:strategy :num-bins :num-bins 5}} (:id lat-dim)]]}]})]
+ :projections [{:type :measure :id (:id measure) :lib/uuid "a" :projection [[:dimension {:binning {:strategy :num-bins :num-bins 5}} (:id lat-dim)]]}]})]
(is (= "completed" (:status response)))
(is (<= (:row_count response) 6) "should have at most 5+1 bins"))))))))
@@ -795,7 +795,7 @@
(is (some? cat-dim))
(let [response (dataset-request {:expression [:measure {:lib/uuid "a"} (:id measure)]
:filters [{:lib/uuid "a" :filter [:>= {} [:dimension {} (:id price-dim)] 2]}]
- :projections [{:type :measure :id (:id measure) :projection [[:dimension {} (:id cat-dim)]]}]})]
+ :projections [{:type :measure :id (:id measure) :lib/uuid "a" :projection [[:dimension {} (:id cat-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 1 (:row_count response)) "should have rows broken out by category"))))))))
@@ -945,7 +945,7 @@
(is (some? date-dim))
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
:filters [{:lib/uuid "a" :filter [:time-interval {} [:dimension {} (:id date-dim)] -365 :day]}]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :month} (:id date-dim)]]}]})]
(is (= "completed" (:status response))))))))
(deftest dataset-results-match-expected-count-test
@@ -982,8 +982,8 @@
:filters [{:lib/uuid "a" :filter [:and {}
[:>= {} [:dimension {} (:id price-dim)] 2]
[:<= {} [:dimension {} (:id price-dim)] 3]]}]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {} (:id price-dim)]
- [:dimension {} (:id cat-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {} (:id price-dim)]
+ [:dimension {} (:id cat-dim)]]}]})]
(is (= "completed" (:status response)))
(is (< 1 (:row_count response)) "should have multiple rows for price/category combinations")
(let [rows (result-rows response)]
@@ -1080,7 +1080,7 @@
user-dim (find-dimension-by-name hydrated "USER_ID")]
(is (some? user-dim) "USER_ID dimension should exist")
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {} (:id user-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {} (:id user-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 1746 (:row_count response))
"should have 1746 rows, one per unique user with orders")))))))
@@ -1095,7 +1095,7 @@
category-dim (find-dimension-by-name hydrated "CATEGORY")]
(is (some? category-dim) "CATEGORY dimension from Products should exist")
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {} (:id category-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {} (:id category-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 4 (:row_count response))
"should have 4 rows, one per product category")))))))
@@ -1113,7 +1113,7 @@
(is (some? total-dim) "TOTAL dimension should exist")
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
:filters [{:lib/uuid "a" :filter [:> {} [:dimension {} (:id total-dim)] 20]}]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {} (:id category-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {} (:id category-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 4 (:row_count response))
"should have 4 rows, one per product category")))))))
@@ -1128,7 +1128,7 @@
created-dim (find-dimension-by-name hydrated "CREATED_AT")]
(is (some? created-dim) "CREATED_AT dimension should exist")
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric) :projection [[:dimension {:temporal-unit :month} (:id created-dim)]]}]})]
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a" :projection [[:dimension {:temporal-unit :month} (:id created-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 49 (:row_count response))
"should have 49 months of order data")))))))
@@ -1251,7 +1251,7 @@
created-dim (find-dimension-by-name hydrated "CREATED_AT")]
(is (some? created-dim) "CREATED_AT dimension should exist for model-based metric")
(let [response (dataset-request {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric :id (:id metric)
+ :projections [{:type :metric :id (:id metric) :lib/uuid "a"
:projection [[:dimension {:temporal-unit :month} (:id created-dim)]]}]})]
(is (= "completed" (:status response)))
(is (= 49 (:row_count response))
diff --git a/test/metabase/metrics/api_math_test.clj b/test/metabase/metrics/api_math_test.clj
index e279f97f70e..e7c62b50036 100644
--- a/test/metabase/metrics/api_math_test.clj
+++ b/test/metabase/metrics/api_math_test.clj
@@ -108,12 +108,26 @@
:filter [:= {} [:dimension {} "550e8400-e29b-41d4-a716-446655440001"] "value"]}]}))))
(deftest valid-definition-with-projections-test
- (testing "Valid definition with matching projection type/id"
+ (testing "Valid definition with matching projection :lib/uuid"
(is (valid-definition?
{:expression [:metric {:lib/uuid "a"} 42]
:projections [{:type :metric
:id 42
- :projection [[:dimension {} "550e8400-e29b-41d4-a716-446655440001"]]}]}))))
+ :lib/uuid "a"
+ :projection [[:dimension {} "550e8400-e29b-41d4-a716-446655440001"]]}]})))
+ (testing "Valid definition with same metric ID twice, different projections per instance"
+ (is (valid-definition?
+ {:expression [:+ {}
+ [:metric {:lib/uuid "a"} 42]
+ [:metric {:lib/uuid "b"} 42]]
+ :projections [{:type :metric
+ :id 42
+ :lib/uuid "a"
+ :projection [[:dimension {} "550e8400-e29b-41d4-a716-446655440001"]]}
+ {:type :metric
+ :id 42
+ :lib/uuid "b"
+ :projection [[:dimension {} "550e8400-e29b-41d4-a716-446655440002"]]}]}))))
(deftest duplicate-uuid-invalid-test
(testing "Duplicate :lib/uuid values in expression are invalid"
@@ -129,12 +143,13 @@
:filters [{:lib/uuid "does-not-exist"
:filter [:= {} [:dimension {} "550e8400-e29b-41d4-a716-446655440001"] "value"]}]})))))
-(deftest projection-type-id-not-in-expression-test
- (testing "Projection type/id not matching expression leaf is invalid"
+(deftest projection-uuid-not-in-expression-test
+ (testing "Projection :lib/uuid not matching any expression leaf is invalid"
(is (not (valid-definition?
{:expression [:metric {:lib/uuid "a"} 42]
- :projections [{:type :measure
- :id 99
+ :projections [{:type :metric
+ :id 42
+ :lib/uuid "does-not-exist"
:projection [[:dimension {} "550e8400-e29b-41d4-a716-446655440001"]]}]})))))
;;; +----------------------------------------------------------------------------------------------------------------+
@@ -174,7 +189,8 @@
(deftest normalize-typed-projection-test
(testing "Typed projection with string keys normalizes correctly"
(let [decoded (decode ::lib-metric.schema/typed-projection
- {"type" "metric" "id" 42 "projection" [["dimension" {} "d1"]]})]
+ {"type" "metric" "id" 42 "lib/uuid" "abc" "projection" [["dimension" {} "d1"]]})]
(is (= :metric (:type decoded)))
(is (= 42 (:id decoded)))
+ (is (= "abc" (:lib/uuid decoded)))
(is (= 1 (count (:projection decoded)))))))
diff --git a/test/metabase/metrics/api_test.clj b/test/metabase/metrics/api_test.clj
index 736b89fcf2c..cad35ccfd1f 100644
--- a/test/metabase/metrics/api_test.clj
+++ b/test/metabase/metrics/api_test.clj
@@ -303,8 +303,9 @@
dim-id (:id dim)
response (mt/user-http-request :rasta :post 200 "metric/breakout-values"
{:definition {:expression [:metric {:lib/uuid "a"} (:id metric)]
- :projections [{:type :metric
- :id (:id metric)
+ :projections [{:type :metric
+ :id (:id metric)
+ :lib/uuid "a"
:projection [[:dimension {} dim-id]]}]}})]
(is (sequential? (:values response)))
(is (seq (:values response)))