MR: Fix IndexOutOfBounds by skip filter translation if there are no leaves

mr/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergFilterFactory.java

@@ -79,6 +79,9 @@ private static Expression translate(ExpressionTree tree, List<PredicateLeaf> lea
       case NOT:
         return not(translate(childNodes.get(0), leaves));
       case LEAF:
+        if (tree.getLeaf() >= leaves.size()) {
+          throw new UnsupportedOperationException("No more leaves are available");
+        }
         return translateLeaf(leaves.get(tree.getLeaf()));
       case CONSTANT:
         throw new UnsupportedOperationException("CONSTANT operator is not supported");
@@ -107,6 +110,9 @@ private static Expression translateLeaf(PredicateLeaf leaf) {
         return in(column, leafToLiteralList(leaf));
       case BETWEEN:
         List<Object> icebergLiterals = leafToLiteralList(leaf);
+        if (icebergLiterals.size() < 2) {
+          throw new UnsupportedOperationException("Missing leaf literals: " + leaf);
+        }
         return and(
             greaterThanOrEqual(column, icebergLiterals.get(0)),
             lessThanOrEqual(column, icebergLiterals.get(1)));

mr/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergFilterFactory.java

@@ -24,10 +24,14 @@
 import java.sql.Date;
 import java.sql.Timestamp;
 import java.time.LocalDate;
+import java.util.Collections;
+import java.util.List;
+import org.apache.hadoop.hive.ql.io.sarg.ExpressionTree;
 import org.apache.hadoop.hive.ql.io.sarg.PredicateLeaf;
 import org.apache.hadoop.hive.ql.io.sarg.SearchArgument;
 import org.apache.hadoop.hive.ql.io.sarg.SearchArgumentFactory;
 import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+import org.apache.iceberg.AssertHelpers;
 import org.apache.iceberg.expressions.And;
 import org.apache.iceberg.expressions.Expressions;
 import org.apache.iceberg.expressions.Literal;
@@ -145,6 +149,24 @@ public void testBetweenOperand() {
     assertEquals(actual.right().op(), expected.right().op());
   }
 
+  @Test
+  public void testUnsupportedBetweenOperandEmptyLeaves() {
+    SearchArgument.Builder builder = SearchArgumentFactory.newBuilder();
+    final SearchArgument arg =
+        new MockSearchArgument(
+            builder
+                .startAnd()
+                .between("salary", PredicateLeaf.Type.LONG, 9000L, 15000L)
+                .end()
+                .build());
+
+    AssertHelpers.assertThrows(
+        "must throw if leaves are empty in between operator",
+        UnsupportedOperationException.class,
+        "Missing leaf literals",
+        () -> HiveIcebergFilterFactory.generateFilterExpression(arg));
+  }
+
   @Test
   public void testIsNullOperand() {
     SearchArgument.Builder builder = SearchArgumentFactory.newBuilder();
@@ -293,4 +315,59 @@ private void assertPredicatesMatch(UnboundPredicate expected, UnboundPredicate a
     assertEquals(expected.literal(), actual.literal());
     assertEquals(expected.ref().name(), actual.ref().name());
   }
+
+  private static class MockSearchArgument implements SearchArgument {
+
+    private final SearchArgument delegate;
+
+    MockSearchArgument(SearchArgument original) {
+      delegate = original;
+    }
+
+    @Override
+    public ExpressionTree getExpression() {
+      return delegate.getExpression();
+    }
+
+    @Override
+    public TruthValue evaluate(TruthValue[] leaves) {
+      return delegate.evaluate(leaves);
+    }
+
+    @Override
+    public List<PredicateLeaf> getLeaves() {
+      return Collections.singletonList(
+          new PredicateLeaf() {
+            @Override
+            public Operator getOperator() {
+              return Operator.BETWEEN;
+            }
+
+            @Override
+            public Type getType() {
+              return Type.LONG;
+            }
+
+            @Override
+            public String getColumnName() {
+              return "salary";
+            }
+
+            @Override
+            public Object getLiteral() {
+              return null;
+            }
+
+            @Override
+            public List<Object> getLiteralList() {
+              return Collections.emptyList();
+            }
+
+            @Override
+            public String toString() {
+              return "Leaf[empty]";
+            }
+          });
+    }
+  }
 }