feat: DH-21235: Column Restriction JS API

engine/table/src/main/java/io/deephaven/engine/util/input/InputTableUpdater.java

@@ -57,12 +57,17 @@ default List<String> getValueNames() {
     }
 
     /**
-     * If there are client-side defined restrictions on this column; return them as a JSON string to be interpreted by
-     * the client for properly displaying the edit field.
+     * If there are client-side defined restrictions on this column, return them as a list of protobuf Any messages.
+     * These restrictions are used by the client for properly displaying and validating the edit field.
+     *
+     * <p>
+     * The restrictions are packed as {@code google.protobuf.Any} messages, which allows for different restriction types
+     * (e.g., {@code IntegerRangeRestriction}, {@code DoubleRangeRestriction}, {@code StringListRestriction}, etc.) to
+     * be sent to the client. The client is responsible for unpacking and interpreting these restrictions.
      *
      * @param columnName the column name to query
-     * @return a string representing the restrictions for this column, or null if no client-side restrictions are
-     *         supplied for this column
+     * @return a list of protobuf Any messages representing the restrictions for this column, or null if no client-side
+     *         restrictions are supplied for this column
      */
     @Nullable
     default List<Any> getColumnRestrictions(final String columnName) {

server/src/main/java/io/deephaven/server/table/inputtables/AbstractBaseValidatingInputTable.java

@@ -0,0 +1,100 @@
+//
+// Copyright (c) 2016-2026 Deephaven Data Labs and Patent Pending
+//
+package io.deephaven.server.table.inputtables;
+
+import com.google.protobuf.Any;
+import io.deephaven.engine.table.Table;
+import io.deephaven.engine.table.TableDefinition;
+import io.deephaven.engine.util.input.InputTableStatusListener;
+import io.deephaven.engine.util.input.InputTableUpdater;
+import io.deephaven.util.annotations.TestUseOnly;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * An abstract base class for {@link InputTableUpdater} implementations that wrap an existing input table.
+ *
+ * <p>
+ * This class provides a default implementation for most methods by delegating to the wrapped input table. Subclasses
+ * should override {@link #getColumnRestrictions(String)} and {@link #validateAddOrModify(Table)} to provide custom
+ * validation logic.
+ * </p>
+ *
+ * <p>
+ * <b>This class is intended for testing and demonstrating validation functionality, it is not production ready and may
+ * be changed or removed at any time.</b>
+ * </p>
+ */
+@TestUseOnly
+public abstract class AbstractBaseValidatingInputTable implements InputTableUpdater {
+    protected final InputTableUpdater wrapped;
+
+    /**
+     * Construct a new validating input table that wraps the given input table.
+     *
+     * @param wrapped the input table to wrap
+     */
+    protected AbstractBaseValidatingInputTable(InputTableUpdater wrapped) {
+        this.wrapped = wrapped;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        return wrapped.getKeyNames();
+    }
+
+    @Override
+    public List<String> getValueNames() {
+        return wrapped.getValueNames();
+    }
+
+    @Override
+    public abstract @Nullable List<Any> getColumnRestrictions(String columnName);
+
+    @Override
+    public TableDefinition getTableDefinition() {
+        return wrapped.getTableDefinition();
+    }
+
+    @Override
+    public abstract void validateAddOrModify(Table tableToApply);
+
+    @Override
+    public void validateDelete(Table tableToDelete) {
+        wrapped.validateDelete(tableToDelete);
+    }
+
+    @Override
+    public void add(Table newData) throws IOException {
+        wrapped.add(newData);
+    }
+
+    @Override
+    public void addAsync(Table newData, InputTableStatusListener listener) {
+        wrapped.addAsync(newData, listener);
+    }
+
+    @Override
+    public void delete(Table table) throws IOException {
+        wrapped.delete(table);
+    }
+
+    @Override
+    public void deleteAsync(Table table, InputTableStatusListener listener) {
+        wrapped.deleteAsync(table, listener);
+    }
+
+    @Override
+    public boolean isKey(String columnName) {
+        return wrapped.isKey(columnName);
+    }
+
+    @Override
+    public boolean hasColumn(String columnName) {
+        return wrapped.hasColumn(columnName);
+    }
+}
+

server/src/main/java/io/deephaven/server/table/inputtables/DoubleRangeValidatingInputTable.java

@@ -0,0 +1,115 @@
+//
+// Copyright (c) 2016-2026 Deephaven Data Labs and Patent Pending
+//
+package io.deephaven.server.table.inputtables;
+
+import com.google.protobuf.Any;
+import io.deephaven.engine.primitive.iterator.CloseablePrimitiveIteratorOfDouble;
+import io.deephaven.engine.table.Table;
+import io.deephaven.engine.util.input.InputTableUpdater;
+import io.deephaven.engine.util.input.InputTableValidationException;
+import io.deephaven.engine.util.input.StructuredErrorImpl;
+import io.deephaven.proto.backplane.grpc.DoubleRangeRestriction;
+import io.deephaven.util.annotations.TestUseOnly;
+import io.deephaven.util.mutable.MutableInt;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This is an example of an {@link InputTableUpdater} that validates that the values in a Double column are within a
+ * given range.
+ *
+ * <p>
+ * This class wraps an existing input table, and before performing the underlying validation performs its own validation
+ * on the range of the column.
+ * </p>
+ *
+ * <p>
+ * <b>This class is intended for testing and demonstrating validation functionality, it is not production ready and may
+ * be changed or removed at any time.</b>
+ * </p>
+ */
+@TestUseOnly
+public class DoubleRangeValidatingInputTable extends AbstractBaseValidatingInputTable {
+    private final String column;
+    private final double min;
+    private final double max;
+
+    /**
+     * Wrap {@code input}, which must be an input table into a new input table that validates that the values in
+     * {@code column} are within the range {@code ([min, max]}.
+     *
+     * @param input the table to wrap
+     * @param column the column to validate, must be a double type
+     * @param min the minimum value allowed, inclusive
+     * @param max the maximum value allowed, inclusive
+     * @return a new input table that validates the range of {@code column}
+     */
+    public static Table make(Table input, final String column,
+            final double min,
+            final double max) {
+        final InputTableUpdater updater = (InputTableUpdater) input.getAttribute(Table.INPUT_TABLE_ATTRIBUTE);
+        final DoubleRangeValidatingInputTable validatedUpdater =
+                new DoubleRangeValidatingInputTable(updater, column, min, max);
+        return input.withAttributes(Map.of(Table.INPUT_TABLE_ATTRIBUTE, validatedUpdater));
+    }
+
+
+    private DoubleRangeValidatingInputTable(InputTableUpdater wrapped,
+            final String column,
+            final double min,
+            final double max) {
+        super(wrapped);
+        this.column = column;
+        final Class<?> dataType = getTableDefinition().getColumn(column).getDataType();
+        if (dataType != double.class) {
+            throw new IllegalArgumentException("Range column must be a double, but " + column + " is " + dataType);
+        }
+        this.min = min;
+        this.max = max;
+    }
+
+
+    @Override
+    public @Nullable List<Any> getColumnRestrictions(String columnName) {
+        final List<Any> columnRestrictions = wrapped.getColumnRestrictions(columnName);
+        if (!columnName.equals(column)) {
+            return columnRestrictions;
+        }
+
+        final List<Any> result = new ArrayList<>();
+        if (columnRestrictions != null) {
+            result.addAll(columnRestrictions);
+        }
+        final DoubleRangeRestriction rangeRestriction =
+                DoubleRangeRestriction.newBuilder().setMinInclusive(min).setMaxInclusive(max).build();
+        result.add(Any.pack(rangeRestriction, "docs.deephaven.io"));
+        return result;
+    }
+
+
+    @Override
+    public void validateAddOrModify(Table tableToApply) {
+        final List<InputTableValidationException.StructuredError> errors = new ArrayList<>();
+        final MutableInt position = new MutableInt(0);
+        try (final CloseablePrimitiveIteratorOfDouble vals = tableToApply.doubleColumnIterator(column)) {
+            vals.forEachRemaining((double val) -> {
+                if (val < min || val > max) {
+                    errors.add(new StructuredErrorImpl(
+                            "Value out of range: " + val + " must be between " + min + " and " + max + " inclusive",
+                            column, position.get()));
+                }
+                position.increment();
+            });
+        }
+        if (!errors.isEmpty()) {
+            throw new InputTableValidationException(errors);
+        }
+
+        wrapped.validateAddOrModify(tableToApply);
+    }
+}
+

server/src/main/java/io/deephaven/server/table/inputtables/NonEmptyValidatingInputTable.java

@@ -0,0 +1,108 @@
+//
+// Copyright (c) 2016-2026 Deephaven Data Labs and Patent Pending
+//
+package io.deephaven.server.table.inputtables;
+
+import com.google.protobuf.Any;
+import io.deephaven.engine.rowset.RowSequence;
+import io.deephaven.engine.table.ColumnSource;
+import io.deephaven.engine.table.Table;
+import io.deephaven.engine.util.input.InputTableUpdater;
+import io.deephaven.engine.util.input.InputTableValidationException;
+import io.deephaven.engine.util.input.StructuredErrorImpl;
+import io.deephaven.proto.backplane.grpc.NonEmptyRestriction;
+import io.deephaven.util.annotations.TestUseOnly;
+import io.deephaven.util.mutable.MutableInt;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This is an example of an {@link InputTableUpdater} that validates that the values in a String column are not empty.
+ *
+ * <p>
+ * This class wraps an existing input table, and before performing the underlying validation performs its own validation
+ * that the column does not contain empty strings.
+ * </p>
+ *
+ * <p>
+ * <b>This class is intended for testing and demonstrating validation functionality, it is not production ready and may
+ * be changed or removed at any time.</b>
+ * </p>
+ */
+@TestUseOnly
+public class NonEmptyValidatingInputTable extends AbstractBaseValidatingInputTable {
+    private final String column;
+
+    /**
+     * Wrap {@code input}, which must be an input table into a new input table that validates that the values in
+     * {@code column} are not empty.
+     *
+     * @param input the table to wrap
+     * @param column the column to validate, must be a String type
+     * @return a new input table that validates {@code column} is not empty
+     */
+    public static Table make(Table input, final String column) {
+        final InputTableUpdater updater = (InputTableUpdater) input.getAttribute(Table.INPUT_TABLE_ATTRIBUTE);
+        final NonEmptyValidatingInputTable validatedUpdater = new NonEmptyValidatingInputTable(updater, column);
+        return input.withAttributes(Map.of(Table.INPUT_TABLE_ATTRIBUTE, validatedUpdater));
+    }
+
+
+    private NonEmptyValidatingInputTable(InputTableUpdater wrapped, final String column) {
+        super(wrapped);
+        this.column = column;
+        final Class<?> dataType = getTableDefinition().getColumn(column).getDataType();
+        if (dataType != String.class) {
+            throw new IllegalArgumentException(
+                    "Non-empty validation only applies to String columns, but " + column + " is " + dataType);
+        }
+    }
+
+
+    @Override
+    public @Nullable List<Any> getColumnRestrictions(String columnName) {
+        final List<Any> columnRestrictions = wrapped.getColumnRestrictions(columnName);
+        if (!columnName.equals(column)) {
+            return columnRestrictions;
+        }
+
+        final List<Any> result = new ArrayList<>();
+        if (columnRestrictions != null) {
+            result.addAll(columnRestrictions);
+        }
+        final NonEmptyRestriction nonEmptyRestriction = NonEmptyRestriction.newBuilder().build();
+        result.add(Any.pack(nonEmptyRestriction, "docs.deephaven.io"));
+        return result;
+    }
+
+
+    @Override
+    public void validateAddOrModify(Table tableToApply) {
+        final List<InputTableValidationException.StructuredError> errors = new ArrayList<>();
+        final MutableInt position = new MutableInt(0);
+        final ColumnSource<String> columnSource = tableToApply.getColumnSource(column, String.class);
+
+        try (final RowSequence rowSequence =
+                tableToApply.getRowSet().getRowSequenceByPosition(0, tableToApply.size())) {
+            rowSequence.forAllRowKeys(rowKey -> {
+                final String value = columnSource.get(rowKey);
+                if (value != null && value.isEmpty()) {
+                    errors.add(new StructuredErrorImpl(
+                            "Value must not be empty",
+                            column, position.get()));
+                }
+                position.increment();
+            });
+        }
+
+        if (!errors.isEmpty()) {
+            throw new InputTableValidationException(errors);
+        }
+
+        wrapped.validateAddOrModify(tableToApply);
+    }
+}
+