Skip to content

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

Fix data app query issues found by a trial build (#84094)

Alexander Polyankin59d66520f2e5
diff --git a/enterprise/backend/src/metabase_enterprise/data_apps/generate/schemas/render.clj b/enterprise/backend/src/metabase_enterprise/data_apps/generate/schemas/render.clj
index 176ff810f1c..588caa5af75 100644
--- a/enterprise/backend/src/metabase_enterprise/data_apps/generate/schemas/render.clj
+++ b/enterprise/backend/src/metabase_enterprise/data_apps/generate/schemas/render.clj
@@ -15,7 +15,8 @@
structurally in tests."
(:require
[clojure.string :as str]
- [metabase-enterprise.data-apps.generate.schemas.javascript :as schemas.javascript]))
+ [metabase-enterprise.data-apps.generate.schemas.javascript :as schemas.javascript]
+ [metabase.util :as u]))
(set! *warn-on-reflection* true)
@@ -195,13 +196,14 @@
(conj [:obj ["sourceFieldId" [:lit source-field-id]]]))))
(defn- dimension-group-output-key
- "Returns the output key for a compacted dimension group.
-
- Multiple joins to the same table need source-field suffixes to stay distinct."
- [table-key source-field-id table-key-count]
+ "Returns the output key for a compacted dimension group, suffixed by its foreign key's field key when several joins
+ reach the same table."
+ [table-key source-field-id table-key-count field-key-by-field-id]
(if (= 1 (get table-key-count table-key))
table-key
- (str table-key "Via" source-field-id)))
+ (str table-key "Via" (if-let [field-key (get field-key-by-field-id source-field-id)]
+ (u/capitalize-first-char field-key)
+ source-field-id))))
(defn- metric-dimension-table-field
"Returns table field metadata when a metric dimension can be represented by `pickFields(...)`."
@@ -244,12 +246,18 @@
{:dimension-keys #{}
:fields-by-group (array-map)}
dimensions)
- table-key-count (frequencies (map (comp :table-key val) fields-by-group))]
+ table-key-count (frequencies (map (comp :table-key val) fields-by-group))
+ field-key-by-field-id (into {}
+ (keep (fn [[[_table-id field-id-or-name] {:keys [field-key]}]]
+ (when (integer? field-id-or-name)
+ [field-id-or-name field-key])))
+ field-key-by-table-and-field)]
{:dimension-keys dimension-keys
:fields (not-empty
(reduce-kv (fn [acc _ {:keys [table-key reference field-keys source-field-id]}]
(assoc acc
- (dimension-group-output-key table-key source-field-id table-key-count)
+ (dimension-group-output-key table-key source-field-id table-key-count
+ field-key-by-field-id)
(pick-fields-call reference
(distinct field-keys)
source-field-id)))
diff --git a/enterprise/backend/test/metabase_enterprise/data_apps/generate/schemas/render_test.clj b/enterprise/backend/test/metabase_enterprise/data_apps/generate/schemas/render_test.clj
index da920315e7a..b013edb3c70 100644
--- a/enterprise/backend/test/metabase_enterprise/data_apps/generate/schemas/render_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/data_apps/generate/schemas/render_test.clj
@@ -115,6 +115,19 @@
(testing "a blank description is not written"
(is (not (str/includes? body "description"))))))
+(deftest typescript-renderer-names-joins-to-the-same-table-by-their-foreign-keys-test
+ (let [orders (-> orders-table
+ (assoc-in [:fields "createdBy"] {:type "column" :name "created_by" :jsType "number" :fieldId 41 :tableId 10})
+ (assoc-in [:fields "approvedBy"] {:type "column" :name "approved_by" :jsType "number" :fieldId 42 :tableId 10}))
+ body (schemas/render-typescript
+ {:schemaVersion 2
+ :tables {"orders" orders "franchises" franchises-table}
+ :metrics {"revenue" (assoc revenue-metric :dimensions
+ {"creatorName" (assoc franchise-name-dimension :sourceFieldId 41)
+ "approverName" (assoc franchise-name-dimension :sourceFieldId 42)})}})]
+ (is (str/includes? body "franchisesViaCreatedBy: pickFields(tables.franchises.fields, [ \"name\" ], { sourceFieldId: 41 })"))
+ (is (str/includes? body "franchisesViaApprovedBy: pickFields(tables.franchises.fields, [ \"name\" ], { sourceFieldId: 42 })"))))
+
(deftest typescript-renderer-compacts-metric-dimensions-test
(let [body (schemas/render-typescript compacting-schema)]
;; Metric dimensions should compact into pickFields(...) references.
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/private/use-data-app-dev-log.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/private/use-data-app-dev-log.ts
new file mode 100644
index 00000000000..8c49bd803f7
--- /dev/null
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/private/use-data-app-dev-log.ts
@@ -0,0 +1,27 @@
+import { useCallback } from "react";
+
+import { useMetabaseProviderPropsStore } from "embedding-sdk-package/lib/provider-props-store";
+
+/**
+ * Logs data app errors to the console in the dev preview only, where the diagnostics feed picks them up.
+ */
+export const useDataAppDevLog = () => {
+ const {
+ state: {
+ internalProps: { dataApp },
+ },
+ } = useMetabaseProviderPropsStore();
+
+ const isDev = dataApp?.isDev === true;
+
+ const logError = useCallback(
+ (error: unknown) => {
+ if (isDev) {
+ console.error(error);
+ }
+ },
+ [isDev],
+ );
+
+ return { logError };
+};
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/query-helpers.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/query-helpers.ts
index 4b6237fa0b1..0245e3ae32b 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/query-helpers.ts
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/query-helpers.ts
@@ -2,6 +2,7 @@ import {
isNamedBreakout,
isUnaryOperator,
} from "embedding-sdk-shared/lib/create-metabase-query/input-guards";
+import type { TemporalUnit } from "metabase-types/api";
import type { SchemaColumn } from "../data-schema";
@@ -14,6 +15,7 @@ import type {
FilterOperator,
MetabaseOrderByDirection,
NamedBreakout,
+ TimeIntervalFilterOperatorForDimension,
UnaryFilterOperatorForDimension,
ValueFilterOperatorForDimension,
} from "./types";
@@ -42,6 +44,15 @@ export function filter<
values: readonly [unknown, unknown],
): FilterForOperator<TDimension, TOperator>;
+export function filter<
+ const TDimension,
+ TOperator extends TimeIntervalFilterOperatorForDimension<TDimension>,
+>(
+ dimension: TDimension,
+ operator: TOperator,
+ interval: readonly [amount: number, unit: TemporalUnit],
+): FilterForOperator<TDimension, TOperator>;
+
export function filter<
const TDimension,
TOperator extends UnaryFilterOperatorForDimension<TDimension>,
@@ -67,6 +78,18 @@ export function filter(
};
}
+ if (operator === "time-interval") {
+ // The `time-interval` overload takes an `[amount, unit]` tuple, but the
+ // implementation signature shared by all overloads widens `value` to `unknown`.
+ const [amount, unit] = value as readonly [number, TemporalUnit];
+
+ return {
+ type: "operator",
+ operator,
+ args: [dimension, toFilterLiteral(amount), toFilterLiteral(unit)],
+ };
+ }
+
if (isUnaryOperator(operator)) {
return { type: "operator", operator, args: [dimension] };
}
@@ -115,7 +138,12 @@ export function breakout<TDimension extends object>(
export function orderBy<const TName extends string>(
breakout: NamedBreakout<unknown, TName>,
direction?: MetabaseOrderByDirection,
-): { type: "column"; name: TName; direction?: MetabaseOrderByDirection };
+): {
+ type: "column";
+ name: TName;
+ sourceFieldId?: number;
+ direction?: MetabaseOrderByDirection;
+};
export function orderBy<
TAggregation extends { columns?: readonly SchemaColumn[] },
@@ -138,9 +166,12 @@ export function orderBy<TDimension>(
direction?: MetabaseOrderByDirection,
) {
if (isNamedBreakout(dimension)) {
+ const { sourceFieldId } = dimension.column;
+
return {
type: "column",
name: dimension.name,
+ ...(sourceFieldId !== undefined ? { sourceFieldId } : undefined),
...(direction ? { direction } : undefined),
};
}
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query.unit.spec.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query.unit.spec.tsx
index 56d7c312f0c..f0594b27cd2 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query.unit.spec.tsx
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/resolve-dataset-query.unit.spec.tsx
@@ -2,7 +2,7 @@
// oxfmt-ignore
import {
createMockStore,
- mockFetchTableMetadata,
+ mockFetchTableMetadataAndForeignKeys,
mockRunRtkEndpoint,
mockSelectMetadataProviderUnfiltered,
resetTestState,
@@ -54,10 +54,12 @@ describe("resolveDatasetQuery", () => {
limit: 100,
});
- expect(mockFetchTableMetadata).toHaveBeenCalledWith({ id: 1 });
+ expect(mockFetchTableMetadataAndForeignKeys).toHaveBeenCalledWith({
+ id: 1,
+ });
expect(store.dispatch).toHaveBeenCalledWith({
- type: "fetchTableMetadata",
+ type: "fetchTableMetadataAndForeignKeys",
payload: 1,
});
@@ -211,7 +213,9 @@ describe("resolveDatasetQuery", () => {
limit: 100,
});
- expect(mockFetchTableMetadata).toHaveBeenCalledWith({ id: 1 });
+ expect(mockFetchTableMetadataAndForeignKeys).toHaveBeenCalledWith({
+ id: 1,
+ });
expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(
1,
@@ -360,7 +364,7 @@ describe("resolveDatasetQuery", () => {
source: TEST_SCHEMA.questions.ordersQuestion,
});
- expect(mockFetchTableMetadata).not.toHaveBeenCalled();
+ expect(mockFetchTableMetadataAndForeignKeys).not.toHaveBeenCalled();
expect(mockRunRtkEndpoint).toHaveBeenNthCalledWith(
1,
@@ -826,6 +830,30 @@ describe("resolveDatasetQuery aggregation column names", () => {
});
});
+describe("resolveDatasetQuery time-interval filters", () => {
+ it("passes a relative date window as an amount and a unit", async () => {
+ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({
+ source: TEST_SCHEMA.tables.orders,
+ filters: [
+ filter(TEST_SCHEMA.tables.orders.fields.createdAt, "time-interval", [
+ -24,
+ "month",
+ ]),
+ ],
+ });
+
+ expect(stagesOf(datasetQuery)[0].filters).toEqual([
+ [
+ "time-interval",
+ expect.anything(),
+ ["field", expect.anything(), 103],
+ -24,
+ "month",
+ ],
+ ]);
+ });
+});
+
describe("resolveDatasetQuery named breakouts", () => {
const orders = TEST_SCHEMA.tables.orders;
const createdMonth = breakout(orders.fields.createdAt, {
@@ -833,6 +861,42 @@ describe("resolveDatasetQuery named breakouts", () => {
name: "created_month",
});
+ it("orders by a named breakout on a joined field through its foreign key", async () => {
+ const productName = breakout(
+ TEST_SCHEMA.metrics.revenue.dimensions.orders.product,
+ { name: "product_name" },
+ );
+
+ expect(orderBy(productName, "desc")).toEqual({
+ type: "column",
+ name: "product_name",
+ sourceFieldId: 104,
+ direction: "desc",
+ });
+
+ const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({
+ source: orders,
+ aggregations: [count()],
+ breakouts: [productName],
+ orderBys: [orderBy(productName, "desc")],
+ });
+
+ expect(stagesOf(datasetQuery)[0]["order-by"]).toEqual([
+ [
+ "desc",
+ expect.anything(),
+ [
+ "field",
+ expect.objectContaining({
+ name: "product_name",
+ "source-field": 104,
+ }),
+ 202,
+ ],
+ ],
+ ]);
+ });
+
it("names a breakout's result column with breakout's name option", async () => {
const datasetQuery = await resolveDatasetQueryInBundle(createMockStore())({
source: orders,
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/setup.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/setup.tsx
index 4502215c097..3fb8ed7bed9 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/setup.tsx
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/setup.tsx
@@ -10,7 +10,7 @@ import { SdkLoadingState } from "embedding-sdk-shared/types/sdk-loading";
import { selectCard, selectTableQueryMetadata } from "metabase/api";
import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
import { selectMetadataProviderUnfiltered } from "metabase/metadata-store";
-import { fetchTableMetadata } from "metabase/redux/tables";
+import { fetchTableMetadataAndForeignKeys } from "metabase/redux/tables";
import * as Lib from "metabase-lib";
import type { DatasetQuery } from "metabase-types/api";
import { isObject } from "metabase-types/guards";
@@ -48,8 +48,8 @@ jest.mock("metabase/api/utils/run-rtk-endpoint", () => ({
}));
jest.mock("metabase/redux/tables", () => ({
- fetchTableMetadata: jest.fn(({ id }) => ({
- type: "fetchTableMetadata",
+ fetchTableMetadataAndForeignKeys: jest.fn(({ id }) => ({
+ type: "fetchTableMetadataAndForeignKeys",
payload: id,
})),
}));
@@ -58,7 +58,9 @@ jest.mock("metabase/metadata-store", () => ({
selectMetadataProviderUnfiltered: jest.fn(),
}));
-export const mockFetchTableMetadata = jest.mocked(fetchTableMetadata);
+export const mockFetchTableMetadataAndForeignKeys = jest.mocked(
+ fetchTableMetadataAndForeignKeys,
+);
export const mockSelectCard = jest.mocked(selectCard);
export const mockSelectTableQueryMetadata = jest.mocked(
selectTableQueryMetadata,
@@ -98,9 +100,12 @@ export const TEST_DATASET_QUERY = createMockDatasetQuery([
{ "source-table": 1 },
]);
-export const mockPropsStore = (reduxStore: SdkStore) =>
+export const mockPropsStore = (
+ reduxStore: SdkStore,
+ dataApp?: { name: string; isDev?: boolean },
+) =>
mockUseMetabaseProviderPropsStore.mockReturnValue({
- state: { internalProps: { reduxStore }, props: null },
+ state: { internalProps: { reduxStore, dataApp }, props: null },
store: ensureMetabaseProviderPropsStore(),
});
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-invalid.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-invalid.ts
index 277b630e493..cacf52a41bd 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-invalid.ts
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-invalid.ts
@@ -118,6 +118,15 @@ const _invalidMetricSourceQuery = {
source: TEST_SCHEMA.metrics.revenue,
} satisfies MetabaseQueryOptions;
+// @ts-expect-error a time interval takes an amount and a unit
+filter(TEST_SCHEMA.tables.orders.fields.createdAt, "time-interval", -24);
+
+// @ts-expect-error only a date dimension takes a time interval
+filter(TEST_SCHEMA.tables.orders.fields.status, "time-interval", [
+ -24,
+ "month",
+]);
+
// @ts-expect-error `unit` buckets a date, so only a date dimension offers it
breakout(TEST_SCHEMA.tables.orders.fields.status, { unit: "month" });
@@ -323,6 +332,16 @@ function InvalidTypeFixtures() {
orderBys: [{ type: "column", name: "total" }],
});
+ useMetabaseQueryObject(plainOrdersQuery, {
+ // @ts-expect-error the static query returns no column of that name
+ filters: [filter({ type: "column", name: "NOPE" }, "not-null")],
+ });
+
+ useMetabaseQueryObject(groupedStaticQuery, {
+ // @ts-expect-error a grouped static query returns no source column
+ orderBys: [{ type: "column", name: "AMOUNT" }],
+ });
+
useMetabaseQuery(plainOrdersQuery, {
// @ts-expect-error a string column takes no numeric comparison
filters: [filter({ type: "column", name: "STATUS" }, ">", 1)],
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-valid.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-valid.ts
index d56270c08d7..2f5faad30c0 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-valid.ts
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/type-contract-valid.ts
@@ -355,9 +355,17 @@ function ValidTypeFixtures() {
filters: [filter({ type: "column", name: "STATUS" }, "contains", "p")],
});
+ useMetabaseQueryObject(groupedStaticQuery, {
+ filters: [filter({ type: "column", name: "created_month" }, "not-null")],
+ orderBys: [{ type: "column", name: "total", direction: "desc" }],
+ });
+
useMetabaseQuery(pickedOrdersQuery, {
filters: [
- filter({ type: "column", name: "CREATED_AT" }, "time-interval", "x"),
+ filter({ type: "column", name: "CREATED_AT" }, "time-interval", [
+ -24,
+ "month",
+ ]),
],
});
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/use-metabase-query.unit.spec.tsx b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/use-metabase-query.unit.spec.tsx
index 999dc1f87e2..f5f7a58cd82 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/use-metabase-query.unit.spec.tsx
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/tests/use-metabase-query.unit.spec.tsx
@@ -5,6 +5,8 @@ import {
TEST_DATASET_QUERY,
createDeferred,
createMockDatasetQuery,
+ createMockStore,
+ mockPropsStore,
mockUseLazySelector,
resetTestState,
stubSdkBundle,
@@ -70,6 +72,26 @@ describe("useMetabaseQueryObject", () => {
);
});
+ it.each([
+ { isDev: true, logged: true },
+ { isDev: false, logged: false },
+ ])(
+ "logs query creation errors only in the dev preview (isDev: $isDev)",
+ async ({ isDev, logged }) => {
+ const error = new Error("No column found");
+ const resolveDatasetQuery = jest.fn(() => () => Promise.reject(error));
+ const consoleError = jest.spyOn(console, "error").mockImplementation();
+
+ stubSdkBundle({ resolveDatasetQuery });
+ mockPropsStore(createMockStore(), { name: "app", isDev });
+
+ const { result } = renderHook(() => useMetabaseQueryObject(query));
+
+ await waitFor(() => expect(result.current.error).toBe(error));
+ expect(consoleError.mock.calls).toEqual(logged ? [[error]] : []);
+ },
+ );
+
it("waits for login before resolving the query", async () => {
const resolveDatasetQuery = jest.fn(() => async () => TEST_DATASET_QUERY);
@@ -242,6 +264,27 @@ describe("useMetabaseQueryObject", () => {
});
describe("useMetabaseQuery", () => {
+ it.each([
+ { isDev: true, logged: true },
+ { isDev: false, logged: false },
+ ])(
+ "logs query errors only in the dev preview (isDev: $isDev)",
+ async ({ isDev, logged }) => {
+ const error = new Error("No column found");
+ const resolveDatasetQuery = jest.fn(() => () => Promise.reject(error));
+ const consoleError = jest.spyOn(console, "error").mockImplementation();
+
+ stubSdkBundle({ resolveDatasetQuery, queryDataset: jest.fn() });
+ mockPropsStore(createMockStore(), { name: "app", isDev });
+
+ const query = defineQuery({ source: TEST_SCHEMA.tables.orders });
+ const { result } = renderHook(() => useMetabaseQuery(query));
+
+ await waitFor(() => expect(result.current.error).toBe(error));
+ expect(consoleError.mock.calls).toEqual(logged ? [[error]] : []);
+ },
+ );
+
it("ignores a stale response after the query changes", async () => {
const firstQuery = defineQuery({
source: TEST_SCHEMA.tables.orders,
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/types.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/types.ts
index e6506a10673..2d9b666fd71 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/types.ts
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/types.ts
@@ -1,3 +1,4 @@
+import type { MetabaseQueryObject } from "metabase/embedding-sdk/types/question";
import type {
BooleanFilterOperator,
DefaultFilterOperator,
@@ -250,6 +251,7 @@ export type FilterOperator =
type UnaryFilterOperator = "is-empty" | "not-empty" | "is-null" | "not-null";
type BetweenFilterOperator = "between";
+type TimeIntervalFilterOperator = "time-interval";
type StringFilterOperator = LibStringFilterOperator | DefaultFilterOperator;
type DateFilterOperator =
| SpecificDateFilterOperator
@@ -283,9 +285,14 @@ export type BetweenFilterOperatorForDimension<TDimension> = Extract<
BetweenFilterOperator
>;
+export type TimeIntervalFilterOperatorForDimension<TDimension> = Extract<
+ FilterOperatorForDimension<TDimension>,
+ TimeIntervalFilterOperator
+>;
+
export type ValueFilterOperatorForDimension<TDimension> = Exclude<
FilterOperatorForDimension<TDimension>,
- UnaryFilterOperator | BetweenFilterOperator
+ UnaryFilterOperator | BetweenFilterOperator | TimeIntervalFilterOperator
>;
export type FilterForOperator<
@@ -735,3 +742,34 @@ export type UseMetabaseQuery = <
>
: MetabaseDynamicQuery<QueryEntity<TEntity, TQuery>, TQuery>),
) => UseMetabaseQueryResult<QueryEntity<TEntity, TQuery>, TQuery, TDynamic>;
+
+export type UseMetabaseQueryObject = <
+ TEntity extends TableSchema | undefined = undefined,
+ TSchema = unknown,
+ const TQuery = MetabaseQueryOptions<TEntity, TSchema> & DefinedQuery,
+ const TDynamic = undefined,
+>(
+ query: TQuery &
+ DefinedQuery &
+ (TQuery extends MetabaseQueryOptions<TEntity, TSchema>
+ ? TQuery extends { source: unknown }
+ ? RequireAggregationsForBreakouts<TQuery> &
+ RequireGroupedOrderByNames<TQuery>
+ : unknown
+ : MetabaseQueryOptions<TEntity, TSchema>),
+ dynamicQuery?: TDynamic &
+ (TDynamic extends MetabaseDynamicQuery<QueryEntity<TEntity, TQuery>, TQuery>
+ ? RequireAggregationsForBreakouts<TDynamic> &
+ RequireDynamicOrderByNames<
+ QueryEntity<TEntity, TQuery>,
+ TQuery,
+ TDynamic
+ >
+ : MetabaseDynamicQuery<QueryEntity<TEntity, TQuery>, TQuery>),
+) => UseMetabaseQueryObjectResult;
+
+export type UseMetabaseQueryObjectResult = {
+ query: MetabaseQueryObject | null;
+ error: unknown;
+ isLoading: boolean;
+};
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query-object.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query-object.ts
index c072b8a9d70..1beaa69b845 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query-object.ts
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query-object.ts
@@ -1,6 +1,7 @@
import { useEffect, useMemo, useRef } from "react";
import { useAsyncFn } from "react-use";
+import { useDataAppDevLog } from "embedding-sdk-package/hooks/private/use-data-app-dev-log";
import { useLazySelector } from "embedding-sdk-package/hooks/private/use-lazy-selector";
import { useMetabaseProviderPropsStore } from "embedding-sdk-package/lib/provider-props-store";
import { useSdkLoadingState } from "embedding-sdk-shared/hooks/use-sdk-loading-state";
@@ -15,23 +16,18 @@ import type {
DefinedQuery,
MetabaseDynamicQuery,
MetabaseQueryOptions,
+ UseMetabaseQueryObject,
+ UseMetabaseQueryObjectResult,
} from "./types";
-export type UseMetabaseQueryObjectResult = {
- query: MetabaseQueryObject | null;
- error: unknown;
- isLoading: boolean;
-};
+export type { UseMetabaseQueryObjectResult } from "./types";
type QueryObjectState = {
query: MetabaseQueryObject;
queryKey: string;
};
-/**
- * Resolves a data app query into a query object that can be passed to SDK question components.
- */
-export function useMetabaseQueryObject(
+function useMetabaseQueryObjectImpl(
query: MetabaseQueryOptions<undefined> & DefinedQuery,
dynamicQuery?: MetabaseDynamicQuery,
): UseMetabaseQueryObjectResult {
@@ -54,6 +50,7 @@ export function useMetabaseQueryObject(
const queryRef = useRef(query);
const dynamicQueryRef = useRef(dynamicQuery);
const pendingQueryKeyRef = useRef<string | null>(null);
+ const { logError } = useDataAppDevLog();
useEffect(() => {
queryRef.current = query;
@@ -68,18 +65,23 @@ export function useMetabaseQueryObject(
return null;
}
- const result = await resolveDatasetQuery(reduxStore)(
- queryRef.current,
- dynamicQueryRef.current,
- );
-
- return {
- // The bundle returns the opaque `DatasetQuery`; the public API publishes
- // the structural `MetabaseQueryObject` instead (see its own docs for why).
- query: result as MetabaseQueryObject,
- queryKey,
- };
- }, [queryKey, reduxStore]);
+ try {
+ const result = await resolveDatasetQuery(reduxStore)(
+ queryRef.current,
+ dynamicQueryRef.current,
+ );
+
+ return {
+ // The bundle returns the opaque `DatasetQuery`; the public API publishes
+ // the structural `MetabaseQueryObject` instead (see its own docs for why).
+ query: result as MetabaseQueryObject,
+ queryKey,
+ };
+ } catch (error) {
+ logError(error);
+ throw error;
+ }
+ }, [logError, queryKey, reduxStore]);
useEffect(() => {
if (
@@ -120,3 +122,10 @@ export function useMetabaseQueryObject(
isLoading: loading,
};
}
+
+/**
+ * Resolves a data app query into a query object that can be passed to SDK question components.
+ */
+export const useMetabaseQueryObject =
+ // The implementation takes any query; the public signature checks the dynamic clauses against the static query.
+ useMetabaseQueryObjectImpl as UseMetabaseQueryObject;
diff --git a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query.ts b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query.ts
index 234da2adc1a..473f05c8e05 100644
--- a/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query.ts
+++ b/enterprise/frontend/src/embedding-sdk-package/hooks/public/use-metabase-query/use-metabase-query.ts
@@ -1,6 +1,7 @@
import { useCallback, useEffect, useMemo, useRef } from "react";
import { useAsyncFn } from "react-use";
+import { useDataAppDevLog } from "embedding-sdk-package/hooks/private/use-data-app-dev-log";
import { useLazySelector } from "embedding-sdk-package/hooks/private/use-lazy-selector";
import { useMetabaseProviderPropsStore } from "embedding-sdk-package/lib/provider-props-store";
import { isQueryInput } from "embedding-sdk-shared/lib/create-metabase-query/input-guards";
@@ -49,6 +50,7 @@ const useMetabaseQueryImpl = <
);
const queryRef = useRef(query);
const dynamicQueryRef = useRef(dynamicQuery);
+ const { logError } = useDataAppDevLog();
useEffect(() => {
queryRef.current = query;
@@ -80,17 +82,22 @@ const useMetabaseQueryImpl = <
return null;
}
- const datasetQuery = await resolveDatasetQuery(reduxStore)(
- currentQuery,
- currentDynamicQuery,
- );
- const result = await queryDataset(reduxStore)({ datasetQuery });
-
- return mapDatasetQueryData(result);
+ try {
+ const datasetQuery = await resolveDatasetQuery(reduxStore)(
+ currentQuery,
+ currentDynamicQuery,
+ );
+ const result = await queryDataset(reduxStore)({ datasetQuery });
+
+ return mapDatasetQueryData(result);
+ } catch (error) {
+ logError(error);
+ throw error;
+ }
}
return null;
- }, [queryDataset, reduxStore, resolveDatasetQuery]);
+ }, [logError, queryDataset, reduxStore, resolveDatasetQuery]);
// Type signature of refetch requires returning Promise<void>
const refetch = useCallback(async () => {
diff --git a/frontend/src/embedding-sdk-bundle/lib/create-metabase-query/index.ts b/frontend/src/embedding-sdk-bundle/lib/create-metabase-query/index.ts
index 9a3a6fb2d4c..e7491951919 100644
--- a/frontend/src/embedding-sdk-bundle/lib/create-metabase-query/index.ts
+++ b/frontend/src/embedding-sdk-bundle/lib/create-metabase-query/index.ts
@@ -10,7 +10,7 @@ import { cardApi, selectCard, selectTableQueryMetadata } from "metabase/api";
import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
import { isDataApp, isDataAppDev } from "metabase/embedding-sdk/config";
import { selectMetadataProviderUnfiltered } from "metabase/metadata-store";
-import { fetchTableMetadata } from "metabase/redux/tables";
+import { fetchTableMetadataAndForeignKeys } from "metabase/redux/tables";
import * as Lib from "metabase-lib";
import type {
Card,
@@ -261,7 +261,9 @@ async function loadSourceMetadata(
}
if (isTableInput(input)) {
- await store.dispatch(fetchTableMetadata({ id: input.source.id }));
+ await store.dispatch(
+ fetchTableMetadataAndForeignKeys({ id: input.source.id }),
+ );
await loadReferencedMetricMetadata(store, input);
}
}
diff --git a/frontend/src/metabase-types/api/card.ts b/frontend/src/metabase-types/api/card.ts
index 991b55d7628..65e5d035bfc 100644
--- a/frontend/src/metabase-types/api/card.ts
+++ b/frontend/src/metabase-types/api/card.ts
@@ -339,6 +339,9 @@ export type VisualizationSettings = {
/** Visible table columns and order, as `{ name, enabled }` entries. */
"table.columns"?: TableColumnOrderSetting[];
+ /** Whether a table of two breakouts and one aggregation pivots; `false` keeps a row per group. */
+ "table.pivot"?: boolean;
+
/**
* Per-column titles, number or currency formatting, and click behavior.
* Keys can be modern (`getColumnKey`) or legacy (`getLegacyColumnKey`).
diff --git a/frontend/src/metabase/embedding-sdk/types/question.ts b/frontend/src/metabase/embedding-sdk/types/question.ts
index f8efbbe9ccb..f8728279488 100644
--- a/frontend/src/metabase/embedding-sdk/types/question.ts
+++ b/frontend/src/metabase/embedding-sdk/types/question.ts
@@ -99,6 +99,7 @@ export type TableVisualizationSettings = Pick<
| "pivot_table.column_split"
| "pivot_table.collapsed_rows"
| "column_settings"
+ | "table.pivot"
>;
/**
diff --git a/frontend/src/metabase/visualizations/visualizations/Table/definition.ts b/frontend/src/metabase/visualizations/visualizations/Table/definition.ts
index fe2c69d8634..d01d3afecbf 100644
--- a/frontend/src/metabase/visualizations/visualizations/Table/definition.ts
+++ b/frontend/src/metabase/visualizations/visualizations/Table/definition.ts
@@ -260,7 +260,7 @@ export const TABLE_DEFINITION = {
rows,
cols,
settings[DataGrid.COLUMN_FORMATTING_SETTING] ?? [],
- settings["table.pivot"],
+ settings["table.pivot"] ?? false,
);
},
readDependencies: [DataGrid.COLUMN_FORMATTING_SETTING, "table.pivot"],
diff --git a/frontend/src/metabase/viz-core/lib/settings/column.ts b/frontend/src/metabase/viz-core/lib/settings/column.ts
index deea1988248..c15a334af4e 100644
--- a/frontend/src/metabase/viz-core/lib/settings/column.ts
+++ b/frontend/src/metabase/viz-core/lib/settings/column.ts
@@ -562,7 +562,7 @@ export function tableColumnSettings({
getSection: () => t`Columns`,
// title: t`Columns`,
widget: "tableColumns",
- getHidden: (_series, vizSettings) => vizSettings["table.pivot"],
+ getHidden: (_series, vizSettings) => vizSettings["table.pivot"] ?? false,
getValue: ([{ data }], vizSettings) => {
const { cols } = data;
const settings = vizSettings["table.columns"] ?? [];
diff --git a/src/metabase/lib/field.cljc b/src/metabase/lib/field.cljc
index 496dea84dc2..8e32eb92d2e 100644
--- a/src/metabase/lib/field.cljc
+++ b/src/metabase/lib/field.cljc
@@ -44,7 +44,7 @@
whatever."
[{:keys [lib/temporal-unit], :as column-metadata}]
(if (and temporal-unit
- (contains? lib.schema.temporal-bucketing/datetime-extraction-units temporal-unit))
+ (contains? lib.schema.temporal-bucketing/datetime-integer-extraction-units temporal-unit))
:type/Integer
((some-fn :effective-type :base-type) column-metadata)))
diff --git a/src/metabase/lib/metadata/calculation.cljc b/src/metabase/lib/metadata/calculation.cljc
index 4b7176e9be8..2f750a9d987 100644
--- a/src/metabase/lib/metadata/calculation.cljc
+++ b/src/metabase/lib/metadata/calculation.cljc
@@ -289,7 +289,7 @@
;; `:type/Integer` if its an extraction operation, e.g. `:month-of-year` always returns an integer; otherwise we
;; can return `:base-type`.
(when (and temporal-unit
- (contains? lib.schema.temporal-bucketing/datetime-extraction-units temporal-unit))
+ (contains? lib.schema.temporal-bucketing/datetime-integer-extraction-units temporal-unit))
:type/Integer)
;; otherwise if `:base-type` is specified, we can return that.
(:base-type options)
@@ -525,8 +525,7 @@
{:selected selected})
(when-let [temporal-unit ((some-fn :lib/temporal-unit :temporal-unit) x-metadata)]
{:is-temporal-extraction
- (and (contains? lib.schema.temporal-bucketing/datetime-extraction-units temporal-unit)
- (not (contains? lib.schema.temporal-bucketing/datetime-truncation-units temporal-unit)))})
+ (contains? lib.schema.temporal-bucketing/datetime-integer-extraction-units temporal-unit)})
(select-keys x-metadata [:breakout-positions :order-by-position :filter-positions]))))
(defmethod display-info-method :default
diff --git a/src/metabase/lib/schema/temporal_bucketing.cljc b/src/metabase/lib/schema/temporal_bucketing.cljc
index e52026babcb..6b686f52447 100644
--- a/src/metabase/lib/schema/temporal_bucketing.cljc
+++ b/src/metabase/lib/schema/temporal_bucketing.cljc
@@ -145,6 +145,10 @@
"Valid EXTRACTION units for a datetime. Extraction units return integers!"
(set/union date-extraction-units time-extraction-units))
+(def datetime-integer-extraction-units
+ "Extraction units that return an integer; `:year` is left out because it truncates to a date."
+ (set/difference datetime-extraction-units datetime-truncation-units))
+
(mr/def ::unit.date-time.extract
(into [:enum {:error/message "Valid datetime extraction unit"
:decode/normalize common/normalize-keyword}]
diff --git a/src/metabase/lib/temporal_bucket.cljc b/src/metabase/lib/temporal_bucket.cljc
index 32d07830a3c..24b2b77cd16 100644
--- a/src/metabase/lib/temporal_bucket.cljc
+++ b/src/metabase/lib/temporal_bucket.cljc
@@ -400,11 +400,8 @@
[query stage-number option]
(merge {:display-name (lib.metadata.calculation/display-name query stage-number option)
:short-name (u/qualified-name (raw-temporal-bucket option))
- :is-temporal-extraction (let [bucket (raw-temporal-bucket option)]
- (and (contains? lib.schema.temporal-bucketing/datetime-extraction-units
- bucket)
- (not (contains? lib.schema.temporal-bucketing/datetime-truncation-units
- bucket))))}
+ :is-temporal-extraction (contains? lib.schema.temporal-bucketing/datetime-integer-extraction-units
+ (raw-temporal-bucket option))}
(select-keys option [:default :selected])))
(defmulti available-temporal-buckets-method
@@ -474,7 +471,7 @@
;; we want to remove it later. We will record this with the key `:lib/original-effective-type`. Note that changing the
;; unit multiple times should keep the original first value of `:lib/original-effective-type`.
(if unit
- (let [extraction-unit? (contains? lib.schema.temporal-bucketing/datetime-extraction-units unit)
+ (let [extraction-unit? (contains? lib.schema.temporal-bucketing/datetime-integer-extraction-units unit)
original-effective-type ((some-fn :lib/original-effective-type :effective-type :base-type)
options)
new-effective-type (if extraction-unit?
diff --git a/test/metabase/lib/field_test.cljc b/test/metabase/lib/field_test.cljc
index ba0b47c3131..5ae1de8e8de 100644
--- a/test/metabase/lib/field_test.cljc
+++ b/test/metabase/lib/field_test.cljc
@@ -48,14 +48,15 @@
(is (= :type/Integer
(lib/type-of query col)))))
(testing "temporal truncation (non-extraction) preserves effective type"
- (let [col (lib/with-temporal-bucket (meta/field-metadata :orders :created-at) :month)]
- (is (= (:effective-type (meta/field-metadata :orders :created-at))
- (lib/type-of query col)))))))
+ (doseq [unit [:month :year]]
+ (let [col (lib/with-temporal-bucket (meta/field-metadata :orders :created-at) unit)]
+ (is (= (:effective-type (meta/field-metadata :orders :created-at))
+ (lib/type-of query col))))))))
(deftest ^:parallel ref-test
(is (=? [:field
{:base-type :type/DateTime
- :effective-type :type/Integer
+ :effective-type :type/DateTime
:temporal-unit :year
:lib/uuid string?}
"CREATED_AT"]
diff --git a/test/metabase/lib/metadata/result_metadata_test.cljc b/test/metabase/lib/metadata/result_metadata_test.cljc
index 10739e58504..c38b4eb367a 100644
--- a/test/metabase/lib/metadata/result_metadata_test.cljc
+++ b/test/metabase/lib/metadata/result_metadata_test.cljc
@@ -918,7 +918,7 @@
(binding [lib.metadata.calculation/*display-name-style* :long]
(is (=? [{:base-type :type/DateTimeWithLocalTZ
:display-name "Created At: Year"
- :effective-type :type/Integer
+ :effective-type :type/DateTimeWithLocalTZ
;; additional keys in field ref are WRONG
::result-metadata/field-ref [:field "CREATED_AT" (partial = {:base-type :type/DateTimeWithLocalTZ
:temporal-unit :year})]
diff --git a/test/metabase/lib/query/test_spec_test.cljc b/test/metabase/lib/query/test_spec_test.cljc
index 48dd9e0a78f..890a1d4ea7c 100644
--- a/test/metabase/lib/query/test_spec_test.cljc
+++ b/test/metabase/lib/query/test_spec_test.cljc
@@ -1498,6 +1498,25 @@
(is (=? [[:field {} "created_year"]]
(lib/breakouts query 1))))))
+(deftest ^:parallel test-query-orders-by-named-implicitly-joined-breakout-test
+ (let [category {:type :column
+ :name "CATEGORY"
+ :field-id (meta/id :products :category)
+ :source-field-id (meta/id :orders :product-id)}
+ query (fn [order-by]
+ (lib.query.test-spec/test-query
+ meta/metadata-provider
+ {:stages [{:source {:type :table :id (meta/id :orders)}
+ :aggregations [{:type :operator :operator :count}]
+ :breakouts [{:type :breakout :name "category" :column category}]
+ :order-bys [order-by]}]}))]
+ (testing "named breakout on an implicitly joined field is found by its name and foreign key"
+ (is (=? [[:asc {} [:field {:name "category" :source-field (meta/id :orders :product-id)} (meta/id :products :category)]]]
+ (lib/order-bys (query {:type :column :name "category" :source-field-id (meta/id :orders :product-id)})))))
+ (testing "its name alone does not say it is implicitly joined"
+ (is (thrown-with-msg? #?(:clj Exception :cljs js/Error) #"No column found"
+ (query {:type :column :name "category"}))))))
+
(def ^:private two-ids-stage
{:source {:type :table :id (meta/id :orders)}
:fields [{:type :column :name "ID" :field-id (meta/id :orders :id)}
diff --git a/test/metabase/lib/stage_test.cljc b/test/metabase/lib/stage_test.cljc
index e21ef9cf703..d31cabb08f0 100644
--- a/test/metabase/lib/stage_test.cljc
+++ b/test/metabase/lib/stage_test.cljc
@@ -237,9 +237,8 @@
(is (=? [[:field
(fn expected-opts? [opts]
(and
- ;; should retain the effective type of `:type/Integer` since `:year` is an extraction operation.
(= (:base-type opts) :type/Date)
- (= (:effective-type opts) :type/Integer)
+ (= (:effective-type opts) :type/Date)
(not (:temporal-unit opts))))
"DATE"]]
(map lib/ref cols)))))
diff --git a/test/metabase/query_processor/breakout_test.clj b/test/metabase/query_processor/breakout_test.clj
index ffab3a8c6dc..4df7a4772cb 100644
--- a/test/metabase/query_processor/breakout_test.clj
+++ b/test/metabase/query_processor/breakout_test.clj
@@ -514,3 +514,17 @@
(lib/aggregate (lib/count)))]
(is (= ["user_id" "venue_id" "count"]
(map :name (mt/cols (qp/process-query query)))))))))
+
+(deftest ^:parallel filter-year-breakout-in-later-stage-test
+ (mt/test-drivers (mt/normal-drivers-with-feature :basic-aggregations :nested-queries)
+ (testing "a later stage filters a year breakout by date, since `:year` truncates to a date"
+ (let [mp (mt/metadata-provider)
+ created-at (lib.metadata/field mp (mt/id :checkins :date))
+ query (-> (lib/query mp (lib.metadata/table mp (mt/id :checkins)))
+ (lib/breakout (lib/with-temporal-bucket created-at :year))
+ (lib/aggregate (lib/count))
+ lib/append-stage)
+ year (first (lib/filterable-columns query))
+ query (lib/filter query (lib/>= year "2015-01-01"))]
+ (is (=? [[#"2015-01-01.*" 267]]
+ (mt/formatted-rows [str int] (qp/process-query query))))))))