implement stub ops for NullStorage so that operations on Null columns can work

Author: radeusgd

distribution/lib/Standard/Table/0.0.0-dev/src/Column.enso

@@ -536,6 +536,7 @@ type Column
                         run_binary_op self fn other new_name
                     _ ->
                         run_vectorized_binary_op self Java_Storage.Maps.SUB other
+            Nothing -> self.const Nothing
 
     ## ALIAS multiply, product, times
        GROUP Standard.Base.Operators

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Value_Type_Helpers.enso

@@ -210,6 +210,8 @@ type Addition_Kind
     ## PRIVATE
     Text_Concat
 
+## Returns the operation kind based on types of the inputs.
+   If both inputs are Null, it is impossible to tell the kind, so Nothing is returned and the caller may decide what to do.
 private resolve_operation_kind arg1:Any arg2:Any operation_name:Text find_operation_kind:(Value_Type -> Any) -> Any | Nothing =
     kinds = [arg1, arg2]
         . map on_problems=No_Wrap.Value find_operation_kind

std-bits/table/src/main/java/org/enso/table/data/column/operation/cast/StorageConverter.java

@@ -9,6 +9,7 @@
 import org.enso.table.data.column.storage.type.DateType;
 import org.enso.table.data.column.storage.type.FloatType;
 import org.enso.table.data.column.storage.type.IntegerType;
+import org.enso.table.data.column.storage.type.NullType;
 import org.enso.table.data.column.storage.type.StorageType;
 import org.enso.table.data.column.storage.type.TextType;
 import org.enso.table.data.column.storage.type.TimeOfDayType;
@@ -31,6 +32,7 @@ static StorageConverter<?> fromStorageType(StorageType storageType) {
       case TimeOfDayType timeOfDayType -> new ToTimeOfDayStorageConverter();
       case BigIntegerType bigIntegerType -> new ToBigIntegerConverter();
       case BigDecimalType bigDecimalType -> new ToBigDecimalConverter();
+      case NullType nullType -> throw new IllegalArgumentException("Cannot cast to Null type.");
     };
   }
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/NullStorage.java

@@ -2,15 +2,22 @@
 
 import java.util.BitSet;
 import java.util.List;
+import org.enso.table.data.column.builder.BoolBuilder;
+import org.enso.table.data.column.operation.map.BinaryMapOperation;
 import org.enso.table.data.column.operation.map.MapOperationProblemAggregator;
+import org.enso.table.data.column.operation.map.MapOperationStorage;
 import org.enso.table.data.column.storage.type.NullType;
 import org.enso.table.data.column.storage.type.StorageType;
 import org.enso.table.data.mask.OrderMask;
 import org.enso.table.data.mask.SliceRange;
+import org.enso.table.error.UnexpectedColumnTypeException;
+import org.enso.table.error.UnexpectedTypeException;
+import org.graalvm.polyglot.Value;
 
 /** A specialized storage that can be used by columns that contain only null values. */
 public class NullStorage extends Storage<Void> {
   private final int size;
+  private final MapOperationStorage<Void, NullStorage> ops = buildOps();
 
   public NullStorage(int size) {
     this.size = size;
@@ -36,26 +43,66 @@ public Void getItemBoxed(int idx) {
     return null;
   }
 
+  private static MapOperationStorage<Void, NullStorage> buildOps() {
+    MapOperationStorage<Void, NullStorage> ops = new MapOperationStorage<>();
+    ops.add(new NullOp(Maps.EQ));
+    ops.add(new NullOp(Maps.LT));
+    ops.add(new NullOp(Maps.LTE));
+    ops.add(new NullOp(Maps.GT));
+    ops.add(new NullOp(Maps.GTE));
+
+    ops.add(new NullOp(Maps.MUL));
+    ops.add(new NullOp(Maps.ADD));
+    ops.add(new NullOp(Maps.SUB));
+    ops.add(new NullOp(Maps.DIV));
+    ops.add(new NullOp(Maps.MOD));
+    ops.add(new NullOp(Maps.POWER));
+
+    ops.add(new NullAndOp());
+    ops.add(new NullOrOp());
+
+    ops.add(new NullOp(Maps.STARTS_WITH));
+    ops.add(new NullOp(Maps.ENDS_WITH));
+    ops.add(new NullOp(Maps.CONTAINS));
+    ops.add(new NullOp(Maps.LIKE));
+    ops.add(new NullOp(Maps.TEXT_LEFT));
+    ops.add(new NullOp(Maps.TEXT_RIGHT));
+
+    ops.add(new CoalescingNullOp(Maps.MIN));
+    ops.add(new CoalescingNullOp(Maps.MAX));
+
+    return ops;
+  }
+
   @Override
   public boolean isBinaryOpVectorized(String name) {
-    return false;
+    return ops.isSupportedBinary(name);
   }
 
   @Override
   public Storage<?> runVectorizedBinaryMap(
       String name, Object argument, MapOperationProblemAggregator problemAggregator) {
-    throw new IllegalArgumentException("Operation " + name + " is not vectorized for NullStorage");
+    return ops.runBinaryMap(name, this, argument, problemAggregator);
   }
 
   @Override
   public Storage<?> runVectorizedZip(
       String name, Storage<?> argument, MapOperationProblemAggregator problemAggregator) {
-    throw new IllegalArgumentException("Operation " + name + " is not vectorized for NullStorage");
+    return ops.runZip(name, this, argument, problemAggregator);
   }
 
   @Override
-  public Storage<?> fillMissingFromPrevious(BoolStorage missingIndicator) {
-    return this;
+  public boolean isTernaryOpVectorized(String name) {
+    return ops.isSupportedTernary(name);
+  }
+
+  @Override
+  public Storage<?> runVectorizedTernaryMap(
+      String name,
+      Object argument0,
+      Object argument1,
+      MapOperationProblemAggregator problemAggregator) {
+    return ops.runTernaryMap(name, this, argument0, argument1, problemAggregator);
   }
 
   @Override
@@ -82,4 +129,123 @@ public Storage<?> appendNulls(int count) {
   public Storage<Void> slice(List<SliceRange> ranges) {
     return new NullStorage(SliceRange.totalLength(ranges));
   }
+
+  @Override
+  public Storage<?> fillMissingFromPrevious(BoolStorage missingIndicator) {
+    return this;
+  }
+
+  /** A binary operation that always returns null. */
+  private static class NullOp extends BinaryMapOperation<Void, NullStorage> {
+    public NullOp(String name) {
+      super(name);
+    }
+
+    @Override
+    public Storage<?> runBinaryMap(
+        NullStorage storage, Object arg, MapOperationProblemAggregator problemAggregator) {
+      // We return the same storage as-is, because all lhs arguments are guaranteed to be null.
+      return storage;
+    }
+
+    @Override
+    public Storage<?> runZip(
+        NullStorage storage, Storage<?> arg, MapOperationProblemAggregator problemAggregator) {
+      // We return the same storage as-is, because all lhs arguments are guaranteed to be null.
+      return storage;
+    }
+  }
+
+  /**
+   * A binary operation that always returns the other argument.
+   *
+   * <p>Useful for implementing operations that should return the other argument when the left-hand
+   * side is null, e.g. min.
+   */
+  private static class CoalescingNullOp extends BinaryMapOperation<Void, NullStorage> {
+    public CoalescingNullOp(String name) {
+      super(name);
+    }
+
+    @Override
+    public Storage<?> runBinaryMap(
+        NullStorage storage, Object arg, MapOperationProblemAggregator problemAggregator) {
+      return Storage.fromRepeatedItem(Value.asValue(arg), storage.size(), problemAggregator);
+    }
+
+    @Override
+    public Storage<?> runZip(
+        NullStorage storage, Storage<?> arg, MapOperationProblemAggregator problemAggregator) {
+      return arg;
+    }
+  }
+
+  private abstract static class BoolAndNullOp extends BinaryMapOperation<Void, NullStorage> {
+    public BoolAndNullOp(String name) {
+      super(name);
+    }
+
+    protected abstract Boolean doBool(boolean a);
+
+    @Override
+    public Storage<?> runBinaryMap(
+        NullStorage storage, Object arg, MapOperationProblemAggregator problemAggregator) {
+      if (arg == null) {
+        return new NullStorage(storage.size());
+      } else if (arg instanceof Boolean b) {
+        return Storage.fromRepeatedItem(
+            Value.asValue(doBool(b)), storage.size(), problemAggregator);
+      } else {
+        throw new UnexpectedTypeException("Boolean", arg.toString());
+      }
+    }
+
+    @Override
+    public Storage<?> runZip(
+        NullStorage storage, Storage<?> arg, MapOperationProblemAggregator problemAggregator) {
+      if (arg instanceof BoolStorage boolStorage) {
+        BoolBuilder builder = new BoolBuilder(storage.size());
+        for (int i = 0; i < storage.size(); i++) {
+          if (boolStorage.isNothing(i)) {
+            builder.appendNulls(1);
+          } else {
+            builder.append(doBool(boolStorage.getItem(i)));
+          }
+        }
+        return builder.seal();
+      } else {
+        throw new UnexpectedColumnTypeException("Boolean");
+      }
+    }
+  }
+
+  private static class NullAndOp extends BoolAndNullOp {
+    public NullAndOp() {
+      super(Maps.AND);
+    }
+
+    @Override
+    protected Boolean doBool(boolean a) {
+      if (a) {
+        return null;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  private static class NullOrOp extends BoolAndNullOp {
+    public NullOrOp() {
+      super(Maps.OR);
+    }
+
+    @Override
+    protected Boolean doBool(boolean a) {
+      if (a) {
+        return true;
+      } else {
+        return null;
+      }
+    }
+  }
 }

std-bits/table/src/main/java/org/enso/table/data/column/storage/Storage.java

@@ -9,6 +9,7 @@
 import org.enso.table.data.column.operation.cast.CastProblemAggregator;
 import org.enso.table.data.column.operation.cast.StorageConverter;
 import org.enso.table.data.column.operation.map.MapOperationProblemAggregator;
+import org.enso.table.data.column.storage.numeric.LongConstantStorage;
 import org.enso.table.data.column.storage.numeric.LongStorage;
 import org.enso.table.data.column.storage.type.IntegerType;
 import org.enso.table.data.column.storage.type.StorageType;
@@ -445,4 +446,32 @@ public final Storage<?> cast(
   public Object getItemAsObject(long index) {
     return getItemBoxed((int) index);
   }
+
+  /** Creates a storage containing a single repeated item. */
+  public static Storage<?> fromRepeatedItem(
+      Value item, int repeat, ProblemAggregator problemAggregator) {
+    if (repeat < 0) {
+      throw new IllegalArgumentException("Repeat count must be non-negative.");
+    }
+
+    Object converted = Polyglot_Utils.convertPolyglotValue(item);
+
+    if (converted == null) {
+      return new NullStorage(repeat);
+    }
+
+    if (converted instanceof Long longValue) {
+      return new LongConstantStorage(longValue, repeat);
+    }
+
+    StorageType storageType = StorageType.forBoxedItem(converted);
+    Builder builder = Builder.getForType(storageType, repeat, problemAggregator);
+    Context context = Context.getCurrent();
+    for (int i = 0; i < repeat; i++) {
+      builder.appendNoGrow(converted);
+      context.safepoint();
+    }
+
+    return builder.seal();
+  }
 }

std-bits/table/src/main/java/org/enso/table/data/table/Column.java

@@ -5,7 +5,6 @@
 import org.enso.base.polyglot.Polyglot_Utils;
 import org.enso.table.data.column.builder.Builder;
 import org.enso.table.data.column.builder.InferredBuilder;
-import org.enso.table.data.column.storage.NullStorage;
 import org.enso.table.data.column.storage.Storage;
 import org.enso.table.data.column.storage.type.StorageType;
 import org.enso.table.data.mask.OrderMask;
@@ -165,25 +164,7 @@ public static Column fromItemsNoDateConversion(
    */
   public static Column fromRepeatedItem(
       String name, Value item, int repeat, ProblemAggregator problemAggregator) {
-    if (repeat < 0) {
-      throw new IllegalArgumentException("Repeat count must be non-negative.");
-    }
-
-    Object converted = Polyglot_Utils.convertPolyglotValue(item);
-
-    if (converted == null) {
-      return new Column(name, new NullStorage(repeat));
-    }
-
-    StorageType storageType = StorageType.forBoxedItem(converted);
-    Builder builder = Builder.getForType(storageType, repeat, problemAggregator);
-    Context context = Context.getCurrent();
-    for (int i = 0; i < repeat; i++) {
-      builder.appendNoGrow(converted);
-      context.safepoint();
-    }
-
-    return new Column(name, builder.seal());
+    return new Column(name, Storage.fromRepeatedItem(item, repeat, problemAggregator));
   }
 
   /**