encapsulate ddml validation

Author: ZorinAnton

core/src/main/java/io/substrait/util/NoException.java

@@ -0,0 +1,5 @@
+package io.substrait.util;
+
+public final class NoException extends RuntimeException {
+  private NoException() {}
+}

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

@@ -94,6 +94,7 @@ public class SubstraitRelNodeConverter
   protected final RelBuilder relBuilder;
   protected final RexBuilder rexBuilder;
   private final TypeConverter typeConverter;
+  private final SubstraitRelNodeConverterDdmlValidator substraitRelNodeConverterDdmlValidator;
 
   public SubstraitRelNodeConverter(
       SimpleExtension.ExtensionCollection extensions,
@@ -142,6 +143,7 @@ public SubstraitRelNodeConverter(
     this.aggregateFunctionConverter = aggregateFunctionConverter;
     this.expressionRexConverter = expressionRexConverter;
     this.expressionRexConverter.setRelNodeConverter(this);
+    this.substraitRelNodeConverterDdmlValidator = new SubstraitRelNodeConverterDdmlValidator(relBuilder, this);
   }
 
   public static RelNode convert(
@@ -554,8 +556,10 @@ public RelNode visit(NamedUpdate update, Context context) {
 
   @Override
   public RelNode visit(NamedDdl namedDdl, Context context) {
-    if (namedDdl.getViewDefinition().isEmpty()) {
-      throw new IllegalArgumentException("no view definition found");
+    final ValidationResult validationResult = namedDdl.accept(substraitRelNodeConverterDdmlValidator, context);
+    if (!validationResult.isValid()) {
+      throw new IllegalArgumentException(
+          String.join(System.lineSeparator(), validationResult.getMessages()));
     }
     Rel viewDefinition = namedDdl.getViewDefinition().get();
     RelNode relNode = viewDefinition.accept(this, context);
@@ -565,7 +569,6 @@ public RelNode visit(NamedDdl namedDdl, Context context) {
 
   @Override
   public RelNode visit(VirtualTableScan virtualTableScan, Context context) {
-
     final RelDataType typeInfoOnly =
         typeConverter.toCalcite(typeFactory, virtualTableScan.getInitialSchema().struct());
 
@@ -609,6 +612,11 @@ private RelNode handleCreateTableAs(NamedWrite namedWrite, Context context) {
 
   @Override
   public RelNode visit(NamedWrite write, Context context) {
+    final ValidationResult validationResult = write.accept(substraitRelNodeConverterDdmlValidator, context);
+    if (!validationResult.isValid()) {
+      throw new IllegalArgumentException(
+          String.join(System.lineSeparator(), validationResult.getMessages()));
+    }
     RelNode input = write.getInput().accept(this, context);
     assert relBuilder.getRelOptSchema() != null;
     final RelOptTable targetTable =
@@ -625,16 +633,12 @@ public RelNode visit(NamedWrite write, Context context) {
       case CTAS:
         return handleCreateTableAs(write, context);
       default:
-        throw new UnsupportedOperationException(
-            "Write operation '"
-                + write.getOperation()
-                + "' is not supported by the NamedWrite visitor. "
-                + "Check if a more specific relation type (e.g., NamedUpdate) should be used.");
+        // checked by validation
+        throw new IllegalArgumentException("Couldn't determine operation");
     }
 
-    if (targetTable == null) {
-      throw new IllegalStateException("Table not found in Calcite catalog: " + write.getNames());
-    }
+    // checked by validation
+    assert targetTable != null;
 
     return LogicalTableModify.create(
         targetTable,

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

@@ -0,0 +1,77 @@
+package io.substrait.isthmus;
+
+import io.substrait.relation.AbstractDdlRel;
+import io.substrait.relation.AbstractRelVisitor;
+import io.substrait.relation.AbstractWriteRel;
+import io.substrait.relation.NamedDdl;
+import io.substrait.relation.NamedWrite;
+import io.substrait.relation.Rel;
+import io.substrait.util.NoException;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import org.apache.calcite.tools.RelBuilder;
+
+public class SubstraitRelNodeConverterDdmlValidator
+    extends AbstractRelVisitor<ValidationResult, SubstraitRelNodeConverter.Context, NoException> {
+  private static final Set<AbstractWriteRel.WriteOp> NAMED_WRITE_OPERATIONS_SUPPORTED =
+      Set.of(
+          AbstractWriteRel.WriteOp.INSERT,
+          AbstractWriteRel.WriteOp.DELETE,
+          AbstractWriteRel.WriteOp.UPDATE,
+          AbstractWriteRel.WriteOp.CTAS);
+
+  private final RelBuilder relBuilder;
+  private final SubstraitRelNodeConverter substraitRelNodeConverter;
+
+  public SubstraitRelNodeConverterDdmlValidator(
+      final RelBuilder relBuilder, SubstraitRelNodeConverter substraitRelNodeConverter) {
+    this.relBuilder = relBuilder;
+    this.substraitRelNodeConverter = substraitRelNodeConverter;
+  }
+
+  @Override
+  public ValidationResult visitFallback(Rel rel, SubstraitRelNodeConverter.Context context) {
+    return ValidationResult.ok();
+  }
+
+  @Override
+  public ValidationResult visit(NamedDdl namedDdl, SubstraitRelNodeConverter.Context ctx) {
+    final List<String> validationMessages = new LinkedList<>();
+    if (namedDdl.getViewDefinition().isEmpty()) {
+      validationMessages.add("No view definition found");
+    }
+    if (!AbstractDdlRel.DdlObject.VIEW.equals(namedDdl.getObject())) {
+      validationMessages.add("Unsupported object: " + namedDdl.getObject().name());
+    }
+    if (!AbstractDdlRel.DdlOp.CREATE.equals(namedDdl.getOperation())) {
+      validationMessages.add("Unsupported operation: " + namedDdl.getOperation().name());
+    }
+    return validationMessages.isEmpty()
+        ? ValidationResult.SUCCESS
+        : ValidationResult.error(validationMessages);
+  }
+
+  @Override
+  public ValidationResult visit(NamedWrite namedWrite, SubstraitRelNodeConverter.Context ctx) {
+    final List<String> validationMessages = new LinkedList<>();
+    if (!NAMED_WRITE_OPERATIONS_SUPPORTED.contains(namedWrite.getOperation())) {
+      validationMessages.add(
+          "Write operation '"
+              + namedWrite.getOperation()
+              + "' is not supported by the NamedWrite visitor. "
+              + "Check if a more specific relation type (e.g., NamedUpdate) should be used.");
+    }
+    if (relBuilder.getRelOptSchema() == null
+        || relBuilder.getRelOptSchema().getTableForMember(namedWrite.getNames()) == null) {
+      validationMessages.add("Table not found in Calcite catalog: " + namedWrite.getNames());
+    }
+
+    if (namedWrite.getInput().accept(substraitRelNodeConverter, ctx) == null) {
+      validationMessages.add("Only write operations with input supported");
+    }
+    return validationMessages.isEmpty()
+        ? ValidationResult.SUCCESS
+        : ValidationResult.error(validationMessages);
+  }
+}

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

@@ -0,0 +1,30 @@
+package io.substrait.isthmus;
+
+import java.util.List;
+
+public class ValidationResult {
+  public static final ValidationResult SUCCESS = ok();
+  private final boolean isValid;
+  private final List<String> messages;
+
+  public ValidationResult(boolean isValid, List<String> messages) {
+    this.isValid = isValid;
+    this.messages = messages;
+  }
+
+  public static ValidationResult ok() {
+    return new ValidationResult(true, List.of("OK"));
+  }
+
+  public static ValidationResult error(List<String> messages) {
+    return new ValidationResult(false, messages);
+  }
+
+  public boolean isValid() {
+    return isValid;
+  }
+
+  public List<String> getMessages() {
+    return messages;
+  }
+}