Skip to content

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

Gdgt 1216 table search should expand dbschema context for matches (#66393)

Jakub Chodorowicz921351ca9472
diff --git a/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio-search.cy.spec.ts b/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio-search.cy.spec.ts
new file mode 100644
index 00000000000..56c2527dc8b
--- /dev/null
+++ b/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio-search.cy.spec.ts
@@ -0,0 +1,163 @@
+import { WRITABLE_DB_ID } from "e2e/support/cypress_data";
+
+const { H } = cy;
+const { TablePicker } = H.DataModel;
+
+describe("Search", () => {
+ beforeEach(() => {
+ cy.signInAsAdmin();
+ H.restore("postgres-writable");
+ H.activateToken("bleeding-edge");
+ H.resetTestTable({ type: "postgres", table: "multi_schema" });
+ H.resyncDatabase({ dbId: WRITABLE_DB_ID });
+ });
+
+ it("should support prefix-based search", () => {
+ H.DataModel.visitDataStudio();
+
+ TablePicker.getSearchInput().type("an");
+ TablePicker.getTables().should("have.length", 3);
+ TablePicker.getTable("Analytic Events").should("be.visible");
+ TablePicker.getTable("Animals").should("be.visible");
+ });
+
+ it("should support wildcard search with *", () => {
+ H.DataModel.visitDataStudio();
+
+ TablePicker.getSearchInput().type("irds");
+ TablePicker.get().findByText("No tables found").should("be.visible");
+
+ TablePicker.getSearchInput().clear().type("*irds");
+ TablePicker.getTables().should("have.length", 1);
+ TablePicker.getTable("Birds").should("be.visible");
+ });
+
+ it("should allow using shift key to select multiple tables", () => {
+ H.DataModel.visitDataStudio();
+ TablePicker.getSearchInput().type("a");
+
+ TablePicker.getTables().should("have.length", 4);
+ TablePicker.getTable("Accounts").find('input[type="checkbox"]').click();
+ TablePicker.getTable("Animals")
+ .eq(0)
+ .find('input[type="checkbox"]')
+ .click({ shiftKey: true });
+
+ cy.findByRole("heading", { name: /3 tables selected/i }).should(
+ "be.visible",
+ );
+ });
+
+ it("should remove the active highlight once tables are selected", () => {
+ H.DataModel.visitDataStudio();
+
+ TablePicker.getSearchInput().type("an");
+ TablePicker.getTable("Animals").eq(0).should("be.visible").click();
+ TablePicker.getTable("Animals")
+ .eq(0)
+ .should("have.attr", "aria-selected", "true");
+
+ TablePicker.getTable("Animals")
+ .eq(0)
+ .find('input[type="checkbox"]')
+ .check();
+ TablePicker.getTable("Animals").eq(1).should("be.visible").click();
+
+ TablePicker.getTable("Animals")
+ .eq(0)
+ .should("not.have.attr", "aria-selected", "true");
+ TablePicker.getTable("Animals")
+ .eq(1)
+ .should("not.have.attr", "aria-selected", "true");
+ });
+
+ it("should select/deselect tables with clicking checkboxes", () => {
+ H.DataModel.visitDataStudio();
+ TablePicker.getSearchInput().type("a");
+ TablePicker.getTables().should("have.length", 4);
+ TablePicker.getTable("Accounts")
+ .find('input[type="checkbox"]')
+ .as("accountsCheckbox");
+ TablePicker.getTable("Analytic Events")
+ .find('input[type="checkbox"]')
+ .as("analyticEventsCheckbox");
+ cy.get("@accountsCheckbox").check();
+ cy.get("@analyticEventsCheckbox").check();
+ cy.findByRole("heading", { name: /2 tables selected/i }).should(
+ "be.visible",
+ );
+ cy.get("@accountsCheckbox").uncheck();
+ cy.findByRole("heading", { name: /2 tables selected/i }).should(
+ "not.exist",
+ );
+
+ // clear selection when changing search query
+ cy.get("@accountsCheckbox").check();
+ cy.findByRole("heading", { name: /2 tables selected/i }).should(
+ "be.visible",
+ );
+ TablePicker.getSearchInput().type("c");
+ cy.findByRole("heading", { name: /2 tables selected/i }).should(
+ "not.exist",
+ );
+ });
+
+ it("should select/deselect databases and schemas", () => {
+ H.DataModel.visitDataStudio();
+ TablePicker.getSearchInput().type("a");
+ const postgres = "Writable Postgres12";
+ const sampleDatabaseName = "Sample Database";
+ const domesticSchema = "Domestic";
+
+ const getDatabaseCheckbox = (name: string) =>
+ TablePicker.getDatabase(name).find('input[type="checkbox"]');
+ const getSchemaCheckbox = (schemaName: string) =>
+ TablePicker.getSchema(schemaName).find('input[type="checkbox"]');
+
+ getDatabaseCheckbox(sampleDatabaseName).click();
+ cy.findByRole("heading", { name: /2 tables selected/i }).should(
+ "be.visible",
+ );
+ getDatabaseCheckbox(postgres).click();
+ cy.findByRole("heading", { name: /4 tables selected/i }).should(
+ "be.visible",
+ );
+ getSchemaCheckbox(domesticSchema).click();
+ cy.findByRole("heading", { name: /3 tables selected/i }).should(
+ "be.visible",
+ );
+ getDatabaseCheckbox(postgres).click();
+ cy.findByRole("heading", { name: /4 tables selected/i }).should(
+ "be.visible",
+ );
+ });
+
+ it("should allow to hide/show table and schemas", () => {
+ H.DataModel.visitDataStudio();
+ TablePicker.getSearchInput().type("a");
+ const postgres = "Writable Postgres12";
+ const sampleDatabaseName = "Sample Database";
+ const domesticSchema = "Domestic";
+ const sampleDbTables = ["Accounts", "Analytic Events"];
+
+ sampleDbTables.forEach((table) => {
+ TablePicker.getTable(table).should("be.visible");
+ });
+
+ TablePicker.getDatabase(sampleDatabaseName).click();
+ TablePicker.getDatabase(sampleDatabaseName).click();
+ sampleDbTables.forEach((table) => {
+ TablePicker.getTable(table).should("not.exist");
+ });
+
+ TablePicker.getTable("Animals").should("have.length", 2);
+ TablePicker.getSchema(domesticSchema).click();
+ TablePicker.getSchema(domesticSchema).click();
+ TablePicker.getTable("Animals").should("have.length", 1);
+
+ TablePicker.getDatabase(postgres).click();
+ TablePicker.getDatabase(postgres).click();
+ TablePicker.getTables().should("have.length", 0);
+ TablePicker.getDatabases().should("have.length", 2);
+ });
+});
diff --git a/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts b/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts
index 604d9f82118..809a4e026ee 100644
--- a/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/data-model/datamodel-data-studio.cy.spec.ts
@@ -473,95 +473,6 @@ describe("scenarios > data studio > datamodel", () => {
},
);
- describe("Search", () => {
- beforeEach(() => {
- H.restore("postgres-writable");
- H.activateToken("bleeding-edge");
- H.resetTestTable({ type: "postgres", table: "multi_schema" });
- H.resyncDatabase({ dbId: WRITABLE_DB_ID });
- });
-
- it("should support prefix-based search", () => {
- H.DataModel.visitDataStudio();
-
- TablePicker.getSearchInput().type("an");
- TablePicker.getTables().should("have.length", 3);
- TablePicker.getTable("Analytic Events").should("be.visible");
- TablePicker.getTable("Animals").should("be.visible");
- });
-
- it("should support wildcard search with *", () => {
- H.DataModel.visitDataStudio();
-
- TablePicker.getSearchInput().type("irds");
- TablePicker.get().findByText("No tables found").should("be.visible");
-
- TablePicker.getSearchInput().clear().type("*irds");
- TablePicker.getTables().should("have.length", 1);
- TablePicker.getTable("Birds").should("be.visible");
- });
-
- it("should allow using shift key to select multiple tables", () => {
- H.DataModel.visitDataStudio();
- TablePicker.getSearchInput().type("a");
-
- TablePicker.getTables().should("have.length", 4);
- TablePicker.getTable("Accounts").find('input[type="checkbox"]').click();
- TablePicker.getTable("Animals")
- .eq(0)
- .find('input[type="checkbox"]')
- .click({ shiftKey: true });
-
- cy.findByRole("heading", { name: /3 tables selected/i }).should(
- "be.visible",
- );
- });
-
- it("should remove the active highlight once tables are selected", () => {
- H.DataModel.visitDataStudio();
-
- TablePicker.getSearchInput().type("an");
- TablePicker.getTable("Animals").eq(0).should("be.visible").click();
- TablePicker.getTable("Animals")
- .eq(0)
- .should("have.attr", "aria-selected", "true");
-
- TablePicker.getTable("Animals")
- .eq(0)
- .find('input[type="checkbox"]')
- .check();
- TablePicker.getTable("Animals").eq(1).should("be.visible").click();
-
- TablePicker.getTable("Animals")
- .eq(0)
- .should("not.have.attr", "aria-selected", "true");
- TablePicker.getTable("Animals")
- .eq(1)
- .should("not.have.attr", "aria-selected", "true");
- });
-
- it("should select/deselect tables with clicking checkboxes", () => {
- H.DataModel.visitDataStudio();
- TablePicker.getSearchInput().type("a");
- TablePicker.getTables().should("have.length", 4);
- TablePicker.getTable("Accounts")
- .find('input[type="checkbox"]')
- .as("accountsCheckbox");
- TablePicker.getTable("Analytic Events")
- .find('input[type="checkbox"]')
- .as("analyticEventsCheckbox");
- cy.get("@accountsCheckbox").check();
- cy.get("@analyticEventsCheckbox").check();
- cy.findByRole("heading", { name: /2 tables selected/i }).should(
- "be.visible",
- );
- cy.get("@accountsCheckbox").uncheck();
- cy.findByRole("heading", { name: /2 table selected/i }).should(
- "not.exist",
- );
- });
- });
-
describe("Extra info about tables", () => {
const databaseName = "Writable Postgres12";
const domesticSchema = "Domestic";
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts
index e73a91f95ac..8a4c49cd869 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.ts
@@ -1,7 +1,20 @@
import type { DatabaseId, TableId } from "metabase-types/api";
-import type { DatabaseNode, ExpandedItem, FlatItem, TreeNode } from "./types";
-import { isExpandedItem, isSchemaNode, isTableNode } from "./types";
+import type {
+ DatabaseNode,
+ ExpandedDatabaseItem,
+ ExpandedItem,
+ ExpandedSchemaItem,
+ FlatItem,
+ SchemaNode,
+ TreeNode,
+} from "./types";
+import {
+ isExpandedItem,
+ isSchemaNode,
+ isTableNode,
+ isTableOrSchemaNode,
+} from "./types";
export interface NodeSelection {
tables: Set<TableId>;
@@ -9,14 +22,16 @@ export interface NodeSelection {
databases: Set<DatabaseId>;
}
+type NodeSelectionValues = "yes" | "no" | "some";
+
export function isItemSelected(
node: TreeNode,
selection: NodeSelection,
-): "yes" | "no" | "some" {
+): NodeSelectionValues {
if (!selection) {
return "no";
}
- if (node.type === "table") {
+ if (isTableNode(node)) {
return selection.tables.has(node.value.tableId) ? "yes" : "no";
}
if (isSchemaNode(node)) {
@@ -39,7 +54,7 @@ export function isItemSelected(
function areChildTablesSelected(
node: TreeNode,
selectedTables: Set<TableId>,
-): "yes" | "no" | "some" {
+): NodeSelectionValues {
if (node.children.length === 0) {
return "no";
}
@@ -59,7 +74,7 @@ function areChildTablesSelected(
function areChildSchemasSelected(
node: TreeNode,
selection: NodeSelection,
-): "yes" | "no" | "some" {
+): NodeSelectionValues {
if (node.children.length === 0) {
return "no";
}
@@ -75,21 +90,22 @@ function areChildSchemasSelected(
: "some";
}
-export function getSchemaId(item: FlatItem) {
- if (!isExpandedItem(item)) {
- return undefined;
- }
- if (!isTableNode(item)) {
- return undefined;
+export function getSchemaId(item: FlatItem | SchemaNode) {
+ if (
+ "value" in item &&
+ item.value &&
+ "databaseId" in item.value &&
+ "schemaName" in item.value
+ ) {
+ return `${item.value.databaseId}:${item.value.schemaName}`;
}
- return `${item.value.databaseId}:${item.value.schemaName}`;
}
export function isParentSchemaSelected(
item: FlatItem,
selectedSchemas: Set<string>,
) {
- if (item.type !== "table") {
+ if (!isTableNode(item)) {
return false;
}
@@ -171,11 +187,11 @@ export function getSchemaTables(
const result = allItems
.filter(
(item) =>
- isTableNode(item) &&
+ isTableOrSchemaNode(item) &&
getSchemaId(schema) === getSchemaId(item) &&
item.value.tableId,
)
- .filter(isTableNode);
+ .filter(isTableOrSchemaNode);
return result;
}
@@ -193,20 +209,6 @@ export function getSchemaChildrenTableIds(schema: TreeNode) {
.map((child) => child.value.tableId);
}
-export function getParentSchemaTables(item: FlatItem, allItems: FlatItem[]) {
- const parentSchema = getParentSchema(item, allItems);
-
- if (!parentSchema) {
- return [];
- }
-
- return allItems.filter((item) => {
- return (
- item.type === "table" && getSchemaId(parentSchema) === getSchemaId(item)
- );
- });
-}
-
export function areTablesSelected(
schema: FlatItem,
allItems: TreeNode[],
@@ -275,3 +277,98 @@ export function areSchemasSelected(
return "none";
}
+
+export function markAllSchemas(
+ item: FlatItem,
+ targetChecked: "yes" | "no",
+ selection: NodeSelection,
+): NodeSelection {
+ const schemas = new Set(selection.schemas);
+ const tables = new Set(selection.tables);
+
+ if (item.type !== "database") {
+ return {
+ tables,
+ schemas,
+ databases: selection.databases,
+ };
+ }
+
+ const filteredSchemas = item.children.filter(
+ (child): child is SchemaNode => child.type === "schema",
+ );
+ filteredSchemas.forEach((schema) => {
+ if (!isSchemaNode(schema)) {
+ return;
+ }
+ const schemaId = getSchemaId(schema);
+ if (!schemaId) {
+ return;
+ }
+ if (schema.children.length === 0) {
+ targetChecked === "yes"
+ ? schemas.add(schemaId)
+ : schemas.delete(schemaId);
+ } else {
+ markAllTables(schema, targetChecked, tables);
+ }
+ });
+
+ return {
+ tables,
+ schemas,
+ databases: selection.databases,
+ };
+}
+
+function markAllTables(
+ schema: SchemaNode,
+ targetChecked: "yes" | "no",
+ tablesSelection: Set<TableId>,
+) {
+ const tables = getSchemaChildrenTableIds(schema);
+ tables.forEach((tableId) => {
+ if (tableId === -1) {
+ return;
+ }
+ targetChecked === "yes"
+ ? tablesSelection.add(tableId)
+ : tablesSelection.delete(tableId);
+ });
+}
+
+export function toggleDatabaseSelection(
+ item: ExpandedDatabaseItem,
+ selection: NodeSelection,
+): NodeSelection {
+ const isSelected = isItemSelected(item, selection);
+ const targetChecked = isSelected === "yes" ? "no" : "yes";
+
+ return markAllSchemas(item, targetChecked, selection);
+}
+
+export function toggleSchemaSelection(
+ item: ExpandedSchemaItem,
+ selection: NodeSelection,
+): NodeSelection {
+ const isSelected = isItemSelected(item, selection);
+ const tables = new Set(selection.tables);
+
+ if (isSelected === "yes") {
+ const tableIds = getSchemaChildrenTableIds(item);
+ tableIds.forEach((x) => {
+ tables.delete(x);
+ });
+ } else {
+ const tableIds = getSchemaChildrenTableIds(item);
+ tableIds.forEach((x) => {
+ tables.add(x);
+ });
+ }
+
+ return {
+ tables,
+ schemas: selection.schemas,
+ databases: selection.databases,
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts
index cc362d9d66a..e034169fbce 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/bulk-selection.utils.unit.spec.ts
@@ -6,7 +6,6 @@ import {
areTablesSelected,
getChildSchemas,
getParentSchema,
- getParentSchemaTables,
getSchemaChildrenTableIds,
getSchemaId,
getSchemaTableIds,
@@ -416,41 +415,6 @@ describe("bulk-selection.utils", () => {
});
});
- describe("getParentSchemaTables", () => {
- it("should return all tables in the same schema as the given table", () => {
- const table1 = createMockTableNode(1, "public", 101);
- const table2 = createMockTableNode(1, "public", 102);
- const table3 = createMockTableNode(1, "private", 103);
- const schema = createMockSchemaNode(1, "public", [table1, table2]);
- const flatItems = [
- createMockFlatItem(table1),
- createMockFlatItem(table2),
- createMockFlatItem(table3),
- createMockFlatItem(schema),
- ];
-
- const tables = getParentSchemaTables(
- createMockFlatItem(table1),
- flatItems,
- );
-
- expect(tables).toHaveLength(2);
- expect(tables.map((t) => (t.value as any).tableId)).toEqual([101, 102]);
- });
-
- it("should return empty array when parent schema not found", () => {
- const table = createMockTableNode(1, "public", 101);
- const flatItems = [createMockFlatItem(table)];
-
- const tables = getParentSchemaTables(
- createMockFlatItem(table),
- flatItems,
- );
-
- expect(tables).toEqual([]);
- });
- });
-
describe("areTablesSelected", () => {
it("should return 'all' when all tables are selected", () => {
const table1 = createMockTableNode(1, "public", 101);
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.tsx
index 9711cf2e061..86093422b3c 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Results.tsx
@@ -23,7 +23,7 @@ import type { UserId } from "metabase-types/api";
import { useSelection } from "../../../pages/DataModel/contexts/SelectionContext";
import { TYPE_ICONS } from "../constants";
-import type { FlatItem, TreePath } from "../types";
+import { type FlatItem, type TreePath, isTableNode } from "../types";
import { hasChildren } from "../utils";
import S from "./Results.module.css";
@@ -85,7 +85,7 @@ export function TablePickerResults({
return;
}
const index = latestItems.current.findIndex(
- (item) => item.type === "table" && item.value?.tableId === path.tableId,
+ (item) => isTableNode(item) && item.value?.tableId === path.tableId,
);
if (index === -1) {
return;
@@ -133,7 +133,7 @@ export function TablePickerResults({
}
const isShiftPressed = Boolean(options?.isShiftPressed);
- const isTable = item.type === "table";
+ const isTable = isTableNode(item);
const hasRangeAnchor =
lastSelectedTableIndex.current != null && onRangeSelect != null;
const isRangeSelection = isShiftPressed && isTable && hasRangeAnchor;
@@ -156,7 +156,6 @@ export function TablePickerResults({
}
}
- // single checkbox toggle
onItemToggle(item);
lastSelectedTableIndex.current = isTable ? itemIndex : null;
};
@@ -334,7 +333,7 @@ function isTableActive(
): boolean {
return (
selectedItemsCount === 0 &&
- item.type === "table" &&
+ isTableNode(item) &&
item.value?.tableId === path.tableId
);
}
@@ -376,7 +375,7 @@ const ResultsItem = ({
const isActive = isItemActive(item, path, selectedItemsCount);
const indent = level * INDENT_OFFSET;
- const hasToggle = hasChildren(type);
+ const itemHasChildren = hasChildren(type);
const handleItemSelect = (open?: boolean, event?: React.MouseEvent) => {
if (disabled) {
@@ -385,7 +384,7 @@ const ResultsItem = ({
// In multi-select mode, prevent navigation and allow toggling for items with children
if (selectedItemsCount > 0) {
- if (hasChildren(type)) {
+ if (itemHasChildren) {
// Toggle expansion for items with children
if (open !== undefined) {
toggle?.(key, open);
@@ -403,7 +402,7 @@ const ResultsItem = ({
// In single-select mode:
// If the item is already active, toggle its expansion state
// Otherwise, navigate to make it active
- if (isActive && hasChildren(type)) {
+ if (isActive && itemHasChildren) {
// Second click on active item: toggle expansion
if (open !== undefined) {
toggle?.(key, open);
@@ -421,12 +420,12 @@ const ResultsItem = ({
toggle?.(key, open);
}
- // Only navigate in single-select mode
- if (selectedItemsCount === 0 && value) {
+ if (value) {
// Expand collapsed items when navigating to them
- if (!isExpanded && hasChildren(type)) {
+ if (!isExpanded && itemHasChildren) {
toggle?.(key, true);
}
+
onItemClick?.(value);
}
}
@@ -508,8 +507,10 @@ const ResultsItem = ({
to={getUrl(baseUrl, {
databaseId: value?.databaseId,
schemaName:
- type === "schema" || type === "table" ? value?.schemaName : undefined,
- tableId: type === "table" ? value?.tableId : undefined,
+ type === "schema" || isTableNode(item)
+ ? item.value?.schemaName
+ : undefined,
+ tableId: isTableNode(item) ? item.value?.tableId : undefined,
})}
data-testid="tree-item"
data-type={type}
@@ -532,7 +533,7 @@ const ResultsItem = ({
<Flex align="flex-start" gap="xs" className={S.content}>
<Flex align="center" gap="xs">
<Box className={S.chevronSlot} w={INDENT_OFFSET}>
- {hasToggle && (
+ {itemHasChildren && (
<Icon
name="chevronright"
size={16}
@@ -553,7 +554,7 @@ const ResultsItem = ({
<Box
className={S.label}
c={
- type === "table" &&
+ isTableNode(item) &&
item.table &&
item.table.visibility_type != null &&
!isActive
@@ -568,7 +569,7 @@ const ResultsItem = ({
)}
</Flex>
- {type === "table" && (
+ {isTableNode(item) && (
<>
<Box
className={cx(S.column, S.ownerColumn)}
@@ -602,7 +603,7 @@ function getOwnerDisplay(
item: FlatItem,
ownerNameById: Map<UserId, string>,
): string {
- if (item.type !== "table" || item.isLoading || !item.table) {
+ if (!isTableNode(item) || item.isLoading || !item.table) {
return "";
}
@@ -622,7 +623,7 @@ function getExpectedRowsDisplay(
item: FlatItem,
formatNumber: NumberFormatter,
): string | null {
- if (item.type !== "table" || item.isLoading || !item.table) {
+ if (!isTableNode(item) || item.isLoading || !item.table) {
return null;
}
@@ -637,7 +638,7 @@ function getExpectedRowsDisplay(
}
function getPublishedDisplay(item: FlatItem): React.ReactNode {
- if (item.type !== "table" || item.isLoading || !item.table) {
+ if (!isTableNode(item) || item.isLoading || !item.table) {
return null;
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx
index 924f752d975..676898d8cf5 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/SearchNew.tsx
@@ -1,20 +1,31 @@
-import cx from "classnames";
-import { useContext, useEffect, useMemo, useRef } from "react";
-import { Link } from "react-router";
+import { useEffect, useMemo } from "react";
import { t } from "ttag";
import { useListDatabasesQuery } from "metabase/api";
import { useListTablesQuery } from "metabase/api/table";
-import { DataModelContext } from "metabase/metadata/pages/shared/DataModelContext";
-import { getUrl, parseRouteParams } from "metabase/metadata/pages/shared/utils";
-import { Box, Checkbox, Flex, Icon, Loader, Stack, Text } from "metabase/ui";
-import type { TableId } from "metabase-types/api";
+import { parseRouteParams } from "metabase/metadata/pages/shared/utils";
+import { Box, Flex, Loader, Text } from "metabase/ui";
+import type { Table } from "metabase-types/api";
import { useSelection } from "../../../pages/DataModel/contexts/SelectionContext";
import type { RouteParams } from "../../../pages/DataModel/types";
-import type { FilterState } from "../types";
-
-import S from "./Results.module.css";
+import {
+ toggleDatabaseSelection,
+ toggleSchemaSelection,
+} from "../bulk-selection.utils";
+import { useExpandedState } from "../hooks";
+import type {
+ DatabaseNode,
+ FilterState,
+ FlatItem,
+ RootNode,
+ SchemaNode,
+ TableNode,
+} from "../types";
+import { isDatabaseItem, isSchemaItem, isTableNode } from "../types";
+import { flatten, rootNode, toKey } from "../utils";
+
+import { TablePickerResults } from "./Results";
interface SearchNewProps {
query: string;
@@ -23,16 +34,81 @@ interface SearchNewProps {
setOnUpdateCallback: (callback: (() => void) | null) => void;
}
+function buildResultTree(tables: Table[]): RootNode {
+ const databases = new Map<string, DatabaseNode>();
+ const seenSchemas = new Map<string, SchemaNode>();
+ const root = rootNode();
+
+ tables.forEach((table) => {
+ const tableId = table.id;
+ const databaseId = table.db_id;
+ const schemaName = table.schema;
+ const dbKey = toKey({ databaseId });
+ const schemaKey = toKey({ databaseId, schemaName });
+ const tableKey = toKey({
+ databaseId,
+ schemaName,
+ tableId,
+ });
+
+ if (!databases.has(dbKey)) {
+ const label = table.db?.name || String(databaseId);
+
+ const databaseNode: DatabaseNode = {
+ type: "database",
+ key: dbKey,
+ label,
+ value: { databaseId: databaseId },
+ children: [],
+ };
+ databases.set(dbKey, databaseNode);
+ root.children.push(databaseNode);
+ }
+
+ if (!seenSchemas.has(schemaKey)) {
+ const schemaNode: SchemaNode = {
+ type: "schema",
+ key: schemaKey,
+ label: schemaName,
+ value: { databaseId, schemaName },
+ children: [],
+ };
+ seenSchemas.set(schemaKey, schemaNode);
+ databases.get(dbKey)?.children.push(schemaNode);
+ }
+
+ const tableNode: TableNode = {
+ type: "table",
+ key: tableKey,
+ label: table.display_name || table.name,
+ value: {
+ databaseId,
+ schemaName,
+ tableId,
+ },
+ children: [],
+ table,
+ };
+ seenSchemas.get(schemaKey)?.children.push(tableNode);
+ });
+
+ return root;
+}
+
export function SearchNew({
query,
params,
filters,
setOnUpdateCallback,
}: SearchNewProps) {
- const { selectedTables, setSelectedTables, selectedItemsCount } =
- useSelection();
+ const {
+ selectedTables,
+ setSelectedTables,
+ selectedSchemas,
+ selectedDatabases,
+ resetSelection,
+ } = useSelection();
const routeParams = parseRouteParams(params);
- const { baseUrl } = useContext(DataModelContext);
const {
data: tables,
isLoading: isLoadingTables,
@@ -54,6 +130,12 @@ export function SearchNew({
});
const { data: databases, isLoading: isLoadingDatabases } =
useListDatabasesQuery({ include_editable_data_model: true });
+ const { isExpanded: getIsExpanded, toggle } = useExpandedState(
+ {}, // we expand all nodes, so need to pass path to expand specific branch
+ {
+ defaultClosed: false,
+ },
+ );
const allowedDatabaseIds = useMemo(
() => new Set(databases?.data.map((database) => database.id) ?? []),
@@ -75,180 +157,92 @@ export function SearchNew({
return () => setOnUpdateCallback(null);
}, [refetch, setOnUpdateCallback]);
- const lastSelectedTableIndex = useRef<number | null>(null);
+ const resultTree = useMemo(
+ () => buildResultTree(filteredTables),
+ [filteredTables],
+ );
+ // clear the selection when tables changes, to make sure that bulk operations
+ // are performed on the intended tables
useEffect(() => {
- if (selectedItemsCount === 0) {
- lastSelectedTableIndex.current = null;
- }
- }, [selectedItemsCount]);
-
- if (isLoading) {
- return (
- <Flex justify="center" align="center" p="xl">
- <Loader />
- </Flex>
- );
- }
-
- if (filteredTables.length === 0) {
- return (
- <Box p="xl">
- <Text c="text.2">{t`No tables found`}</Text>
- </Box>
- );
- }
-
- const handleTableSelect = (
- tableId: TableId,
- tableIndex: number,
- options?: { isShiftPressed?: boolean },
- ) => {
- const isShiftPressed = Boolean(options?.isShiftPressed);
- const hasRangeAnchor = lastSelectedTableIndex.current != null;
+ resetSelection();
+ }, [tables, resetSelection]);
+
+ const flatItems = flatten(resultTree, {
+ isExpanded: getIsExpanded,
+ addLoadingNodes: false,
+ canFlattenSingleSchema: true,
+ selection: {
+ tables: selectedTables,
+ schemas: selectedSchemas,
+ databases: selectedDatabases,
+ },
+ });
- if (isShiftPressed && hasRangeAnchor) {
- const anchorIndex = lastSelectedTableIndex.current;
- if (anchorIndex == null) {
- return;
- }
+ const handleItemToggle = (item: FlatItem) => {
+ const selection = {
+ tables: selectedTables,
+ schemas: selectedSchemas,
+ databases: selectedDatabases,
+ };
- const start = Math.min(anchorIndex, tableIndex);
- const end = Math.max(anchorIndex, tableIndex);
- const rangeTables = filteredTables.slice(start, end + 1);
+ if (isDatabaseItem(item)) {
+ setSelectedTables(toggleDatabaseSelection(item, selection).tables);
+ }
+ if (isSchemaItem(item)) {
+ setSelectedTables(toggleSchemaSelection(item, selection).tables);
+ }
+ if (isTableNode(item)) {
setSelectedTables((prev) => {
const newSet = new Set(prev);
- rangeTables.forEach((rangeTable) => {
- newSet.add(rangeTable.id);
- });
+ if (newSet.has(item.value.tableId)) {
+ newSet.delete(item.value.tableId);
+ } else {
+ newSet.add(item.value.tableId);
+ }
return newSet;
});
-
- lastSelectedTableIndex.current = tableIndex;
- return;
}
+ };
+
+ const handleRangeSelect = (items: FlatItem[]) => {
+ const tableItems = items.filter((item) => isTableNode(item) && item.table);
setSelectedTables((prev) => {
const newSet = new Set(prev);
- if (newSet.has(tableId)) {
- newSet.delete(tableId);
- } else {
- newSet.add(tableId);
- }
+ tableItems.forEach((item) => {
+ if (isTableNode(item) && item.table) {
+ newSet.add(item.table.id);
+ }
+ });
return newSet;
});
-
- lastSelectedTableIndex.current = tableIndex;
};
- return (
- <Stack h="100%" style={{ overflow: "auto" }}>
- <Stack gap={0}>
- {filteredTables.map((table, tableIndex) => {
- const breadcrumbs = table.schema
- ? `${table.db?.name} (${table.schema})`
- : table.db?.name;
- const isActive =
- selectedItemsCount === 0 &&
- routeParams.databaseId === table.db_id &&
- routeParams.schemaName === table.schema &&
- routeParams.tableId === table.id;
-
- return (
- <Flex
- component={Link}
- aria-selected={isActive}
- className={cx(S.item, {
- [S.active]: isActive,
- })}
- key={table.id}
- data-testid="tree-item"
- data-type="table"
- py="sm"
- pe="sm"
- align="center"
- gap="sm"
- to={getUrl(baseUrl, {
- databaseId: table.db_id,
- schemaName: table.schema,
- tableId: table.id,
- })}
- pos="relative"
- left={0}
- right={0}
- >
- <Checkbox
- w={40}
- style={{
- alignSelf: "flex-start",
- justifyContent: "center",
- position: "relative",
- top: 4,
- display: "flex",
- }}
- size="sm"
- checked={selectedTables.has(table.id)}
- onClick={(event) => {
- event.stopPropagation();
- handleTableSelect(table.id, tableIndex, {
- isShiftPressed: Boolean(
- (event.nativeEvent as { shiftKey?: boolean }).shiftKey,
- ),
- });
- }}
- onChange={() => {}}
- />
- <Icon
- style={{
- alignSelf: "flex-start",
- position: "relative",
- top: 4,
- }}
- name="table2"
- c={isActive ? "brand" : "text-light"}
- size={16}
- />
- <Text
- c={isActive ? "brand" : "text-primary"}
- fw={500}
- style={{ flex: 1 }}
- >
- {table.display_name}
- </Text>
- {breadcrumbs && (
- <BreadCrumbs active={isActive} breadcrumbs={breadcrumbs} />
- )}
- </Flex>
- );
- })}
- </Stack>
- </Stack>
- );
-}
+ if (isLoading) {
+ return (
+ <Flex justify="center" align="center" p="xl">
+ <Loader />
+ </Flex>
+ );
+ }
-function BreadCrumbs({
- breadcrumbs,
- active = true,
-}: {
- breadcrumbs: string;
- active?: boolean;
-}) {
- if (!breadcrumbs) {
- return null;
+ if (filteredTables.length === 0) {
+ return (
+ <Box p="xl">
+ <Text c="text.2">{t`No tables found`}</Text>
+ </Box>
+ );
}
return (
- <Text
- ta="right"
- flex="0 0 auto"
- c={active ? "var(--mb-color-text-medium)" : "var(--mb-color-text-light)"}
- fz="0.75rem"
- lh="1rem"
- lineClamp={1}
- maw="40%"
- >
- {breadcrumbs}
- </Text>
+ <TablePickerResults
+ items={flatItems}
+ path={routeParams}
+ onItemToggle={handleItemToggle}
+ toggle={toggle}
+ onRangeSelect={handleRangeSelect}
+ />
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx
index e8a493760e9..84bd6de2ecd 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/TablePicker.tsx
@@ -68,11 +68,10 @@ export function TablePicker({
}
useEffect(() => {
- if (previousDeferredQuery === "" && deferredQuery !== "") {
- resetSelection();
- }
-
- if (previousDeferredQuery !== "" && deferredQuery === "") {
+ const togglingBetweenSearchAndTree =
+ (previousDeferredQuery === "" && deferredQuery !== "") ||
+ (previousDeferredQuery !== "" && deferredQuery === "");
+ if (togglingBetweenSearchAndTree) {
resetSelection();
}
}, [deferredQuery, previousDeferredQuery, resetSelection]);
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx
index 4686deb7587..06d1b30b30b 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/components/Tree.tsx
@@ -5,27 +5,34 @@ import type { TableId } from "metabase-types/api";
import { useSelection } from "../../../pages/DataModel/contexts/SelectionContext";
import {
- type NodeSelection,
- getSchemaChildrenTableIds,
getSchemaId,
getSchemaTableIds,
isItemSelected,
noManuallySelectedDatabaseChildrenTables,
noManuallySelectedSchemas,
noManuallySelectedTables,
+ toggleDatabaseSelection,
+ toggleSchemaSelection,
} from "../bulk-selection.utils";
import { useExpandedState, useTableLoader } from "../hooks";
import type {
ChangeOptions,
DatabaseNode,
ExpandedItem,
+ ExpandedSchemaItem,
FlatItem,
SchemaItem,
- SchemaNode,
TreeNode,
TreePath,
} from "../types";
-import { isSchemaNode, isTableNode } from "../types";
+import {
+ isDatabaseItem,
+ isDatabaseNode,
+ isSchemaItem,
+ isSchemaNode,
+ isTableNode,
+ isTableOrSchemaNode,
+} from "../types";
import { flatten } from "../utils";
import { EmptyState } from "./EmptyState";
@@ -69,9 +76,7 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
useEffect(() => {
const expandedDatabases = items.filter(
(item) =>
- item.type === "database" &&
- item.isExpanded &&
- item.children.length === 0,
+ isDatabaseItem(item) && item.isExpanded && item.children.length === 0,
);
expandedDatabases.forEach((database) => {
@@ -101,9 +106,7 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
useEffect(() => {
// When we detect only one database, we automatically select and expand it.
- const databases = tree.children.filter(
- (node) => (node as DatabaseNode).type === "database",
- ) as DatabaseNode[];
+ const databases = tree.children.filter((node) => isDatabaseNode(node));
if (databases.length !== 1) {
return;
@@ -124,8 +127,7 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
// When we detect a database with just one schema, we automatically
// select and expand that schema.
const database = tree.children.find(
- (node) =>
- node.type === "database" && node.value.databaseId === databaseId,
+ (node) => isDatabaseNode(node) && node.value.databaseId === databaseId,
);
if (
databaseId &&
@@ -134,7 +136,7 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
schemaName == null
) {
const schema = database.children[0];
- if (schema.type === "schema") {
+ if (isSchemaNode(schema)) {
toggle(schema.key, true);
onChange(schema.value, { isAutomatic: true });
}
@@ -143,31 +145,31 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
useEffect(() => {
const expandedSelectedSchemaItems = items.filter(
- (x) =>
- x.type === "schema" &&
- selectedSchemas.has(getSchemaId(x) ?? "") &&
- x.children.length > 0,
- );
+ (item) =>
+ isSchemaItem(item) &&
+ selectedSchemas.has(getSchemaId(item) ?? "") &&
+ item.children.length > 0,
+ ) as ExpandedSchemaItem[];
- expandedSelectedSchemaItems.forEach((x) => {
- if (noManuallySelectedTables(x, items, selectedTables)) {
+ expandedSelectedSchemaItems.forEach((schemaItem) => {
+ if (noManuallySelectedTables(schemaItem, items, selectedTables)) {
// when expanding a schema, let's select all the tables in that schema
- const tableIds = getSchemaTableIds(x, items);
+ const tableIds = getSchemaTableIds(schemaItem, items);
if (tableIds.length === 0) {
return;
}
setSelectedTables((prev) => {
const newSet = new Set(prev);
- tableIds.forEach((x) => {
- newSet.add(x);
+ tableIds.forEach((tableId) => {
+ newSet.add(tableId);
});
return newSet;
});
setSelectedSchemas((prev) => {
const newSet = new Set(prev);
- newSet.delete(getSchemaId(x) ?? "");
+ newSet.delete(getSchemaId(schemaItem) ?? "");
return newSet;
});
}
@@ -183,33 +185,30 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
useEffect(() => {
const expandedSelectedDatabaseItems = items.filter(
- (x) =>
- x.type === "database" &&
- selectedDatabases.has(x.value?.databaseId ?? -1) &&
- x.children.length > 0,
- ) as unknown as DatabaseNode[];
+ (item) =>
+ isDatabaseItem(item) &&
+ selectedDatabases.has(item.value?.databaseId ?? -1) &&
+ item.children.length > 0,
+ ) as DatabaseNode[];
- expandedSelectedDatabaseItems.forEach((x) => {
+ expandedSelectedDatabaseItems.forEach((dbNode) => {
if (
- noManuallySelectedSchemas(x, items, selectedSchemas) &&
- noManuallySelectedDatabaseChildrenTables(
- x as unknown as DatabaseNode,
- selectedTables,
- )
+ noManuallySelectedSchemas(dbNode, items, selectedSchemas) &&
+ noManuallySelectedDatabaseChildrenTables(dbNode, selectedTables)
) {
// single schema that's not rendered and it's not part of flattened list
- if (x.children.length === 1) {
+ if (dbNode.children.length === 1) {
setSelectedTables((prev) => {
const newSet = new Set(prev);
- x.children[0].children.forEach((y) => {
+ dbNode.children[0].children.forEach((y) => {
newSet.add(y.value?.tableId ?? -1);
});
return newSet;
});
} else {
// when expanding a db, let's select all the schemas in that db
- const schemaIds = (x as unknown as DatabaseNode).children.map((y) =>
- getSchemaId(y as unknown as FlatItem),
+ const schemaIds = dbNode.children.map((schemaNode) =>
+ getSchemaId(schemaNode),
);
if (schemaIds.length === 0) {
@@ -218,8 +217,8 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
setSelectedSchemas((prev) => {
const newSet = new Set(prev);
- schemaIds.forEach((z) => {
- newSet.add(z ?? "");
+ schemaIds.forEach((schemaId) => {
+ newSet.add(schemaId ?? "");
});
return newSet;
});
@@ -227,7 +226,7 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
setSelectedDatabases((prev) => {
const newSet = new Set(prev);
- newSet.delete((x as unknown as DatabaseNode).value?.databaseId ?? -1);
+ newSet.delete(dbNode.value?.databaseId ?? -1);
return newSet;
});
}
@@ -248,13 +247,14 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
}
function onItemToggle(item: FlatItem) {
- const isSelected = isItemSelected(item as unknown as TreeNode, {
+ const selection = {
tables: selectedTables,
schemas: selectedSchemas,
databases: selectedDatabases,
- });
+ };
+ const isSelected = isItemSelected(item as TreeNode, selection);
- if (item.type === "table") {
+ if (isTableNode(item)) {
const tableId = item.value?.tableId ?? -1;
if (tableId === -1) {
return;
@@ -272,19 +272,15 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
return newSet;
});
}
- if (item.type === "database") {
+ if (isDatabaseItem(item)) {
if (item.children.length > 0) {
- const targetChecked = isSelected === "yes" ? "no" : "yes";
-
- const { schemasSelection, tablesSelection, databasesSelection } =
- markAllSchemas(item, targetChecked, {
- tables: selectedTables,
- schemas: selectedSchemas,
- databases: selectedDatabases,
- });
- setSelectedSchemas(schemasSelection);
- setSelectedTables(tablesSelection);
- setSelectedDatabases(databasesSelection);
+ const { schemas, tables, databases } = toggleDatabaseSelection(
+ item,
+ selection,
+ );
+ setSelectedSchemas(schemas);
+ setSelectedTables(tables);
+ setSelectedDatabases(databases);
} else {
const databaseId = item.value?.databaseId;
if (databaseId) {
@@ -292,27 +288,10 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
}
}
}
- if (item.type === "schema" && item.isLoading === undefined) {
- if (item.children.length > 0 && isSchemaNode(item)) {
- if (isSelected === "yes") {
- setSelectedTables((prev) => {
- const tableIds = getSchemaChildrenTableIds(item);
- const newSet = new Set(prev);
- tableIds.forEach((x) => {
- newSet.delete(x);
- });
- return newSet;
- });
- } else {
- setSelectedTables((prev) => {
- const tableIds = getSchemaChildrenTableIds(item);
- const newSet = new Set(prev);
- tableIds.forEach((x) => {
- newSet.add(x);
- });
- return newSet;
- });
- }
+ if (isSchemaItem(item)) {
+ if (item.children.length > 0) {
+ const { tables } = toggleSchemaSelection(item, selection);
+ setSelectedTables(tables);
} else {
setSelectedSchemas((prev) => {
const newSet = new Set(prev);
@@ -337,7 +316,7 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
(rangeItem): rangeItem is ExpandedItem =>
rangeItem.isLoading === undefined,
)
- .filter(isTableNode)
+ .filter(isTableOrSchemaNode)
.map((rangeItem) =>
rangeItem.value?.tableId ? rangeItem.value.tableId : null,
)
@@ -355,7 +334,7 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
return newSet;
});
- if (targetItem.type === "table" && targetItem.value) {
+ if (isTableNode(targetItem) && targetItem.value) {
onChange(targetItem.value);
}
}
@@ -372,67 +351,6 @@ export function Tree({ path, onChange, setOnUpdateCallback }: Props) {
);
}
-function markAllSchemas(
- item: FlatItem,
- targetChecked: "yes" | "no",
- selection: NodeSelection,
-) {
- const schemasSelection = new Set(selection.schemas);
- const tablesSelection = new Set(selection.tables);
-
- if (item.type !== "database") {
- return {
- schemasSelection,
- tablesSelection,
- databasesSelection: selection.databases,
- };
- }
-
- const schemas = item.children.filter(
- (child): child is SchemaNode => child.type === "schema",
- );
- schemas.forEach((schema) => {
- if (!isSchemaNode(schema)) {
- return;
- }
- const schemaId = getSchemaId(schema);
- if (!schemaId) {
- return;
- }
- if (schema.children.length === 0) {
- targetChecked === "yes"
- ? schemasSelection.add(schemaId)
- : schemasSelection.delete(schemaId);
- } else {
- markAllTables(schema, targetChecked, tablesSelection);
- }
- });
-
- return {
- schemasSelection,
- tablesSelection,
- databasesSelection: selection.databases,
- };
-}
-
-function markAllTables(
- schema: SchemaNode,
- targetChecked: "yes" | "no",
- tablesSelection: Set<TableId>,
-) {
- const tables = getSchemaChildrenTableIds(schema);
- tables.forEach((tableId) => {
- if (tableId === -1) {
- return;
- }
- targetChecked === "yes"
- ? tablesSelection.add(tableId)
- : tablesSelection.delete(tableId);
- });
-
- return tablesSelection;
-}
-
function toggleInSet<T>(set: Set<T>, item: T) {
const newSet = new Set(set);
if (newSet.has(item)) {
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts
index 4a9eb7f7d98..297463e02e7 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/hooks/useExpandedState.ts
@@ -6,13 +6,17 @@ import { expandPath, toKey } from "../utils";
/**
* Returns a state object that indicates which nodes are expanded in the tree.
*/
-export function useExpandedState(path: TreePath) {
+export function useExpandedState(
+ path: TreePath,
+ options: { defaultClosed?: boolean } = {},
+) {
+ const defaultClosed = options.defaultClosed ?? true;
const [state, setState] = useState(expandPath({}, path));
const { databaseId, schemaName, tableId } = path;
useEffect(() => {
- // When the path changes, this means a user has navigated throught the browser back
+ // When the path changes, this means a user has navigated through the browser back
// button, ensure the path is completely expanded.
setState((state) => expandPath(state, { databaseId, schemaName, tableId }));
}, [databaseId, schemaName, tableId]);
@@ -20,9 +24,10 @@ export function useExpandedState(path: TreePath) {
const isExpanded = useCallback(
(path: string | TreePath) => {
const key = typeof path === "string" ? path : toKey(path);
- return Boolean(state[key]);
+ const isToggled = Boolean(state[key]);
+ return defaultClosed ? isToggled : !isToggled;
},
- [state],
+ [state, defaultClosed],
);
const toggle = useCallback((key: string, value?: boolean) => {
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts
index ef9d39b5b59..a734d073d40 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/components/TablePicker/types.ts
@@ -62,22 +62,21 @@ export type ItemType = Item["type"];
export type FlatItem = LoadingItem | ExpandedItem;
-interface ExpandedItemBase {
+interface ExpandedItemBase<TChild = TreeNode> {
isExpanded?: boolean;
isLoading?: false;
parent?: NodeKey;
level: number;
disabled?: boolean;
isSelected?: "yes" | "no" | "some";
- children: TreeNode[];
+ children: TChild[];
}
export type ExpandedItem = Item & ExpandedItemBase;
-export type ExpandedSchemaItem = SchemaItem &
- ExpandedItemBase & {
- children: TableNode[];
- };
+export type ExpandedSchemaItem = SchemaItem & ExpandedItemBase<TableNode>;
+
+export type ExpandedDatabaseItem = DatabaseItem & ExpandedItemBase<SchemaNode>;
export type ExpandedTableItem = TableItem & ExpandedItemBase;
@@ -115,16 +114,32 @@ export function isExpandedItem(node: FlatItem): node is ExpandedItem {
return node.isLoading === undefined;
}
-export function isSchemaNode(
- node: ExpandedItem | TreeNode,
-): node is ExpandedSchemaItem {
- return (
- node.type === "schema" &&
- node.children.every((child) => child.type === "table")
- );
+export function isDatabaseItem(node: FlatItem): node is ExpandedDatabaseItem {
+ if ("isLoading" in node && node.isLoading === true) {
+ return false;
+ }
+ return node.type === "database";
}
-export function isTableNode(
+export function isDatabaseNode(node: TreeNode): node is DatabaseNode {
+ return node.type === "database";
+}
+
+export function isSchemaNode(node: TreeNode): node is SchemaNode {
+ if ("isLoading" in node && node.isLoading === true) {
+ return false;
+ }
+ return node.type === "schema";
+}
+
+export function isSchemaItem(node: FlatItem): node is ExpandedSchemaItem {
+ if ("isLoading" in node && node.isLoading === true) {
+ return false;
+ }
+ return node.type === "schema";
+}
+
+export function isTableOrSchemaNode(
node: ExpandedItem | TreeNode,
): node is ExpandedTableItem {
return (
@@ -133,3 +148,14 @@ export function isTableNode(
node.children.every((child) => child.type === "table"))
);
}
+
+export function isTableNode(node: FlatItem): node is ExpandedTableItem;
+export function isTableNode(node: TreeNode): node is TableNode;
+export function isTableNode(
+ node: FlatItem | TreeNode,
+): node is ExpandedTableItem | TableNode {
+ if ("isLoading" in node && node.isLoading === true) {
+ return false;
+ }
+ return node.type === "table";
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/contexts/SelectionContext.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/contexts/SelectionContext.tsx
index ba8ec33ca6a..333630d3e29 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/contexts/SelectionContext.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/data-model/pages/DataModel/contexts/SelectionContext.tsx
@@ -3,6 +3,7 @@ import {
type ReactNode,
type SetStateAction,
createContext,
+ useCallback,
useContext,
useState,
} from "react";
@@ -34,11 +35,11 @@ export function SelectionProvider({ children }: { children: ReactNode }) {
new Set(),
);
- const resetSelection = () => {
+ const resetSelection = useCallback(() => {
setSelectedTables(new Set());
setSelectedSchemas(new Set());
setSelectedDatabases(new Set());
- };
+ }, []);
const hasSelectedItems =
selectedTables.size > 0 ||