@finos/legend-data-cube 0.3.54 → 0.3.56

package/lib/stores/core/filter/DataCubeQueryFilterOperation__NotIn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataCubeQueryFilterOperation__NotIn.js","sourceRoot":"","sources":["../../../../src/stores/core/filter/DataCubeQueryFilterOperation__NotIn.tsx"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos/legend-data-cube",
-  "version": "0.3.54",
+  "version": "0.3.56",
   "description": "Legend DataCube",
   "keywords": [
     "legend",
@@ -42,10 +42,10 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@finos/legend-application": "16.0.87",
-    "@finos/legend-art": "7.1.137",
-    "@finos/legend-code-editor": "2.0.140",
-    "@finos/legend-graph": "32.3.20",
+    "@finos/legend-application": "16.0.88",
+    "@finos/legend-art": "7.1.138",
+    "@finos/legend-code-editor": "2.0.142",
+    "@finos/legend-graph": "32.3.22",
     "@finos/legend-shared": "11.0.22",
     "@types/react": "19.0.10",
     "ag-grid-community": "33.1.1",

package/src/components/view/filter/DataCubeFilterEditor.tsx

@@ -44,14 +44,26 @@ import {
   FormDropdownMenuTrigger,
 } from '../../core/DataCubeFormUtils.js';
 import type { DataCubeViewState } from '../../../stores/view/DataCubeViewState.js';
-import { forwardRef, useCallback, useEffect, useRef, useState } from 'react';
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+  useMemo,
+} from 'react';
 import {
   DATE_FORMAT,
   PRECISE_PRIMITIVE_TYPE,
   PRIMITIVE_TYPE,
 } from '@finos/legend-graph';
 
-import { formatDate, guaranteeIsNumber, parseISO } from '@finos/legend-shared';
+import {
+  formatDate,
+  guaranteeIsNumber,
+  isNullable,
+  parseISO,
+} from '@finos/legend-shared';
 import { evaluate } from 'mathjs';
 import { useDataCube } from '../../DataCubeProvider.js';
 import { _findCol } from '../../../stores/core/model/DataCubeColumn.js';
@@ -360,6 +372,349 @@ const DataCubeEditorFilterConditionNodeColumnSelector = observer(
   }),
 );
 
+const DataCubeEditorFilterConditionNodeListValueEditor = observer(
+  forwardRef<
+    HTMLElement,
+    {
+      value: DataCubeOperationValue;
+      updateValue: (value: unknown) => void;
+      view: DataCubeViewState;
+    }
+  >(function DataCubeEditorFilterConditionNodeListValueEditor(props, ref) {
+    const { value, updateValue } = props;
+    const items = useMemo(
+      () =>
+        Array.isArray(value.value)
+          ? (value.value as DataCubeOperationValue[])
+          : [],
+      [value.value],
+    );
+    const idSeq = useRef(0);
+    const makeId = () => `${Date.now()}_${idSeq.current++}`;
+    type LocalItem = { id: string; value: DataCubeOperationValue };
+    const [localItems, setLocalItems] = useState<LocalItem[]>(
+      items.map((it) => ({ id: makeId(), value: it })),
+    );
+    const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null);
+    const inputRef = useRef<HTMLInputElement>(null);
+    const [newInput, setNewInput] = useState('');
+
+    useEffect(() => {
+      // rebuild local items from incoming value; generate ids locally
+      setLocalItems(items.map((it) => ({ id: makeId(), value: it })));
+    }, [items]);
+
+    const close = () => {
+      // commit normalized list shape when closing
+      updateValue(localItems.map((e) => e.value));
+      setAnchorEl(null);
+    };
+
+    const commit = useCallback((nextItems: LocalItem[]) => {
+      setLocalItems(nextItems);
+    }, []);
+
+    const addItem = useCallback(() => {
+      const trimmed = newInput.trim();
+      // if input provided, try to coerce to column type; else create default typed item
+      let newItem: DataCubeOperationValue;
+      const firstType = localItems[0]?.value.type ?? PRIMITIVE_TYPE.STRING;
+      switch (firstType) {
+        case PRIMITIVE_TYPE.BOOLEAN: {
+          const v = trimmed.toLowerCase();
+          const boolVal = v === 'true' || v === '1';
+          newItem = { type: firstType, value: boolVal };
+          break;
+        }
+        case PRIMITIVE_TYPE.NUMBER:
+        case PRIMITIVE_TYPE.DECIMAL:
+        case PRIMITIVE_TYPE.FLOAT:
+        case PRIMITIVE_TYPE.INTEGER:
+        case PRECISE_PRIMITIVE_TYPE.INT:
+        case PRECISE_PRIMITIVE_TYPE.BIG_INT:
+        case PRECISE_PRIMITIVE_TYPE.DECIMAL:
+        case PRECISE_PRIMITIVE_TYPE.NUMERIC:
+        case PRECISE_PRIMITIVE_TYPE.DOUBLE:
+        case PRECISE_PRIMITIVE_TYPE.SMALL_INT:
+        case PRECISE_PRIMITIVE_TYPE.FLOAT:
+        case PRECISE_PRIMITIVE_TYPE.U_INT:
+        case PRECISE_PRIMITIVE_TYPE.TINY_INT:
+        case PRECISE_PRIMITIVE_TYPE.U_BIG_INT:
+        case PRECISE_PRIMITIVE_TYPE.U_SMALL_INT:
+        case PRECISE_PRIMITIVE_TYPE.U_TINY_INT: {
+          const n = Number(trimmed);
+          newItem = { type: firstType, value: isNaN(n) ? 0 : n };
+          break;
+        }
+        case PRIMITIVE_TYPE.DATE:
+        case PRIMITIVE_TYPE.STRICTDATE:
+        case PRIMITIVE_TYPE.DATETIME:
+        case PRECISE_PRIMITIVE_TYPE.STRICTDATE:
+        case PRECISE_PRIMITIVE_TYPE.DATETIME:
+        case PRECISE_PRIMITIVE_TYPE.STRICTTIME:
+        case PRECISE_PRIMITIVE_TYPE.TIMESTAMP: {
+          // try parse ISO, else use formatted now
+          let dateVal = trimmed;
+          try {
+            const d = parseISO(trimmed);
+            dateVal = formatDate(d, DATE_FORMAT);
+          } catch {
+            dateVal = formatDate(new Date(), DATE_FORMAT);
+          }
+          newItem = { type: firstType, value: dateVal };
+          break;
+        }
+        default:
+          newItem = { type: firstType, value: trimmed };
+      }
+      const next = [...localItems, { id: makeId(), value: newItem }];
+      commit(next);
+      setNewInput('');
+      inputRef.current?.focus();
+    }, [localItems, newInput, commit]);
+
+    // When the popover is open, allow pressing Enter (when focus is not in an
+    // input/control) to add a new item. We keep Enter behavior of individual
+    // editors (e.g. number evaluator) intact by ignoring keypress when focus
+    // is on common form controls.
+    useEffect(() => {
+      const handler = (e: KeyboardEvent): void => {
+        if (e.key !== 'Enter') {
+          return;
+        }
+        if (!anchorEl) {
+          return;
+        }
+        const active = document.activeElement as HTMLElement | null;
+        if (!active) {
+          addItem();
+          e.preventDefault();
+          return;
+        }
+        const tag = active.tagName;
+        // if focus is on typical input controls, let their handlers process Enter
+        if (['INPUT', 'TEXTAREA', 'SELECT', 'BUTTON'].includes(tag)) {
+          return;
+        }
+        // otherwise, treat Enter as add
+        addItem();
+        e.preventDefault();
+      };
+      window.addEventListener('keydown', handler);
+      return () => window.removeEventListener('keydown', handler);
+    }, [anchorEl, addItem]);
+
+    const removeItem = (idx: number) => {
+      const next = localItems.filter((_, i) => i !== idx);
+      commit(next);
+    };
+
+    const summary =
+      localItems.length === 0
+        ? 'Add...'
+        : `${localItems
+            .slice(0, 2)
+            .map((entry) => {
+              const v = entry.value.value;
+              return String(v ?? '');
+            })
+            .join(
+              ', ',
+            )}${localItems.length > 2 ? ` (+${localItems.length - 2})` : ''}`;
+
+    return (
+      <>
+        <button
+          ref={ref as React.RefObject<HTMLButtonElement>}
+          className="relative h-5 w-full border border-neutral-400 px-1 text-left text-sm"
+          onClick={(e) => setAnchorEl(e.currentTarget)}
+        >
+          {summary}
+        </button>
+        <BasePopover
+          open={Boolean(anchorEl)}
+          anchorEl={anchorEl}
+          anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
+          transformOrigin={{ vertical: 'top', horizontal: 'left' }}
+          onClose={() => close()}
+          classes={{
+            paper: 'shadow-md rounded-none border border-neutral-300 p-2',
+          }}
+        >
+          <div className="w-60">
+            <div className="max-h-40 overflow-auto">
+              {localItems.length === 0 && (
+                <div className="mb-2 text-sm text-neutral-600">
+                  No values added.
+                </div>
+              )}
+              {localItems.map((entry) => {
+                const it = entry.value;
+                const id = entry.id;
+                return (
+                  <div key={id} className="mb-1 flex items-center gap-2">
+                    <div className="flex-1">
+                      {(() => {
+                        switch (it.type) {
+                          case PRIMITIVE_TYPE.BOOLEAN:
+                            return (
+                              <DataCubeEditorFilterConditionNodeBooleanValueEditor
+                                value={Boolean(it.value)}
+                                updateValue={(v: boolean) => {
+                                  const next = localItems.slice();
+                                  const idx = next.findIndex(
+                                    (e) => e.id === id,
+                                  );
+                                  if (idx >= 0) {
+                                    next[idx] = {
+                                      id,
+                                      value: { type: it.type, value: v },
+                                    };
+                                    setLocalItems(next);
+                                  }
+                                }}
+                              />
+                            );
+                          case PRIMITIVE_TYPE.NUMBER:
+                          case PRIMITIVE_TYPE.DECIMAL:
+                          case PRIMITIVE_TYPE.FLOAT:
+                          case PRIMITIVE_TYPE.INTEGER:
+                          case PRECISE_PRIMITIVE_TYPE.INT:
+                          case PRECISE_PRIMITIVE_TYPE.BIG_INT:
+                          case PRECISE_PRIMITIVE_TYPE.DECIMAL:
+                          case PRECISE_PRIMITIVE_TYPE.NUMERIC:
+                          case PRECISE_PRIMITIVE_TYPE.DOUBLE:
+                          case PRECISE_PRIMITIVE_TYPE.SMALL_INT:
+                          case PRECISE_PRIMITIVE_TYPE.FLOAT:
+                          case PRECISE_PRIMITIVE_TYPE.U_INT:
+                          case PRECISE_PRIMITIVE_TYPE.TINY_INT:
+                          case PRECISE_PRIMITIVE_TYPE.U_BIG_INT:
+                          case PRECISE_PRIMITIVE_TYPE.U_SMALL_INT:
+                          case PRECISE_PRIMITIVE_TYPE.U_TINY_INT:
+                            return (
+                              <DataCubeEditorFilterConditionNodeNumberValueEditor
+                                value={
+                                  !isNullable(it.value)
+                                    ? (it.value as number)
+                                    : 0
+                                }
+                                updateValue={(v: number) => {
+                                  const next = localItems.slice();
+                                  const idx = next.findIndex(
+                                    (e) => e.id === id,
+                                  );
+                                  if (idx >= 0) {
+                                    next[idx] = {
+                                      id,
+                                      value: { type: it.type, value: v },
+                                    };
+                                    setLocalItems(next);
+                                  }
+                                }}
+                              />
+                            );
+                          case PRIMITIVE_TYPE.DATE:
+                          case PRIMITIVE_TYPE.STRICTDATE:
+                          case PRIMITIVE_TYPE.DATETIME:
+                          case PRECISE_PRIMITIVE_TYPE.STRICTDATE:
+                          case PRECISE_PRIMITIVE_TYPE.DATETIME:
+                          case PRECISE_PRIMITIVE_TYPE.STRICTTIME:
+                          case PRECISE_PRIMITIVE_TYPE.TIMESTAMP:
+                            return (
+                              <DataCubeEditorFilterConditionNodeDateValueEditor
+                                value={String(
+                                  it.value ??
+                                    formatDate(new Date(), DATE_FORMAT),
+                                )}
+                                updateValue={(v: string) => {
+                                  const next = localItems.slice();
+                                  const idx = next.findIndex(
+                                    (e) => e.id === id,
+                                  );
+                                  if (idx >= 0) {
+                                    next[idx] = {
+                                      id,
+                                      value: { type: it.type, value: v },
+                                    };
+                                    setLocalItems(next);
+                                  }
+                                }}
+                              />
+                            );
+                          default:
+                            return (
+                              <DataCubeEditorFilterConditionNodeTextValueEditor
+                                value={String(it.value ?? '')}
+                                updateValue={(v: string) => {
+                                  const next = localItems.slice();
+                                  const idx = next.findIndex(
+                                    (e) => e.id === id,
+                                  );
+                                  if (idx >= 0) {
+                                    next[idx] = {
+                                      id,
+                                      value: { type: it.type, value: v },
+                                    };
+                                    setLocalItems(next);
+                                  }
+                                }}
+                              />
+                            );
+                        }
+                      })()}
+                    </div>
+                    <button
+                      className="text-sm text-red-600"
+                      onClick={() => {
+                        const idx = localItems.findIndex((e) => e.id === id);
+                        if (idx >= 0) {
+                          removeItem(idx);
+                        }
+                      }}
+                      title="Remove"
+                    >
+                      ×
+                    </button>
+                  </div>
+                );
+              })}
+            </div>
+            <div className="mt-2 flex items-center gap-2">
+              <input
+                ref={inputRef}
+                className="flex-1 border border-neutral-300 px-1 text-sm"
+                placeholder="Add value"
+                value={newInput}
+                onChange={(e) => setNewInput(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === 'Enter') {
+                    addItem();
+                    e.preventDefault();
+                  } else if (e.key === 'Escape') {
+                    close();
+                  }
+                }}
+              />
+              <button className="ml-1" onClick={addItem} title="Add">
+                +
+              </button>
+            </div>
+            <div className="mt-2 flex justify-end">
+              <FormButton
+                onClick={() => {
+                  close();
+                }}
+              >
+                Done
+              </FormButton>
+            </div>
+          </div>
+        </BasePopover>
+      </>
+    );
+  }),
+);
+
 const DataCubeEditorFilterConditionNodeValueEditor = observer(
   forwardRef<
     HTMLElement,
@@ -370,7 +725,7 @@ const DataCubeEditorFilterConditionNodeValueEditor = observer(
     }
   >(function DataCubeEditorFilterConditionNodeValueEditor(props, ref) {
     const { value, updateValue, view } = props;
-    // WIP: support collection/column
+    // WIP: support column
     switch (value.type) {
       case PRIMITIVE_TYPE.STRING:
       case PRECISE_PRIMITIVE_TYPE.VARCHAR:
@@ -435,6 +790,15 @@ const DataCubeEditorFilterConditionNodeValueEditor = observer(
             view={view}
           />
         );
+      case DataCubeOperationAdvancedValueType.LIST:
+        return (
+          <DataCubeEditorFilterConditionNodeListValueEditor
+            ref={ref}
+            value={value}
+            updateValue={(val) => updateValue(val)}
+            view={view}
+          />
+        );
       case DataCubeOperationAdvancedValueType.VOID:
       default:
         return null;

package/src/stores/core/DataCubeEngine.tsx

@@ -60,6 +60,8 @@ import { DataCubeQueryFilterOperation__GreaterThanOrEqualColumn } from './filter
 import { DataCubeQueryFilterOperation__Contain } from './filter/DataCubeQueryFilterOperation__Contain.js';
 import { DataCubeQueryFilterOperation__ContainCaseInsensitive } from './filter/DataCubeQueryFilterOperation__ContainCaseInsensitive.js';
 import { DataCubeQueryFilterOperation__NotContain } from './filter/DataCubeQueryFilterOperation__NotContain.js';
+import { DataCubeQueryFilterOperation__In } from './filter/DataCubeQueryFilterOperation__In.js';
+import { DataCubeQueryFilterOperation__NotIn } from './filter/DataCubeQueryFilterOperation__NotIn.js';
 import { DataCubeQueryFilterOperation__StartWith } from './filter/DataCubeQueryFilterOperation__StartWith.js';
 import { DataCubeQueryFilterOperation__StartWithCaseInsensitive } from './filter/DataCubeQueryFilterOperation__StartWithCaseInsensitive.js';
 import { DataCubeQueryFilterOperation__NotStartWith } from './filter/DataCubeQueryFilterOperation__NotStartWith.js';
@@ -148,6 +150,8 @@ export abstract class DataCubeEngine {
     new DataCubeQueryFilterOperation__Contain(),
     new DataCubeQueryFilterOperation__ContainCaseInsensitive(),
     new DataCubeQueryFilterOperation__NotContain(),
+    new DataCubeQueryFilterOperation__In(),
+    new DataCubeQueryFilterOperation__NotIn(),
     new DataCubeQueryFilterOperation__StartWith(),
     new DataCubeQueryFilterOperation__StartWithCaseInsensitive(),
     new DataCubeQueryFilterOperation__NotStartWith(),

package/src/stores/core/DataCubeQueryBuilderUtils.ts

@@ -322,7 +322,7 @@ export function _colSpec(
   return colSpec;
 }
 
-export function _value(value: DataCubeOperationValue) {
+export function _value(value: DataCubeOperationValue): V1_ValueSpecification {
   switch (value.type) {
     case PRIMITIVE_TYPE.STRING:
     case PRECISE_PRIMITIVE_TYPE.VARCHAR:
@@ -361,6 +361,17 @@ export function _value(value: DataCubeOperationValue) {
     }
     case DataCubeOperationAdvancedValueType.COLUMN:
       return _property(guaranteeIsString(value.value));
+    case DataCubeOperationAdvancedValueType.LIST: {
+      // value.value is expected to be an array of DataCubeOperationValue
+      if (!Array.isArray(value.value)) {
+        throw new UnsupportedOperationError(
+          `List value must be an array for type '${DataCubeOperationAdvancedValueType.LIST}'`,
+        );
+      }
+      return _collection(
+        (value.value as DataCubeOperationValue[]).map((val) => _value(val)),
+      );
+    }
     default:
       throw new UnsupportedOperationError(
         `Can't build value instance for unsupported type '${value.type}'`,

package/src/stores/core/DataCubeQueryEngine.ts

@@ -155,6 +155,7 @@ export enum DataCubeColumnKind {
 
 export enum DataCubeOperationAdvancedValueType {
   COLUMN = 'COLUMN',
+  LIST = 'LIST',
   VOID = 'VOID',
   // PARAMETER
 }
@@ -472,6 +473,22 @@ export function isPrimitiveType(type: string) {
       PRIMITIVE_TYPE.DATETIME,
       PRIMITIVE_TYPE.STRING,
       PRIMITIVE_TYPE.BOOLEAN,
+      PRECISE_PRIMITIVE_TYPE.INT,
+      PRECISE_PRIMITIVE_TYPE.BIG_INT,
+      PRECISE_PRIMITIVE_TYPE.DECIMAL,
+      PRECISE_PRIMITIVE_TYPE.NUMERIC,
+      PRECISE_PRIMITIVE_TYPE.DOUBLE,
+      PRECISE_PRIMITIVE_TYPE.SMALL_INT,
+      PRECISE_PRIMITIVE_TYPE.FLOAT,
+      PRECISE_PRIMITIVE_TYPE.U_INT,
+      PRECISE_PRIMITIVE_TYPE.TINY_INT,
+      PRECISE_PRIMITIVE_TYPE.U_BIG_INT,
+      PRECISE_PRIMITIVE_TYPE.U_SMALL_INT,
+      PRECISE_PRIMITIVE_TYPE.U_TINY_INT,
+      PRECISE_PRIMITIVE_TYPE.STRICTDATE,
+      PRECISE_PRIMITIVE_TYPE.STRICTTIME,
+      PRECISE_PRIMITIVE_TYPE.TIMESTAMP,
+      PRECISE_PRIMITIVE_TYPE.VARCHAR,
     ] as string[]
   ).includes(type);
 }

package/src/stores/core/DataCubeSnapshotBuilderUtils.ts

@@ -233,7 +233,7 @@ export function _operationValue(
   value: V1_ValueSpecification | undefined,
   columnGetter: (name: string) => DataCubeColumn,
   columnChecker?: ((column: DataCubeColumn) => void) | undefined,
-) {
+): DataCubeOperationValue {
   if (value instanceof V1_PrimitiveValueSpecification) {
     return _operationPrimitiveValue(value);
   } else if (value instanceof V1_AppliedProperty) {
@@ -243,6 +243,13 @@ export function _operationValue(
       value: column.name,
       type: DataCubeOperationAdvancedValueType.COLUMN,
     };
+  } else if (value instanceof V1_Collection) {
+    return {
+      type: DataCubeOperationAdvancedValueType.LIST,
+      value: value.values.map((val) =>
+        _operationValue(val, columnGetter, columnChecker),
+      ),
+    };
   } else if (value === undefined) {
     return {
       type: DataCubeOperationAdvancedValueType.VOID,

package/src/stores/core/filter/DataCubeQueryFilterOperation__In.tsx

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2025-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 { DataCubeQueryFilterOperation } from './DataCubeQueryFilterOperation.js';
+import type { DataCubeSnapshotFilterCondition } from '../DataCubeSnapshot.js';
+import type { DataCubeColumn } from '../model/DataCubeColumn.js';
+import {
+  DataCubeColumnDataType,
+  DataCubeFunction,
+  DataCubeQueryFilterOperator,
+  isPrimitiveType,
+  ofDataType,
+  _defaultPrimitiveTypeValue,
+  DataCubeOperationAdvancedValueType,
+  type DataCubeOperationValue,
+} from '../DataCubeQueryEngine.js';
+import {
+  _function,
+  _functionName,
+  _property,
+  _value,
+} from '../DataCubeQueryBuilderUtils.js';
+import { type V1_AppliedFunction } from '@finos/legend-graph';
+import { _filterCondition_base } from '../DataCubeSnapshotBuilderUtils.js';
+
+export class DataCubeQueryFilterOperation__In extends DataCubeQueryFilterOperation {
+  override get label() {
+    return 'in list of';
+  }
+
+  override get textLabel() {
+    return 'in list of';
+  }
+
+  override get description() {
+    return 'in list of';
+  }
+
+  override get operator() {
+    return DataCubeQueryFilterOperator.IN;
+  }
+
+  isCompatibleWithColumn(column: DataCubeColumn) {
+    return ofDataType(column.type, [
+      DataCubeColumnDataType.TEXT,
+      DataCubeColumnDataType.NUMBER,
+      DataCubeColumnDataType.DATE,
+    ]);
+  }
+
+  isCompatibleWithValue(value: DataCubeOperationValue) {
+    // - advanced LIST type: { type: DataCubeOperationAdvancedValueType.LIST, value: [{ type: <primitive>, value: <primitive> }, ...] }
+    if (value.value === undefined) {
+      return false;
+    }
+    if (value.type === DataCubeOperationAdvancedValueType.LIST) {
+      if (
+        !Array.isArray(value.value) ||
+        (value.value as unknown[]).length === 0
+      ) {
+        return false;
+      }
+      return (value.value as unknown[]).every((v) => {
+        const maybe = v as DataCubeOperationValue;
+        return (
+          maybe.value !== undefined &&
+          isPrimitiveType(maybe.type) &&
+          ofDataType(maybe.type, [
+            DataCubeColumnDataType.TEXT,
+            DataCubeColumnDataType.NUMBER,
+            DataCubeColumnDataType.DATE,
+          ])
+        );
+      });
+    }
+    return (
+      isPrimitiveType(value.type) &&
+      ofDataType(value.type, [
+        DataCubeColumnDataType.TEXT,
+        DataCubeColumnDataType.NUMBER,
+        DataCubeColumnDataType.DATE,
+      ]) &&
+      Array.isArray(value.value) &&
+      (value.value as unknown[]).length > 0
+    );
+  }
+
+  generateDefaultValue(column: DataCubeColumn) {
+    return {
+      type: DataCubeOperationAdvancedValueType.LIST,
+      value: [
+        {
+          type: column.type,
+          value: _defaultPrimitiveTypeValue(column.type),
+        },
+      ],
+    };
+  }
+
+  buildConditionSnapshot(
+    expression: V1_AppliedFunction,
+    columnGetter: (name: string) => DataCubeColumn,
+  ) {
+    return this._finalizeConditionSnapshot(
+      _filterCondition_base(expression, DataCubeFunction.IN, columnGetter),
+    );
+  }
+
+  buildConditionExpression(condition: DataCubeSnapshotFilterCondition) {
+    return _function(_functionName(DataCubeFunction.IN), [
+      _property(condition.name),
+      _value(condition.value),
+    ]);
+  }
+}