Skip to content

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

Use MBQL lib for table editing (#64722)

Alexander Polyankin5a880ebfb8e6
diff --git a/enterprise/frontend/src/metabase-enterprise/table-editing/common/utils.ts b/enterprise/frontend/src/metabase-enterprise/table-editing/common/utils.ts
index b98bd74ae69..d8147d15ac2 100644
--- a/enterprise/frontend/src/metabase-enterprise/table-editing/common/utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/table-editing/common/utils.ts
@@ -1,41 +1,8 @@
-import { b64hash_to_utf8, utf8_to_b64url } from "metabase/lib/encoding";
import { isPK } from "metabase-lib/v1/types/utils/isa";
-import type {
- DatasetColumn,
- Filter,
- OrderBy,
- RowValue,
- RowValues,
-} from "metabase-types/api";
+import type { DatasetColumn, RowValue, RowValues } from "metabase-types/api";
import type { RowCellsWithPkValue } from "../api/types";
-export const serializeMbqlParam = (filterMbql: Array<any>): string => {
- return utf8_to_b64url(JSON.stringify(filterMbql));
-};
-
-export const deserializeTableFilter = (filterParam: string): Filter | null => {
- const maybeFilter = JSON.parse(b64hash_to_utf8(filterParam));
-
- // simple and hacky way to test if param is a valid filter
- return Array.isArray(maybeFilter) && typeof maybeFilter[0] === "string"
- ? (maybeFilter as Filter)
- : null;
-};
-
-export const deserializeTableSorting = (
- sortingParam: string,
-): Array<OrderBy> | null => {
- const maybeParam = JSON.parse(b64hash_to_utf8(sortingParam));
-
- // simple and hacky way to test if param is valid
- return Array.isArray(maybeParam) &&
- Array.isArray(maybeParam[0]) &&
- typeof maybeParam[0][0] === "string"
- ? (maybeParam as Array<OrderBy>)
- : null;
-};
-
export const getPkColumns = (
columns: DatasetColumn[],
): { indexes: number[]; names: string[] } => {
diff --git a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/EditTableDataContainer.tsx b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/EditTableDataContainer.tsx
index ad91335d297..56886068273 100644
--- a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/EditTableDataContainer.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/EditTableDataContainer.tsx
@@ -44,7 +44,7 @@ type EditTableDataContainerProps = {
tableId: string;
objectId?: string;
};
- location: Location<{ filter?: string }>;
+ location: Location<{ query?: string }>;
};
export const EditTableDataContainer = ({
diff --git a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/data-grid/getHeaderTemplate.tsx b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/data-grid/getHeaderTemplate.tsx
index 7762128f558..9e3ec105b10 100644
--- a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/data-grid/getHeaderTemplate.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/data-grid/getHeaderTemplate.tsx
@@ -1,12 +1,12 @@
import { Ellipsified } from "metabase/common/components/Ellipsified";
import { Box, Icon } from "metabase/ui";
-import type { OrderByDirection } from "metabase-lib";
+import type * as Lib from "metabase-lib";
import type { DatasetColumn } from "metabase-types/api";
import S from "./EditTableDataGrid.module.css";
type Props = {
- sortDirection?: OrderByDirection;
+ sortDirection?: Lib.OrderByDirection;
column: DatasetColumn;
onColumnSort?: (column: DatasetColumn) => void;
};
diff --git a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-adhoc-table-query.ts b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-adhoc-table-query.ts
index 9ee1b643360..6491bccfb53 100644
--- a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-adhoc-table-query.ts
+++ b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-adhoc-table-query.ts
@@ -2,23 +2,17 @@ import type { Location } from "history";
import { useCallback, useEffect, useMemo } from "react";
import { push } from "react-router-redux";
+import { b64url_to_utf8, utf8_to_b64url } from "metabase/lib/encoding";
import { useDispatch, useSelector } from "metabase/lib/redux";
import { loadMetadataForTable } from "metabase/questions/actions";
import { getMetadata } from "metabase/selectors/metadata";
import * as Lib from "metabase-lib";
import Question from "metabase-lib/v1/Question";
-import type { StructuredDatasetQuery } from "metabase-types/api";
-
-import {
- deserializeTableFilter,
- deserializeTableSorting,
- serializeMbqlParam,
-} from "../common/utils";
type UseAdHocTableQueryProps = {
tableId: number;
databaseId: number;
- location: Location<{ filter?: string; sorting?: string }>;
+ location: Location<{ query?: string }>;
};
export const useAdHocTableQuery = ({
@@ -26,80 +20,60 @@ export const useAdHocTableQuery = ({
databaseId,
location,
}: UseAdHocTableQueryProps) => {
- const filterQueryParam = useMemo(
- () =>
- location.query?.filter
- ? deserializeTableFilter(location.query.filter)
- : null,
- [location.query.filter],
- );
+ const metadata = useSelector(getMetadata);
+ const dispatch = useDispatch();
- const sortingQueryParam = useMemo(
+ const queryParam = useMemo(
() =>
- location.query?.sorting
- ? deserializeTableSorting(location.query.sorting)
+ location.query?.query
+ ? JSON.parse(b64url_to_utf8(location.query.query))
: null,
- [location.query.sorting],
+ [location.query.query],
);
- const metadata = useSelector(getMetadata);
- const dispatch = useDispatch();
-
- const table = metadata.table(tableId);
+ const metadataProvider = useMemo(
+ () => Lib.metadataProvider(databaseId, metadata),
+ [databaseId, metadata],
+ );
+ const table = useMemo(
+ () => Lib.tableOrCardMetadata(metadataProvider, tableId),
+ [metadataProvider, tableId],
+ );
useEffect(() => {
dispatch(loadMetadataForTable(tableId));
}, [dispatch, tableId]);
const tableQuestion = useMemo(() => {
- if (table) {
- let question = Question.create({ databaseId, tableId, metadata });
-
- if (filterQueryParam || sortingQueryParam) {
- const legacyQuery = Lib.toLegacyQuery(
- question.query(),
- ) as StructuredDatasetQuery;
-
- if (filterQueryParam) {
- legacyQuery.query.filter = filterQueryParam;
- }
-
- if (sortingQueryParam) {
- legacyQuery.query["order-by"] = sortingQueryParam;
- }
-
- question = question.setDatasetQuery(legacyQuery);
+ if (queryParam != null) {
+ const query = Lib.fromJsQuery(metadataProvider, queryParam);
+ if (Lib.sourceTableOrCardId(query) === tableId) {
+ return Question.create({
+ dataset_query: Lib.toJsQuery(query),
+ metadata,
+ });
}
+ }
- return question;
+ if (table != null) {
+ const query = Lib.queryFromTableOrCardMetadata(metadataProvider, table);
+ return Question.create({ dataset_query: Lib.toJsQuery(query), metadata });
}
- }, [
- table,
- databaseId,
- tableId,
- metadata,
- filterQueryParam,
- sortingQueryParam,
- ]);
+ }, [tableId, table, queryParam, metadata, metadataProvider]);
const handleTableQuestionChange = useCallback(
(newQuestion: Question) => {
- const legacyQuery = Lib.toLegacyQuery(
- newQuestion.query(),
- ) as StructuredDatasetQuery;
- const newFilterMbql = legacyQuery.query.filter;
- const newSortingMbql = legacyQuery.query["order-by"];
+ const newQuery = newQuestion.query();
+ const newFilters = Lib.filters(newQuery, 0);
+ const newOrderBys = Lib.orderBys(newQuery, 0);
- if (newFilterMbql || newSortingMbql) {
+ // don't set the query string param if there are no filters or sorting
+ if (newFilters.length > 0 || newOrderBys.length > 0) {
const searchParams = new URLSearchParams();
- if (newFilterMbql) {
- searchParams.append("filter", serializeMbqlParam(newFilterMbql));
- }
- if (newSortingMbql) {
- searchParams.append("sorting", serializeMbqlParam(newSortingMbql));
- }
-
- // don't set filter param if it is empty
+ searchParams.set(
+ "query",
+ utf8_to_b64url(JSON.stringify(Lib.toJsQuery(newQuery))),
+ );
dispatch(
push(`${window.location.pathname}?${searchParams.toString()}`),
);
@@ -112,7 +86,7 @@ export const useAdHocTableQuery = ({
const tableQuery = useMemo(() => {
if (tableQuestion) {
- return Lib.toLegacyQuery(tableQuestion.query());
+ return Lib.toJsQuery(tableQuestion.query());
}
}, [tableQuestion]);
diff --git a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-edit-table-data.ts b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-edit-table-data.ts
index bb8a7e16071..511ad377fac 100644
--- a/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-edit-table-data.ts
+++ b/enterprise/frontend/src/metabase-enterprise/table-editing/table-edit/use-edit-table-data.ts
@@ -2,17 +2,7 @@ import type { Location } from "history";
import { useCallback } from "react";
import { skipToken, useGetAdhocQueryQuery } from "metabase/api";
-import type { OrderByDirection, Query } from "metabase-lib";
-import {
- changeDirection,
- displayInfo,
- findMatchingColumn,
- fromLegacyColumn,
- orderBy,
- orderBys,
- orderableColumns,
- removeOrderBys,
-} from "metabase-lib";
+import * as Lib from "metabase-lib";
import type Question from "metabase-lib/v1/Question";
import type { DatasetColumn } from "metabase-types/api";
@@ -21,12 +11,12 @@ import { useAdHocTableQuery } from "./use-adhoc-table-query";
type Props = {
tableId: number;
databaseId: number;
- location: Location<{ filter?: string }>;
+ location: Location<{ query?: string }>;
};
export type TableDataGetColumnSortDirection = (
column: DatasetColumn,
-) => OrderByDirection | undefined;
+) => Lib.OrderByDirection | undefined;
export function useEditTableData({ tableId, databaseId, location }: Props) {
const { tableQuestion, tableQuery, handleTableQuestionChange } =
@@ -44,11 +34,11 @@ export function useEditTableData({ tableId, databaseId, location }: Props) {
);
if (column != null) {
- const columnInfo = displayInfo(query, stageIndex, column);
+ const columnInfo = Lib.displayInfo(query, stageIndex, column);
if (columnInfo.orderByPosition != null) {
- const orderBysMap = orderBys(query, stageIndex);
+ const orderBysMap = Lib.orderBys(query, stageIndex);
const orderBy = orderBysMap[columnInfo.orderByPosition];
- const orderByInfo = displayInfo(query, stageIndex, orderBy);
+ const orderByInfo = Lib.displayInfo(query, stageIndex, orderBy);
return orderByInfo.direction;
}
}
@@ -70,18 +60,18 @@ export function useEditTableData({ tableId, databaseId, location }: Props) {
if (column) {
const sortDirection = getColumnSortDirection(columnOrField);
- let newQuery: Query;
+ let newQuery: Lib.Query;
if (sortDirection === "asc") {
// have existing sorting by asc, then make it desc
- const clauses = orderBys(query, stageIndex);
- newQuery = changeDirection(query, clauses[0]);
+ const clauses = Lib.orderBys(query, stageIndex);
+ newQuery = Lib.changeDirection(query, clauses[0]);
} else if (sortDirection === "desc") {
// have existing sorting by desc, then remove sorting - WRK-446
- newQuery = removeOrderBys(query, stageIndex);
+ newQuery = Lib.removeOrderBys(query, stageIndex);
} else {
// no existing sorting on this column - apply new sorting (default - by asc)
- newQuery = orderBy(
- removeOrderBys(query, stageIndex),
+ newQuery = Lib.orderBy(
+ Lib.removeOrderBys(query, stageIndex),
stageIndex,
column,
);
@@ -113,11 +103,11 @@ export function useEditTableData({ tableId, databaseId, location }: Props) {
const getQueryColumn = (question: Question, columnOrField: DatasetColumn) => {
const query = question.query();
const stageIndex = -1;
- const column = findMatchingColumn(
+ const column = Lib.findMatchingColumn(
query,
stageIndex,
- fromLegacyColumn(query, stageIndex, columnOrField),
- orderableColumns(query, stageIndex),
+ Lib.fromLegacyColumn(query, stageIndex, columnOrField),
+ Lib.orderableColumns(query, stageIndex),
);
return {