@finos/legend-cube-builder 0.0.2 → 0.0.3

package/src/components/grid/CubeResultGrid.tsx

@@ -19,16 +19,59 @@ import {
   DataGrid,
   type DataGridCellRendererParams,
   type DataGridColumnDefinition,
+  type DataGridDefaultMenuItem,
+  type DataGridGetContextMenuItemsParams,
+  type DataGridMenuItemDef,
 } from '@finos/legend-lego/data-grid';
-import { memo, useMemo } from 'react';
+import { memo, useCallback, useMemo } from 'react';
 import { NULL_CELL_TEXT } from '../../__lib__/LegendCubeLabels.js';
 import { LEGEND_CUBE_TEST_ID } from '../../__lib__/LegendCubeTesting.js';
 import type { CubeResultValue } from '../../graph-manager/CubeEngine.js';
+import type { CubeEditorState } from '../../stores/CubeEditorState.js';
 import type { CubeExecutionResult } from '../../stores/CubeExecutionState.js';
+import { getCubeGridQuickActions } from '../../stores/CubeGridQuickActions.js';
 import { compareCellValues, isNumericFamily } from './CubeGridValues.js';
 
 type CubeRow = readonly CubeResultValue[];
 
+/** A column's id in the grid: its position, as `c<position>` */
+const COLUMN_ID_PREFIX = 'c';
+
+/**
+ * The grid's context menu (spec §12.4): on a cell, its quick actions, then
+ * ag-grid's own items, which M7 curates; elsewhere ag-grid's only. Read when
+ * the menu opens, so it reflects the cube and the run as they are then.
+ */
+export const getCubeGridContextMenuItems = (
+  editorState: CubeEditorState,
+  params: DataGridGetContextMenuItemsParams<CubeRow>,
+): (DataGridDefaultMenuItem | DataGridMenuItemDef<CubeRow>)[] => {
+  const defaultItems = params.defaultItems ?? [];
+  const colId = params.column?.getColId();
+  if (!colId?.startsWith(COLUMN_ID_PREFIX)) {
+    return defaultItems;
+  }
+  const position = Number(colId.slice(COLUMN_ID_PREFIX.length));
+  const cell = params.node?.data?.[position] ?? null;
+  const actions = getCubeGridQuickActions(editorState, position, cell);
+  if (!actions.length) {
+    return defaultItems;
+  }
+  return [
+    ...actions.map((quickAction): DataGridMenuItemDef<CubeRow> => {
+      const tooltip = quickAction.disabledReason ?? quickAction.hint;
+      return {
+        name: quickAction.label,
+        disabled: quickAction.disabledReason !== undefined,
+        ...(tooltip === undefined ? {} : { tooltip }),
+        action: () => quickAction.apply(),
+      };
+    }),
+    'separator',
+    ...defaultItems,
+  ];
+};
+
 const CubeCell: React.FC<
   DataGridCellRendererParams<CubeRow, CubeResultValue>
 > = (props) =>
@@ -41,17 +84,27 @@ const CubeCell: React.FC<
 /**
  * The rows of a run (PLAN §9): columns from Cube's own schema of the capture
  * node, by position, so any column name works. Numbers are right-aligned and
- * shown and sorted exactly as the engine wrote them.
+ * shown and sorted exactly as the engine wrote them. A cell's context menu
+ * offers the quick actions (`getCubeGridContextMenuItems`).
  */
 export const CubeResultGrid = memo(
-  (props: { result: CubeExecutionResult; darkMode: boolean }) => {
-    const { result, darkMode } = props;
+  (props: {
+    editorState: CubeEditorState;
+    result: CubeExecutionResult;
+    darkMode: boolean;
+  }) => {
+    const { editorState, result, darkMode } = props;
+    const getContextMenuItems = useCallback(
+      (params: DataGridGetContextMenuItemsParams<CubeRow>) =>
+        getCubeGridContextMenuItems(editorState, params),
+      [editorState],
+    );
     const columnDefs = useMemo(
       (): DataGridColumnDefinition<CubeRow, CubeResultValue>[] =>
         result.schema.columns.map((column, position) => {
           const numeric = isNumericFamily(column.type.family);
           return {
-            colId: `c${position}`,
+            colId: `${COLUMN_ID_PREFIX}${position}`,
             headerName: column.name,
             headerTooltip: `${column.type.displayName}${column.nullable ? '?' : ''} (${column.type.fullName})`,
             valueGetter: (params) => params.data?.[position] ?? null,
@@ -76,6 +129,7 @@ export const CubeResultGrid = memo(
           columnDefs={columnDefs}
           suppressFieldDotNotation={true}
           tooltipShowDelay={500}
+          getContextMenuItems={getContextMenuItems}
         />
       </div>
     );

package/src/graph-manager/CubeEngine.ts

@@ -64,10 +64,24 @@ export interface CubeOutlineDatabase {
   readonly schemas: readonly CubeOutlineSchema[];
 }
 
+/** A relational connection of a runtime, for the operations some databases take another way (PLAN §11.4) */
+export interface CubeOutlineConnection {
+  /** The store it is keyed by */
+  readonly storePath: string;
+  /** The engine's name for its database type, e.g. `H2` or `SqlServer` */
+  readonly databaseType: string;
+}
+
 export interface CubeOutlineRuntime {
   readonly path: string;
   /** The stores its connections are keyed by, exactly; includes are not followed (PLAN §6.2.5) */
   readonly storePaths: readonly string[];
+  /**
+   * Its relational connections that name a database type, a list rather
+   * than a record keyed by a store path from the model; optional, as an
+   * outline from before M2 has none
+   */
+  readonly connections?: readonly CubeOutlineConnection[];
 }
 
 /** What a model offers the source picker: its databases and runtimes, as plain data */

package/src/graph-manager/CubeModelOutlineHelper.ts

@@ -30,3 +30,29 @@ export const getRuntimesForDatabase = (
   outline.runtimes.filter((runtime) =>
     runtime.storePaths.includes(databasePath),
   );
+
+/**
+ * The database type a query on these databases runs on with the runtime, for
+ * the operations some databases take another way (PLAN §11.4): the type of
+ * the runtime's connections to them. None when the runtime isn't in the
+ * outline, a database has no typed connection, or the databases' types
+ * differ: the native forms are written then.
+ */
+export const getDatabaseType = (
+  outline: CubeModelOutline,
+  runtimePath: string,
+  databasePaths: readonly string[],
+): string | undefined => {
+  const runtime = outline.runtimes.find(({ path }) => path === runtimePath);
+  const types = new Set<string>();
+  for (const databasePath of new Set(databasePaths)) {
+    const databaseTypes = (runtime?.connections ?? [])
+      .filter(({ storePath }) => storePath === databasePath)
+      .map(({ databaseType }) => databaseType);
+    if (!databaseTypes.length) {
+      return undefined;
+    }
+    databaseTypes.forEach((databaseType) => types.add(databaseType));
+  }
+  return types.size === 1 ? [...types][0] : undefined;
+};

package/src/graph-manager/protocol/pure/v1/V1_CubeModelOutlineBuilder.ts

@@ -19,6 +19,7 @@ import type { PlainObject } from '@finos/legend-shared';
 import {
   CubeTableFlag,
   type CubeModelOutline,
+  type CubeOutlineConnection,
   type CubeOutlineDatabase,
   type CubeOutlineRuntime,
   type CubeOutlineSchema,
@@ -32,6 +33,9 @@ import {
 
 const DATABASE_TYPE = 'relational';
 const RUNTIME_TYPE = 'runtime';
+const CONNECTION_TYPE = 'connection';
+const CONNECTION_POINTER_TYPE = 'connectionPointer';
+const RELATIONAL_CONNECTION_TYPE = 'RelationalDatabaseConnection';
 /** The only runtime value whose store keys Cube can read; others are hidden */
 const ENGINE_RUNTIME_TYPE = 'engineRuntime';
 
@@ -117,8 +121,34 @@ const buildDatabase = (element: PlainObject): CubeOutlineDatabase => ({
   schemas: asList(element.schemas).map(buildSchema),
 });
 
+/** The database type of a relational connection value: its `type`, else its `databaseType` */
+const getRelationalDatabaseType = (value: PlainObject): string | undefined =>
+  value._type === RELATIONAL_CONNECTION_TYPE
+    ? (asString(value.type) ?? asString(value.databaseType))
+    : undefined;
+
+/**
+ * The database type of a runtime's connection, embedded or a pointer to a
+ * connection element (`connectionTypes`, by path); none for one that isn't
+ * relational
+ */
+const getConnectionDatabaseType = (
+  json: unknown,
+  connectionTypes: ReadonlyMap<string, string>,
+): string | undefined => {
+  const connection = asObject(json);
+  if (connection._type === CONNECTION_POINTER_TYPE) {
+    const path = asString(connection.connection);
+    return path === undefined ? undefined : connectionTypes.get(path);
+  }
+  return getRelationalDatabaseType(connection);
+};
+
 /** The stores a runtime's connections are keyed by, in both syntaxes; none when it can't be read */
-const buildRuntime = (element: PlainObject): CubeOutlineRuntime | undefined => {
+const buildRuntime = (
+  element: PlainObject,
+  connectionTypes: ReadonlyMap<string, string>,
+): CubeOutlineRuntime | undefined => {
   const value = asObject(element.runtimeValue);
   if (value._type !== ENGINE_RUNTIME_TYPE) {
     return undefined;
@@ -135,7 +165,51 @@ const buildRuntime = (element: PlainObject): CubeOutlineRuntime | undefined => {
       ),
     ),
   ].filter((path): path is string => path !== undefined);
-  return { path: elementPath(element), storePaths: [...new Set(storePaths)] };
+  const connections: CubeOutlineConnection[] = [];
+  const addConnection = (
+    storePath: string | undefined,
+    databaseType: string | undefined,
+  ): void => {
+    if (
+      storePath !== undefined &&
+      databaseType !== undefined &&
+      !connections.some(
+        (connection) =>
+          connection.storePath === storePath &&
+          connection.databaseType === databaseType,
+      )
+    ) {
+      connections.push({ storePath, databaseType });
+    }
+  };
+  asList(value.connections).forEach((json) => {
+    const storeConnections = asObject(json);
+    const storePath = asString(asObject(storeConnections.store).path);
+    asList(storeConnections.storeConnections).forEach((identified) =>
+      addConnection(
+        storePath,
+        getConnectionDatabaseType(
+          asObject(identified).connection,
+          connectionTypes,
+        ),
+      ),
+    );
+  });
+  asList(value.connectionStores).forEach((json) => {
+    const connectionStore = asObject(json);
+    const databaseType = getConnectionDatabaseType(
+      connectionStore.connectionPointer,
+      connectionTypes,
+    );
+    asList(connectionStore.storePointers).forEach((pointer) =>
+      addConnection(asString(asObject(pointer).path), databaseType),
+    );
+  });
+  return {
+    path: elementPath(element),
+    storePaths: [...new Set(storePaths)],
+    connections,
+  };
 };
 
 /** The outline of a parsed model: its Database elements and its readable runtimes, in model order */
@@ -143,13 +217,25 @@ export const V1_buildCubeModelOutline = (
   modelData: PlainObject,
 ): CubeModelOutline => {
   const elements = asList(modelData.elements).map(asObject);
+  // the database type of each relational connection element, by path
+  const connectionTypes = new Map<string, string>();
+  elements
+    .filter((element) => element._type === CONNECTION_TYPE)
+    .forEach((element) => {
+      const databaseType = getRelationalDatabaseType(
+        asObject(element.connectionValue),
+      );
+      if (databaseType !== undefined) {
+        connectionTypes.set(elementPath(element), databaseType);
+      }
+    });
   return {
     databases: elements
       .filter((element) => element._type === DATABASE_TYPE)
       .map(buildDatabase),
     runtimes: elements
       .filter((element) => element._type === RUNTIME_TYPE)
-      .map(buildRuntime)
+      .map((element) => buildRuntime(element, connectionTypes))
       .filter(
         (runtime): runtime is CubeOutlineRuntime => runtime !== undefined,
       ),

package/src/graph-manager/protocol/pure/v1/__test-utils__/V1_CubeEngineTestUtils.ts

@@ -15,7 +15,10 @@
  */
 
 import { jest } from '@jest/globals';
-import { ENGINE_TEST_SUPPORT__grammarToJSON_model } from '@finos/legend-graph/test';
+import {
+  ENGINE_TEST_SUPPORT__grammarToJSON_model,
+  ENGINE_TEST_SUPPORT_API_URL,
+} from '@finos/legend-graph/test';
 import {
   NetworkClientError,
   type PlainObject,
@@ -40,7 +43,7 @@ const clientError = (status: number, payload: unknown): NetworkClientError =>
     {
       status,
       statusText: String(status),
-      url: 'http://localhost:6300/api',
+      url: ENGINE_TEST_SUPPORT_API_URL,
     } as Response,
     payload as NetworkClientError['payload'],
   );
@@ -74,7 +77,7 @@ export const V1_createEngineBackedCubeEngine = (): {
   >;
 } => {
   const engine = new V1_LegendCubeEngine(
-    { baseUrl: 'http://localhost:6300/api' },
+    { baseUrl: ENGINE_TEST_SUPPORT_API_URL },
     new TracerService(),
   );
   const { client } = engine;

package/src/stores/CubeEditorState.ts

@@ -19,6 +19,10 @@ import {
   createNodeRegistry,
   CubeDocument,
   diffSchemas,
+  findLostSortOrders,
+  MESSAGE_SORT_COLUMNS_CUT,
+  MESSAGE_SORT_COLUMNS_DROPPED,
+  MESSAGE_SORT_ORDER_LOST,
   type ModelContext,
   type NodeRegistry,
   type Query,
@@ -53,6 +57,7 @@ import {
   CubeEngineErrorKind,
   type CubeModelOutline,
 } from '../graph-manager/CubeEngine.js';
+import { getDatabaseType } from '../graph-manager/CubeModelOutlineHelper.js';
 import { CubeExecutionState } from './CubeExecutionState.js';
 import type { CubeHost } from './CubeHost.js';
 import { CubeNodeEditorState } from './CubeNodeEditorState.js';
@@ -138,6 +143,7 @@ export class CubeEditorState implements CommandRegistrar {
       history: observable.ref,
       hostIssues: observable.ref,
       warnings: observable.ref,
+      derivedWarnings: computed,
       isResolvingSources: computed,
       rowLimit: observable,
       isPaletteCollapsed: observable,
@@ -155,6 +161,7 @@ export class CubeEditorState implements CommandRegistrar {
       select: action,
       connect: action,
       addNode: action,
+      addConfiguredNode: action,
       dropNode: action,
       removeNode: action,
       swapInputs: action,
@@ -208,6 +215,52 @@ export class CubeEditorState implements CommandRegistrar {
     return this.pendingSources.has(node);
   }
 
+  /**
+   * Warnings worked out from the query, by node id: a Sort whose order is
+   * lost before it is used (PLAN §11.4). Never stored and never errors, so
+   * Execute stays enabled; they go as soon as the query no longer loses it.
+   * A partial loss names each node that removes some of the Sort's columns,
+   * then the columns that came after a removed one. A loss waits until the
+   * Sort and every node it names have no errors, e.g. a Restrict just added,
+   * with no column yet: their own errors come first.
+   */
+  get derivedWarnings(): ReadonlyMap<string, readonly string[]> {
+    const { validity, schemas } = this.analysis;
+    const isValid = (nodeId: string): boolean =>
+      validity.get(nodeId)?.length === 0;
+    const { query } = this.document;
+    return new Map(
+      Array.from(findLostSortOrders(query, undefined, schemas))
+        .filter(
+          ([sortId, loss]) =>
+            isValid(sortId) &&
+            isValid(loss.nodeId) &&
+            (loss.removals ?? []).every(({ nodeId }) => isValid(nodeId)),
+        )
+        .map(([sortId, loss]) => [
+          sortId,
+          loss.removals
+            ? [
+                ...loss.removals.map(({ nodeId, columns }) =>
+                  MESSAGE_SORT_COLUMNS_DROPPED(columns, nodeId),
+                ),
+                ...(loss.cutColumns?.length
+                  ? [MESSAGE_SORT_COLUMNS_CUT(loss.cutColumns)]
+                  : []),
+              ]
+            : [MESSAGE_SORT_ORDER_LOST(loss.nodeId)],
+        ]),
+    );
+  }
+
+  /** A node's warnings: the stored ones (by key), then the derived ones (by id) */
+  getNodeWarnings(node: QueryNode): readonly string[] {
+    return [
+      ...(this.warnings.get(node.key) ?? []),
+      ...(this.derivedWarnings.get(node.id) ?? []),
+    ];
+  }
+
   /**
    * The node's errors, each once: its own and those of the query rules, then
    * the first line of the engine's error on it
@@ -225,15 +278,53 @@ export class CubeEditorState implements CommandRegistrar {
   /** The outline of the cube's model, once an editor has loaded it */
   get modelOutline(): CubeModelOutline | undefined {
     const model = this.document.context?.model;
-    return model === undefined ? undefined : this.modelOutlines.get(model);
+    return model === undefined ? undefined : this.getModelOutline(model);
+  }
+
+  /** The outline of a model, once loaded */
+  getModelOutline(model: ModelContext): CubeModelOutline | undefined {
+    return this.modelOutlines.get(model);
   }
 
   /**
-   * Loads the outline of the cube's model, once per model. It only adds
-   * warnings, so a model that fails to load shows none.
+   * The database type a run of the query up to the node needs, with the
+   * model's runtime (PLAN §11.4), from the model's outline once it is loaded
+   * (`loadModelOutline`): the type of the runtime's connections to the
+   * databases the node reads. None without an outline, which writes every
+   * operation the native way.
    */
-  *loadModelOutline(): GeneratorFn<void> {
-    const model = this.document.context?.model;
+  getRunDatabaseType(
+    query: Query,
+    nodeId: string,
+    model: ModelContext,
+    runtime: string,
+  ): string | undefined {
+    const outline = this.getModelOutline(model);
+    if (!outline) {
+      return undefined;
+    }
+    const databases = new Set<string>();
+    const visit = (id: string): void => {
+      const node = query.getNode(id);
+      if (node instanceof RelationalTableSource) {
+        databases.add(node.database);
+      }
+      query
+        .getInputIds(id)
+        .forEach((inputId) => inputId !== undefined && visit(inputId));
+    };
+    visit(nodeId);
+    return getDatabaseType(outline, runtime, [...databases]);
+  }
+
+  /**
+   * Loads the outline of a model, the cube's by default, once per model. It
+   * only adds warnings and database types, so a model that fails to load
+   * shows none and runs every operation the native way.
+   */
+  *loadModelOutline(
+    model: ModelContext | undefined = this.document.context?.model,
+  ): GeneratorFn<void> {
     if (model === undefined || this.modelOutlines.has(model)) {
       return;
     }
@@ -585,6 +676,20 @@ export class CubeEditorState implements CommandRegistrar {
     );
   }
 
+  /**
+   * Adds a node made elsewhere, with its settings, as the grid's quick
+   * actions do (spec §12.4): spliced in after `afterId`, so it becomes the
+   * node that runs when that one did, as one undo step. Does nothing in a
+   * read-only cube, or when the query can't take it.
+   */
+  addConfiguredNode(node: QueryNode, afterId?: string): void {
+    const { query } = this.document;
+    if (this.readOnly || !query.canAdd(node, afterId)) {
+      return;
+    }
+    this.applyQuery(query.add(node, afterId));
+  }
+
   /** Whether dropping a node on another does anything: connect it, or else move it after it */
   canDropNode(nodeId: string, targetId: string): boolean {
     const { query } = this.document;

package/src/stores/CubeExecutionState.ts

@@ -14,9 +14,21 @@
  * limitations under the License.
  */
 
-import { isSchemasError, type Query, type Schema } from '@finos/legend-cube';
+import {
+  isSchemasError,
+  needsDatabaseType,
+  type Query,
+  type Schema,
+} from '@finos/legend-cube';
 import { assertErrorThrown, type GeneratorFn } from '@finos/legend-shared';
-import { action, computed, flow, makeObservable, observable } from 'mobx';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
 import {
   CubeEngineError,
   CubeEngineErrorKind,
@@ -162,12 +174,33 @@ export class CubeExecutionState {
     if (!model || !runtime || !schema) {
       return;
     }
-    const lambda = emitter.emitExecutionLambda({ rowLimit, runtime });
+    // the run starts before any wait, so Stop works and a second F9 is ignored
     const controller = new AbortController();
     this.runController = controller;
     this.error = undefined;
     this.editorState.clearHostIssues();
     try {
+      // a Drop, Slice, Limit or Distinct is written for the database it runs on
+      // (PLAN §11.4), which the model's outline gives: loaded once, waited
+      // for only then; the query, model and runtime are the ones captured
+      let databaseType: string | undefined;
+      if (needsDatabaseType(query, captureId)) {
+        yield flowResult(this.editorState.loadModelOutline(model));
+        if (this.runController !== controller || controller.signal.aborted) {
+          return;
+        }
+        databaseType = this.editorState.getRunDatabaseType(
+          query,
+          captureId,
+          model,
+          runtime,
+        );
+      }
+      const lambda = emitter.emitExecutionLambda({
+        rowLimit,
+        runtime,
+        databaseType,
+      });
       const response = (yield host.engine.execute(model, lambda, {
         abortController: controller,
       })) as CubeResult;

package/src/stores/CubeGridQuickActions.ts

@@ -0,0 +1,129 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  buildQuickFilterRule,
+  FilterOperator,
+  Filter,
+  isOperatorAvailable,
+  isSortableType,
+  Sort,
+  TypeFamily,
+} from '@finos/legend-cube';
+import {
+  CUBE_QUICK_ACTION_DISABLED_REASON,
+  FILTER_FLOAT_COMPARISON_HINT,
+  READ_ONLY_CUBE_TITLE,
+} from '../__lib__/LegendCubeLabels.js';
+import type { CubeResultValue } from '../graph-manager/CubeEngine.js';
+import type { CubeEditorState } from './CubeEditorState.js';
+
+/** One of the grid's quick actions on a cell (spec §12.4) */
+export interface CubeGridQuickAction {
+  /** e.g. `Sort by "SHIP_COUNTRY"` */
+  readonly label: string;
+  /** Why it can't be used, its tooltip then; `undefined` when it can */
+  readonly disabledReason: string | undefined;
+  /** A note shown as its tooltip when it can be used, e.g. on comparing floats */
+  readonly hint: string | undefined;
+  /** Adds its node after the node that runs, as one undo step; nothing runs */
+  readonly apply: () => void;
+}
+
+/**
+ * The quick actions on a cell of the shown rows (spec §12.4, PLAN §11.4):
+ * "Sort by" adds an ascending Sort on the cell's column, and "Filter by" an
+ * Equal on its value (Is Empty on a null), after the node that runs, which
+ * they replace as the node that runs. Both need the rows to be from the
+ * current query, no run in flight, and a cube that can change; "Sort by" a
+ * type that sorts, and "Filter by" a value its column's type can compare.
+ * Read when the menu opens; `[]` when the position is not a column of the
+ * shown rows.
+ */
+export const getCubeGridQuickActions = (
+  editorState: CubeEditorState,
+  position: number,
+  cell: CubeResultValue,
+): CubeGridQuickAction[] => {
+  const { execution, document } = editorState;
+  const { result } = execution;
+  const column = result?.schema.columns[position];
+  if (!result || !column) {
+    return [];
+  }
+  const { query } = document;
+  const afterId = query.selected;
+  const typeName = column.type.displayName;
+  const rule = buildQuickFilterRule(column.name, column.type, cell);
+  // what keeps both from being used, in order
+  const blocked =
+    result.query !== query
+      ? CUBE_QUICK_ACTION_DISABLED_REASON.STALE_ROWS
+      : execution.isRunning
+        ? CUBE_QUICK_ACTION_DISABLED_REASON.RUNNING
+        : editorState.readOnly
+          ? READ_ONLY_CUBE_TITLE
+          : undefined;
+  const sortReason =
+    blocked ??
+    (isSortableType(column.type)
+      ? undefined
+      : CUBE_QUICK_ACTION_DISABLED_REASON.notSortable(typeName));
+  const filterReason =
+    blocked ??
+    (rule
+      ? undefined
+      : isOperatorAvailable(FilterOperator.EQUAL, column.type)
+        ? CUBE_QUICK_ACTION_DISABLED_REASON.UNREADABLE_VALUE
+        : CUBE_QUICK_ACTION_DISABLED_REASON.notComparable(typeName));
+  return [
+    {
+      label: `Sort by "${column.name}"`,
+      disabledReason: sortReason,
+      hint: undefined,
+      apply: () => {
+        // as the menu found it: nothing changed since it opened
+        if (sortReason === undefined && editorState.document.query === query) {
+          editorState.addConfiguredNode(
+            Sort.byColumn(query.generateId(Sort.TYPE), column.name),
+            afterId,
+          );
+        }
+      },
+    },
+    {
+      label: `Filter by "${column.name}"`,
+      disabledReason: filterReason,
+      hint:
+        rule?.operator === FilterOperator.EQUAL &&
+        column.type.family === TypeFamily.FLOAT
+          ? FILTER_FLOAT_COMPARISON_HINT
+          : undefined,
+      apply: () => {
+        if (
+          filterReason === undefined &&
+          rule &&
+          editorState.document.query === query
+        ) {
+          editorState.addConfiguredNode(
+            new Filter(query.generateId(Filter.TYPE), rule),
+            afterId,
+          );
+        }
+      },
+    },
+  ];
+};