kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From danburk...@apache.org
Subject [2/2] kudu git commit: [java-client] IN-list predicate
Date Thu, 29 Sep 2016 01:31:00 GMT
[java-client] IN-list predicate

Change-Id: Ia556196963153f9db64d67bc699f96cb920ecac6
Reviewed-on: http://gerrit.cloudera.org:8080/4530
Tested-by: Kudu Jenkins
Reviewed-by: Jean-Daniel Cryans <jdcryans@apache.org>


Project: http://git-wip-us.apache.org/repos/asf/kudu/repo
Commit: http://git-wip-us.apache.org/repos/asf/kudu/commit/cb92799b
Tree: http://git-wip-us.apache.org/repos/asf/kudu/tree/cb92799b
Diff: http://git-wip-us.apache.org/repos/asf/kudu/diff/cb92799b

Branch: refs/heads/master
Commit: cb92799baf195d70b80535d11e54447e25b71c42
Parents: 9b50bd5
Author: Dan Burkert <dan@cloudera.com>
Authored: Fri Sep 23 13:50:58 2016 -0700
Committer: Dan Burkert <dan@cloudera.com>
Committed: Thu Sep 29 01:30:31 2016 +0000

----------------------------------------------------------------------
 .../org/apache/kudu/client/KuduPredicate.java   | 298 ++++++++++++++++---
 .../org/apache/kudu/client/PartitionPruner.java |  19 +-
 .../org/apache/kudu/client/TestKuduClient.java  |  17 ++
 .../apache/kudu/client/TestKuduPredicate.java   | 206 +++++++++++++
 .../apache/kudu/client/TestPartitionPruner.java | 192 +++++++-----
 5 files changed, 615 insertions(+), 117 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/kudu/blob/cb92799b/java/kudu-client/src/main/java/org/apache/kudu/client/KuduPredicate.java
----------------------------------------------------------------------
diff --git a/java/kudu-client/src/main/java/org/apache/kudu/client/KuduPredicate.java b/java/kudu-client/src/main/java/org/apache/kudu/client/KuduPredicate.java
index 03a6004..a78d63d 100644
--- a/java/kudu-client/src/main/java/org/apache/kudu/client/KuduPredicate.java
+++ b/java/kudu-client/src/main/java/org/apache/kudu/client/KuduPredicate.java
@@ -18,6 +18,7 @@
 package org.apache.kudu.client;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Joiner;
 import com.google.common.base.Objects;
 import com.google.common.base.Preconditions;
 import com.google.common.primitives.UnsignedBytes;
@@ -30,7 +31,13 @@ import org.apache.kudu.Type;
 import org.apache.kudu.annotations.InterfaceAudience;
 import org.apache.kudu.annotations.InterfaceStability;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
 
 /**
  * A predicate which can be used to filter rows based on the value of a column.
@@ -52,6 +59,8 @@ public class KuduPredicate {
     RANGE,
     /** A predicate which filters all null rows. */
     IS_NOT_NULL,
+    /** A predicate which filters all rows not matching a list of values. */
+    IN_LIST,
   }
 
   /**
@@ -79,6 +88,9 @@ public class KuduPredicate {
   /** The exclusive upper bound value if this is a Range predicate. */
   private final byte[] upper;
 
+  /** IN-list values. */
+  private final byte[][] inListValues;
+
   /**
    * Creates a new {@code KuduPredicate} on a boolean column.
    * @param column the column schema
@@ -316,6 +328,80 @@ public class KuduPredicate {
   }
 
   /**
+   * Creates a new IN list predicate.
+   *
+   * The list must contain values of the correct type for the column.
+   *
+   * @param column the column that the predicate applies to
+   * @param values list of values which the column values must match
+   * @param <T> the type of values, must match the type of the column
+   * @return an IN list predicate
+   */
+  public static <T> KuduPredicate newInListPredicate(final ColumnSchema column, List<T> values) {
+    if (values.isEmpty()) return none(column);
+    T t = values.get(0);
+
+    SortedSet<byte[]> vals = new TreeSet<>(new Comparator<byte[]>() {
+      @Override
+      public int compare(byte[] a, byte[] b) {
+        return KuduPredicate.compare(column, a, b);
+      }
+    });
+
+    if (t instanceof Boolean) {
+      checkColumn(column, Type.BOOL);
+      for (T value : values) {
+        vals.add(Bytes.fromBoolean((Boolean) value));
+      }
+    } else if (t instanceof Byte) {
+      checkColumn(column, Type.INT8);
+      for (T value : values) {
+        vals.add(new byte[] {(Byte) value});
+      }
+    } else if (t instanceof Short) {
+      checkColumn(column, Type.INT16);
+      for (T value : values) {
+        vals.add(Bytes.fromShort((Short) value));
+      }
+    } else if (t instanceof Integer) {
+      checkColumn(column, Type.INT32);
+      for (T value : values) {
+        vals.add(Bytes.fromInt((Integer) value));
+      }
+    } else if (t instanceof Long) {
+      checkColumn(column, Type.INT64, Type.UNIXTIME_MICROS);
+      for (T value : values) {
+        vals.add(Bytes.fromLong((Long) value));
+      }
+    } else if (t instanceof Float) {
+      checkColumn(column, Type.FLOAT);
+      for (T value : values) {
+        vals.add(Bytes.fromFloat((Float) value));
+      }
+    } else if (t instanceof Double) {
+      checkColumn(column, Type.DOUBLE);
+      for (T value : values) {
+        vals.add(Bytes.fromDouble((Double) value));
+      }
+    } else if (t instanceof String) {
+      checkColumn(column, Type.STRING);
+      for (T value : values) {
+        vals.add(Bytes.fromString((String) value));
+      }
+    } else if (t instanceof byte[]) {
+      checkColumn(column, Type.BINARY);
+      for (T value : values) {
+        vals.add((byte[]) value);
+      }
+    } else {
+      throw new IllegalArgumentException(String.format("illegal type for IN list values: %s",
+                                                       t.getClass().getName()));
+    }
+
+    return buildInList(column, vals);
+  }
+
+  /**
    * @param type the predicate type
    * @param column the column to which the predicate applies
    * @param lower the lower bound serialized value if this is a Range predicate,
@@ -328,6 +414,20 @@ public class KuduPredicate {
     this.column = column;
     this.lower = lower;
     this.upper = upper;
+    this.inListValues = null;
+  }
+
+  /**
+   * Constructor for IN list predicate.
+   * @param column the column to which the predicate applies
+   * @param inListValues the encoded IN list values
+   */
+  private KuduPredicate(ColumnSchema column, byte[][] inListValues) {
+    this.column = column;
+    this.type = PredicateType.IN_LIST;
+    this.lower = null;
+    this.upper = null;
+    this.inListValues = inListValues;
   }
 
   /**
@@ -367,57 +467,132 @@ public class KuduPredicate {
   KuduPredicate merge(KuduPredicate other) {
     Preconditions.checkArgument(column.equals(other.column),
                                 "predicates from different columns may not be merged");
-    if (type == PredicateType.NONE || other.type == PredicateType.NONE) {
-      return none(column);
-    }
 
-    if (type == PredicateType.IS_NOT_NULL) {
-      // NOT NULL is less selective than all other predicate types, so the
-      // intersection of NOT NULL with any other predicate is just the other
-      // predicate.
-      //
-      // Note: this will no longer be true when an IS NULL predicate type is
-      // added.
-      return other;
-    }
+    // NONE predicates dominate.
+    if (other.type == PredicateType.NONE) return other;
+
+    // NOT NULL is dominated by all other predicates.
+    // Note: this will no longer be true when an IS NULL predicate type is
+    // added.
+    if (other.type == PredicateType.IS_NOT_NULL) return this;
 
-    if (type == PredicateType.EQUALITY) {
-      if (other.type == PredicateType.EQUALITY) {
-        if (compare(lower, other.lower) != 0) {
-          return none(this.column);
+    switch (type) {
+      case NONE: return this;
+      case IS_NOT_NULL: return other;
+      case EQUALITY: {
+        if (other.type == PredicateType.EQUALITY) {
+          if (compare(column, lower, other.lower) != 0) {
+            return none(this.column);
+          } else {
+            return this;
+          }
+        } else if (other.type == PredicateType.RANGE) {
+          if (other.rangeContains(lower)) {
+            return this;
+          } else {
+            return none(this.column);
+          }
         } else {
-          return this;
+          Preconditions.checkState(other.type == PredicateType.IN_LIST);
+          return other.merge(this);
         }
-      } else {
-        if ((other.lower == null || compare(lower, other.lower) >= 0) &&
-            (other.upper == null || compare(lower, other.upper) < 0)) {
-          return this;
+      }
+      case RANGE: {
+        if (other.type == PredicateType.EQUALITY || other.type == PredicateType.IN_LIST) {
+          return other.merge(this);
         } else {
-          return none(this.column);
+          Preconditions.checkState(other.type == PredicateType.RANGE);
+          byte[] newLower = other.lower == null ||
+              (lower != null && compare(column, lower, other.lower) >= 0) ? lower : other.lower;
+          byte[] newUpper = other.upper == null ||
+              (upper != null && compare(column, upper, other.upper) <= 0) ? upper : other.upper;
+          if (newLower != null && newUpper != null && compare(column, newLower, newUpper) >= 0) {
+            return none(column);
+          } else {
+            if (newLower != null && newUpper != null && areConsecutive(newLower, newUpper)) {
+              return new KuduPredicate(PredicateType.EQUALITY, column, newLower, null);
+            } else {
+              return new KuduPredicate(PredicateType.RANGE, column, newLower, newUpper);
+            }
+          }
         }
       }
-    } else {
-      if (other.type == PredicateType.EQUALITY) {
-        return other.merge(this);
-      } else {
-        byte[] newLower = other.lower == null ||
-            (lower != null && compare(lower, other.lower) >= 0) ? lower : other.lower;
-        byte[] newUpper = other.upper == null ||
-            (upper != null && compare(upper, other.upper) <= 0) ? upper : other.upper;
-        if (newLower != null && newUpper != null && compare(newLower, newUpper) >= 0) {
-          return none(column);
-        } else {
-          if (newLower != null && newUpper != null && areConsecutive(newLower, newUpper)) {
-            return new KuduPredicate(PredicateType.EQUALITY, column, newLower, null);
+      case IN_LIST: {
+        if (other.type == PredicateType.EQUALITY) {
+          if (this.inListContains(other.lower)) {
+            return other;
           } else {
-            return new KuduPredicate(PredicateType.RANGE, column, newLower, newUpper);
+            return none(column);
+          }
+        } else if (other.type == PredicateType.RANGE) {
+          List<byte[]> values = new ArrayList<>();
+          for (byte[] value : inListValues) {
+            if (other.rangeContains(value)) {
+              values.add(value);
+            }
           }
+          return buildInList(column, values);
+        } else {
+          Preconditions.checkState(other.type == PredicateType.IN_LIST);
+          List<byte[]> values = new ArrayList<>();
+          for (byte[] value : inListValues) {
+            if (other.inListContains(value)) {
+              values.add(value);
+            }
+          }
+          return buildInList(column, values);
         }
       }
+      default: throw new IllegalStateException(String.format("unknown predicate type %s", this));
     }
   }
 
   /**
+   * Builds an IN list predicate from a collection of raw values. The collection
+   * must be sorted and deduplicated.
+   *
+   * @param column the column
+   * @param values the IN list values
+   * @return an IN list predicate
+   */
+  private static KuduPredicate buildInList(ColumnSchema column, Collection<byte[]> values) {
+    // IN (true, false) predicates can be simplified to IS NOT NULL.
+    if (column.getType().getDataType() == Common.DataType.BOOL && values.size() > 1) {
+      return KuduPredicate.newIsNotNullPredicate(column);
+    }
+
+    switch (values.size()) {
+      case 0: return KuduPredicate.none(column);
+      case 1: return new KuduPredicate(PredicateType.EQUALITY, column,
+                                       values.iterator().next(), null);
+      default: return new KuduPredicate(column, values.toArray(new byte[values.size()][]));
+    }
+  }
+
+  /**
+   * @param value the value to check for
+   * @return {@code true} if this IN list predicate contains the value
+   */
+  boolean inListContains(byte[] value) {
+    final Comparator<byte[]> comparator = new Comparator<byte[]>() {
+      @Override
+      public int compare(byte[] a, byte[] b) {
+        return KuduPredicate.compare(column, a, b);
+      }
+    };
+    return Arrays.binarySearch(inListValues, value, comparator) >= 0;
+  }
+
+  /**
+   * @param value the value to check
+   * @return {@code true} if this RANGE predicate contains the value
+   */
+  boolean rangeContains(byte[] value) {
+    return (lower == null || compare(column, value, lower) >= 0) &&
+           (upper == null || compare(column, value, upper) < 0);
+  }
+
+  /**
    * @return the schema of the predicate column
    */
   ColumnSchema getColumn() {
@@ -426,7 +601,7 @@ public class KuduPredicate {
 
   /**
    * Convert the predicate to the protobuf representation.
-   * @return the protobuf message for this predicate.
+   * @return the protobuf message for this predicate
    */
   @InterfaceAudience.Private
   public Common.ColumnPredicatePB toPB() {
@@ -452,6 +627,13 @@ public class KuduPredicate {
         builder.setIsNotNull(builder.getIsNotNullBuilder());
         break;
       }
+      case IN_LIST: {
+        Common.ColumnPredicatePB.InList.Builder inListBuilder = builder.getInListBuilder();
+        for (byte[] value : inListValues) {
+          inListBuilder.addValues(ByteString.copyFrom(value));
+        }
+        break;
+      }
       case NONE: throw new IllegalStateException(
           "can not convert None predicate to protobuf message");
       default: throw new IllegalArgumentException(
@@ -466,7 +648,7 @@ public class KuduPredicate {
    */
   @InterfaceAudience.Private
   public static KuduPredicate fromPB(Schema schema, Common.ColumnPredicatePB pb) {
-    ColumnSchema column = schema.getColumn(pb.getColumn());
+    final ColumnSchema column = schema.getColumn(pb.getColumn());
     switch (pb.getPredicateCase()) {
       case EQUALITY:
         return new KuduPredicate(PredicateType.EQUALITY, column,
@@ -479,18 +661,34 @@ public class KuduPredicate {
       }
       case IS_NOT_NULL:
         return newIsNotNullPredicate(column);
+      case IN_LIST: {
+        Common.ColumnPredicatePB.InList inList = pb.getInList();
+
+        SortedSet<byte[]> values = new TreeSet<>(new Comparator<byte[]>() {
+          @Override
+          public int compare(byte[] a, byte[] b) {
+            return KuduPredicate.compare(column, a, b);
+          }
+        });
+
+        for (ByteString value : inList.getValuesList()) {
+          values.add(value.toByteArray());
+        }
+        return buildInList(column, values);
+      }
       default:
         throw new IllegalArgumentException("unknown predicate type");
     }
   }
 
   /**
-   * Compares two bounds based on the type of this predicate's column.
+   * Compares two bounds based on the type of the column.
+   * @param column the column which the values belong to
    * @param a the first serialized value
    * @param b the second serialized value
    * @return the comparison of the serialized values based on the column type
    */
-  private int compare(byte[] a, byte[] b) {
+  private static int compare(ColumnSchema column, byte[] a, byte[] b) {
     switch (column.getType().getDataType()) {
       case BOOL:
         return Boolean.compare(Bytes.getBoolean(a), Bytes.getBoolean(b));
@@ -583,6 +781,13 @@ public class KuduPredicate {
   }
 
   /**
+   * @return the IN list values. Always kept sorted and de-duplicated.
+   */
+  byte[][] getInListValues() {
+    return inListValues;
+  }
+
+  /**
    * Returns the maximum value for the integer type.
    * @param type an integer type
    * @return the maximum value
@@ -674,6 +879,13 @@ public class KuduPredicate {
                                column.getName(), valueToString(upper));
         }
       }
+      case IN_LIST: {
+        List<String> strings = new ArrayList<>(inListValues.length);
+        for (byte[] value : inListValues) {
+          strings.add(valueToString(value));
+        }
+        return String.format("`%s` IN (%s)", column.getName(), Joiner.on(", ").join(strings));
+      }
       case IS_NOT_NULL: return String.format("`%s` IS NOT NULL", column.getName());
       case NONE: return String.format("`%s` NONE", column.getName());
       default: throw new IllegalArgumentException(String.format("unknown predicate type %s", type));
@@ -688,11 +900,13 @@ public class KuduPredicate {
     return type == that.type &&
         column.equals(that.column) &&
         Arrays.equals(lower, that.lower) &&
-        Arrays.equals(upper, that.upper);
+        Arrays.equals(upper, that.upper) &&
+        Arrays.deepEquals(inListValues, that.inListValues);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hashCode(type, column, Arrays.hashCode(lower), Arrays.hashCode(upper));
+    return Objects.hashCode(type, column, Arrays.hashCode(lower),
+                            Arrays.hashCode(upper), Arrays.deepHashCode(inListValues));
   }
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/cb92799b/java/kudu-client/src/main/java/org/apache/kudu/client/PartitionPruner.java
----------------------------------------------------------------------
diff --git a/java/kudu-client/src/main/java/org/apache/kudu/client/PartitionPruner.java b/java/kudu-client/src/main/java/org/apache/kudu/client/PartitionPruner.java
index 910083f..59c85d5 100644
--- a/java/kudu-client/src/main/java/org/apache/kudu/client/PartitionPruner.java
+++ b/java/kudu-client/src/main/java/org/apache/kudu/client/PartitionPruner.java
@@ -373,7 +373,12 @@ public class PartitionPruner {
           row.setRaw(idx, predicate.getLower());
           pushedPredicates++;
           break;
-        case IS_NOT_NULL: break loop;
+        case IS_NOT_NULL:
+          break loop;
+        case IN_LIST:
+          row.setRaw(idx, predicate.getInListValues()[0]);
+          pushedPredicates++;
+          break;
         default:
           throw new IllegalArgumentException(
               String.format("unexpected predicate type can not be pushed into key: %s", predicate));
@@ -435,6 +440,13 @@ public class PartitionPruner {
           break loop;
         case IS_NOT_NULL:
           break loop;
+        case IN_LIST: {
+          byte[][] values = predicate.getInListValues();
+          row.setRaw(idx, values[values.length - 1]);
+          pushedPredicates++;
+          finalPredicate = predicate;
+          break;
+        }
         default:
           throw new IllegalArgumentException(
               String.format("unexpected predicate type can not be pushed into key: %s", predicate));
@@ -444,9 +456,10 @@ public class PartitionPruner {
     // If no predicates were pushed, no need to do any more work.
     if (pushedPredicates == 0) return AsyncKuduClient.EMPTY_ARRAY;
 
-    // Step 2: If the final predicate is an equality predicate, increment the
+    // Step 2: If the final predicate is an equality or IN-list predicate, increment the
     // key to convert it to an exclusive upper bound.
-    if (finalPredicate.getType() == KuduPredicate.PredicateType.EQUALITY) {
+    if (finalPredicate.getType() == KuduPredicate.PredicateType.EQUALITY ||
+        finalPredicate.getType() == KuduPredicate.PredicateType.IN_LIST) {
       incrementKey(row, rangePartitionColumnIdxs.subList(0, pushedPredicates));
     }
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/cb92799b/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduClient.java
----------------------------------------------------------------------
diff --git a/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduClient.java b/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduClient.java
index e59ea8e..d78a433 100644
--- a/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduClient.java
+++ b/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduClient.java
@@ -337,6 +337,23 @@ public class TestKuduClient extends BaseKuduTest {
        KuduPredicate.newIsNotNullPredicate(schema.getColumn("c2")),
        KuduPredicate.newIsNotNullPredicate(schema.getColumn("key"))
     ).size());
+
+    // IN list
+    assertEquals(3, scanTableToStrings(table,
+       KuduPredicate.newInListPredicate(schema.getColumn("key"),
+                                        ImmutableList.of("key_30", "key_01", "invalid", "key_99"))
+    ).size());
+    assertEquals(3, scanTableToStrings(table,
+       KuduPredicate.newInListPredicate(schema.getColumn("c2"),
+                                        ImmutableList.of("c2_30", "c2_1", "invalid", "c2_99"))
+    ).size());
+    assertEquals(2, scanTableToStrings(table,
+       KuduPredicate.newInListPredicate(schema.getColumn("c2"),
+                                        ImmutableList.of("c2_30", "c2_1", "invalid", "c2_99")),
+       KuduPredicate.newIsNotNullPredicate(schema.getColumn("c2")),
+       KuduPredicate.newInListPredicate(schema.getColumn("key"),
+                                        ImmutableList.of("key_30", "key_45", "invalid", "key_99"))
+    ).size());
   }
 
   /**

http://git-wip-us.apache.org/repos/asf/kudu/blob/cb92799b/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduPredicate.java
----------------------------------------------------------------------
diff --git a/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduPredicate.java b/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduPredicate.java
index 3ad39fe..785594f 100644
--- a/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduPredicate.java
+++ b/java/kudu-client/src/test/java/org/apache/kudu/client/TestKuduPredicate.java
@@ -18,11 +18,15 @@
 package org.apache.kudu.client;
 
 import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
 import org.junit.Assert;
 import org.junit.Test;
 import org.apache.kudu.ColumnSchema;
 import org.apache.kudu.Type;
 
+import java.util.Arrays;
+
 import static org.apache.kudu.client.KuduPredicate.ComparisonOp.EQUAL;
 import static org.apache.kudu.client.KuduPredicate.ComparisonOp.GREATER;
 import static org.apache.kudu.client.KuduPredicate.ComparisonOp.GREATER_EQUAL;
@@ -64,6 +68,18 @@ public class TestKuduPredicate {
     return new KuduPredicate(RANGE, intCol, Bytes.fromInt(lower), Bytes.fromInt(upper));
   }
 
+  private static KuduPredicate intInList(Integer... values) {
+    return KuduPredicate.newInListPredicate(intCol, Arrays.asList(values));
+  }
+
+  private static KuduPredicate boolInList(Boolean... values) {
+    return KuduPredicate.newInListPredicate(boolCol, Arrays.asList(values));
+  }
+
+  private static KuduPredicate stringInList(String... values) {
+    return KuduPredicate.newInListPredicate(stringCol, Arrays.asList(values));
+  }
+
   private void testMerge(KuduPredicate a,
                          KuduPredicate b,
                          KuduPredicate expected) {
@@ -351,6 +367,113 @@ public class TestKuduPredicate {
               KuduPredicate.newComparisonPredicate(intCol, EQUAL, 7),
               KuduPredicate.none(intCol));
 
+    // IN list + IN list
+
+    // | | |
+    //   | | |
+    testMerge(intInList(0, 10, 20),
+              intInList(20, 10, 20, 30),
+              intInList(10, 20));
+
+    // |   |
+    //    | |
+    testMerge(intInList(0, 20),
+              intInList(15, 30),
+              KuduPredicate.none(intCol));
+
+    // IN list + NOT NULL
+    testMerge(intInList(10),
+              KuduPredicate.newIsNotNullPredicate(intCol),
+              KuduPredicate.newComparisonPredicate(intCol, EQUAL, 10));
+
+    testMerge(intInList(10, -100),
+              KuduPredicate.newIsNotNullPredicate(intCol),
+              intInList(-100, 10));
+
+    // IN list + Equality
+
+    // | | |
+    //   |
+    // =
+    //   |
+    testMerge(intInList(0, 10, 20),
+              KuduPredicate.newComparisonPredicate(intCol, EQUAL, 10),
+              KuduPredicate.newComparisonPredicate(intCol, EQUAL, 10));
+
+    // | | |
+    //       |
+    // =
+    // none
+    testMerge(intInList(0, 10, 20),
+              KuduPredicate.newComparisonPredicate(intCol, EQUAL, 30),
+              KuduPredicate.none(intCol));
+
+    // IN list + Range
+
+    // | | | | |
+    //   [---)
+    // =
+    //   | |
+    testMerge(intInList(0, 10, 20, 30, 40),
+              intRange(10, 30),
+              intInList(10, 20));
+
+    // | |   | |
+    //    [--)
+    // =
+    // none
+    testMerge(intInList(0, 10, 20, 30),
+              intRange(25, 30),
+              KuduPredicate.none(intCol));
+
+    // | | | |
+    //    [------>
+    // =
+    //   | |
+    testMerge(intInList(0, 10, 20, 30),
+              KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 15),
+              intInList(20, 30));
+
+    // | | |
+    //    [------>
+    // =
+    //     |
+    testMerge(intInList(0, 10, 20),
+              KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 15),
+              KuduPredicate.newComparisonPredicate(intCol, EQUAL, 20));
+
+    // | |
+    //    [------>
+    // =
+    // none
+    testMerge(intInList(0, 10),
+              KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 15),
+              KuduPredicate.none(intCol));
+
+    // | | | |
+    // <--)
+    // =
+    // | |
+    testMerge(intInList(0, 10, 20, 30),
+              KuduPredicate.newComparisonPredicate(intCol, LESS, 15),
+              intInList(0, 10));
+
+    // |  | |
+    // <--)
+    // =
+    // |
+    testMerge(intInList(0, 10, 20),
+              KuduPredicate.newComparisonPredicate(intCol, LESS, 10),
+              KuduPredicate.newComparisonPredicate(intCol, EQUAL, 0));
+
+    //      | |
+    // <--)
+    // =
+    // none
+    testMerge(intInList(10, 20),
+              KuduPredicate.newComparisonPredicate(intCol, LESS, 5),
+              KuduPredicate.none(intCol));
+
     // None
 
     // None AND
@@ -431,6 +554,22 @@ public class TestKuduPredicate {
               KuduPredicate.newComparisonPredicate(stringCol, LESS, "a\0\0"),
               new KuduPredicate(RANGE, stringCol,
                                 Bytes.fromString("a"), Bytes.fromString("a\0\0")));
+
+    //     [----->
+    //   | | | |
+    // =
+    //     [--)
+    testMerge(KuduPredicate.newComparisonPredicate(stringCol, GREATER_EQUAL, "a"),
+              stringInList("a", "c", "b", ""),
+              stringInList("a", "b", "c"));
+
+    //   IS NOT NULL
+    //   | | | |
+    // =
+    //     [--)
+    testMerge(KuduPredicate.newIsNotNullPredicate(stringCol),
+              stringInList("a", "c", "b", ""),
+              stringInList("", "a", "b", "c"));
   }
 
   @Test
@@ -467,6 +606,21 @@ public class TestKuduPredicate {
     // b <= true
     Assert.assertEquals(KuduPredicate.newIsNotNullPredicate(boolCol),
                         KuduPredicate.newComparisonPredicate(boolCol, LESS_EQUAL, true));
+
+    // b IN ()
+    Assert.assertEquals(KuduPredicate.none(boolCol), boolInList());
+
+    // b IN (true)
+    Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, true),
+                        boolInList(true, true, true));
+
+    // b IN (false)
+    Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, false),
+                        boolInList(false));
+
+    // b IN (false, true)
+    Assert.assertEquals(KuduPredicate.newIsNotNullPredicate(boolCol),
+                        boolInList(false, true, false, true));
   }
 
   /**
@@ -493,6 +647,10 @@ public class TestKuduPredicate {
                                 new byte[] { (byte) 0 },
                                 new byte[] { (byte) 10 }));
 
+    testMerge(KuduPredicate.newInListPredicate(byteCol, ImmutableList.of((byte) 12, (byte) 14, (byte) 16, (byte) 18)),
+              KuduPredicate.newInListPredicate(byteCol, ImmutableList.of((byte) 14, (byte) 18, (byte) 20)),
+              KuduPredicate.newInListPredicate(byteCol, ImmutableList.of((byte) 14, (byte) 18)));
+
     testMerge(KuduPredicate.newComparisonPredicate(shortCol, GREATER_EQUAL, 0),
               KuduPredicate.newComparisonPredicate(shortCol, LESS, 10),
               new KuduPredicate(RANGE,
@@ -500,6 +658,10 @@ public class TestKuduPredicate {
                                 Bytes.fromShort((short) 0),
                                 Bytes.fromShort((short) 10)));
 
+    testMerge(KuduPredicate.newInListPredicate(shortCol, ImmutableList.of((short) 12, (short) 14, (short) 16, (short) 18)),
+              KuduPredicate.newInListPredicate(shortCol, ImmutableList.of((short) 14, (short) 18, (short) 20)),
+              KuduPredicate.newInListPredicate(shortCol, ImmutableList.of((short) 14, (short) 18)));
+
     testMerge(KuduPredicate.newComparisonPredicate(longCol, GREATER_EQUAL, 0),
               KuduPredicate.newComparisonPredicate(longCol, LESS, 10),
               new KuduPredicate(RANGE,
@@ -507,6 +669,10 @@ public class TestKuduPredicate {
                                 Bytes.fromLong(0),
                                 Bytes.fromLong(10)));
 
+    testMerge(KuduPredicate.newInListPredicate(longCol, ImmutableList.of(12L, 14L, 16L, 18L)),
+              KuduPredicate.newInListPredicate(longCol, ImmutableList.of(14L, 18L, 20L)),
+              KuduPredicate.newInListPredicate(longCol, ImmutableList.of(14L, 18L)));
+
     testMerge(KuduPredicate.newComparisonPredicate(floatCol, GREATER_EQUAL, 123.45f),
               KuduPredicate.newComparisonPredicate(floatCol, LESS, 678.90f),
               new KuduPredicate(RANGE,
@@ -514,6 +680,10 @@ public class TestKuduPredicate {
                                 Bytes.fromFloat(123.45f),
                                 Bytes.fromFloat(678.90f)));
 
+    testMerge(KuduPredicate.newInListPredicate(floatCol, ImmutableList.of(12f, 14f, 16f, 18f)),
+              KuduPredicate.newInListPredicate(floatCol, ImmutableList.of(14f, 18f, 20f)),
+              KuduPredicate.newInListPredicate(floatCol, ImmutableList.of(14f, 18f)));
+
     testMerge(KuduPredicate.newComparisonPredicate(doubleCol, GREATER_EQUAL, 123.45),
               KuduPredicate.newComparisonPredicate(doubleCol, LESS, 678.90),
               new KuduPredicate(RANGE,
@@ -521,6 +691,10 @@ public class TestKuduPredicate {
                                 Bytes.fromDouble(123.45),
                                 Bytes.fromDouble(678.90)));
 
+    testMerge(KuduPredicate.newInListPredicate(doubleCol, ImmutableList.of(12d, 14d, 16d, 18d)),
+              KuduPredicate.newInListPredicate(doubleCol, ImmutableList.of(14d, 18d, 20d)),
+              KuduPredicate.newInListPredicate(doubleCol, ImmutableList.of(14d, 18d)));
+
     testMerge(KuduPredicate.newComparisonPredicate(binaryCol, GREATER_EQUAL,
                                                    new byte[] { 0, 1, 2, 3, 4, 5, 6 }),
               KuduPredicate.newComparisonPredicate(binaryCol, LESS, new byte[] { 10 }),
@@ -528,6 +702,10 @@ public class TestKuduPredicate {
                                 binaryCol,
                                 new byte[] { 0, 1, 2, 3, 4, 5, 6 },
                                 new byte[] { 10 }));
+
+    testMerge(KuduPredicate.newInListPredicate(binaryCol, ImmutableList.of("a".getBytes(), "b".getBytes(), "c".getBytes(), "d".getBytes())),
+              KuduPredicate.newInListPredicate(binaryCol, ImmutableList.of("b".getBytes(), "d".getBytes(), "e".getBytes())),
+              KuduPredicate.newInListPredicate(binaryCol, ImmutableList.of("b".getBytes(), "d".getBytes())));
   }
 
   @Test
@@ -624,5 +802,33 @@ public class TestKuduPredicate {
                         KuduPredicate.newComparisonPredicate(stringCol, EQUAL, "my string").toString());
     Assert.assertEquals("`binary` = 0xAB01CD", KuduPredicate.newComparisonPredicate(
         binaryCol, EQUAL, new byte[] { (byte) 0xAB, (byte) 0x01, (byte) 0xCD }).toString());
+    Assert.assertEquals("`int` IN (-10, 0, 10)",
+                        intInList(10, 0, -10).toString());
+    Assert.assertEquals("`string` IS NOT NULL",
+                        KuduPredicate.newIsNotNullPredicate(stringCol).toString());
+
+    Assert.assertEquals("`bool` = true", KuduPredicate.newInListPredicate(
+        boolCol, ImmutableList.of(true)).toString());
+    Assert.assertEquals("`bool` = false", KuduPredicate.newInListPredicate(
+        boolCol, ImmutableList.of(false)).toString());
+    Assert.assertEquals("`bool` IS NOT NULL", KuduPredicate.newInListPredicate(
+        boolCol, ImmutableList.of(false, true, true)).toString());
+    Assert.assertEquals("`byte` IN (1, 10, 100)", KuduPredicate.newInListPredicate(
+        byteCol, ImmutableList.of((byte) 1, (byte) 10, (byte) 100)).toString());
+    Assert.assertEquals("`short` IN (1, 10, 100)", KuduPredicate.newInListPredicate(
+        shortCol, ImmutableList.of((short) 1, (short) 100, (short) 10)).toString());
+    Assert.assertEquals("`int` IN (1, 10, 100)", KuduPredicate.newInListPredicate(
+        intCol, ImmutableList.of(1, 100, 10)).toString());
+    Assert.assertEquals("`long` IN (1, 10, 100)", KuduPredicate.newInListPredicate(
+        longCol, ImmutableList.of(1L, 100L, 10L)).toString());
+    Assert.assertEquals("`float` IN (78.9, 123.456)", KuduPredicate.newInListPredicate(
+        floatCol, ImmutableList.of(123.456f, 78.9f)).toString());
+    Assert.assertEquals("`double` IN (78.9, 123.456)", KuduPredicate.newInListPredicate(
+        doubleCol, ImmutableList.of(123.456d, 78.9d)).toString());
+    Assert.assertEquals("`string` IN (\"a\", \"my string\")",
+                        KuduPredicate.newInListPredicate(stringCol, ImmutableList.of("my string", "a")).toString());
+    Assert.assertEquals("`binary` IN (0x00, 0xAB01CD)", KuduPredicate.newInListPredicate(
+        binaryCol, ImmutableList.of(new byte[] { (byte) 0xAB, (byte) 0x01, (byte) 0xCD },
+                                    new byte[] { (byte) 0x00 })).toString());
   }
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/cb92799b/java/kudu-client/src/test/java/org/apache/kudu/client/TestPartitionPruner.java
----------------------------------------------------------------------
diff --git a/java/kudu-client/src/test/java/org/apache/kudu/client/TestPartitionPruner.java b/java/kudu-client/src/test/java/org/apache/kudu/client/TestPartitionPruner.java
index 6c3faff..3a5610f 100644
--- a/java/kudu-client/src/test/java/org/apache/kudu/client/TestPartitionPruner.java
+++ b/java/kudu-client/src/test/java/org/apache/kudu/client/TestPartitionPruner.java
@@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableList;
 import org.apache.kudu.ColumnSchema;
 import org.apache.kudu.Schema;
 import org.apache.kudu.Type;
+import org.apache.kudu.client.KuduPredicate.ComparisonOp;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -277,124 +278,144 @@ public class TestPartitionPruner extends BaseKuduTest {
 
     // c < -10
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.LESS, -10)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.LESS, -10)));
 
     // c = -10
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, -10)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, -10)));
 
     // c < 10
     assertEquals(2, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.LESS, 10)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.LESS, 10)));
 
     // c < 100
     assertEquals(3, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.LESS, 100)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.LESS, 100)));
 
 
     // c >= -10
     assertEquals(3, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, -10)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, -10)));
 
     // c >= 0
     assertEquals(3, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, -10)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, -10)));
 
     // c >= 5
     assertEquals(2, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, 5)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, 5)));
 
     // c >= 10
     assertEquals(2, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, 10)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, 10)));
 
     // c >= 100
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, 100)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, 100)));
 
     // c >= -10
     // c < 0
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, -10),
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.LESS, 0)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, -10),
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.LESS, 0)));
 
     // c >= 5
     // c < 100
     assertEquals(2, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, 5),
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.LESS, 100)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, 5),
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.LESS, 100)));
 
     // b = ""
     assertEquals(3, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.EQUAL, "")));
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.EQUAL, "")));
 
     // b >= "z"
     assertEquals(3, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.GREATER_EQUAL, "z")));
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.GREATER_EQUAL, "z")));
 
     // b < "a"
     assertEquals(3, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "a")));
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "a")));
 
     // b >= "m"
     // b < "z"
     assertEquals(3, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.GREATER_EQUAL, "m"),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "z")));
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.GREATER_EQUAL, "m"),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "z")));
 
     // c >= 10
     // b >= "r"
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, 10),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.GREATER_EQUAL, "r")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, 10),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.GREATER_EQUAL, "r")));
 
     // c >= 10
     // b < "r"
     assertEquals(2, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.GREATER_EQUAL, 10),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "r")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.GREATER_EQUAL, 10),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "r")));
 
     // c = 10
     // b < "r"
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 10),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "r")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 10),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "r")));
 
     // c < 0
     // b < "m"
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 0),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "m")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 0),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "m")));
 
     // c < 0
     // b < "z"
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.LESS, 0),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "z")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.LESS, 0),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "z")));
 
     // c = 0
     // b = "m\0"
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 0),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.EQUAL, "m\0")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 0),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.EQUAL, "m\0")));
 
     // c = 0
     // b < "m"
     assertEquals(1, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 0),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "m")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 0),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "m")));
 
     // c = 0
     // b < "m\0"
     assertEquals(2, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 0),
-        KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.LESS, "m\0")));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 0),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "m\0")));
 
     // c = 0
     // c = 2
     assertEquals(0, countPartitions(table, partitions,
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 0),
-        KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 2)));
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 0),
+        KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 2)));
+
+    // a IN (1, 2)
+    assertEquals(1, countPartitions(table, partitions,
+        KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 1, (byte) 2))));
+
+    // a IN (0, 1, 2)
+    assertEquals(2, countPartitions(table, partitions,
+        KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 0, (byte) 1, (byte) 2))));
+
+    // a IN (-10, 0)
+    // B < "m"
+    assertEquals(1, countPartitions(table, partitions,
+        KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) -10, (byte) 0)),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "m")));
+
+    // a IN (-10, 0)
+    // B < "m\0"
+    assertEquals(2, countPartitions(table, partitions,
+        KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) -10, (byte) 0)),
+        KuduPredicate.newComparisonPredicate(b, ComparisonOp.LESS, "m\0")));
   }
 
   @Test
@@ -425,41 +446,45 @@ public class TestPartitionPruner extends BaseKuduTest {
 
     // a = 0;
     assertEquals(2, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(a, KuduPredicate.ComparisonOp.EQUAL, 0)));
+          KuduPredicate.newComparisonPredicate(a, ComparisonOp.EQUAL, 0)));
 
     // a >= 0;
     assertEquals(4, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(a, KuduPredicate.ComparisonOp.GREATER_EQUAL, 0)));
+          KuduPredicate.newComparisonPredicate(a, ComparisonOp.GREATER_EQUAL, 0)));
 
     // a >= 0;
     // a < 1;
     assertEquals(2, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(a, KuduPredicate.ComparisonOp.GREATER_EQUAL, 0),
-          KuduPredicate.newComparisonPredicate(a, KuduPredicate.ComparisonOp.LESS, 1)));
+          KuduPredicate.newComparisonPredicate(a, ComparisonOp.GREATER_EQUAL, 0),
+          KuduPredicate.newComparisonPredicate(a, ComparisonOp.LESS, 1)));
 
     // a >= 0;
     // a < 2;
     assertEquals(4, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(a, KuduPredicate.ComparisonOp.GREATER_EQUAL, 0),
-          KuduPredicate.newComparisonPredicate(a, KuduPredicate.ComparisonOp.LESS, 2)));
+          KuduPredicate.newComparisonPredicate(a, ComparisonOp.GREATER_EQUAL, 0),
+          KuduPredicate.newComparisonPredicate(a, ComparisonOp.LESS, 2)));
 
     // b = 1;
     assertEquals(4, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.EQUAL, 1)));
+          KuduPredicate.newComparisonPredicate(b, ComparisonOp.EQUAL, 1)));
 
     // b = 1;
     // c = 2;
     assertEquals(2, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.EQUAL, 1),
-          KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 2)));
+          KuduPredicate.newComparisonPredicate(b, ComparisonOp.EQUAL, 1),
+          KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 2)));
 
     // a = 0;
     // b = 1;
     // c = 2;
     assertEquals(1, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(a, KuduPredicate.ComparisonOp.EQUAL, 0),
-          KuduPredicate.newComparisonPredicate(b, KuduPredicate.ComparisonOp.EQUAL, 1),
-          KuduPredicate.newComparisonPredicate(c, KuduPredicate.ComparisonOp.EQUAL, 2)));
+          KuduPredicate.newComparisonPredicate(a, ComparisonOp.EQUAL, 0),
+          KuduPredicate.newComparisonPredicate(b, ComparisonOp.EQUAL, 1),
+          KuduPredicate.newComparisonPredicate(c, ComparisonOp.EQUAL, 2)));
+
+    // a IN (0, 10)
+    assertEquals(4, countPartitions(table, partitions,
+          KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 0, (byte) 10))));
   }
 
   @Test
@@ -468,9 +493,9 @@ public class TestPartitionPruner extends BaseKuduTest {
     // (host STRING, metric STRING, timestamp UNIXTIME_MICROS, value DOUBLE)
     // PRIMARY KEY (host, metric, time)
     // DISTRIBUTE BY
-    //    RANGE(time) SPLIT ROWS [(10)],
-    //        (PARTITION       VALUES < 10,
-    //         PARTITION 10 <= VALUES);
+    //    RANGE(time)
+    //        (PARTITION VALUES < 10,
+    //         PARTITION VALUES >= 10);
     //    HASH (host, metric) 2 PARTITIONS;
 
     ColumnSchema host = new ColumnSchema.ColumnSchemaBuilder("host", Type.STRING).key(true).build();
@@ -498,55 +523,55 @@ public class TestPartitionPruner extends BaseKuduTest {
 
     // host = "a"
     assertEquals(4, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(host, KuduPredicate.ComparisonOp.EQUAL, "a")));
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a")));
 
     // host = "a"
     // metric = "a"
     assertEquals(2, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(host, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(metric, KuduPredicate.ComparisonOp.EQUAL, "a")));
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(metric, ComparisonOp.EQUAL, "a")));
 
     // host = "a"
     // metric = "a"
     // timestamp >= 9;
     assertEquals(2, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(host, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(metric, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.GREATER_EQUAL, 9)));
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(metric, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.GREATER_EQUAL, 9)));
 
     // host = "a"
     // metric = "a"
     // timestamp >= 10;
     // timestamp < 20;
     assertEquals(1, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(host, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(metric, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.GREATER_EQUAL, 10),
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.LESS, 20)));
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(metric, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.GREATER_EQUAL, 10),
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.LESS, 20)));
 
     // host = "a"
     // metric = "a"
     // timestamp < 10;
     assertEquals(1, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(host, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(metric, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.LESS, 10)));
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(metric, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.LESS, 10)));
 
     // host = "a"
     // metric = "a"
     // timestamp >= 10;
     assertEquals(1, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(host, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(metric, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.GREATER_EQUAL, 10)));
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(metric, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.GREATER_EQUAL, 10)));
 
     // host = "a"
     // metric = "a"
     // timestamp = 10;
     assertEquals(1, countPartitions(table, partitions,
-          KuduPredicate.newComparisonPredicate(host, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(metric, KuduPredicate.ComparisonOp.EQUAL, "a"),
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.EQUAL, 10)));
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(metric, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.EQUAL, 10)));
 
     // partition key < (hash=1)
     assertEquals(2, countPartitions(table, partitions, new byte[] {}, new byte[] { 0, 0, 0, 1 }));
@@ -557,11 +582,34 @@ public class TestPartitionPruner extends BaseKuduTest {
     // timestamp = 10
     // partition key < (hash=1)
     assertEquals(1, countPartitions(table, partitions, new byte[] {}, new byte[] { 0, 0, 0, 1 },
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.EQUAL, 10)));
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.EQUAL, 10)));
 
     // timestamp = 10
     // partition key >= (hash=1)
     assertEquals(1, countPartitions(table, partitions, new byte[] { 0, 0, 0, 1 }, new byte[] {},
-          KuduPredicate.newComparisonPredicate(timestamp, KuduPredicate.ComparisonOp.EQUAL, 10)));
+          KuduPredicate.newComparisonPredicate(timestamp, ComparisonOp.EQUAL, 10)));
+
+    // timestamp IN (0, 9)
+    // host = "a"
+    // metric IN ("foo", "bar")
+    //
+    // We do not prune hash partitions based on IN list predicates (yet),
+    // so the IN list on the hash columns is really just testing that it doesn't fail.
+    assertEquals(2, countPartitions(table, partitions,
+          KuduPredicate.newInListPredicate(timestamp, ImmutableList.of(0L, 9L)),
+          KuduPredicate.newComparisonPredicate(host, ComparisonOp.EQUAL, "a"),
+          KuduPredicate.newInListPredicate(metric, ImmutableList.of("foo", "bar"))));
+
+    // timestamp IN (10, 100)
+    assertEquals(2, countPartitions(table, partitions,
+          KuduPredicate.newInListPredicate(timestamp, ImmutableList.of(10L, 100L))));
+
+    // timestamp IN (9, 10)
+    assertEquals(4, countPartitions(table, partitions,
+          KuduPredicate.newInListPredicate(timestamp, ImmutableList.of(9L, 10L))));
+
+    // timestamp IS NOT NULL
+    assertEquals(4, countPartitions(table, partitions,
+          KuduPredicate.newIsNotNullPredicate(timestamp)));
   }
 }


Mime
View raw message