Skip to content

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

Read the data selector's entities from the store (#82405)

Romeo Van Snick7e36117dbcd8
diff --git a/e2e/support/helpers/e2e-data-studio-helpers.ts b/e2e/support/helpers/e2e-data-studio-helpers.ts
index 06ee45ce369..2054e815c17 100644
--- a/e2e/support/helpers/e2e-data-studio-helpers.ts
+++ b/e2e/support/helpers/e2e-data-studio-helpers.ts
@@ -21,12 +21,6 @@ const editSnippetPage = () => cy.findByTestId("edit-snippet-page");
export const DataStudio = {
nav: () => cy.findByTestId("data-studio-nav"),
breadcrumbs: () => cy.findByTestId("data-studio-breadcrumbs"),
- visit: () => {
- cy.visit("/data-studio");
- // The target is only known once the `hasSeenGuide` request comes back.
- cy.location("pathname").should("match", /^\/data-studio\/.+/);
- DataStudio.nav().should("be.visible");
- },
Transforms: {
// The transform page shows a loader until the transform, databases and the
// lazy editor chunk have loaded, which can take longer than the default 4s
diff --git a/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts b/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts
index 5a766efdb32..b30edbbd275 100644
--- a/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/data-studio-library.cy.spec.ts
@@ -41,8 +41,6 @@ describe("scenarios > data studio > library", () => {
H.popover()
.findByText(/Data studio/)
.click();
- // Let the Data Studio index redirect settle.
- cy.location("pathname").should("not.eq", "/data-studio");
cy.log(
"Verify tracking event when opening Data Studio from the profile menu",
diff --git a/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts b/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
index 3f154b09fcd..a571856a73e 100644
--- a/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/transforms/transforms.cy.spec.ts
@@ -4356,7 +4356,8 @@ describe("scenarios > data studio > transforms > permissions > oss", () => {
cy.findByRole("columnheader", { name: /Transforms/ }).should("not.exist");
cy.log("Visit data studio page");
- H.DataStudio.visit();
+ cy.visit("/data-studio");
+ H.DataStudio.nav().should("be.visible");
cy.log("Verify Transforms menu item is visible");
H.DataStudio.nav()
@@ -4429,7 +4430,8 @@ describe(
);
cy.log("Visit data studio page");
- H.DataStudio.visit();
+ cy.visit("/data-studio");
+ H.DataStudio.nav().should("be.visible");
cy.log("Verify Transforms menu item is visible");
H.DataStudio.nav()
diff --git a/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts b/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts
index 0ed91ba3156..13dff09eccc 100644
--- a/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts
+++ b/e2e/test/scenarios/schema-viewer/schema-viewer.cy.spec.ts
@@ -506,7 +506,7 @@ describe("scenarios > schema-viewer (entry points + loader/error states)", () =>
cy.log(
"Click 'Schema viewer' tab in the Data Studio sidebar — opens the bare schema viewer URL",
);
- H.DataStudio.visit();
+ cy.visit("/data-studio");
H.DataStudio.nav().findByText("Schema viewer").click();
cy.url().should("include", "/data-studio/schema-viewer");
cy.findByTestId("schema-picker-button")
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformTopBar/PythonTransformTopBar.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformTopBar/PythonTransformTopBar.tsx
index ae9fc35bedc..8207167570e 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformTopBar/PythonTransformTopBar.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-python/components/PythonTransformEditor/PythonTransformTopBar/PythonTransformTopBar.tsx
@@ -8,8 +8,7 @@ import { DatabaseDataSelector } from "metabase/querying/common/components/DataSe
import { EditDefinitionButton } from "metabase/transforms/components/TransformEditor/EditDefinitionButton";
import { doesDatabaseSupportTransforms } from "metabase/transforms/utils";
import { Flex } from "metabase/ui";
-import type MetadataDatabase from "metabase-lib/v1/metadata/Database";
-import type { Database, DatabaseId, Transform } from "metabase-types/api";
+import type { DatabaseId, Transform } from "metabase-types/api";
import S from "./PythonTransformTopBar.module.css";
@@ -56,22 +55,11 @@ export function PythonTransformTopBar({
className={S.databaseSelector}
selectedDatabaseId={databaseId}
setDatabaseFn={handleDatabaseChange}
- // DataSelector is typed against metabase-lib entities; here we feed
- // it plain API databases, which carry the fields it actually reads.
- // TODO(dataselector-api-vs-metabase-lib-casts): remove this cast once
- // DataSelector's entity props use structural interfaces.
- databases={(databases?.data ?? []) as unknown as MetadataDatabase[]}
+ databases={databases?.data ?? []}
readOnly={!isEditMode}
- databaseIsDisabled={
- // DataSelector types this callback against metabase-lib databases;
- // the predicate only reads plain API database fields.
- // TODO(dataselector-api-vs-metabase-lib-casts): remove this cast
- // once DataSelector's entity props use structural interfaces.
- ((database: Database) =>
- !doesDatabaseSupportTransforms(database) ||
- !hasFeature(database, "transforms/python")) as unknown as (
- database: MetadataDatabase,
- ) => boolean
+ databaseIsDisabled={(database) =>
+ !doesDatabaseSupportTransforms(database) ||
+ !hasFeature(database, "transforms/python")
}
/>
</Flex>
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx
index e7c3c9dd832..7eea32b080d 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.tsx
@@ -1,8 +1,11 @@
import { msgid, ngettext } from "ttag";
+import type Table from "metabase-lib/v1/metadata/Table";
+
import { Label, LabelContainer } from "../MetadataInfo.styled";
-export function ColumnCount({ fieldCount }: { fieldCount: number }) {
+export function ColumnCount({ table }: { table: Table }) {
+ const fieldCount = table.numFields();
return (
<LabelContainer color="text-primary">
<Label>
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx
index bf59fc7a2cf..e8ea28f2e97 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ColumnCount.unit.spec.tsx
@@ -1,22 +1,53 @@
+import { createMockState } from "__support__/state";
+import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
+import { getMetadata } from "metabase/metadata-store";
+import { checkNotNull } from "metabase/utils/types";
+import type { Table } from "metabase-types/api";
+import { createMockField, createMockTable } from "metabase-types/api/mocks";
import { ColumnCount } from "./ColumnCount";
+interface SetupOpts {
+ table: Table;
+}
+
+function setup({ table }: SetupOpts) {
+ const state = createMockState({
+ entities: createMockEntitiesState({
+ tables: [table],
+ }),
+ });
+ const metadata = getMetadata(state);
+
+ renderWithProviders(
+ <ColumnCount table={checkNotNull(metadata.table(table.id))} />,
+ );
+}
+
describe("ColumnCount", () => {
it("should show a non-plural label for a table with a single field", () => {
- renderWithProviders(<ColumnCount fieldCount={1} />);
+ setup({
+ table: createMockTable({
+ fields: [createMockField()],
+ }),
+ });
expect(screen.getByText("1 column")).toBeInTheDocument();
});
it("should show a plural label for a table with multiple fields", () => {
- renderWithProviders(<ColumnCount fieldCount={2} />);
+ setup({
+ table: createMockTable({
+ fields: [createMockField(), createMockField()],
+ }),
+ });
expect(screen.getByText("2 columns")).toBeInTheDocument();
});
- it("should show a plural label for a table with no fields", () => {
- renderWithProviders(<ColumnCount fieldCount={0} />);
+ it("should handle a scenario where a table has no fields property", () => {
+ setup({ table: createMockTable() });
expect(screen.getByText("0 columns")).toBeInTheDocument();
});
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx
index 1bca96d3f83..534ecd75729 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.tsx
@@ -1,8 +1,7 @@
import { t } from "ttag";
-import { useQuestionFromOpts } from "metabase/metadata-store";
import * as Urls from "metabase/urls";
-import type { NormalizedTable } from "metabase-types/api";
+import type Table from "metabase-lib/v1/metadata/Table";
import { Container, Label, LabelContainer } from "../MetadataInfo.styled";
@@ -12,23 +11,20 @@ import {
LabelLink,
} from "./ConnectedTables.styled";
-export type ConnectedTable = Pick<
- NormalizedTable,
- "id" | "db_id" | "display_name"
->;
-
type Props = {
- tables: ConnectedTable[];
- onConnectedTableClick?: (table: ConnectedTable) => void;
+ table: Table;
+ onConnectedTableClick?: (table: Table) => void;
};
-export function ConnectedTables({ tables, onConnectedTableClick }: Props) {
- return tables.length ? (
+export function ConnectedTables({ table, onConnectedTableClick }: Props) {
+ const fkTables = table.connectedTables();
+
+ return fkTables.length ? (
<Container>
<LabelContainer color="text-primary">
<Label>{t`Connected to these tables`}</Label>
</LabelContainer>
- {tables.slice(0, 8).map((fkTable) => {
+ {fkTables.slice(0, 8).map((fkTable) => {
return onConnectedTableClick ? (
<ConnectedTableButton
key={fkTable.id}
@@ -47,8 +43,8 @@ function ConnectedTableButton({
table,
onClick,
}: {
- table: ConnectedTable;
- onClick: (table: ConnectedTable) => void;
+ table: Table;
+ onClick: (table: Table) => void;
}) {
return (
<LabelButton key={table.id} onClick={() => onClick(table)}>
@@ -57,18 +53,9 @@ function ConnectedTableButton({
);
}
-function ConnectedTableLink({ table }: { table: ConnectedTable }) {
- const buildQuestion = useQuestionFromOpts();
- const question = buildQuestion({
- dataset_query: {
- database: table.db_id,
- type: "query",
- query: { "source-table": table.id },
- },
- }).setDefaultDisplay();
-
+function ConnectedTableLink({ table }: { table: Table }) {
return (
- <LabelLink to={Urls.question(question)}>
+ <LabelLink to={Urls.question(table.newQuestion())}>
<InteractiveTableLabel table={table} />
</LabelLink>
);
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx
index a30ac2c20d4..6f26b5ac827 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/ConnectedTables.unit.spec.tsx
@@ -2,72 +2,101 @@ import { createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
import { getMetadata } from "metabase/metadata-store";
-import * as Urls from "metabase/urls";
import { checkNotNull } from "metabase/utils/types";
-import { createMockTable } from "metabase-types/api/mocks";
+import type { Table } from "metabase-types/api";
import {
- PRODUCTS_ID,
- createProductsTable,
- createSampleDatabase,
-} from "metabase-types/api/mocks/presets";
+ createMockField,
+ createMockForeignKey,
+ createMockTable,
+} from "metabase-types/api/mocks";
-import { type ConnectedTable, ConnectedTables } from "./ConnectedTables";
+import { ConnectedTables } from "./ConnectedTables";
-function setup({ tables }: { tables: ConnectedTable[] }) {
+const EMPTY_TABLE = createMockTable();
+
+const TABLE_WITH_FKS = createMockTable({
+ id: 1,
+ fks: [
+ createMockForeignKey({
+ origin_id: 1,
+ origin: createMockField({
+ id: 1,
+ table_id: 2,
+ table: createMockTable({
+ id: 2,
+ display_name: "Foo",
+ }),
+ }),
+ }),
+ createMockForeignKey({
+ origin_id: 2,
+ origin: createMockField({
+ id: 2,
+ table_id: 3,
+ table: createMockTable({
+ id: 3,
+ display_name: "Bar",
+ }),
+ }),
+ }),
+ ],
+});
+
+interface SetupOpts {
+ table: Table;
+}
+
+function setup({ table }: SetupOpts) {
const state = createMockState({
entities: createMockEntitiesState({
- databases: [createSampleDatabase()],
+ tables: [table],
}),
});
+ const metadata = getMetadata(state);
- renderWithProviders(
+ return renderWithProviders(
<div data-testid="test-container">
- <ConnectedTables tables={tables} />
+ <ConnectedTables table={checkNotNull(metadata.table(table.id))} />
</div>,
- { storeInitialState: state },
);
-
- return { state };
}
describe("ConnectedTables", () => {
- it("should show nothing when there are no connected tables", () => {
- setup({ tables: [] });
+ it("should show nothing when the table has no fks", () => {
+ setup({ table: EMPTY_TABLE });
const container = screen.getByTestId("test-container");
expect(container).toBeEmptyDOMElement();
});
it("should show a label for each connected table", () => {
- setup({
- tables: [
- createMockTable({ id: 2, display_name: "Foo" }),
- createMockTable({ id: 3, display_name: "Bar" }),
- ],
- });
+ setup({ table: TABLE_WITH_FKS });
expect(screen.getByText("Foo")).toBeInTheDocument();
expect(screen.getByText("Bar")).toBeInTheDocument();
});
it("should limit the number of connected tables to 8", () => {
+ const fks = Array.from({ length: 20 }).map((_, idx) =>
+ createMockForeignKey({
+ origin_id: idx,
+ origin: createMockField({
+ id: idx,
+ table_id: 21 + idx,
+ table: createMockTable({
+ id: 21 + idx,
+ display_name: `Bar-${idx + 1}`,
+ }),
+ }),
+ }),
+ );
+
setup({
- tables: Array.from({ length: 20 }).map((_, idx) =>
- createMockTable({ id: 21 + idx, display_name: `Bar-${idx + 1}` }),
- ),
+ table: {
+ ...TABLE_WITH_FKS,
+ fks,
+ },
});
expect(screen.getAllByText(/Bar-\d/)).toHaveLength(8);
});
-
- it("should link each table to a new question on it", () => {
- const { state } = setup({ tables: [createProductsTable()] });
- const newQuestion = checkNotNull(
- getMetadata(state).table(PRODUCTS_ID),
- ).newQuestion();
-
- expect(screen.getByRole("link", { name: /Products/ })).toHaveAttribute(
- "href",
- Urls.question(newQuestion),
- );
- });
});
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx
index 618e6c9da22..998e249c2b2 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.tsx
@@ -1,13 +1,8 @@
-import { createSelector } from "@reduxjs/toolkit";
import { useEffect, useState } from "react";
import { useAsyncFn } from "react-use";
import { t } from "ttag";
-import {
- getShallowTableFieldIds,
- getShallowTableForeignKeys,
- getShallowTables,
-} from "metabase/metadata-store";
+import { getMetadata } from "metabase/metadata-store";
import { connect } from "metabase/redux";
import type { Dispatch, State } from "metabase/redux/store";
import {
@@ -15,57 +10,35 @@ import {
fetchTableMetadata,
} from "metabase/redux/tables";
import { Loader } from "metabase/ui";
-import { isNotNull } from "metabase/utils/types";
-import type { NormalizedTable, TableId } from "metabase-types/api";
+import type Table from "metabase-lib/v1/metadata/Table";
import { Description, EmptyDescription } from "../MetadataInfo";
import { AbsoluteContainer, Fade } from "../MetadataInfo.styled";
import { ColumnCount } from "./ColumnCount";
-import { type ConnectedTable, ConnectedTables } from "./ConnectedTables";
+import { ConnectedTables } from "./ConnectedTables";
import { InfoContainer, MetadataContainer } from "./TableInfo.styled";
export type TableInfoProps = {
className?: string;
- tableId: TableId;
- onConnectedTableClick?: (table: ConnectedTable) => void;
+ tableId: Table["id"];
+ onConnectedTableClick?: (table: Table) => void;
};
-/**
- * The tables whose foreign keys point at this one. `undefined` until the
- * table's foreign keys are loaded.
- */
-const getConnectedTables = createSelector(
- [
- (state: State, tableId: TableId) =>
- getShallowTableForeignKeys(state, tableId),
- (state: State) => getShallowTables(state),
- ],
- (foreignKeys, tables) =>
- foreignKeys
- ?.map((foreignKey) => tables[foreignKey.origin.table_id])
- .filter(isNotNull),
-);
-
const mapStateToProps = (
state: State,
props: TableInfoProps,
-): {
- table?: NormalizedTable;
- fieldCount: number;
- connectedTables?: NormalizedTable[];
-} => {
+): { table?: Table } => {
return {
- table: getShallowTables(state)[props.tableId],
- fieldCount: getShallowTableFieldIds(state, props.tableId).length,
- connectedTables: getConnectedTables(state, props.tableId),
+ table: getMetadata(state).table(props.tableId) ?? undefined,
};
};
const mapDispatchToProps = (dispatch: Dispatch) => ({
- fetchForeignKeys: (args: { id: TableId }) =>
+ fetchForeignKeys: (args: { id: Table["id"] }) =>
dispatch(fetchTableForeignKeys(args)),
- fetchMetadata: (args: { id: TableId }) => dispatch(fetchTableMetadata(args)),
+ fetchMetadata: (args: { id: Table["id"] }) =>
+ dispatch(fetchTableMetadata(args)),
});
type AllProps = TableInfoProps &
@@ -74,20 +47,12 @@ type AllProps = TableInfoProps &
function useDependentTableMetadata({
tableId,
- fieldCount,
- connectedTables,
+ table,
fetchForeignKeys,
fetchMetadata,
-}: Pick<
- AllProps,
- | "tableId"
- | "fieldCount"
- | "connectedTables"
- | "fetchForeignKeys"
- | "fetchMetadata"
->) {
- const isMissingFields = fieldCount === 0;
- const isMissingFks = connectedTables === undefined;
+}: Pick<AllProps, "tableId" | "table" | "fetchForeignKeys" | "fetchMetadata">) {
+ const isMissingFields = !table?.numFields();
+ const isMissingFks = table?.fks === undefined;
const shouldFetchMetadata = isMissingFields || isMissingFks;
const [hasFetchedMetadata, setHasFetchedMetadata] =
useState(!shouldFetchMetadata);
@@ -113,8 +78,6 @@ export function TableInfoInner({
className,
tableId,
table,
- fieldCount,
- connectedTables,
fetchForeignKeys,
fetchMetadata,
onConnectedTableClick,
@@ -122,8 +85,7 @@ export function TableInfoInner({
const description = table?.description;
const hasFetchedMetadata = useDependentTableMetadata({
tableId,
- fieldCount,
- connectedTables,
+ table,
fetchForeignKeys,
fetchMetadata,
});
@@ -142,12 +104,12 @@ export function TableInfoInner({
</AbsoluteContainer>
</Fade>
<Fade visible={hasFetchedMetadata}>
- {table && <ColumnCount fieldCount={fieldCount} />}
+ {table && <ColumnCount table={table} />}
</Fade>
<Fade visible={hasFetchedMetadata}>
{table && (
<ConnectedTables
- tables={connectedTables ?? []}
+ table={table}
onConnectedTableClick={onConnectedTableClick}
/>
)}
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx
index 2091d1a89aa..27ad7bfd3c9 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableInfo/TableInfo.unit.spec.tsx
@@ -1,8 +1,7 @@
-import fetchMock from "fetch-mock";
-
import { createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
-import { renderWithProviders, screen, waitFor } from "__support__/ui";
+import { renderWithProviders, screen } from "__support__/ui";
+import { getMetadata } from "metabase/metadata-store";
import type { Table, TableId } from "metabase-types/api";
import {
createMockField,
@@ -10,12 +9,11 @@ import {
createMockTable,
} from "metabase-types/api/mocks";
-import { TableInfo } from "./TableInfo";
+import { TableInfoInner } from "./TableInfo";
const TABLE_ID = 1;
const TABLE_FK = createMockForeignKey({
- origin_id: 1,
origin: createMockField({
id: 1,
table_id: 2,
@@ -27,7 +25,6 @@ const TABLE_FK = createMockForeignKey({
});
const TABLE_FIELD = createMockField({
- id: 10,
table_id: TABLE_ID,
});
@@ -60,99 +57,98 @@ interface SetupOpts {
table?: Table;
}
-const QUERY_METADATA_URL = `path:/api/table/${TABLE_ID}/query_metadata`;
-const FOREIGN_KEYS_URL = `path:/api/table/${TABLE_ID}/fks`;
-
-async function setup({ id, table }: SetupOpts) {
+function setup({ id, table }: SetupOpts) {
const state = createMockState({
entities: createMockEntitiesState({
tables: table ? [table] : [],
}),
});
- fetchMock.get(QUERY_METADATA_URL, TABLE);
- fetchMock.get(FOREIGN_KEYS_URL, [TABLE_FK]);
-
- renderWithProviders(<TableInfo tableId={id} />, {
- storeInitialState: state,
- });
-
- // The loader fades out once every missing piece has loaded.
- await waitFor(() => expect(screen.getByText("1 column")).toBeVisible());
-
- return {
- hasFetchedMetadata: () => fetchMock.callHistory.called(QUERY_METADATA_URL),
- hasFetchedForeignKeys: () => fetchMock.callHistory.called(FOREIGN_KEYS_URL),
- };
+ const metadata = getMetadata(state);
+
+ const fetchMetadata = jest.fn();
+ const fetchForeignKeys = jest.fn();
+
+ renderWithProviders(
+ <TableInfoInner
+ tableId={id}
+ table={metadata.table(table?.id) ?? undefined}
+ fetchMetadata={fetchMetadata}
+ fetchForeignKeys={fetchForeignKeys}
+ />,
+ { storeInitialState: state },
+ );
+
+ return { fetchMetadata, fetchForeignKeys };
}
describe("TableInfo", () => {
- it("should fetch table metadata if fields are missing", async () => {
- const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
+ it("should fetch table metadata if fields are missing", () => {
+ const { fetchMetadata, fetchForeignKeys } = setup({
id: TABLE_ID,
table: TABLE_WITH_FKS,
});
-
- expect(hasFetchedMetadata()).toBe(true);
- expect(hasFetchedForeignKeys()).toBe(false);
+ expect(fetchMetadata).toHaveBeenCalledWith({
+ id: TABLE_ID,
+ });
+ expect(fetchForeignKeys).not.toHaveBeenCalled();
});
- it("should fetch table metadata if the table is undefined", async () => {
- const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
+ it("should fetch table metadata if the table is undefined", () => {
+ const { fetchMetadata, fetchForeignKeys } = setup({
id: TABLE_ID,
table: undefined,
});
- expect(hasFetchedMetadata()).toBe(true);
- expect(hasFetchedForeignKeys()).toBe(true);
+ expect(fetchMetadata).toHaveBeenCalledWith({
+ id: TABLE_ID,
+ });
+ expect(fetchForeignKeys).toHaveBeenCalledWith({
+ id: TABLE_ID,
+ });
});
- it("should fetch fks if fks are undefined on table", async () => {
- const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
+ it("should fetch fks if fks are undefined on table", () => {
+ const { fetchMetadata, fetchForeignKeys } = setup({
id: TABLE_ID,
table: TABLE_WITH_FIELDS,
});
- expect(hasFetchedMetadata()).toBe(false);
- expect(hasFetchedForeignKeys()).toBe(true);
+ expect(fetchMetadata).not.toHaveBeenCalled();
+ expect(fetchForeignKeys).toHaveBeenCalledWith({ id: TABLE_ID });
});
- it("should not send requests fetching table metadata when metadata is already present", async () => {
- const { hasFetchedMetadata, hasFetchedForeignKeys } = await setup({
+ it("should not send requests fetching table metadata when metadata is already present", () => {
+ const { fetchMetadata, fetchForeignKeys } = setup({
id: TABLE_ID,
table: TABLE,
});
- expect(hasFetchedMetadata()).toBe(false);
- expect(hasFetchedForeignKeys()).toBe(false);
+ expect(fetchMetadata).not.toHaveBeenCalled();
+ expect(fetchForeignKeys).not.toHaveBeenCalled();
});
it("should display a placeholder if table has no description", async () => {
- fetchMock.get(QUERY_METADATA_URL, TABLE_WITHOUT_DESCRIPTION);
- fetchMock.get(FOREIGN_KEYS_URL, []);
- renderWithProviders(<TableInfo tableId={TABLE_ID} />, {
- storeInitialState: createMockState({
- entities: createMockEntitiesState({
- tables: [TABLE_WITHOUT_DESCRIPTION],
- }),
- }),
+ setup({
+ id: TABLE_ID,
+ table: TABLE_WITHOUT_DESCRIPTION,
});
expect(await screen.findByText("No description")).toBeInTheDocument();
});
describe("after metadata has been fetched", () => {
- it("should display the given table's description", async () => {
- await setup({ id: TABLE_ID, table: TABLE });
+ it("should display the given table's description", () => {
+ setup({ id: TABLE_ID, table: TABLE });
expect(screen.getByText(TABLE.description ?? "")).toBeInTheDocument();
});
- it("should show a count of columns on the table", async () => {
- await setup({ id: TABLE_ID, table: TABLE });
+ it("should show a count of columns on the table", () => {
+ setup({ id: TABLE_ID, table: TABLE });
expect(screen.getByText("1 column")).toBeInTheDocument();
});
- it("should list connected tables", async () => {
- await setup({ id: TABLE_ID, table: TABLE });
+ it("should list connected tables", () => {
+ setup({ id: TABLE_ID, table: TABLE });
expect(screen.getByText("Connected Table")).toBeInTheDocument();
});
});
diff --git a/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx b/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx
index 86297e34b90..0e1d16c43b5 100644
--- a/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx
+++ b/frontend/src/metabase/common/components/MetadataInfo/TableLabel/TableLabel.tsx
@@ -1,4 +1,4 @@
-import type { NormalizedTable } from "metabase-types/api";
+import type Table from "metabase-lib/v1/metadata/Table";
import { Label, LabelContainer } from "../MetadataInfo.styled";
@@ -9,12 +9,12 @@ export function TableLabel({
table,
}: {
className?: string;
- table: Pick<NormalizedTable, "display_name">;
+ table: Table;
}) {
return (
<LabelContainer className={className}>
<TableIcon name="table" />
- <Label>{table.display_name}</Label>
+ <Label>{table.displayName()}</Label>
</LabelContainer>
);
}
diff --git a/frontend/src/metabase/data-studio/routes.tsx b/frontend/src/metabase/data-studio/routes.tsx
index 10941584f30..75a162ef737 100644
--- a/frontend/src/metabase/data-studio/routes.tsx
+++ b/frontend/src/metabase/data-studio/routes.tsx
@@ -13,7 +13,6 @@ import {
Route,
type RouteComponent,
redirect,
- useIsNavigating,
} from "metabase/router";
import { getDataStudioTransformRoutes } from "metabase/transforms/routes";
import { canAccessTransforms } from "metabase/transforms/selectors";
@@ -155,14 +154,13 @@ export function getDataStudioDependencyDiagnosticsRedirects() {
export function DataStudioIndexRedirect() {
const indexPath = useSelector(getIndexPath);
- const isNavigating = useIsNavigating();
const { value: hasSeenGuide, isLoading } = useUserKeyValue({
namespace: "data_studio",
key: "hasSeenGuide",
defaultValue: false,
});
- if (isLoading || isNavigating) {
+ if (isLoading) {
return <LoadingAndErrorWrapper loading />;
}
diff --git a/frontend/src/metabase/data-studio/routes.unit.spec.tsx b/frontend/src/metabase/data-studio/routes.unit.spec.tsx
index c1b4f192938..1e7c37f82d2 100644
--- a/frontend/src/metabase/data-studio/routes.unit.spec.tsx
+++ b/frontend/src/metabase/data-studio/routes.unit.spec.tsx
@@ -1,12 +1,8 @@
-import fetchMock from "fetch-mock";
-
import { lazyLoaders } from "__support__/lazy-routes";
import { setupUserKeyValueEndpoints } from "__support__/server-mocks";
import { createMockState } from "__support__/state";
-import { act, renderWithProviders, screen } from "__support__/ui";
-import { delay } from "__support__/utils";
+import { renderWithProviders, screen } from "__support__/ui";
import { Route } from "metabase/router";
-import { defer } from "metabase/utils/promise";
import { createMockUser } from "metabase-types/api/mocks";
import { DataStudioIndexRedirect, getDataStudioRoutes } from "./routes";
@@ -29,52 +25,27 @@ describe("data-studio routes", () => {
function setupIndexRedirect({
hasSeenGuide,
isAdmin = false,
- transformsLoading,
}: {
- hasSeenGuide: boolean | Promise<boolean>;
+ hasSeenGuide: boolean;
isAdmin?: boolean;
- transformsLoading?: Promise<void>;
}) {
- if (typeof hasSeenGuide === "boolean") {
- setupUserKeyValueEndpoints({
- namespace: "data_studio",
- key: "hasSeenGuide",
- value: hasSeenGuide,
- });
- } else {
- fetchMock.get(
- "path:/api/user-key-value/namespace/data_studio/key/hasSeenGuide",
- async () =>
- new Response(JSON.stringify(await hasSeenGuide), {
- status: 200,
- headers: { "Content-Type": "application/json" },
- }),
- );
- }
+ setupUserKeyValueEndpoints({
+ namespace: "data_studio",
+ key: "hasSeenGuide",
+ value: hasSeenGuide,
+ });
- return renderWithProviders(
+ renderWithProviders(
<Route path="/">
<Route path="data-studio">
<Route index element={<DataStudioIndexRedirect />} />
<Route path="guide" element={<div data-testid="guide-page" />} />
<Route path="data" element={<div data-testid="data-index" />} />
<Route path="library" element={<div data-testid="library-index" />} />
- {transformsLoading ? (
- <Route
- path="transforms"
- lazy={async () => {
- await transformsLoading;
- return {
- Component: () => <div data-testid="transforms-index" />,
- };
- }}
- />
- ) : (
- <Route
- path="transforms"
- element={<div data-testid="transforms-index" />}
- />
- )}
+ <Route
+ path="transforms"
+ element={<div data-testid="transforms-index" />}
+ />
</Route>
</Route>,
{
@@ -108,25 +79,4 @@ describe("Data Studio index redirect", () => {
expect(await screen.findByTestId("library-index")).toBeInTheDocument();
expect(screen.queryByTestId("guide-page")).not.toBeInTheDocument();
});
-
- it("lets a navigation the user already started finish", async () => {
- const hasSeenGuide = defer<boolean>();
- const transformsModule = defer<void>();
- const { router } = setupIndexRedirect({
- hasSeenGuide: hasSeenGuide.promise,
- isAdmin: true,
- transformsLoading: transformsModule.promise,
- });
-
- act(() => router?.navigate("/data-studio/transforms"));
-
- // The redirect resolves while the lazy route is still loading.
- hasSeenGuide.resolve(false);
- await delay(0);
-
- transformsModule.resolve();
-
- expect(await screen.findByTestId("transforms-index")).toBeInTheDocument();
- expect(screen.queryByTestId("guide-page")).not.toBeInTheDocument();
- });
});
diff --git a/frontend/src/metabase/metadata-store/index.ts b/frontend/src/metabase/metadata-store/index.ts
index 364146aee4d..d880dbe5eaa 100644
--- a/frontend/src/metabase/metadata-store/index.ts
+++ b/frontend/src/metabase/metadata-store/index.ts
@@ -5,13 +5,20 @@ export {
getMetadataWithHiddenTables,
getRemappedFieldValue,
getShallowDatabases,
+ getShallowDatabaseSchemas,
+ getShallowDatabaseTables,
+ getShallowFieldById,
+ getShallowFieldName,
getShallowFields,
+ getShallowQuestions,
+ getShallowSchemaTables,
+ getShallowSchemas,
+ getShallowTableFields,
+ getShallowTableSchema,
getShallowSegments,
- getShallowTableFieldIds,
- getShallowTableForeignKeys,
getShallowTables,
} from "./selectors";
-export type { MetadataSelectorOpts, ShallowForeignKey } from "./selectors";
+export type { MetadataSelectorOpts } from "./selectors";
export {
selectMetadataProvider,
diff --git a/frontend/src/metabase/metadata-store/relations.unit.spec.ts b/frontend/src/metabase/metadata-store/relations.unit.spec.ts
new file mode 100644
index 00000000000..ff47e864434
--- /dev/null
+++ b/frontend/src/metabase/metadata-store/relations.unit.spec.ts
@@ -0,0 +1,164 @@
+import { createMockState } from "__support__/state";
+import { createMockEntitiesState } from "__support__/store";
+import {
+ createMockDatabase,
+ createMockField,
+ createMockTable,
+} from "metabase-types/api/mocks";
+import {
+ ORDERS,
+ ORDERS_ID,
+ SAMPLE_DB_ID,
+ createSampleDatabase,
+} from "metabase-types/api/mocks/presets";
+
+import {
+ getMetadata,
+ getShallowDatabaseSchemas,
+ getShallowDatabaseTables,
+ getShallowDatabases,
+ getShallowFieldById,
+ getShallowFieldName,
+ getShallowSchemaTables,
+ getShallowSchemas,
+ getShallowTableFields,
+ getShallowTables,
+} from "./selectors";
+
+const MULTI_SCHEMA_DB_ID = 2;
+const HIDDEN_TABLE_ID = 100;
+const PARENT_FIELD_ID = 1000;
+const CHILD_FIELD_ID = 1001;
+
+const entities = createMockEntitiesState({
+ databases: [
+ createSampleDatabase(),
+ createMockDatabase({
+ id: MULTI_SCHEMA_DB_ID,
+ tables: [
+ createMockTable({
+ id: 101,
+ db_id: MULTI_SCHEMA_DB_ID,
+ schema: "first",
+ fields: [
+ createMockField({
+ id: PARENT_FIELD_ID,
+ table_id: 101,
+ display_name: "Parent",
+ }),
+ createMockField({
+ id: CHILD_FIELD_ID,
+ table_id: 101,
+ parent_id: PARENT_FIELD_ID,
+ display_name: "Child",
+ }),
+ ],
+ }),
+ createMockTable({
+ id: 102,
+ db_id: MULTI_SCHEMA_DB_ID,
+ schema: "second",
+ }),
+ createMockTable({
+ id: HIDDEN_TABLE_ID,
+ db_id: MULTI_SCHEMA_DB_ID,
+ schema: "second",
+ visibility_type: "hidden",
+ }),
+ ],
+ }),
+ ],
+});
+
+const ids = (records: { id: unknown }[] | undefined) =>
+ records?.map((record) => record.id);
+
+function setup() {
+ const state = createMockState({ entities });
+
+ return {
+ state,
+ metadata: getMetadata(state),
+ databases: getShallowDatabases(state),
+ schemas: getShallowSchemas(state),
+ tables: getShallowTables(state),
+ databaseSchemas: getShallowDatabaseSchemas(state),
+ databaseTables: getShallowDatabaseTables(state),
+ schemaTables: getShallowSchemaTables(state),
+ tableFields: getShallowTableFields(state),
+ fieldById: getShallowFieldById(state),
+ fieldName: getShallowFieldName(state),
+ };
+}
+
+describe("the store's relation selectors", () => {
+ it("should resolve each relation the way the v1 Metadata object hydrates it", () => {
+ const {
+ metadata,
+ databaseSchemas,
+ databaseTables,
+ schemaTables,
+ tableFields,
+ } = setup();
+ const database = metadata.database(MULTI_SCHEMA_DB_ID);
+ const [firstSchema, secondSchema] = databaseSchemas(MULTI_SCHEMA_DB_ID);
+
+ expect(ids(databaseSchemas(MULTI_SCHEMA_DB_ID))).toEqual(
+ ids(database?.getSchemas()),
+ );
+ expect(ids(databaseTables(MULTI_SCHEMA_DB_ID))).toEqual(
+ ids(database?.getTables()),
+ );
+ expect(ids(schemaTables(secondSchema.id))).toEqual(
+ ids(metadata.schema(secondSchema.id)?.tables),
+ );
+ expect(ids(tableFields(ORDERS_ID))).toEqual(
+ ids(metadata.table(ORDERS_ID)?.getFields()),
+ );
+
+ // Guards the comparisons above: two empty lists would also match.
+ expect(firstSchema.name).toBe("first");
+ expect(ids(schemaTables(secondSchema.id))).toEqual([102]);
+ expect(tableFields(ORDERS_ID).length).toBeGreaterThan(0);
+ });
+
+ it("should leave out hidden tables, like the v1 Metadata object", () => {
+ const { metadata, tables } = setup();
+
+ expect(tables[HIDDEN_TABLE_ID]).toBeUndefined();
+ expect(metadata.table(HIDDEN_TABLE_ID)).toBeNull();
+ });
+
+ it("should hand out the store's normalized records", () => {
+ const { databases, schemas, tables, databaseSchemas, fieldById } = setup();
+ const [schema] = databaseSchemas(SAMPLE_DB_ID);
+
+ expect(databases[SAMPLE_DB_ID]).toBe(entities.databases[SAMPLE_DB_ID]);
+ expect(schemas[schema.id]).toBe(schema);
+ expect(tables[ORDERS_ID]).toBe(entities.tables[ORDERS_ID]);
+ expect(fieldById(ORDERS.TOTAL)).toBe(entities.fields[ORDERS.TOTAL]);
+ });
+
+ it("should name a nested field after its parents", () => {
+ const { fieldById, fieldName } = setup();
+ const child = fieldById(CHILD_FIELD_ID);
+
+ expect(child && fieldName(child)).toBe("Parent: Child");
+ });
+
+ it("should fall back to a field's own display name when it did not hand the field out", () => {
+ const { fieldName } = setup();
+
+ expect(
+ fieldName(
+ createMockField({ id: 9999, table_id: 999, display_name: "Own name" }),
+ ),
+ ).toBe("Own name");
+ });
+
+ it("should return the same lookup until the store's slices change", () => {
+ const { state, databaseSchemas } = setup();
+
+ expect(getShallowDatabaseSchemas({ ...state })).toBe(databaseSchemas);
+ });
+});
diff --git a/frontend/src/metabase/metadata-store/selectors.ts b/frontend/src/metabase/metadata-store/selectors.ts
index 6aedc515860..5e43e154800 100644
--- a/frontend/src/metabase/metadata-store/selectors.ts
+++ b/frontend/src/metabase/metadata-store/selectors.ts
@@ -20,10 +20,11 @@ import {
} from "metabase-lib/v1/queries/utils/field";
import { isNumeric } from "metabase-lib/v1/types/utils/isa";
import type {
- Field as ApiField,
Table as ApiTable,
Card,
+ DatabaseId,
FieldId,
+ FieldReference,
FieldValue,
Measure,
Metric,
@@ -35,6 +36,7 @@ import type {
NormalizedSchema,
NormalizedSegment,
NormalizedTable,
+ SchemaId,
Segment,
TableId,
} from "metabase-types/api";
@@ -125,53 +127,100 @@ export const getShallowDatabases = getNormalizedDatabases;
export const getShallowTables = getNormalizedTables;
export const getShallowFields = getNormalizedFields;
export const getShallowSegments = getNormalizedSegments;
+export const getShallowSchemas = getNormalizedSchemas;
+export const getShallowQuestions = getNormalizedQuestions;
-const getVisibleTable = (state: MetadataState, tableId: TableId) =>
- getNormalizedTables(state)[tableId];
+// The relations between the store's records need the same resolving the v1
+// `Metadata` object does: a table that arrived without its ids still belongs to
+// its schema, and `original_fields` outranks a table's field ids. Each selector
+// below returns that lookup, memoised on the records behind it, so a caller
+// that only learns the id it wants later still reads a stable function.
-const getVisibleFields = (state: MetadataState) => getNormalizedFields(state);
+const getMetadataForShallowReads = (state: State) => getMetadata(state);
-// Field values can arrive before the field itself, which leaves a stub record
-// with no `uniqueId`. `getMetadata` drops those.
-const isResolvedField = (
- field: NormalizedField | undefined,
-): field is NormalizedField => field?.uniqueId != null;
+/**
+ * A lookup from a database id to its schemas.
+ */
+export const getShallowDatabaseSchemas = createSelector(
+ [getMetadataForShallowReads, getNormalizedSchemas],
+ (metadata, schemas) =>
+ (databaseId: DatabaseId): NormalizedSchema[] =>
+ (metadata.database(databaseId)?.getSchemas() ?? [])
+ .map((schema) => schemas[schema.id])
+ .filter((schema) => schema != null),
+);
/**
- * The ids of a table's fields, as `getMetadata` resolves `Table.fields`: the
- * table's `original_fields` when it has them, otherwise its visible fields.
+ * A lookup from a database id to its tables.
*/
-export const getShallowTableFieldIds = createSelector(
- [getVisibleTable, getVisibleFields],
- (table, fields): ApiField["id"][] => {
- if (table == null) {
- return [];
- }
- if (table.original_fields) {
- return table.original_fields.map((field) => field.id);
- }
- return (table.fields ?? [])
- .map((fieldKey) => fields[fieldKey])
- .filter(isResolvedField)
- .map((field) => field.id);
- },
+export const getShallowDatabaseTables = createSelector(
+ [getMetadataForShallowReads],
+ (metadata) =>
+ (databaseId: DatabaseId): NormalizedTable[] =>
+ (metadata.database(databaseId)?.getTables() ?? []).map((table) =>
+ table.getPlainObject(),
+ ),
);
-export type ShallowForeignKey = Omit<NormalizedForeignKey, "origin"> & {
- origin: NormalizedField;
-};
+/**
+ * A lookup from a schema id to its tables.
+ */
+export const getShallowSchemaTables = createSelector(
+ [getMetadataForShallowReads],
+ (metadata) =>
+ (schemaId: SchemaId): NormalizedTable[] =>
+ (metadata.schema(schemaId)?.tables ?? []).map((table) =>
+ table.getPlainObject(),
+ ),
+);
+
+/**
+ * A lookup from a table id to the schema it belongs to. A table the store does
+ * not hold, and a schema it has not loaded, both give nothing.
+ */
+export const getShallowTableSchema = createSelector(
+ [getMetadataForShallowReads, getNormalizedSchemas],
+ (metadata, schemas) =>
+ (tableId: TableId): NormalizedSchema | undefined => {
+ const schemaId = metadata.table(tableId)?.getPlainObject().schema;
+ return schemaId != null ? schemas[schemaId] : undefined;
+ },
+);
+
+/**
+ * A lookup from a table id to its fields.
+ */
+export const getShallowTableFields = createSelector(
+ [getMetadataForShallowReads],
+ (metadata) =>
+ (tableId: TableId): NormalizedField[] =>
+ (metadata.table(tableId)?.getFields() ?? []).map((field) =>
+ field.getPlainObject(),
+ ),
+);
+
+/**
+ * A lookup from a field id, or a field reference, to the field.
+ */
+export const getShallowFieldById = createSelector(
+ [getMetadataForShallowReads],
+ (metadata) =>
+ (fieldId: FieldId | FieldReference): NormalizedField | undefined =>
+ metadata.field(fieldId)?.getPlainObject(),
+);
/**
- * A table's foreign keys whose origin field is visible, with that field in
- * place of its id. `undefined` until the table's foreign keys are loaded.
+ * A lookup from a field to its name, with the names of its parents for a
+ * nested field. A field the store does not hold keeps its own `display_name`.
*/
-export const getShallowTableForeignKeys = createSelector(
- [getVisibleTable, getVisibleFields],
- (table, fields): ShallowForeignKey[] | undefined =>
- table?.fks?.flatMap((foreignKey) => {
- const origin = fields[foreignKey.origin_id];
- return isResolvedField(origin) ? [{ ...foreignKey, origin }] : [];
- }),
+export const getShallowFieldName = createSelector(
+ [getMetadataForShallowReads],
+ (metadata) =>
+ (
+ field: Pick<NormalizedField, "id" | "table_id" | "display_name">,
+ ): string =>
+ metadata.field(field.id, field.table_id)?.displayName() ??
+ field.display_name,
);
// Takes the whole `State`, not `MetadataState`: it composes `getSettings`,
diff --git a/frontend/src/metabase/metadata-store/selectors.unit.spec.ts b/frontend/src/metabase/metadata-store/selectors.unit.spec.ts
index dad44269164..ebf90a35f44 100644
--- a/frontend/src/metabase/metadata-store/selectors.unit.spec.ts
+++ b/frontend/src/metabase/metadata-store/selectors.unit.spec.ts
@@ -1,15 +1,11 @@
import { createMockSettingsState, createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
-import type { EntitiesState } from "metabase/redux/store";
import { checkNotNull } from "metabase/utils/types";
import Metadata from "metabase-lib/v1/metadata/Metadata";
import {
createMockDatabase,
- createMockField,
- createMockForeignKey,
createMockSegment,
createMockSettings,
- createMockTable,
} from "metabase-types/api/mocks";
import {
ORDERS,
@@ -18,11 +14,7 @@ import {
createSampleDatabase,
} from "metabase-types/api/mocks/presets";
-import {
- getMetadata,
- getShallowTableFieldIds,
- getShallowTableForeignKeys,
-} from "./selectors";
+import { getMetadata } from "./selectors";
function setup() {
const sampleDatabase = createSampleDatabase();
@@ -89,122 +81,3 @@ describe("getMetadata", () => {
});
});
});
-
-describe("table relations", () => {
- const TABLE_ID = 1;
- const CONNECTED_TABLE_ID = 2;
- const HIDDEN_TABLE_ID = 3;
-
- const entities = createMockEntitiesState({
- tables: [
- createMockTable({
- id: TABLE_ID,
- fields: [
- createMockField({ id: 10, table_id: TABLE_ID }),
- createMockField({
- id: 11,
- table_id: TABLE_ID,
- visibility_type: "sensitive",
- }),
- ],
- fks: [
- createMockForeignKey({
- origin_id: 20,
- origin: createMockField({ id: 20, table_id: CONNECTED_TABLE_ID }),
- }),
- createMockForeignKey({
- origin_id: 30,
- origin: createMockField({ id: 30, table_id: HIDDEN_TABLE_ID }),
- }),
- ],
- }),
- createMockTable({ id: CONNECTED_TABLE_ID, fks: undefined }),
- createMockTable({ id: HIDDEN_TABLE_ID, visibility_type: "hidden" }),
- ],
- });
-
- // A field updated on its own drops the table's `original_fields`, which
- // leaves only the table's field ids to resolve.
- const entitiesWithoutOriginalFields: EntitiesState = {
- ...entities,
- tables: {
- ...entities.tables,
- [TABLE_ID]: { ...entities.tables[TABLE_ID], original_fields: undefined },
- },
- };
-
- const v1FieldIds = (state: ReturnType<typeof createMockState>) =>
- getMetadata(state)
- .table(TABLE_ID)
- ?.fields?.map((field) => field.id);
-
- describe("getShallowTableFieldIds", () => {
- it("should list every original field, sensitive ones included, like getMetadata", () => {
- const state = createMockState({ entities });
-
- expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual([10, 11]);
- expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual(
- v1FieldIds(state),
- );
- });
-
- it("should list only visible fields without original fields, like getMetadata", () => {
- const state = createMockState({
- entities: entitiesWithoutOriginalFields,
- });
-
- expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual([10]);
- expect(getShallowTableFieldIds(state, TABLE_ID)).toEqual(
- v1FieldIds(state),
- );
- });
-
- it("should list nothing for a hidden table, which getMetadata leaves out", () => {
- const state = createMockState({ entities });
-
- expect(getShallowTableFieldIds(state, HIDDEN_TABLE_ID)).toEqual([]);
- expect(getMetadata(state).table(HIDDEN_TABLE_ID)).toBeNull();
- });
-
- it("should return the same array until the table or its fields change", () => {
- const state = createMockState({ entities });
- const nextState = createMockState({ entities });
-
- expect(getShallowTableFieldIds(nextState, TABLE_ID)).toBe(
- getShallowTableFieldIds(state, TABLE_ID),
- );
- });
- });
-
- describe("getShallowTableForeignKeys", () => {
- it("should keep only foreign keys from visible tables, like getMetadata", () => {
- const state = createMockState({ entities });
- const v1OriginIds = getMetadata(state)
- .table(TABLE_ID)
- ?.fks?.filter((foreignKey) => foreignKey.origin != null)
- .map((foreignKey) => foreignKey.origin_id);
-
- const foreignKeys = getShallowTableForeignKeys(state, TABLE_ID);
-
- expect(foreignKeys?.map((foreignKey) => foreignKey.origin_id)).toEqual([
- 20,
- ]);
- expect(foreignKeys?.map((foreignKey) => foreignKey.origin_id)).toEqual(
- v1OriginIds,
- );
- expect(foreignKeys?.[0].origin).toMatchObject({
- id: 20,
- table_id: CONNECTED_TABLE_ID,
- });
- });
-
- it("should be undefined before the table's foreign keys load", () => {
- const state = createMockState({ entities });
-
- expect(
- getShallowTableForeignKeys(state, CONNECTED_TABLE_ID),
- ).toBeUndefined();
- expect(getMetadata(state).table(CONNECTED_TABLE_ID)?.fks).toBeUndefined();
- });
- });
-});
diff --git a/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/RemappingPicker.tsx b/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/RemappingPicker.tsx
index fec838bc187..5bae42034f0 100644
--- a/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/RemappingPicker.tsx
+++ b/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/RemappingPicker.tsx
@@ -25,8 +25,6 @@ import {
Stack,
rem,
} from "metabase/ui";
-import type MetadataDatabase from "metabase-lib/v1/metadata/Database";
-import type MetadataTable from "metabase-lib/v1/metadata/Table";
import { getRemappings } from "metabase-lib/v1/queries/utils/field";
import type { Database, Field, FieldId, FieldValue } from "metabase-types/api";
@@ -45,7 +43,6 @@ import {
getFkTargetTableEntityNameOrNull,
getOptions,
getValue,
- hydrateTableFields,
is403Error,
} from "./utils";
@@ -88,11 +85,7 @@ export const RemappingPicker = ({
...PLUGIN_FEATURE_LEVEL_PERMISSIONS.dataModelQueryProps,
},
);
- const fkTargetTable = useMemo(
- () => hydrateTableFields(fkTargetTableData),
- [fkTargetTableData],
- );
- const tables = useMemo(() => [fkTargetTable], [fkTargetTable]);
+ const fkTargetTable = fkTargetTableData;
const value = useMemo(() => getValue(field), [field]);
const {
@@ -280,19 +273,16 @@ export const RemappingPicker = ({
*/}
{fkTargetTable && (
<FieldDataSelector
- // DataSelector is typed against metabase-lib entities; here we
- // feed it plain API entities, which carry the fields it reads.
- // TODO(dataselector-api-vs-metabase-lib-casts): remove these casts
- // once DataSelector's entity props use structural interfaces.
- databases={[database] as unknown as MetadataDatabase[]}
+ databases={[database]}
isInitiallyOpen={isChoosingInitialFkTarget}
selectedDatabaseId={database.id}
selectedFieldId={fkRemappingField?.id}
selectedTableId={fkTargetTable?.id}
setFieldFn={handleFkRemappingFieldChange}
- // TODO(dataselector-api-vs-metabase-lib-casts): remove this cast
- // once DataSelector's entity props use structural interfaces.
- tables={tables as unknown as MetadataTable[]}
+ tables={[fkTargetTable]}
+ // The target table is the one this picker fetched, so its fields
+ // come from there rather than from the store.
+ fields={fkTargetTable.fields ?? []}
triggerElement={
<Select
data={[
diff --git a/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.ts b/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.ts
index 8e48302476a..30ad836bc66 100644
--- a/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.ts
+++ b/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.ts
@@ -1,10 +1,8 @@
import { t } from "ttag";
import _ from "underscore";
-import { getColumnIcon } from "metabase/common/utils/columns";
import { getRawTableFieldId } from "metabase/metadata/utils/field";
import { is403Error } from "metabase/utils/errors";
-import * as Lib from "metabase-lib";
import { getRemappings } from "metabase-lib/v1/queries/utils/field";
import { isEntityName, isFK } from "metabase-lib/v1/types/utils/isa";
import type { Field, FieldId, FieldValue, Table } from "metabase-types/api";
@@ -80,27 +78,3 @@ function hasMappableNumeralValues(
)
);
}
-
-/**
- * Adds 4 extra attributes to every Field, so that DataSelector does not break.
- * DataSelector component expects metabase-lib/v1/metadata/Field objects (entity framework),
- * but this modern module uses Field from metabase-types/api/field.ts instead.
- */
-export function hydrateTableFields(
- table: Table | undefined,
-): Table | undefined {
- if (!table) {
- return undefined;
- }
-
- return {
- ...table,
- fields: table.fields?.map((field) => ({
- ...field,
- displayName: () => field.display_name,
- icon: () => getColumnIcon(Lib.legacyColumnTypeInfo(field)),
- getPlainObject: () => field,
- table,
- })),
- };
-}
diff --git a/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.unit.spec.ts b/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.unit.spec.ts
index 48e3a1a7b35..0f1b108611d 100644
--- a/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.unit.spec.ts
+++ b/frontend/src/metabase/metadata/components/FieldSection/BehaviorSection/RemappingPicker/utils.unit.spec.ts
@@ -1,4 +1,3 @@
-import { checkNotNull } from "metabase/utils/types";
import type { FieldValue } from "metabase-types/api";
import {
createMockField,
@@ -10,7 +9,6 @@ import {
getFkTargetTableEntityNameOrNull,
getOptions,
getValue,
- hydrateTableFields,
} from "./utils";
describe("RemappingPicker/utils", () => {
@@ -90,30 +88,4 @@ describe("RemappingPicker/utils", () => {
expect(getFkTargetTableEntityNameOrNull(undefined)).toBe(undefined);
});
});
-
- describe("hydrateTableFields", () => {
- it("adds DataSelector compatibility methods to every field", () => {
- const table = createMockTable({
- fields: [createMockField({ display_name: "Total" })],
- });
-
- const hydratedField = checkNotNull(
- hydrateTableFields(table)?.fields?.[0],
- );
-
- expect(hydratedField).toEqual(
- expect.objectContaining({
- display_name: "Total",
- displayName: expect.any(Function),
- icon: expect.any(Function),
- getPlainObject: expect.any(Function),
- table,
- }),
- );
- });
-
- it("passes through an undefined table", () => {
- expect(hydrateTableFields(undefined)).toBe(undefined);
- });
- });
});
diff --git a/frontend/src/metabase/query_builder/actions/object-detail.ts b/frontend/src/metabase/query_builder/actions/object-detail.ts
index b9938afce05..5b85602a09f 100644
--- a/frontend/src/metabase/query_builder/actions/object-detail.ts
+++ b/frontend/src/metabase/query_builder/actions/object-detail.ts
@@ -3,7 +3,6 @@ import _ from "underscore";
import { datasetApi } from "metabase/api";
import { runRtkEndpoint } from "metabase/api/utils/run-rtk-endpoint";
import {
- type ShallowForeignKey,
selectMetadataProvider,
selectQuestionFromCard,
selectQuestionFromOpts,
@@ -12,13 +11,8 @@ import { createThunkAction } from "metabase/redux";
import type { Dispatch, GetState } from "metabase/redux/store";
import type { ObjectId } from "metabase/visualizations/components/ObjectDetail/types";
import * as Lib from "metabase-lib";
-import type {
- Card,
- DatasetColumn,
- Field,
- FieldId,
- NormalizedField,
-} from "metabase-types/api";
+import type ForeignKey from "metabase-lib/v1/metadata/ForeignKey";
+import type { Card, DatasetColumn, Field, FieldId } from "metabase-types/api";
import {
CLEAR_OBJECT_DETAIL_FK_REFERENCES,
@@ -47,7 +41,7 @@ export const resetRowZoom = () => (dispatch: Dispatch) => {
function filterByFk(
query: Lib.Query,
- field: DatasetColumn | Field | NormalizedField,
+ field: DatasetColumn | Field,
objectId: ObjectId,
) {
const stageIndex = -1;
@@ -131,14 +125,14 @@ export const loadObjectDetailFKReferences = createThunkAction(
async function getFKCount(
card: Card,
- fk: ShallowForeignKey,
+ fk: ForeignKey,
): Promise<FKInfo | undefined> {
const databaseId = selectQuestionFromCard(
getState(),
card,
).databaseId();
- const tableId = fk.origin.table_id;
- if (!tableId || !databaseId) {
+ const tableId = fk.origin?.table_id;
+ if (!tableId || !databaseId || !fk.origin) {
return;
}
const metadataProvider = selectMetadataProvider(getState(), databaseId);
@@ -151,7 +145,12 @@ export const loadObjectDetailFKReferences = createThunkAction(
table,
);
const aggregatedQuery = Lib.aggregateByCount(baseQuery, -1);
- const query = filterByFk(aggregatedQuery, fk.origin, objectId);
+ const query = filterByFk(
+ aggregatedQuery,
+ // Unjustified type cast. FIXME
+ fk.origin.getPlainObject() as Field,
+ objectId,
+ );
const finalCard = selectQuestionFromOpts(getState(), {
dataset_query: Lib.toJsQuery(query),
}).datasetQuery();
diff --git a/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx b/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx
index a318a88c708..f1502a90001 100644
--- a/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx
+++ b/frontend/src/metabase/query_builder/containers/QueryBuilder.tsx
@@ -156,6 +156,7 @@ import {
getShouldShowUnsavedChangesWarning,
getSnippetCollectionId,
getTableForeignKeyReferences,
+ getTableForeignKeys,
getTimeseriesXDomain,
getUiControls,
getVisibleTimelineEventIds,
@@ -182,6 +183,7 @@ const mapStateToProps = (state: State) => {
parameterValues: getParameterValues(state),
+ tableForeignKeys: getTableForeignKeys(state),
tableForeignKeyReferences: getTableForeignKeyReferences(state),
card: getCard(state),
diff --git a/frontend/src/metabase/query_builder/store/selectors.ts b/frontend/src/metabase/query_builder/store/selectors.ts
index 57379a3f965..1619a9d2748 100644
--- a/frontend/src/metabase/query_builder/store/selectors.ts
+++ b/frontend/src/metabase/query_builder/store/selectors.ts
@@ -11,9 +11,7 @@ import { getSortedTimelines } from "metabase/common/utils/timelines";
import { dayjs } from "metabase/dayjs";
import { getEmbedOptions } from "metabase/embedding/interactive-embedding";
import {
- getShallowTableFieldIds,
- getShallowTableForeignKeys,
- getShallowTables,
+ getMetadata,
selectQuestionFromCardBuilder,
} from "metabase/metadata-store";
import {
@@ -38,6 +36,7 @@ import {
} from "metabase/viz-core";
import * as Lib from "metabase-lib";
import type Question from "metabase-lib/v1/Question";
+import type Table from "metabase-lib/v1/metadata/Table";
import {
normalizeParameterValue,
normalizeParameters,
@@ -313,23 +312,21 @@ export const getTableId = createSelector([getQuestion], (question) => {
});
export const getTableMetadata = createSelector(
- [getTableId, getShallowTables],
- (tableId, tables) => (tableId != null ? tables[tableId] : undefined),
+ [getTableId, getMetadata],
+ (tableId, metadata) => metadata.table(tableId),
);
-const NO_FIELD_IDS: Field["id"][] = [];
-
-const getTableFieldIds = (state: QueryBuilderStoreState) => {
- const tableId = getTableId(state);
- return tableId != null
- ? getShallowTableFieldIds(state, tableId)
- : NO_FIELD_IDS;
-};
+export const getTableForeignKeys = createSelector(
+ [getTableMetadata],
+ (table) => {
+ const tableForeignKeys = table?.fks ?? [];
+ const tableForeignKeysWithoutHiddenTables = tableForeignKeys.filter(
+ (tableForeignKey) => tableForeignKey.origin != null,
+ );
-export const getTableForeignKeys = (state: QueryBuilderStoreState) => {
- const tableId = getTableId(state);
- return (tableId != null && getShallowTableForeignKeys(state, tableId)) || [];
-};
+ return tableForeignKeysWithoutHiddenTables;
+ },
+);
export const getPKColumnIndex = createSelector(
[getFirstQueryResult, getTableId],
@@ -400,7 +397,7 @@ export const getRowIndexToPKMap = createSelector(
function areLegacyQueriesEqual(
queryA: DatasetQuery | undefined,
queryB: DatasetQuery | undefined,
- tableFieldIds: Field["id"][],
+ tableMetadata?: Table | null,
) {
if (queryA == null || queryB == null) {
return false;
@@ -408,7 +405,9 @@ function areLegacyQueriesEqual(
return Lib.areLegacyQueriesEqual(
queryA,
queryB,
- tableFieldIds.filter((id): id is number => typeof id === "number"),
+ tableMetadata?.fields
+ ?.map(({ id }) => id)
+ ?.filter((id): id is number => typeof id === "number") ?? [],
);
}
@@ -420,12 +419,12 @@ function areComposedEntitiesEquivalent({
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableFieldIds,
+ tableMetadata,
}: {
originalQuestion?: Question | null;
lastRunQuestion?: Question | null;
currentQuestion?: Question | null;
- tableFieldIds: Field["id"][];
+ tableMetadata?: Table | null;
}) {
const isQuestion = originalQuestion?.type() === "question";
if (!originalQuestion || !lastRunQuestion || !currentQuestion || isQuestion) {
@@ -437,12 +436,12 @@ function areComposedEntitiesEquivalent({
const isLastRunComposed = areLegacyQueriesEqual(
lastRunQuestion.datasetQuery(),
composedOriginal.datasetQuery(),
- tableFieldIds,
+ tableMetadata,
);
const isCurrentComposed = areLegacyQueriesEqual(
currentQuestion.datasetQuery(),
composedOriginal.datasetQuery(),
- tableFieldIds,
+ tableMetadata,
);
const isLastRunEquivalentToCurrent =
@@ -450,7 +449,7 @@ function areComposedEntitiesEquivalent({
areLegacyQueriesEqual(
currentQuestion.datasetQuery(),
originalQuestion.datasetQuery(),
- tableFieldIds,
+ tableMetadata,
);
const isCurrentEquivalentToLastRun =
@@ -458,7 +457,7 @@ function areComposedEntitiesEquivalent({
areLegacyQueriesEqual(
lastRunQuestion.datasetQuery(),
originalQuestion.datasetQuery(),
- tableFieldIds,
+ tableMetadata,
);
return isLastRunEquivalentToCurrent || isCurrentEquivalentToLastRun;
@@ -468,24 +467,24 @@ export function areQueriesEquivalent({
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableFieldIds,
+ tableMetadata,
}: {
originalQuestion?: Question | null;
lastRunQuestion?: Question | null;
currentQuestion?: Question | null;
- tableFieldIds: Field["id"][];
+ tableMetadata?: Table | null;
}) {
return (
areLegacyQueriesEqual(
lastRunQuestion?.datasetQuery(),
currentQuestion?.datasetQuery(),
- tableFieldIds,
+ tableMetadata,
) ||
areComposedEntitiesEquivalent({
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableFieldIds,
+ tableMetadata,
})
);
}
@@ -497,7 +496,7 @@ export const getIsResultDirty = createSelector(
getLastRunQuestion,
getLastRunParameterValues,
getNextRunParameterValues,
- getTableFieldIds,
+ getTableMetadata,
],
(
currentQuestion,
@@ -505,7 +504,7 @@ export const getIsResultDirty = createSelector(
lastRunQuestion,
lastParameters,
nextParameters,
- tableFieldIds,
+ tableMetadata,
) => {
const haveParametersChanged = !_.isEqual(lastParameters, nextParameters);
const isEditable =
@@ -518,7 +517,7 @@ export const getIsResultDirty = createSelector(
originalQuestion,
lastRunQuestion,
currentQuestion,
- tableFieldIds,
+ tableMetadata,
})),
);
},
diff --git a/frontend/src/metabase/query_builder/store/state.ts b/frontend/src/metabase/query_builder/store/state.ts
index c44fb2201f0..6fae3915dd7 100644
--- a/frontend/src/metabase/query_builder/store/state.ts
+++ b/frontend/src/metabase/query_builder/store/state.ts
@@ -1,6 +1,6 @@
import type { timelineApi } from "metabase/api";
import type { getEmbedOptions } from "metabase/embedding/interactive-embedding";
-import type { selectQuestionFromCardBuilder } from "metabase/metadata-store";
+import type { getMetadata } from "metabase/metadata-store";
import type { QueryBuilderState } from "metabase/redux/store/qb";
import type { getSetting } from "metabase/settings";
@@ -11,7 +11,7 @@ import type { getSetting } from "metabase/settings";
* stop reading the global `State`.
*/
export type QueryBuilderStoreState = { qb: QueryBuilderState } & Parameters<
- typeof selectQuestionFromCardBuilder
+ typeof getMetadata
>[0] &
Parameters<typeof getSetting>[0] &
Parameters<typeof getEmbedOptions>[0] &
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.tsx
index 1278d093d64..fb312670b30 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.tsx
@@ -17,18 +17,12 @@ import { EmptyState } from "metabase/common/components/EmptyState";
import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
import CS from "metabase/css/core/index.css";
import { canUserCreateQueries } from "metabase/current-user";
-import { getMetadata } from "metabase/metadata-store";
+import { getShallowQuestions } from "metabase/metadata-store";
import { connect } from "metabase/redux";
import type { Dispatch, State } from "metabase/redux/store";
import { fetchTableMetadata } from "metabase/redux/tables";
import { getSetting } from "metabase/settings";
import { Box, Popover } from "metabase/ui";
-import type Question from "metabase-lib/v1/Question";
-import type Database from "metabase-lib/v1/metadata/Database";
-import type Field from "metabase-lib/v1/metadata/Field";
-import type Metadata from "metabase-lib/v1/metadata/Metadata";
-import type Schema from "metabase-lib/v1/metadata/Schema";
-import type Table from "metabase-lib/v1/metadata/Table";
import {
SAVED_QUESTIONS_VIRTUAL_DB_ID,
getQuestionIdFromVirtualTableId,
@@ -62,8 +56,15 @@ import {
type TriggerComponentProps,
} from "./TriggerComponents";
import { CONTAINER_WIDTH, DATA_BUCKET } from "./constants";
+import { type EntityLookups, getEntityLookups } from "./entity-lookups";
import { SavedEntityPicker } from "./saved-entity-picker/SavedEntityPicker";
-import type { DataPickerDataType } from "./types";
+import type {
+ DataPickerDataType,
+ DataSelectorDatabase,
+ DataSelectorField,
+ DataSelectorSchema,
+ DataSelectorTable,
+} from "./types";
import { getDataTypes } from "./utils";
// chooses a data source bucket (datasets / raw data (tables) / saved questions)
@@ -114,22 +115,20 @@ export interface DataSelectorOwnProps {
selectedCollectionId?: CollectionId;
databaseQuery?: ListDatabasesRequest;
- // TODO(dataselector-api-vs-metabase-lib-casts): these entity props are typed
- // as metabase-lib classes, but some consumers pass plain metabase-types/api
- // entities and cast. Replace with minimal structural interfaces (threaded
- // through the pickers) so both representations type-check without casts.
- databases?: Database[];
- schemas?: Schema[];
- tables?: Table[];
- fields?: Field[];
+ databases?: DataSelectorDatabase[];
+ schemas?: DataSelectorSchema[];
+ tables?: DataSelectorTable[];
+ fields?: DataSelectorField[];
setDatabaseFn?: (databaseId: DatabaseId) => void;
setFieldFn?: (fieldId: FieldId) => void;
setSourceTableFn?: (tableId: TableId, databaseId?: DatabaseId) => void;
- tableFilter?: (table: Table) => boolean;
- fieldFilter?: (field: Field) => boolean;
- databaseIsDisabled?: (database: Database) => boolean;
- databaseDisabledTooltip?: (database: Database) => string | undefined;
+ tableFilter?: (table: DataSelectorTable) => boolean;
+ fieldFilter?: (field: DataSelectorField) => boolean;
+ databaseIsDisabled?: (database: DataSelectorDatabase) => boolean;
+ databaseDisabledTooltip?: (
+ database: DataSelectorDatabase,
+ ) => string | undefined;
canChangeDatabase?: boolean;
canSelectModel?: boolean;
@@ -142,14 +141,14 @@ export interface DataSelectorOwnProps {
interface DataSelectorStateProps {
availableModels: SearchModel[];
- metadata: Metadata;
- databases: Database[];
+ entityLookups: EntityLookups;
+ databases: DataSelectorDatabase[];
hasLoadedDatabasesWithTablesSaved: boolean;
hasLoadedDatabasesWithSaved: boolean;
hasLoadedDatabasesWithTables: boolean;
hasDataAccess: boolean;
hasNestedQueriesEnabled: boolean;
- selectedQuestion: Question | null;
+ selectedCardType?: CardType;
}
interface DataSelectorDispatchProps {
@@ -176,14 +175,14 @@ type DataSelectorProps = DataSelectorOwnProps &
AvailableModelsInjectedProps;
interface ComputedDataSelectorState {
- databases: Database[];
- selectedDatabase: Database | null;
- schemas: Schema[];
- selectedSchema: Schema | null;
- tables: Table[];
- selectedTable: Table | null;
- fields: Field[];
- selectedField: Field | null;
+ databases: DataSelectorDatabase[];
+ selectedDatabase: DataSelectorDatabase | null;
+ schemas: DataSelectorSchema[];
+ selectedSchema: DataSelectorSchema | null;
+ tables: DataSelectorTable[];
+ selectedTable: DataSelectorTable | null;
+ fields: DataSelectorField[];
+ selectedField: DataSelectorField | null;
}
interface DataSelectorState extends ComputedDataSelectorState {
@@ -336,13 +335,14 @@ export class UnconnectedDataSelector extends Component<
return this.state.isPopoverOpen;
}
- // computes selected metadata objects (`selectedDatabase`, etc) and options (`databases`, etc)
- // from props (`metadata`, `databases`, etc) and state (`selectedDatabaseId`, etc)
+ // computes selected entities (`selectedDatabase`, etc) and options
+ // (`databases`, etc) from props (`entityLookups`, `databases`, etc) and state
+ // (`selectedDatabaseId`, etc)
//
// NOTE: this is complicated because we allow you to:
// 1. pass in databases/schemas/tables/fields as props
- // 2. pull them from the currently selected "parent" metadata object
- // 3. pull them out of metadata
+ // 2. pull them from the currently selected "parent" entity
+ // 3. pull them out of the store
//
// We also want to recompute the selected objects from their selected ID
// each time rather than storing the object itself in case new metadata is
@@ -352,7 +352,7 @@ export class UnconnectedDataSelector extends Component<
props: DataSelectorProps,
state: SelectedIdsState,
): ComputedDataSelectorState {
- const { metadata, tableFilter, fieldFilter } = props;
+ const { entityLookups, tableFilter, fieldFilter } = props;
const {
selectedDatabaseId,
selectedSchemaId,
@@ -361,38 +361,38 @@ export class UnconnectedDataSelector extends Component<
} = state;
let { databases, schemas, tables, fields } = props;
- let selectedDatabase: Database | null = null;
- let selectedSchema: Schema | null = null;
- let selectedTable: Table | null = null;
- let selectedField: Field | null = null;
+ let selectedDatabase: DataSelectorDatabase | null = null;
+ let selectedSchema: DataSelectorSchema | null = null;
+ let selectedTable: DataSelectorTable | null = null;
+ let selectedField: DataSelectorField | null = null;
const getDatabase = (id: DatabaseId) =>
- _.findWhere(databases, { id }) || metadata.database(id);
+ _.findWhere(databases, { id }) || entityLookups.database(id);
const getSchema = (id: SchemaId) =>
- _.findWhere(schemas ?? [], { id }) || metadata.schema(id);
+ _.findWhere(schemas ?? [], { id }) || entityLookups.schema(id);
const getTable = (id: TableId) =>
- _.findWhere(tables ?? [], { id }) || metadata.table(id);
+ _.findWhere(tables ?? [], { id }) || entityLookups.table(id);
const getField = (id: FieldId | FieldReference) =>
- _.findWhere(fields ?? [], { id }) || metadata.field(id);
+ _.findWhere(fields ?? [], { id }) || entityLookups.field(id);
- const deriveFromDatabase = (database: Database | null) => {
+ const deriveFromDatabase = (database: DataSelectorDatabase | null) => {
if (!schemas && database) {
- schemas = database.schemas;
+ schemas = entityLookups.databaseSchemas(database.id);
}
if (!tables && Array.isArray(schemas) && schemas.length === 1) {
- tables = schemas[0].tables;
+ tables = entityLookups.schemaTables(schemas[0].id);
}
};
- const deriveFromSchema = (schema: Schema | null) => {
+ const deriveFromSchema = (schema: DataSelectorSchema | null) => {
if (!tables && schema) {
- tables = schema.tables;
+ tables = entityLookups.schemaTables(schema.id);
}
};
- const deriveFromTable = (table: Table | null) => {
+ const deriveFromTable = (table: DataSelectorTable | null) => {
if (!fields && table) {
- fields = table.fields;
+ fields = entityLookups.tableFields(table.id);
}
};
@@ -413,15 +413,16 @@ export class UnconnectedDataSelector extends Component<
}
// now do it in in reverse to propagate it back up
if (!selectedTable && selectedField) {
- selectedTable = selectedField.table ?? null;
+ selectedTable = entityLookups.table(selectedField.table_id) ?? null;
deriveFromTable(selectedTable);
}
if (!selectedSchema && selectedTable) {
- selectedSchema = selectedTable.schema ?? null;
+ selectedSchema = entityLookups.tableSchema(selectedTable.id) ?? null;
deriveFromSchema(selectedSchema);
}
if (!selectedDatabase && selectedSchema) {
- selectedDatabase = selectedSchema.database ?? null;
+ selectedDatabase =
+ entityLookups.database(selectedSchema.database) ?? null;
deriveFromDatabase(selectedDatabase);
}
@@ -491,7 +492,7 @@ export class UnconnectedDataSelector extends Component<
}
if (Object.keys(newState).length > 0) {
this.setStateWithComputedState(newState, nextProps);
- } else if (nextProps.metadata !== this.props.metadata) {
+ } else if (nextProps.entityLookups !== this.props.entityLookups) {
this.setStateWithComputedState({}, nextProps);
}
}
@@ -519,7 +520,7 @@ export class UnconnectedDataSelector extends Component<
await fetchQuestion(sourceId);
this.showSavedEntityPicker({
- entityType: this.props.selectedQuestion?.type(),
+ entityType: this.props.selectedCardType,
});
}
}
@@ -548,12 +549,17 @@ export class UnconnectedDataSelector extends Component<
schemas,
} = this.state;
+ const { entityLookups } = this.props;
+ const selectedSchemaDatabase = selectedSchema
+ ? entityLookups.database(selectedSchema.database)
+ : undefined;
+
const invalidSchema =
selectedDatabase &&
selectedSchema &&
- selectedSchema.database &&
- selectedSchema.database.id !== selectedDatabase.id &&
- selectedSchema.database.id !== SAVED_QUESTIONS_VIRTUAL_DB_ID;
+ selectedSchemaDatabase &&
+ selectedSchemaDatabase.id !== selectedDatabase.id &&
+ selectedSchemaDatabase.id !== SAVED_QUESTIONS_VIRTUAL_DB_ID;
const onStepMissingSchemaAndTable =
!selectedSchema &&
@@ -566,12 +572,12 @@ export class UnconnectedDataSelector extends Component<
selectedSchema &&
selectedTable &&
!isVirtualCardId(selectedTable.id) &&
- selectedTable.schema?.id !== selectedSchema.id;
+ entityLookups.tableSchema(selectedTable.id)?.id !== selectedSchema.id;
const invalidField =
selectedTable &&
selectedField &&
- selectedField.table?.id !== selectedTable.id;
+ selectedField.table_id !== selectedTable.id;
// A database with a single schema auto-selects it (see `skipSteps`). When the
// schema list arrives asynchronously *after* we already switched to the schema
@@ -966,7 +972,7 @@ export class UnconnectedDataSelector extends Component<
}
};
- onChangeDatabase = async (database: Database) => {
+ onChangeDatabase = async (database: DataSelectorDatabase) => {
if (database.is_saved_questions) {
this.showSavedEntityPicker({ entityType: "question" });
return;
@@ -984,19 +990,19 @@ export class UnconnectedDataSelector extends Component<
await this.nextStep({ selectedDatabaseId: database && database.id });
};
- onChangeSchema = async (schema?: Schema) => {
+ onChangeSchema = async (schema?: DataSelectorSchema) => {
// NOTE: not really any need to have a setSchemaFn since schemas are just a namespace
await this.nextStep({ selectedSchemaId: schema?.id ?? null });
};
- onChangeTable = async (table?: Table) => {
+ onChangeTable = async (table?: DataSelectorTable) => {
if (this.props.setSourceTableFn && table?.id != null) {
this.props.setSourceTableFn(table.id, table.db_id);
}
await this.nextStep({ selectedTableId: table?.id ?? null });
};
- onChangeField = async (field?: Field) => {
+ onChangeField = async (field?: DataSelectorField) => {
const fieldId = field?.id;
if (this.props.setFieldFn && typeof fieldId === "number") {
this.props.setFieldFn(fieldId);
@@ -1022,6 +1028,16 @@ export class UnconnectedDataSelector extends Component<
const { selectedDatabase, selectedTable, selectedField } = this.state;
+ // Only the field trigger reads this, to tell a schema-qualified table name
+ // from a plain one.
+ const hasMultipleSchemas =
+ selectedField != null &&
+ selectedDatabase != null &&
+ _.uniq(
+ this.props.entityLookups.databaseTables(selectedDatabase.id),
+ (table) => table.schema_name,
+ ).length > 1;
+
return (
<Trigger
className={className}
@@ -1035,6 +1051,7 @@ export class UnconnectedDataSelector extends Component<
database={selectedDatabase}
table={selectedTable}
field={selectedField}
+ hasMultipleSchemas={hasMultipleSchemas}
/>
)}
</Trigger>
@@ -1095,6 +1112,8 @@ export class UnconnectedDataSelector extends Component<
hasInitialFocus: true,
databaseIsDisabled: this.props.databaseIsDisabled,
databaseDisabledTooltip: this.props.databaseDisabledTooltip,
+ getDatabaseSchemas: this.props.entityLookups.databaseSchemas,
+ getFieldDisplayName: this.props.entityLookups.fieldName,
};
switch (this.state.activeStep) {
@@ -1145,7 +1164,7 @@ export class UnconnectedDataSelector extends Component<
handleSavedEntitySelect = async (tableOrCardId: string) => {
await this.props.fetchFields(tableOrCardId);
if (this.props.setSourceTableFn) {
- const table = this.props.metadata.table(tableOrCardId);
+ const table = this.props.entityLookups.table(tableOrCardId);
this.props.setSourceTableFn(tableOrCardId, table?.db_id);
}
this.togglePopoverOpen();
@@ -1352,15 +1371,18 @@ const mapStateToProps = (
};
const queriedDatabases =
databaseApi.endpoints.listDatabases.select(databaseQuery)(state).data?.data;
- const metadata = getMetadata(state);
+ const entityLookups = getEntityLookups(state);
+ const selectedCardId = getQuestionIdFromVirtualTableId(
+ ownProps.selectedTableId,
+ );
return {
availableModels: ownProps.availableModelsResult?.available_models ?? [],
- metadata,
+ entityLookups,
databases:
ownProps.databases ||
queriedDatabases
- ?.map(({ id }) => metadata.database(id))
- .filter((database): database is Database => database != null) ||
+ ?.map(({ id }) => entityLookups.database(id))
+ .filter((database) => database != null) ||
[],
hasLoadedDatabasesWithTablesSaved: isListDatabasesQuerySuccess(state, {
include: "tables",
@@ -1377,9 +1399,10 @@ const mapStateToProps = (
}),
hasDataAccess: canUserCreateQueries(state),
hasNestedQueriesEnabled: getSetting(state, "enable-nested-queries"),
- selectedQuestion: getMetadata(state).question(
- getQuestionIdFromVirtualTableId(ownProps.selectedTableId),
- ),
+ selectedCardType:
+ selectedCardId != null
+ ? getShallowQuestions(state)[selectedCardId]?.type
+ : undefined,
};
};
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.unit.spec.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.unit.spec.tsx
index a1ac0b32fc5..49d296860fa 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.unit.spec.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelector.unit.spec.tsx
@@ -1,11 +1,14 @@
import userEvent from "@testing-library/user-event";
import type { ComponentProps } from "react";
-import { createMockMetadata } from "__support__/metadata";
import { createMockSettingsState, createMockState } from "__support__/state";
+import { createMockEntitiesState } from "__support__/store";
import { getIcon, render, renderWithProviders, screen } from "__support__/ui";
import { delay } from "__support__/utils";
-import { UnconnectedDataSelector as DataSelector } from "metabase/querying/common/components/DataSelector";
+import {
+ UnconnectedDataSelector as DataSelector,
+ getEntityLookups,
+} from "metabase/querying/common/components/DataSelector";
import { checkNotNull } from "metabase/utils/types";
import { SAVED_QUESTIONS_VIRTUAL_DB_ID } from "metabase-lib/v1/metadata/utils/saved-questions";
import {
@@ -74,31 +77,43 @@ describe("DataSelector", () => {
}),
];
- const metadata = createMockMetadata({ databases });
- const emptyMetadata = createMockMetadata({});
+ const entities = createMockEntitiesState({ databases });
+ // Each stage of loading is a store with fewer records in it.
+ const lookupsWith = (overrides: Partial<typeof entities> = {}) =>
+ getEntityLookups(
+ createMockState({ entities: { ...entities, ...overrides } }),
+ );
+ const entityLookups = lookupsWith();
+ const emptyLookups = getEntityLookups(
+ createMockState({ entities: createMockEntitiesState({}) }),
+ );
const storeInitialState = createMockState({
settings: createMockSettingsState({
"enable-nested-queries": true,
}),
});
- const SAMPLE_DATABASE = checkNotNull(metadata.database(SAMPLE_DB_ID));
- const ANOTHER_DATABASE = checkNotNull(metadata.database(EMPTY_DB_ID));
+ const SAMPLE_DATABASE = checkNotNull(entityLookups.database(SAMPLE_DB_ID));
+ const ANOTHER_DATABASE = checkNotNull(entityLookups.database(EMPTY_DB_ID));
const MULTI_SCHEMA_DATABASE = checkNotNull(
- metadata.database(MULTI_SCHEMA_DB_ID),
+ entityLookups.database(MULTI_SCHEMA_DB_ID),
);
const OTHER_MULTI_SCHEMA_DATABASE = checkNotNull(
- metadata.database(OTHER_MULTI_SCHEMA_DB_ID),
+ entityLookups.database(OTHER_MULTI_SCHEMA_DB_ID),
);
const SAVED_QUESTIONS_DATABASE = checkNotNull(
- createMockMetadata({
- databases: [createMockSavedQuestionsDatabase()],
- }).database(SAVED_QUESTIONS_VIRTUAL_DB_ID),
+ getEntityLookups(
+ createMockState({
+ entities: createMockEntitiesState({
+ databases: [createMockSavedQuestionsDatabase()],
+ }),
+ }),
+ ).database(SAVED_QUESTIONS_VIRTUAL_DB_ID),
);
const defaultProps: DataSelectorProps = {
steps: ["DATABASE"],
- metadata: emptyMetadata,
+ entityLookups: emptyLookups,
databases: [],
availableModels: [],
hasLoadedDatabasesWithTablesSaved: false,
@@ -106,7 +121,6 @@ describe("DataSelector", () => {
hasLoadedDatabasesWithTables: false,
hasDataAccess: false,
hasNestedQueriesEnabled: false,
- selectedQuestion: null,
loading: false,
loaded: false,
allLoading: false,
@@ -126,7 +140,7 @@ describe("DataSelector", () => {
combineDatabaseSchemaSteps
triggerElement={<div />}
databases={[MULTI_SCHEMA_DATABASE, SAMPLE_DATABASE, ANOTHER_DATABASE]}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
setSourceTableFn={setTable}
/>,
@@ -177,7 +191,7 @@ describe("DataSelector", () => {
combineDatabaseSchemaSteps: true,
triggerElement: <div />,
databases: [],
- metadata: emptyMetadata,
+ entityLookups: emptyLookups,
isOpen: true,
fetchDatabases,
fetchSchemas,
@@ -187,12 +201,12 @@ describe("DataSelector", () => {
const { rerender } = render(<DataSelector {...props} />);
// we call rerenderWith to add more data after a fetch function was called
- const rerenderWith = (nextMetadata: typeof metadata) => {
+ const rerenderWith = (nextLookups: typeof entityLookups) => {
rerender(
<DataSelector
{...props}
- metadata={nextMetadata}
- databases={Object.values(metadata.databases)}
+ entityLookups={nextLookups}
+ databases={Object.values(entities.databases)}
/>,
);
};
@@ -204,11 +218,7 @@ describe("DataSelector", () => {
expect(screen.getByTestId("loading-indicator")).toBeInTheDocument();
// select a db
- let nextMetadata = createMockMetadata({ databases });
- nextMetadata.schemas = {};
- nextMetadata.tables = {};
- nextMetadata.fields = {};
- rerenderWith(nextMetadata);
+ rerenderWith(lookupsWith({ schemas: {}, tables: {}, fields: {} }));
expect(screen.getByText("Sample Database")).toBeInTheDocument();
expect(screen.getByText("Multi-schema Database")).toBeInTheDocument();
@@ -219,10 +229,7 @@ describe("DataSelector", () => {
expect(fetchSchemas).toHaveBeenCalled();
// select a schema
- nextMetadata = createMockMetadata({ databases });
- nextMetadata.tables = {};
- nextMetadata.fields = {};
- rerenderWith(nextMetadata);
+ rerenderWith(lookupsWith({ tables: {}, fields: {} }));
expect(screen.getByText("First Schema")).toBeInTheDocument();
expect(screen.getByText("Second Schema")).toBeInTheDocument();
await userEvent.click(screen.getByText("Second Schema"));
@@ -232,7 +239,7 @@ describe("DataSelector", () => {
expect(fetchSchemaTables).toHaveBeenCalled();
// table is displayed
- rerenderWith(metadata);
+ rerenderWith(entityLookups);
expect(screen.getByText("Table in Second Schema")).toBeInTheDocument();
});
@@ -244,7 +251,7 @@ describe("DataSelector", () => {
combineDatabaseSchemaSteps
triggerElement={<div />}
databases={[SAMPLE_DATABASE]}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -262,9 +269,12 @@ describe("DataSelector", () => {
const fetchSchemas = jest.fn();
const fetchSchemaTables = jest.fn();
- const metadataWithoutTables = createMockMetadata({
+ const entitiesWithoutTables = createMockEntitiesState({
databases: [createMockDatabase({ id: SAMPLE_DB_ID, tables: [] })],
});
+ const lookupsWithoutTables = getEntityLookups(
+ createMockState({ entities: entitiesWithoutTables }),
+ );
const props: DataSelectorProps = {
...defaultProps,
@@ -280,8 +290,8 @@ describe("DataSelector", () => {
const { rerender } = render(
<DataSelector
{...props}
- databases={[checkNotNull(metadataWithoutTables.database(SAMPLE_DB_ID))]}
- metadata={metadataWithoutTables}
+ databases={[checkNotNull(lookupsWithoutTables.database(SAMPLE_DB_ID))]}
+ entityLookups={lookupsWithoutTables}
/>,
);
@@ -294,8 +304,8 @@ describe("DataSelector", () => {
rerender(
<DataSelector
{...props}
- databases={[checkNotNull(metadata.database(SAMPLE_DB_ID))]}
- metadata={metadata}
+ databases={[checkNotNull(entityLookups.database(SAMPLE_DB_ID))]}
+ entityLookups={entityLookups}
/>,
);
@@ -309,7 +319,7 @@ describe("DataSelector", () => {
{...defaultProps}
steps={["DATABASE"]}
triggerElement={<div>button</div>}
- metadata={emptyMetadata}
+ entityLookups={emptyLookups}
databases={[]}
fetchDatabases={fetchDatabases}
/>,
@@ -328,7 +338,7 @@ describe("DataSelector", () => {
combineDatabaseSchemaSteps
triggerElement={<div />}
databases={[MULTI_SCHEMA_DATABASE, SAMPLE_DATABASE]}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -348,7 +358,7 @@ describe("DataSelector", () => {
combineDatabaseSchemaSteps
triggerElement={<div />}
databases={[MULTI_SCHEMA_DATABASE, SAMPLE_DATABASE]}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -378,7 +388,7 @@ describe("DataSelector", () => {
combineDatabaseSchemaSteps
triggerElement={<div />}
databases={[MULTI_SCHEMA_DATABASE, SAMPLE_DATABASE]}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -410,7 +420,7 @@ describe("DataSelector", () => {
combineDatabaseSchemaSteps
triggerElement={<div />}
databases={[MULTI_SCHEMA_DATABASE, SAMPLE_DATABASE]}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -442,7 +452,7 @@ describe("DataSelector", () => {
selectedDatabaseId={SAMPLE_DATABASE.id}
databases={[SAMPLE_DATABASE]}
triggerElement={<div />}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -459,7 +469,7 @@ describe("DataSelector", () => {
selectedDatabaseId={MULTI_SCHEMA_DATABASE.id}
databases={[MULTI_SCHEMA_DATABASE]}
triggerElement={<div />}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -476,7 +486,7 @@ describe("DataSelector", () => {
databases={[SAMPLE_DATABASE, MULTI_SCHEMA_DATABASE]}
selectedDatabaseId={SAMPLE_DATABASE.id}
triggerElement={<div />}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -494,7 +504,7 @@ describe("DataSelector", () => {
databases={[MULTI_SCHEMA_DATABASE, OTHER_MULTI_SCHEMA_DATABASE]}
combineDatabaseSchemaSteps
triggerElement={<div />}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -516,7 +526,7 @@ describe("DataSelector", () => {
databases={[SAMPLE_DATABASE, ANOTHER_DATABASE]}
combineDatabaseSchemaSteps
triggerElement={<div />}
- metadata={metadata}
+ entityLookups={entityLookups}
isOpen={true}
/>,
);
@@ -581,6 +591,7 @@ describe("DataSelector", () => {
steps={["BUCKET", "DATABASE", "SCHEMA", "TABLE"]}
combineDatabaseSchemaSteps
databases={[SAMPLE_DATABASE]}
+ entityLookups={entityLookups}
hasNestedQueriesEnabled
loaded
triggerElement={<div />}
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabasePicker/DataSelectorDatabasePicker.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabasePicker/DataSelectorDatabasePicker.tsx
index ffd240c9545..dcbcf5e5467 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabasePicker/DataSelectorDatabasePicker.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabasePicker/DataSelectorDatabasePicker.tsx
@@ -8,32 +8,33 @@ import {
} from "metabase/common/components/AccordionList";
import CS from "metabase/css/core/index.css";
import { Icon, Tooltip } from "metabase/ui";
-import type Database from "metabase-lib/v1/metadata/Database";
-import type Schema from "metabase-lib/v1/metadata/Schema";
import { DataSelectorLoading } from "../DataSelectorLoading";
import { RawDataBackButton } from "../RawDataBackButton";
+import type { DataSelectorDatabase, DataSelectorSchema } from "../types";
type DataSelectorDatabasePickerProps = {
- databases: Database[];
+ databases: DataSelectorDatabase[];
hasBackButton?: boolean;
hasFiltering?: boolean;
hasInitialFocus?: boolean;
hasNextStep?: boolean;
isLoading?: boolean;
- selectedDatabase?: Database;
- selectedSchema?: Schema;
+ selectedDatabase?: DataSelectorDatabase;
+ selectedSchema?: DataSelectorSchema;
onBack?: () => void;
- onChangeDatabase: (database: Database) => void;
- onChangeSchema: (schema?: Schema) => void;
- databaseIsDisabled?: (database: Database) => boolean;
- databaseDisabledTooltip?: (database: Database) => string | undefined;
+ onChangeDatabase: (database: DataSelectorDatabase) => void;
+ onChangeSchema: (schema?: DataSelectorSchema) => void;
+ databaseIsDisabled?: (database: DataSelectorDatabase) => boolean;
+ databaseDisabledTooltip?: (
+ database: DataSelectorDatabase,
+ ) => string | undefined;
};
type Item = {
name: string;
index: number;
- database: Database;
+ database: DataSelectorDatabase;
};
export const DataSelectorDatabasePicker = ({
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.tsx
index 3b9998b1aa9..a85a9016a0d 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.tsx
@@ -8,29 +8,30 @@ import {
import CS from "metabase/css/core/index.css";
import { Icon } from "metabase/ui";
import { isSyncCompleted } from "metabase/utils/syncing";
-import type Database from "metabase-lib/v1/metadata/Database";
-import type Schema from "metabase-lib/v1/metadata/Schema";
import { getSchemaDisplayName } from "metabase-lib/v1/metadata/utils/schema";
+import type { DatabaseId } from "metabase-types/api";
import { DataSelectorLoading } from "../DataSelectorLoading";
import { RawDataBackButton } from "../RawDataBackButton";
+import type { DataSelectorDatabase, DataSelectorSchema } from "../types";
type DataSelectorDatabaseSchemaPicker = {
- databases: Database[];
+ databases: DataSelectorDatabase[];
hasBackButton: boolean;
hasFiltering: boolean;
hasInitialFocus: boolean;
hasNextStep: boolean;
isLoading: boolean;
- selectedDatabase?: Database;
- selectedSchema?: Schema;
+ selectedDatabase?: DataSelectorDatabase;
+ selectedSchema?: DataSelectorSchema;
onBack?: () => void;
- onChangeDatabase: (database: Database) => void;
- onChangeSchema: (schema?: Schema) => void;
+ onChangeDatabase: (database: DataSelectorDatabase) => void;
+ onChangeSchema: (schema?: DataSelectorSchema) => void;
+ getDatabaseSchemas: (databaseId: DatabaseId) => DataSelectorSchema[];
};
type Item = {
- schema: Schema;
+ schema: DataSelectorSchema;
name: string;
};
@@ -49,28 +50,33 @@ export const DataSelectorDatabaseSchemaPicker = ({
hasBackButton,
onBack,
hasInitialFocus,
+ getDatabaseSchemas,
}: DataSelectorDatabaseSchemaPicker) => {
if (databases.length === 0) {
return <DataSelectorLoading />;
}
- const sections: Section[] = databases.map((database) => ({
- name: database.is_saved_questions ? t`Saved Questions` : database.name,
- items:
- !database.is_saved_questions && database.getSchemas().length > 1
- ? database.getSchemas().map((schema) => ({
- schema,
- name: getSchemaDisplayName(schema.name) ?? "",
- }))
- : [],
- className: database.is_saved_questions ? CS.bgLight : undefined,
- icon: database.is_saved_questions ? "collection" : "database",
- loading:
- selectedDatabase?.id === database.id &&
- database.getSchemas().length === 0 &&
- isLoading,
- active: database.is_saved_questions || isSyncCompleted(database),
- }));
+ const sections: Section[] = databases.map((database) => {
+ const schemas = getDatabaseSchemas(database.id);
+
+ return {
+ name: database.is_saved_questions ? t`Saved Questions` : database.name,
+ items:
+ !database.is_saved_questions && schemas.length > 1
+ ? schemas.map((schema) => ({
+ schema,
+ name: getSchemaDisplayName(schema.name) ?? "",
+ }))
+ : [],
+ className: database.is_saved_questions ? CS.bgLight : undefined,
+ icon: database.is_saved_questions ? "collection" : "database",
+ loading:
+ selectedDatabase?.id === database.id &&
+ schemas.length === 0 &&
+ isLoading,
+ active: database.is_saved_questions || isSyncCompleted(database),
+ };
+ });
const handleChangeSection = (_section: any, sectionIndex: number) => {
const isNavigationSection = hasBackButton && sectionIndex === 0;
@@ -105,12 +111,17 @@ export const DataSelectorDatabaseSchemaPicker = ({
}
let openSection = selectedSchema
- ? databases.findIndex((db) => db.id === selectedSchema.database?.id)
+ ? databases.findIndex((db) => db.id === selectedSchema.database)
: selectedDatabase
? databases.findIndex((db) => db.id === selectedDatabase.id)
: -1;
- if (openSection >= 0 && databases[openSection]?.getSchemas().length === 1) {
+ const openSectionDatabase = databases[openSection];
+ if (
+ openSection >= 0 &&
+ openSectionDatabase != null &&
+ getDatabaseSchemas(openSectionDatabase.id).length === 1
+ ) {
openSection = -1;
}
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.unit.spec.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.unit.spec.tsx
index c1ab94ed8c7..8fadab00de2 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorDatabaseSchemaPicker/DataSelectorDatabaseSchemaPicker.unit.spec.tsx
@@ -1,13 +1,14 @@
import { createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
import { render, renderWithProviders, screen } from "__support__/ui";
-import { getMetadata } from "metabase/metadata-store";
+import { getEntityLookups } from "metabase/querying/common/components/DataSelector";
import { checkNotNull } from "metabase/utils/types";
-import type Database from "metabase-lib/v1/metadata/Database";
import { getSchemaDisplayName } from "metabase-lib/v1/metadata/utils/schema";
import type { Database as ApiDatabase } from "metabase-types/api";
import { createMockDatabase, createMockTable } from "metabase-types/api/mocks";
+import type { DataSelectorDatabase, DataSelectorSchema } from "../types";
+
import { DataSelectorDatabaseSchemaPicker } from "./DataSelectorDatabaseSchemaPicker";
const defaultProps = {
@@ -18,15 +19,16 @@ const defaultProps = {
isLoading: false,
onChangeDatabase: jest.fn(),
onChangeSchema: jest.fn(),
+ getDatabaseSchemas: () => [],
};
const setup = (opts: { database: ApiDatabase }) => {
const state = createMockState({
entities: createMockEntitiesState({ databases: [opts.database] }),
});
- const metadata = getMetadata(state);
- const database = checkNotNull(metadata.database(opts.database.id));
- const schemas = database.getSchemas();
+ const lookups = getEntityLookups(state);
+ const database = checkNotNull(lookups.database(opts.database.id));
+ const schemas = lookups.databaseSchemas(database.id);
renderWithProviders(
<DataSelectorDatabaseSchemaPicker
@@ -34,6 +36,7 @@ const setup = (opts: { database: ApiDatabase }) => {
selectedDatabase={database}
selectedSchema={schemas[0]}
databases={[database]}
+ getDatabaseSchemas={lookups.databaseSchemas}
/>,
{ storeInitialState: state },
);
@@ -53,23 +56,23 @@ describe("DataSelectorDatabaseSchemaPicker", () => {
const databaseName = "Database name";
const schemaName = "Schema name";
- // The picker only reads database id/name and getSchemas, so a partial
- // mock is enough here.
+ // The picker only reads database id and name, so a partial mock is
+ // enough here.
const databases = [
- {
- id: 1,
- name: databaseName,
- getSchemas: () => [
- { name: schemaName },
- { name: "another schema name" },
- ],
- },
- ] as unknown as Database[];
+ { id: 1, name: databaseName },
+ ] as DataSelectorDatabase[];
render(
<DataSelectorDatabaseSchemaPicker
{...defaultProps}
databases={databases}
+ getDatabaseSchemas={() =>
+ // The picker only reads schema names here.
+ [
+ { name: schemaName },
+ { name: "another schema name" },
+ ] as DataSelectorSchema[]
+ }
/>,
);
@@ -83,24 +86,23 @@ describe("DataSelectorDatabaseSchemaPicker", () => {
const databaseName = "Database name";
const schemaName = "Schema name";
- // The picker only reads database id/name, is_saved_questions and
- // getSchemas, so a partial mock is enough here.
+ // The picker only reads database id, name and is_saved_questions, so a
+ // partial mock is enough here.
const databases = [
- {
- id: 1,
- is_saved_questions: true,
- name: databaseName,
- getSchemas: () => [
- { name: schemaName },
- { name: "another schema name" },
- ],
- },
- ] as unknown as Database[];
+ { id: 1, is_saved_questions: true, name: databaseName },
+ ] as DataSelectorDatabase[];
render(
<DataSelectorDatabaseSchemaPicker
{...defaultProps}
databases={databases}
+ getDatabaseSchemas={() =>
+ // The picker only reads schema names here.
+ [
+ { name: schemaName },
+ { name: "another schema name" },
+ ] as DataSelectorSchema[]
+ }
/>,
);
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.tsx
index 2b120aaffd7..a27754e8ee0 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.tsx
@@ -10,26 +10,27 @@ import CS from "metabase/css/core/index.css";
import { useMetadataProvider } from "metabase/metadata-store";
import { getQueryAndColumns } from "metabase/querying/common/utils";
import { Box, DelayGroup, Icon } from "metabase/ui";
-import type Field from "metabase-lib/v1/metadata/Field";
-import type Table from "metabase-lib/v1/metadata/Table";
+import { getIconForField } from "metabase-lib/v1/metadata/utils/fields";
import type { IconName } from "metabase-types/api";
import { DataSelectorLoading } from "../DataSelectorLoading";
import { CONTAINER_WIDTH } from "../constants";
+import type { DataSelectorField, DataSelectorTable } from "../types";
import DataSelectorFieldPickerS from "./DataSelectorFieldPicker.module.css";
const STAGE_INDEX = -1;
type DataSelectorFieldPickerProps = {
- fields: Field[];
+ fields: DataSelectorField[];
hasFiltering?: boolean;
hasInitialFocus?: boolean;
isLoading?: boolean;
- selectedField?: Field;
- selectedTable?: Table;
+ selectedField?: DataSelectorField;
+ selectedTable?: DataSelectorTable;
onBack?: () => void;
- onChangeField: (field: Field) => void;
+ onChangeField: (field: DataSelectorField) => void;
+ getFieldDisplayName: (field: DataSelectorField) => string;
};
type HeaderProps = {
@@ -39,7 +40,7 @@ type HeaderProps = {
type FieldWithName = {
name: string;
- field: Field;
+ field: DataSelectorField;
};
export const DataSelectorFieldPicker = ({
@@ -51,15 +52,11 @@ export const DataSelectorFieldPicker = ({
onBack,
hasFiltering,
hasInitialFocus,
+ getFieldDisplayName,
}: DataSelectorFieldPickerProps) => {
const metadataProvider = useMetadataProvider(selectedTable?.db_id ?? null);
const queryAndColumns = useMemo(
- () =>
- getQueryAndColumns(
- metadataProvider,
- selectedTable,
- fields.map((field) => field.getPlainObject()),
- ),
+ () => getQueryAndColumns(metadataProvider, selectedTable, fields),
[metadataProvider, selectedTable, fields],
);
@@ -73,7 +70,7 @@ export const DataSelectorFieldPicker = ({
{
name: header,
items: fields.map((field) => ({
- name: field.displayName(),
+ name: getFieldDisplayName(field),
field: field,
})),
},
@@ -83,7 +80,7 @@ export const DataSelectorFieldPicker = ({
item.field && selectedField && item.field.id === selectedField.id;
const renderItemIcon = (item: FieldWithName) => {
- const queryAndColumn = queryAndColumns.get(item.field.getPlainObject());
+ const queryAndColumn = queryAndColumns.get(item.field);
return (
queryAndColumn && (
<QueryColumnInfoIcon
@@ -92,8 +89,9 @@ export const DataSelectorFieldPicker = ({
column={queryAndColumn.column}
position="top-end"
size={18}
- // Unjustified type cast. FIXME
- icon={item.field.icon() as unknown as IconName}
+ // getIconForField returns one of the icon names in its own
+ // mapping, typed as a plain string.
+ icon={getIconForField(item.field) as IconName}
/>
)
);
@@ -111,7 +109,9 @@ export const DataSelectorFieldPicker = ({
maxHeight={Infinity}
width="100%"
searchable={hasFiltering}
- onChange={(item: { field: Field }) => onChangeField(item.field)}
+ onChange={(item: { field: DataSelectorField }) =>
+ onChangeField(item.field)
+ }
itemIsSelected={checkIfItemIsSelected}
itemIsClickable={(item: FieldWithName) => Boolean(item.field)}
renderItemWrapper={renderItemWrapper}
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.unit.spec.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.unit.spec.tsx
index 68b8a55866d..1a3069428e1 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorFieldPicker/DataSelectorFieldPicker.unit.spec.tsx
@@ -1,16 +1,16 @@
import { createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
import { fireEvent, renderWithProviders, screen } from "__support__/ui";
-import { getMetadata } from "metabase/metadata-store";
+import { getEntityLookups } from "metabase/querying/common/components/DataSelector";
import { checkNotNull } from "metabase/utils/types";
-import type Field from "metabase-lib/v1/metadata/Field";
-import type Table from "metabase-lib/v1/metadata/Table";
import {
ORDERS,
ORDERS_ID,
createSampleDatabase,
} from "metabase-types/api/mocks/presets";
+import type { DataSelectorField, DataSelectorTable } from "../types";
+
import { DataSelectorFieldPicker } from "./DataSelectorFieldPicker";
const state = createMockState({
@@ -19,12 +19,12 @@ const state = createMockState({
}),
});
-const metadata = getMetadata(state);
+const lookups = getEntityLookups(state);
interface SetupOpts {
- fields?: Field[];
+ fields?: DataSelectorField[];
isLoading?: boolean;
- selectedTable?: Table;
+ selectedTable?: DataSelectorTable;
}
const setup = ({ fields = [], isLoading, selectedTable }: SetupOpts = {}) => {
@@ -39,6 +39,7 @@ const setup = ({ fields = [], isLoading, selectedTable }: SetupOpts = {}) => {
selectedTable={selectedTable}
onBack={onBack}
onChangeField={jest.fn()}
+ getFieldDisplayName={lookups.fieldName}
/>,
{ storeInitialState: state },
);
@@ -55,7 +56,7 @@ describe("DataSelectorFieldPicker", () => {
});
it("uses table display name as title if passed", () => {
- const selectedTable = checkNotNull(metadata.table(ORDERS_ID));
+ const selectedTable = checkNotNull(lookups.table(ORDERS_ID));
setup({ isLoading: true, selectedTable });
@@ -75,11 +76,11 @@ describe("DataSelectorFieldPicker", () => {
describe("loaded", () => {
it("displays table name and fields", () => {
- const selectedTable = checkNotNull(metadata.table(ORDERS_ID));
+ const selectedTable = checkNotNull(lookups.table(ORDERS_ID));
setup({
selectedTable,
- fields: [checkNotNull(metadata.field(ORDERS.PRODUCT_ID))],
+ fields: [checkNotNull(lookups.field(ORDERS.PRODUCT_ID))],
});
expect(
@@ -91,10 +92,10 @@ describe("DataSelectorFieldPicker", () => {
it("keeps the search box visible and shows an empty state when no field matches the search (metabase#74670)", () => {
setup({
- selectedTable: checkNotNull(metadata.table(ORDERS_ID)),
+ selectedTable: checkNotNull(lookups.table(ORDERS_ID)),
fields: [
- checkNotNull(metadata.field(ORDERS.ID)),
- checkNotNull(metadata.field(ORDERS.TOTAL)),
+ checkNotNull(lookups.field(ORDERS.ID)),
+ checkNotNull(lookups.field(ORDERS.TOTAL)),
],
});
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.tsx
index 543f5ce5f52..4cce1b96267 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.tsx
@@ -1,20 +1,20 @@
import { AccordionList } from "metabase/common/components/AccordionList";
import CS from "metabase/css/core/index.css";
import { Box, Icon } from "metabase/ui";
-import type Schema from "metabase-lib/v1/metadata/Schema";
import { getSchemaDisplayName } from "metabase-lib/v1/metadata/utils/schema";
import type { SchemaId } from "metabase-types/api";
import { CONTAINER_WIDTH } from "../constants";
+import type { DataSelectorSchema } from "../types";
type DataSelectorSchemaPickerProps = {
hasFiltering: boolean;
hasInitialFocus: boolean;
hasNextStep: boolean;
isLoading: boolean;
- schemas: Schema[];
+ schemas: DataSelectorSchema[];
selectedSchemaId?: SchemaId;
- onChangeSchema: (schema?: Schema) => void;
+ onChangeSchema: (schema?: DataSelectorSchema) => void;
};
export const DataSelectorSchemaPicker = ({
@@ -44,7 +44,7 @@ export const DataSelectorSchemaPicker = ({
sections={sections}
searchable={hasFiltering}
onChange={({ schema }: any) => onChangeSchema(schema)}
- itemIsSelected={(item: { schema: Schema }) =>
+ itemIsSelected={(item: { schema: DataSelectorSchema }) =>
item?.schema.id === selectedSchemaId
}
renderItemIcon={() => <Icon name="folder" size={16} />}
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.unit.spec.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.unit.spec.tsx
index 668168d50f4..48d210e77ae 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorSchemaPicker/DataSelectorSchemaPicker.unit.spec.tsx
@@ -1,15 +1,16 @@
import { render, screen } from "__support__/ui";
import { checkNotNull } from "metabase/utils/types";
-import type Schema from "metabase-lib/v1/metadata/Schema";
import { getSchemaDisplayName } from "metabase-lib/v1/metadata/utils/schema";
+import type { DataSelectorSchema } from "../types";
+
import { DataSelectorSchemaPicker } from "./DataSelectorSchemaPicker";
describe("DataSelectorSchemaPicker", () => {
it("displays schema name", () => {
const schemaName = "Schema name";
// The picker only reads schema names, so a partial mock is enough here.
- const schemas = [{ name: schemaName }] as Schema[];
+ const schemas = [{ name: schemaName }] as DataSelectorSchema[];
render(
<DataSelectorSchemaPicker
schemas={schemas}
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.tsx
index 4e058e90b67..3259716a0f1 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.tsx
@@ -16,13 +16,15 @@ import CS from "metabase/css/core/index.css";
import { Box, DelayGroup, Flex, Icon, rem } from "metabase/ui";
import { isSyncCompleted } from "metabase/utils/syncing";
import { isNotNull } from "metabase/utils/types";
-import type Database from "metabase-lib/v1/metadata/Database";
-import type Schema from "metabase-lib/v1/metadata/Schema";
-import type Table from "metabase-lib/v1/metadata/Table";
import { getSchemaDisplayName } from "metabase-lib/v1/metadata/utils/schema";
import { DataSelectorSectionHeader } from "../DataSelectorSectionHeader";
import { CONTAINER_WIDTH } from "../constants";
+import type {
+ DataSelectorDatabase,
+ DataSelectorSchema,
+ DataSelectorTable,
+} from "../types";
type DataSelectorTablePickerProps = {
hasFiltering?: boolean;
@@ -30,26 +32,26 @@ type DataSelectorTablePickerProps = {
hasNextStep?: boolean;
isLoading?: boolean;
minTablesToShowSearch?: number;
- schemas: Schema[];
- selectedDatabase?: Database;
- selectedSchema?: Schema;
- selectedTable?: Table;
- tables: Table[];
+ schemas: DataSelectorSchema[];
+ selectedDatabase?: DataSelectorDatabase;
+ selectedSchema?: DataSelectorSchema;
+ selectedTable?: DataSelectorTable;
+ tables: DataSelectorTable[];
onBack?: () => void;
- onChangeTable: (table: Table) => void;
+ onChangeTable: (table: DataSelectorTable) => void;
};
type HeaderProps = Pick<
DataSelectorTablePickerProps,
"schemas" | "selectedSchema" | "onBack"
> & {
- selectedDatabase: Database;
+ selectedDatabase: DataSelectorDatabase;
};
type Item = {
name: string;
- table: Table;
- database: Database;
+ table: DataSelectorTable;
+ database: DataSelectorDatabase;
};
export const DataSelectorTablePicker = ({
@@ -90,7 +92,7 @@ export const DataSelectorTablePicker = ({
{
name: header,
items: tables.filter(isNotNull).map((table) => ({
- name: table.displayName(),
+ name: table.display_name,
table: table,
database: selectedDatabase,
})),
@@ -99,13 +101,13 @@ export const DataSelectorTablePicker = ({
},
];
- const checkIfItemIsClickable = ({ table }: { table: Table }) =>
+ const checkIfItemIsClickable = ({ table }: { table: DataSelectorTable }) =>
table && isSyncCompleted(table);
- const checkIfItemIsSelected = ({ table }: { table: Table }) =>
+ const checkIfItemIsSelected = ({ table }: { table: DataSelectorTable }) =>
table && selectedTable ? table.id === selectedTable.id : false;
- const renderItemIcon = ({ table }: { table: Table }) =>
+ const renderItemIcon = ({ table }: { table: DataSelectorTable }) =>
table ? <TableInfoIcon table={table} position="top-start" /> : null;
const renderItemWrapper = (content: ReactNode) => (
@@ -115,7 +117,8 @@ export const DataSelectorTablePicker = ({
const showSpinner = (itemOrSection: Item | Section<Item>) =>
"table" in itemOrSection && !isSyncCompleted(itemOrSection.table);
- const handleChange = ({ table }: { table: Table }) => onChangeTable(table);
+ const handleChange = ({ table }: { table: DataSelectorTable }) =>
+ onChangeTable(table);
const isSearchable = hasFiltering && tables.length >= minTablesToShowSearch;
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.unit.spec.tsx b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.unit.spec.tsx
index 42923820757..84d79406f54 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.unit.spec.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/DataSelectorTablePicker/DataSelectorTablePicker.unit.spec.tsx
@@ -1,7 +1,7 @@
import { createMockState } from "__support__/state";
import { createMockEntitiesState } from "__support__/store";
import { renderWithProviders, screen } from "__support__/ui";
-import { getMetadata } from "metabase/metadata-store";
+import { getEntityLookups } from "metabase/querying/common/components/DataSelector";
import { checkNotNull } from "metabase/utils/types";
import type { Database, InitialSyncStatus } from "metabase-types/api";
import { createMockDatabase, createMockTable } from "metabase-types/api/mocks";
@@ -18,10 +18,10 @@ const setup = (opts: SetupOpts) => {
const state = createMockState({
entities: createMockEntitiesState({ databases: [opts.database] }),
});
- const metadata = getMetadata(state);
- const database = checkNotNull(metadata.database(opts.database.id));
- const schemas = database.getSchemas();
- const tables = database.getTables();
+ const lookups = getEntityLookups(state);
+ const database = checkNotNull(lookups.database(opts.database.id));
+ const schemas = lookups.databaseSchemas(database.id);
+ const tables = lookups.databaseTables(database.id);
renderWithProviders(
<DataSelectorTablePicker
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/TriggerComponents.tsx b/frontend/src/metabase/querying/common/components/DataSelector/TriggerComponents.tsx
index eb2aa7aae5c..95cd97fc2dc 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/TriggerComponents.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/TriggerComponents.tsx
@@ -1,20 +1,22 @@
import cx from "classnames";
import type { CSSProperties, ReactNode } from "react";
import { t } from "ttag";
-import _ from "underscore";
import CS from "metabase/css/core/index.css";
import { Box, Flex, Icon, Text } from "metabase/ui";
-import type Database from "metabase-lib/v1/metadata/Database";
-import type Field from "metabase-lib/v1/metadata/Field";
-import type Table from "metabase-lib/v1/metadata/Table";
import DataSelectorS from "./DataSelector.module.css";
+import type {
+ DataSelectorDatabase,
+ DataSelectorField,
+ DataSelectorTable,
+} from "./types";
export type TriggerComponentProps = {
- database?: Database | null;
- table?: Table | null;
- field?: Field | null;
+ database?: DataSelectorDatabase | null;
+ table?: DataSelectorTable | null;
+ field?: DataSelectorField | null;
+ hasMultipleSchemas?: boolean;
};
export function Trigger({
@@ -67,18 +69,20 @@ export function Trigger({
);
}
-export function FieldTrigger({ database, field }: TriggerComponentProps) {
- if (!field || !field.table) {
+export function FieldTrigger({
+ table,
+ field,
+ hasMultipleSchemas,
+}: TriggerComponentProps) {
+ if (!field || !table) {
return <Text>{t`Select...`}</Text>;
}
- const hasMultipleSchemas =
- _.uniq(database?.tables ?? [], (t) => t.schema_name).length > 1;
return (
<div>
<Box className={DataSelectorS.TextSchema}>
- {hasMultipleSchemas && field.table.schema_name + " > "}
- {field.table.display_name}
+ {hasMultipleSchemas && table.schema_name + " > "}
+ {table.display_name}
</Box>
<Text lh="1.2rem">{field.display_name}</Text>
</div>
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/entity-lookups.ts b/frontend/src/metabase/querying/common/components/DataSelector/entity-lookups.ts
new file mode 100644
index 00000000000..8df1de65e0a
--- /dev/null
+++ b/frontend/src/metabase/querying/common/components/DataSelector/entity-lookups.ts
@@ -0,0 +1,86 @@
+import { createSelector } from "@reduxjs/toolkit";
+
+import {
+ getShallowDatabaseSchemas,
+ getShallowDatabaseTables,
+ getShallowDatabases,
+ getShallowFieldById,
+ getShallowFieldName,
+ getShallowSchemaTables,
+ getShallowSchemas,
+ getShallowTableFields,
+ getShallowTableSchema,
+ getShallowTables,
+} from "metabase/metadata-store";
+import type { State } from "metabase/redux/store";
+import type { DatabaseId, SchemaId, TableId } from "metabase-types/api";
+
+import type {
+ DataSelectorDatabase,
+ DataSelectorField,
+ DataSelectorSchema,
+ DataSelectorTable,
+} from "./types";
+
+/**
+ * The reads the data selector makes while it walks from a database to a field.
+ * It learns each id as the user picks one, so it holds the lookups rather than
+ * the records.
+ */
+export type EntityLookups = {
+ database: (
+ id: DatabaseId | null | undefined,
+ ) => DataSelectorDatabase | undefined;
+ schema: (id: SchemaId | null | undefined) => DataSelectorSchema | undefined;
+ table: (id: TableId | null | undefined) => DataSelectorTable | undefined;
+ field: DataSelectorFieldLookup;
+ databaseSchemas: (databaseId: DatabaseId) => DataSelectorSchema[];
+ databaseTables: (databaseId: DatabaseId) => DataSelectorTable[];
+ schemaTables: (schemaId: SchemaId) => DataSelectorTable[];
+ tableSchema: (tableId: TableId) => DataSelectorSchema | undefined;
+ tableFields: (tableId: TableId) => DataSelectorField[];
+ fieldName: (field: DataSelectorField) => string;
+};
+
+type DataSelectorFieldLookup = ReturnType<typeof getShallowFieldById>;
+
+export const selectEntityLookups = createSelector(
+ [
+ getShallowDatabases,
+ getShallowSchemas,
+ getShallowTables,
+ getShallowDatabaseSchemas,
+ getShallowDatabaseTables,
+ getShallowSchemaTables,
+ getShallowTableSchema,
+ getShallowTableFields,
+ getShallowFieldById,
+ getShallowFieldName,
+ ],
+ (
+ databases,
+ schemas,
+ tables,
+ databaseSchemas,
+ databaseTables,
+ schemaTables,
+ tableSchema,
+ tableFields,
+ field,
+ fieldName,
+ ): EntityLookups => ({
+ database: (id) => (id != null ? databases[id] : undefined),
+ schema: (id) => (id != null ? schemas[id] : undefined),
+ table: (id) => (id != null ? tables[id] : undefined),
+ field,
+ databaseSchemas,
+ databaseTables,
+ schemaTables,
+ tableSchema,
+ tableFields,
+ fieldName,
+ }),
+);
+
+export const getEntityLookups = (state: State): EntityLookups =>
+ selectEntityLookups(state);
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/index.tsx b/frontend/src/metabase/querying/common/components/DataSelector/index.tsx
index e131b8c9870..8965d2c2eca 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/index.tsx
+++ b/frontend/src/metabase/querying/common/components/DataSelector/index.tsx
@@ -1 +1,9 @@
export * from "./DataSelector";
+export { getEntityLookups } from "./entity-lookups";
+export type { EntityLookups } from "./entity-lookups";
+export type {
+ DataSelectorDatabase,
+ DataSelectorField,
+ DataSelectorSchema,
+ DataSelectorTable,
+} from "./types";
diff --git a/frontend/src/metabase/querying/common/components/DataSelector/types.ts b/frontend/src/metabase/querying/common/components/DataSelector/types.ts
index 3be525431e4..ec382b4ae36 100644
--- a/frontend/src/metabase/querying/common/components/DataSelector/types.ts
+++ b/frontend/src/metabase/querying/common/components/DataSelector/types.ts
@@ -1,4 +1,11 @@
-import type { IconName } from "metabase-types/api";
+import type {
+ Database,
+ Field,
+ IconName,
+ NormalizedSchema,
+ SchemaName,
+ Table,
+} from "metabase-types/api";
export type DataPickerDataType =
| "models"
| "raw-data"
@@ -11,3 +18,26 @@ export type DataTypeInfoItem = {
name: string;
description: string;
};
+
+// The data selector reads an entity's own columns and resolves the relations
+// between entities through the store's `EntityGraph`. Leaving the relation
+// keys out is what lets plain API objects, the store's normalized records and
+// the v1 metadata objects all fit.
+export type DataSelectorDatabase = Omit<Database, "tables" | "schemas">;
+
+export type DataSelectorSchema = Pick<
+ NormalizedSchema,
+ "id" | "name" | "database"
+>;
+
+export type DataSelectorTable = Omit<
+ Table,
+ "db" | "fields" | "fks" | "segments" | "measures" | "metrics" | "schema"
+> & {
+ schema_name?: SchemaName;
+};
+
+export type DataSelectorField = Omit<
+ Field,
+ "table" | "target" | "name_field" | "dimensions"
+>;
diff --git a/frontend/src/metabase/querying/components/NativeQueryEditor/DataSourceSelectors/DataSourceSelectors.tsx b/frontend/src/metabase/querying/components/NativeQueryEditor/DataSourceSelectors/DataSourceSelectors.tsx
index c5f64fafc9c..bc953bbca56 100644
--- a/frontend/src/metabase/querying/components/NativeQueryEditor/DataSourceSelectors/DataSourceSelectors.tsx
+++ b/frontend/src/metabase/querying/components/NativeQueryEditor/DataSourceSelectors/DataSourceSelectors.tsx
@@ -6,6 +6,7 @@ import CS from "metabase/css/core/index.css";
import QueryBuilderS from "metabase/css/query_builder.module.css";
import { getNativeQueryLanguage } from "metabase/databases/utils/engine";
import {
+ type DataSelectorDatabase,
DatabaseDataSelector,
SchemaAndTableDataSelector,
} from "metabase/querying/common/components/DataSelector";
@@ -26,8 +27,10 @@ interface DataSourceSelectorsProps {
setDatabaseId: (databaseId: DatabaseId) => void;
setTableId: (tableId: TableId) => void;
editorContext?: EditorContext;
- databaseIsDisabled?: (database: Database) => boolean;
- databaseDisabledTooltip?: (database: Database) => string | undefined;
+ databaseIsDisabled?: (database: DataSelectorDatabase) => boolean;
+ databaseDisabledTooltip?: (
+ database: DataSelectorDatabase,
+ ) => string | undefined;
}
export const DataSourceSelectors = ({
@@ -87,8 +90,10 @@ interface PopulatedDataSourceSelectorsProps {
readOnly?: boolean;
setDatabaseId: (databaseId: DatabaseId) => void;
setTableId: (tableId: TableId) => void;
- databaseIsDisabled?: (database: Database) => boolean;
- databaseDisabledTooltip?: (database: Database) => string | undefined;
+ databaseIsDisabled?: (database: DataSelectorDatabase) => boolean;
+ databaseDisabledTooltip?: (
+ database: DataSelectorDatabase,
+ ) => string | undefined;
}
const PopulatedDataSourceSelectors = ({
@@ -153,8 +158,10 @@ interface DatabaseSelectorProps {
databases: Database[];
readOnly?: boolean;
setDatabaseId: (databaseId: DatabaseId) => void;
- databaseIsDisabled?: (database: Database) => boolean;
- databaseDisabledTooltip?: (database: Database) => string | undefined;
+ databaseIsDisabled?: (database: DataSelectorDatabase) => boolean;
+ databaseDisabledTooltip?: (
+ database: DataSelectorDatabase,
+ ) => string | undefined;
}
const DatabaseSelector = ({
diff --git a/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorRoot.tsx b/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorRoot.tsx
index 3c4623ec0bd..4da136ea191 100644
--- a/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorRoot.tsx
+++ b/frontend/src/metabase/querying/components/NativeQueryEditor/NativeQueryEditorRoot.tsx
@@ -16,6 +16,7 @@ import { t } from "ttag";
import { useListCollectionsQuery, useListSnippetsQuery } from "metabase/api";
import { PLUGIN_REMOTE_SYNC } from "metabase/plugins";
+import type { DataSelectorDatabase } from "metabase/querying/common/components/DataSelector";
import {
CodeMirrorEditor,
type CodeMirrorEditorProps,
@@ -29,7 +30,6 @@ import { useSelector } from "metabase/redux";
import { Button, Flex, Icon, Stack, Tooltip } from "metabase/ui";
import * as Lib from "metabase-lib";
import type Question from "metabase-lib/v1/Question";
-import type Database from "metabase-lib/v1/metadata/Database";
import type NativeQuery from "metabase-lib/v1/queries/NativeQuery";
import type {
CardId,
@@ -74,8 +74,10 @@ export type NativeQueryEditorCoreProps = Omit<
cancelQuery?: () => void;
className?: string;
closeSnippetModal?: () => void;
- databaseIsDisabled?: (database: Database) => boolean;
- databaseDisabledTooltip?: (database: Database) => string | undefined;
+ databaseIsDisabled?: (database: DataSelectorDatabase) => boolean;
+ databaseDisabledTooltip?: (
+ database: DataSelectorDatabase,
+ ) => string | undefined;
editorContext?: "question" | "action";
handleResize?: () => void;
highlightedLineNumbers?: number[];
diff --git a/frontend/src/metabase/querying/components/NativeQueryEditor/context/NativeQueryEditorContext.tsx b/frontend/src/metabase/querying/components/NativeQueryEditor/context/NativeQueryEditorContext.tsx
index dcac28b56b6..6dfc6192adc 100644
--- a/frontend/src/metabase/querying/components/NativeQueryEditor/context/NativeQueryEditorContext.tsx
+++ b/frontend/src/metabase/querying/components/NativeQueryEditor/context/NativeQueryEditorContext.tsx
@@ -1,8 +1,8 @@
import { createContext, useContext } from "react";
+import type { DataSelectorDatabase } from "metabase/querying/common/components/DataSelector";
import type { QueryModalType } from "metabase/querying/constants";
import type Question from "metabase-lib/v1/Question";
-import type Database from "metabase-lib/v1/metadata/Database";
import type NativeQuery from "metabase-lib/v1/queries/NativeQuery";
import type {
Collection,
@@ -35,8 +35,10 @@ export interface NativeQueryEditorContextValue {
canChangeDatabase: boolean;
editorContext: "question" | "action";
- databaseIsDisabled?: (database: Database) => boolean;
- databaseDisabledTooltip?: (database: Database) => string | undefined;
+ databaseIsDisabled?: (database: DataSelectorDatabase) => boolean;
+ databaseDisabledTooltip?: (
+ database: DataSelectorDatabase,
+ ) => string | undefined;
onSetDatabaseId?: (id: DatabaseId) => void;
setParameterValue?: (parameterId: ParameterId, value: string) => void;
diff --git a/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts b/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts
index 55971483cf4..619bdb01600 100644
--- a/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts
+++ b/frontend/src/metabase/visualizations/components/ObjectDetail/utils.ts
@@ -14,7 +14,6 @@ import type {
Table as ApiTable,
DatasetColumn,
DatasetData,
- NormalizedTable,
TableId,
VisualizationSettings,
} from "metabase-types/api";
@@ -135,7 +134,7 @@ export const getSinglePKIndex = (cols: DatasetColumn[]) => {
};
export function getApiTable(
- table: NormalizedTable | undefined | null,
+ table: Table | undefined | null,
): ApiTable | undefined {
if (!table) {
return undefined;
@@ -143,7 +142,7 @@ export function getApiTable(
// Unjustified type cast. FIXME
const apiTable: ApiTable = {
- ...table,
+ ...table.getPlainObject(),
fields: table.original_fields,
} as ApiTable;