feat: support Nested Lists

core/src/main/java/io/substrait/expression/AbstractExpressionVisitor.java

@@ -186,6 +186,11 @@ public O visit(Expression.MultiOrList expr, C context) throws E {
     return visitFallback(expr, context);
   }
 
+  @Override
+  public O visit(Expression.NestedList expr, C context) throws E {
+    return visitFallback(expr, context);
+  }
+
   @Override
   public O visit(FieldReference expr, C context) throws E {
     return visitFallback(expr, context);

core/src/main/java/io/substrait/expression/Expression.java

@@ -32,6 +32,13 @@ default boolean nullable() {
     }
   }
 
+  interface Nested extends Expression {
+    @Value.Default
+    default boolean nullable() {
+      return false;
+    }
+  }
+
   <R, C extends VisitationContext, E extends Throwable> R accept(
       ExpressionVisitor<R, C, E> visitor, C context) throws E;
 
@@ -922,6 +929,26 @@ public <R, C extends VisitationContext, E extends Throwable> R accept(
     }
   }
 
+  @Value.Immutable
+  abstract class NestedList implements Nested {
+    public abstract List<Expression> values();
+
+    @Override
+    public Type getType() {
+      return Type.withNullability(nullable()).list(values().get(0).getType());
+    }
+
+    @Override
+    public <R, C extends VisitationContext, E extends Throwable> R accept(
+        ExpressionVisitor<R, C, E> visitor, C context) throws E {
+      return visitor.visit(this, context);
+    }
+
+    public static ImmutableExpression.NestedList.Builder builder() {
+      return ImmutableExpression.NestedList.builder();
+    }
+  }
+
   @Value.Immutable
   abstract class MultiOrListRecord {
     public abstract List<Expression> values();

core/src/main/java/io/substrait/expression/ExpressionCreator.java

@@ -281,6 +281,10 @@ public static Expression.StructLiteral struct(boolean nullable, Expression.Liter
     return Expression.StructLiteral.builder().nullable(nullable).addFields(values).build();
   }
 
+  public static Expression.NestedList nestedList(boolean nullable, List<Expression> values) {
+    return Expression.NestedList.builder().nullable(nullable).addAllValues(values).build();
+  }
+
   public static Expression.StructLiteral struct(
       boolean nullable, Iterable<? extends Expression.Literal> values) {
     return Expression.StructLiteral.builder().nullable(nullable).addAllFields(values).build();

core/src/main/java/io/substrait/expression/ExpressionVisitor.java

@@ -78,6 +78,8 @@ public interface ExpressionVisitor<R, C extends VisitationContext, E extends Thr
 
   R visit(Expression.MultiOrList expr, C context) throws E;
 
+  R visit(Expression.NestedList expr, C context) throws E;
+
   R visit(FieldReference expr, C context) throws E;
 
   R visit(Expression.SetPredicate expr, C context) throws E;

core/src/main/java/io/substrait/expression/proto/ExpressionProtoConverter.java

@@ -496,6 +496,26 @@ public Expression visit(
         .build();
   }
 
+  private Expression nested(Consumer<Expression.Nested.Builder> consumer) {
+    Expression.Nested.Builder builder = Expression.Nested.newBuilder();
+    builder.setNullable(builder.getNullable());
+    consumer.accept(builder);
+    return Expression.newBuilder().setNested(builder).build();
+  }
+
+  @Override
+  public Expression visit(
+      io.substrait.expression.Expression.NestedList expr, EmptyVisitationContext context)
+      throws RuntimeException {
+    return nested(
+        bldr -> {
+          List<Expression> values =
+              expr.values().stream().map(this::toProto).collect(Collectors.toList());
+          bldr.setNullable(expr.nullable())
+              .setList(Expression.Nested.List.newBuilder().addAllValues(values));
+        });
+  }
+
   @Override
   public Expression visit(FieldReference expr, EmptyVisitationContext context) {
 

core/src/main/java/io/substrait/expression/proto/ProtoExpressionConverter.java

@@ -197,6 +197,8 @@ public Expression from(io.substrait.proto.Expression expr) {
                   multiOrList.getValueList().stream().map(this::from).collect(Collectors.toList()))
               .build();
         }
+      case NESTED:
+        return from(expr.getNested());
       case CAST:
         return ExpressionCreator.cast(
             protoTypeConverter.from(expr.getCast().getType()),
@@ -361,6 +363,15 @@ private WindowBound toWindowBound(io.substrait.proto.Expression.WindowFunction.B
     }
   }
 
+  public Expression.Nested from(io.substrait.proto.Expression.Nested nested) {
+    if (nested.getNestedTypeCase() == io.substrait.proto.Expression.Nested.NestedTypeCase.LIST) {
+      List<Expression> list =
+          nested.getList().getValuesList().stream().map(this::from).collect(Collectors.toList());
+      return ExpressionCreator.nestedList(nested.getNullable(), list);
+    }
+    return null;
+  }
+
   public Expression.Literal from(io.substrait.proto.Expression.Literal literal) {
     switch (literal.getLiteralTypeCase()) {
       case BOOLEAN:

core/src/main/java/io/substrait/relation/ExpressionCopyOnWriteVisitor.java

@@ -348,6 +348,16 @@ public Optional<Expression> visit(
             .build());
   }
 
+  @Override
+  public Optional<Expression> visit(Expression.NestedList expr, EmptyVisitationContext context)
+      throws E {
+    Optional<List<Expression>> expressions = visitExprList(expr.values(), context);
+
+    return expressions.map(
+        expressionList ->
+            Expression.NestedList.builder().from(expr).values(expressionList).build());
+  }
+
   protected Optional<Expression.MultiOrListRecord> visitMultiOrListRecord(
       Expression.MultiOrListRecord multiOrListRecord, EmptyVisitationContext context) throws E {
     return visitExprList(multiOrListRecord.values(), context)

core/src/test/java/io/substrait/type/proto/NestedListExpressionTest.java

@@ -0,0 +1,52 @@
+package io.substrait.type.proto;
+
+import io.substrait.TestBase;
+import io.substrait.expression.Expression;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class NestedListExpressionTest extends TestBase {
+  io.substrait.expression.Expression literalExpression =
+      Expression.BoolLiteral.builder().value(true).build();
+  Expression.ScalarFunctionInvocation nonLiteralExpression = b.add(b.i32(7), b.i32(42));
+
+  @Test
+  void literalNestedListTest() {
+    List<Expression> expressionList = new ArrayList<>();
+    Expression.NestedList literalNestedList =
+        Expression.NestedList.builder()
+            .addValues(literalExpression)
+            .addValues(literalExpression)
+            .build();
+    expressionList.add(literalNestedList);
+
+    io.substrait.relation.Project project =
+        io.substrait.relation.Project.builder()
+            .expressions(expressionList)
+            .input(b.emptyScan())
+            .build();
+
+    verifyRoundTrip(project);
+  }
+
+  @Test
+  void nonLiteralNestedListTest() {
+    List<Expression> expressionList = new ArrayList<>();
+
+    Expression.NestedList nonLiteralNestedList =
+        Expression.NestedList.builder()
+            .addValues(nonLiteralExpression)
+            .addValues(nonLiteralExpression)
+            .build();
+    expressionList.add(nonLiteralNestedList);
+
+    io.substrait.relation.Project project =
+        io.substrait.relation.Project.builder()
+            .expressions(expressionList)
+            .input(b.emptyScan())
+            .build();
+
+    verifyRoundTrip(project);
+  }
+}

examples/substrait-spark/src/main/java/io/substrait/examples/util/ExpressionStringify.java

@@ -1,5 +1,6 @@
 package io.substrait.examples.util;
 
+import io.substrait.expression.Expression;
 import io.substrait.expression.Expression.BinaryLiteral;
 import io.substrait.expression.Expression.BoolLiteral;
 import io.substrait.expression.Expression.Cast;
@@ -256,6 +257,12 @@ public String visit(MultiOrList expr, EmptyVisitationContext context) throws Run
     return sb.toString();
   }
 
+  @Override
+  public String visit(Expression.NestedList expr, EmptyVisitationContext context)
+      throws RuntimeException {
+    return "<NestedList>";
+  }
+
   @Override
   public String visit(FieldReference expr, EmptyVisitationContext context) throws RuntimeException {
     StringBuilder sb = new StringBuilder("FieldRef#");

isthmus/src/main/java/io/substrait/isthmus/NestedFunctions.java

@@ -0,0 +1,19 @@
+package io.substrait.isthmus;
+
+import org.apache.calcite.sql.SqlFunction;
+import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+/** Substrait-specific extension function for the Expression Nested List type */
+public class NestedFunctions {
+
+  public static final SqlFunction NESTED_LIST =
+      new SqlFunction(
+          "nested_list",
+          SqlKind.OTHER_FUNCTION,
+          ReturnTypes.BOOLEAN,
+          null,
+          null,
+          SqlFunctionCategory.USER_DEFINED_FUNCTION);
+}

isthmus/src/main/java/io/substrait/isthmus/SubstraitRelVisitor.java

@@ -179,6 +179,10 @@ public Rel visit(org.apache.calcite.rel.core.Project project) {
             .map(this::toExpression)
             .collect(java.util.stream.Collectors.toList());
 
+    //    if there is no input fields, don’t put a remapping on it
+    if (project.getInput().getRowType().getFieldCount() == 0) {
+      return Project.builder().expressions(expressions).input(apply(project.getInput())).build();
+    }
     // todo: eliminate excessive projects. This should be done by converting rexinputrefs to remaps.
     return Project.builder()
         .remap(

isthmus/src/main/java/io/substrait/isthmus/calcite/SubstraitOperatorTable.java

@@ -1,6 +1,7 @@
 package io.substrait.isthmus.calcite;
 
 import io.substrait.isthmus.AggregateFunctions;
+import io.substrait.isthmus.NestedFunctions;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Set;
@@ -34,7 +35,8 @@ public class SubstraitOperatorTable implements SqlOperatorTable {
               AggregateFunctions.MIN,
               AggregateFunctions.AVG,
               AggregateFunctions.SUM,
-              AggregateFunctions.SUM0));
+              AggregateFunctions.SUM0,
+              NestedFunctions.NESTED_LIST));
 
   // SQL Kinds for which Substrait specific operators are provided
   private static final Set<SqlKind> OVERRIDE_KINDS =

isthmus/src/main/java/io/substrait/isthmus/expression/CallConverters.java

@@ -141,7 +141,8 @@ public static List<CallConverter> defaults(TypeConverter typeConverter) {
         CallConverters.CASE,
         CallConverters.CAST.apply(typeConverter),
         CallConverters.REINTERPRET.apply(typeConverter),
-        new LiteralConstructorConverter(typeConverter));
+        new LiteralConstructorConverter(typeConverter),
+        new NestedExpressionConverter());
   }
 
   public interface SimpleCallConverter extends CallConverter {

isthmus/src/main/java/io/substrait/isthmus/expression/ExpressionRexConverter.java

@@ -19,6 +19,7 @@
 import io.substrait.expression.FunctionArg;
 import io.substrait.expression.WindowBound;
 import io.substrait.extension.SimpleExtension;
+import io.substrait.isthmus.NestedFunctions;
 import io.substrait.isthmus.SubstraitRelNodeConverter;
 import io.substrait.isthmus.SubstraitRelNodeConverter.Context;
 import io.substrait.isthmus.TypeConverter;
@@ -320,6 +321,13 @@ public RexNode visit(Expression.ListLiteral expr, Context context) throws Runtim
     return rexBuilder.makeCall(SqlStdOperatorTable.ARRAY_VALUE_CONSTRUCTOR, args);
   }
 
+  @Override
+  public RexNode visit(Expression.NestedList expr, Context context) {
+    List<RexNode> args =
+        expr.values().stream().map(e -> e.accept(this, context)).collect(Collectors.toList());
+    return rexBuilder.makeCall(NestedFunctions.NESTED_LIST, args);
+  }
+
   @Override
   public RexNode visit(Expression.EmptyListLiteral expr, Context context) throws RuntimeException {
     RelDataType calciteType = typeConverter.toCalcite(typeFactory, expr.getType());

isthmus/src/main/java/io/substrait/isthmus/expression/NestedExpressionConverter.java

@@ -0,0 +1,33 @@
+package io.substrait.isthmus.expression;
+
+import io.substrait.expression.Expression;
+import io.substrait.isthmus.CallConverter;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexNode;
+
+public class NestedExpressionConverter implements CallConverter {
+
+  public NestedExpressionConverter() {}
+
+  @Override
+  public Optional<Expression> convert(
+      RexCall call, Function<RexNode, Expression> topLevelConverter) {
+
+    if (!call.getOperator().getName().equals("nested_list")) {
+      return Optional.empty();
+    }
+
+    List<Expression> values =
+        call.operands.stream().map(topLevelConverter).collect(Collectors.toList());
+
+    return Optional.of(
+        Expression.NestedList.builder()
+            .nullable(call.getType().isNullable())
+            .values(values)
+            .build());
+  }
+}