You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by br...@apache.org on 2015/02/11 18:48:41 UTC

svn commit: r1659014 [12/25] - in /hive/branches/parquet: ./ beeline/src/java/org/apache/hive/beeline/ beeline/src/main/resources/ beeline/src/test/org/apache/hive/beeline/ bin/ common/src/java/org/apache/hadoop/hive/conf/ data/conf/ data/conf/spark/ d...

Modified: hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateSub.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateSub.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateSub.java (original)
+++ hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDateSub.java Wed Feb 11 17:48:36 2015
@@ -89,7 +89,7 @@ public class GenericUDFDateSub extends G
     if (arguments[1].getCategory() != ObjectInspector.Category.PRIMITIVE) {
       throw new UDFArgumentTypeException(1,
           "Only primitive type arguments are accepted but "
-              + arguments[2].getTypeName() + " is passed. as second arguments");
+              + arguments[1].getTypeName() + " is passed. as second arguments");
     }
 
     inputType1 = ((PrimitiveObjectInspector) arguments[0]).getPrimitiveCategory();

Modified: hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDecode.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDecode.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDecode.java (original)
+++ hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFDecode.java Wed Feb 11 17:48:36 2015
@@ -38,8 +38,8 @@ import org.apache.hadoop.hive.serde2.obj
 import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory;
 import org.apache.hadoop.hive.serde2.objectinspector.primitive.BinaryObjectInspector;
 import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
-import org.apache.hadoop.hive.serde2.objectinspector.primitive.StringObjectInspector;
-import org.apache.hadoop.io.Text;
+import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils;
+import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils.PrimitiveGrouping;
 
 @Description(name = "decode",
     value = "_FUNC_(bin, str) - Decode the first argument using the second argument character set",
@@ -47,35 +47,42 @@ import org.apache.hadoop.io.Text;
         "'UTF-8', 'UTF-16BE', 'UTF-16LE', and 'UTF-16'. If either argument\n" +
         "is null, the result will also be null")
 public class GenericUDFDecode extends GenericUDF {
-  private transient CharsetDecoder decoder = null;
-  private transient BinaryObjectInspector bytesOI = null;
-  private transient StringObjectInspector charsetOI = null;
+  private transient CharsetDecoder decoder;
+  private transient BinaryObjectInspector bytesOI;
+  private transient PrimitiveObjectInspector charsetOI;
 
   @Override
   public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException {
     if (arguments.length != 2) {
-      throw new UDFArgumentLengthException("Encode() requires exactly two arguments");
+      throw new UDFArgumentLengthException("Decode() requires exactly two arguments");
     }
 
     if (arguments[0].getCategory() != Category.PRIMITIVE ||
         ((PrimitiveObjectInspector)arguments[0]).getPrimitiveCategory() != PrimitiveCategory.BINARY){
-      throw new UDFArgumentTypeException(0, "The first argument to Encode() must be a binary");
+      throw new UDFArgumentTypeException(0, "The first argument to Decode() must be a binary");
     }
 
     bytesOI = (BinaryObjectInspector) arguments[0];
 
-    if (arguments[1].getCategory() != Category.PRIMITIVE ||
-        ((PrimitiveObjectInspector)arguments[1]).getPrimitiveCategory() != PrimitiveCategory.STRING){
-      throw new UDFArgumentTypeException(1, "The second argument to Encode() must be a string");
+    if (arguments[1].getCategory() != Category.PRIMITIVE) {
+      throw new UDFArgumentTypeException(1, "The second argument to Decode() must be primitive");
     }
 
-    charsetOI = (StringObjectInspector) arguments[1];
-
-    // If the character set for encoding is constant, we can optimize that
-    StringObjectInspector charSetOI = (StringObjectInspector) arguments[1];
-    if (charSetOI instanceof ConstantObjectInspector){
-      String charSetName = ((Text) ((ConstantObjectInspector) charSetOI).getWritableConstantValue()).toString();
-      decoder = Charset.forName(charSetName).newDecoder().onMalformedInput(CodingErrorAction.REPORT).onUnmappableCharacter(CodingErrorAction.REPORT);
+    charsetOI = (PrimitiveObjectInspector) arguments[1];
+
+    if (PrimitiveGrouping.STRING_GROUP != PrimitiveObjectInspectorUtils
+        .getPrimitiveGrouping(charsetOI.getPrimitiveCategory())) {
+      throw new UDFArgumentTypeException(1,
+          "The second argument to Decode() must be from string group");
+    }
+
+    // If the character set for decoding is constant, we can optimize that
+    if (arguments[1] instanceof ConstantObjectInspector) {
+      String charSetName = ((ConstantObjectInspector) arguments[1]).getWritableConstantValue()
+          .toString();
+      decoder = Charset.forName(charSetName).newDecoder()
+          .onMalformedInput(CodingErrorAction.REPORT)
+          .onUnmappableCharacter(CodingErrorAction.REPORT);
     }
 
     return (ObjectInspector) PrimitiveObjectInspectorFactory.javaStringObjectInspector;
@@ -97,7 +104,8 @@ public class GenericUDFDecode extends Ge
         throw new HiveException(e);
       }
     } else {
-      decoded = Charset.forName(charsetOI.getPrimitiveJavaObject(arguments[1].get())).decode(wrappedBytes);
+      String charSetName = PrimitiveObjectInspectorUtils.getString(arguments[1].get(), charsetOI);
+      decoded = Charset.forName(charSetName).decode(wrappedBytes);
     }
     return decoded.toString();
   }
@@ -106,7 +114,7 @@ public class GenericUDFDecode extends Ge
   public String getDisplayString(String[] children) {
     assert (children.length == 2);
     StringBuilder sb = new StringBuilder();
-    sb.append("encode(");
+    sb.append("decode(");
     sb.append(children[0]).append(",");
     sb.append(children[1]).append(")");
     return sb.toString();

Modified: hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFEncode.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFEncode.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFEncode.java (original)
+++ hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFEncode.java Wed Feb 11 17:48:36 2015
@@ -35,13 +35,10 @@ import org.apache.hadoop.hive.serde2.obj
 import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
 import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category;
 import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
-import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory;
 import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
 import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils;
 import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils.PrimitiveGrouping;
-import org.apache.hadoop.hive.serde2.objectinspector.primitive.StringObjectInspector;
 import org.apache.hadoop.io.BytesWritable;
-import org.apache.hadoop.io.Text;
 
 @Description(name = "encode",
 value = "_FUNC_(str, str) - Encode the first argument using the second argument character set",

Modified: hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFLastDay.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFLastDay.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFLastDay.java (original)
+++ hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFLastDay.java Wed Feb 11 17:48:36 2015
@@ -68,7 +68,7 @@ public class GenericUDFLastDay extends G
     }
     if (arguments[0].getCategory() != ObjectInspector.Category.PRIMITIVE) {
       throw new UDFArgumentTypeException(0, "Only primitive type arguments are accepted but "
-          + arguments[0].getTypeName() + " is passed. as first arguments");
+          + arguments[0].getTypeName() + " is passed");
     }
     inputType1 = ((PrimitiveObjectInspector) arguments[0]).getPrimitiveCategory();
     ObjectInspector outputOI = PrimitiveObjectInspectorFactory.writableStringObjectInspector;
@@ -91,9 +91,8 @@ public class GenericUDFLastDay extends G
           PrimitiveObjectInspectorFactory.writableDateObjectInspector);
       break;
     default:
-      throw new UDFArgumentException(
-          " LAST_DAY() only takes STRING/TIMESTAMP/DATEWRITABLE types as first argument, got "
-              + inputType1);
+      throw new UDFArgumentTypeException(0,
+          "LAST_DAY() only takes STRING/TIMESTAMP/DATEWRITABLE types, got " + inputType1);
     }
     return outputOI;
   }
@@ -112,23 +111,21 @@ public class GenericUDFLastDay extends G
       } catch (ParseException e) {
         return null;
       }
-      lastDay(date);
       break;
     case TIMESTAMP:
       Timestamp ts = ((TimestampWritable) timestampConverter.convert(arguments[0].get()))
           .getTimestamp();
       date = ts;
-      lastDay(date);
       break;
     case DATE:
       DateWritable dw = (DateWritable) dateWritableConverter.convert(arguments[0].get());
       date = dw.get();
-      lastDay(date);
       break;
     default:
-      throw new UDFArgumentException(
+      throw new UDFArgumentTypeException(0,
           "LAST_DAY() only takes STRING/TIMESTAMP/DATEWRITABLE types, got " + inputType1);
     }
+    lastDay(date);
     Date newDate = calendar.getTime();
     output.set(formatter.format(newDate));
     return output;

Modified: hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDTFInline.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDTFInline.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDTFInline.java (original)
+++ hive/branches/parquet/ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDTFInline.java Wed Feb 11 17:48:36 2015
@@ -19,6 +19,7 @@
 package org.apache.hadoop.hive.ql.udf.generic;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import org.apache.hadoop.hive.ql.exec.Description;
 import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
@@ -57,8 +58,11 @@ public class GenericUDTFInline extends G
 
   @Override
   public void process(Object[] os) throws HiveException {
-    for (Object row : new ArrayList<Object>(li.getList(os[0]))) {
-      forward(row);
+    List<?> list = li.getList(os[0]);
+    if (list != null && !list.isEmpty()) {
+      for (Object row : list.toArray()) {
+        forward(row);
+      }
     }
   }
 

Modified: hive/branches/parquet/ql/src/protobuf/org/apache/hadoop/hive/ql/io/orc/orc_proto.proto
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/protobuf/org/apache/hadoop/hive/ql/io/orc/orc_proto.proto?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/protobuf/org/apache/hadoop/hive/ql/io/orc/orc_proto.proto (original)
+++ hive/branches/parquet/ql/src/protobuf/org/apache/hadoop/hive/ql/io/orc/orc_proto.proto Wed Feb 11 17:48:36 2015
@@ -86,6 +86,15 @@ message RowIndex {
   repeated RowIndexEntry entry = 1;
 }
 
+message BloomFilter {
+  optional uint32 numHashFunctions = 1;
+  repeated fixed64 bitset = 2;
+}
+
+message BloomFilterIndex {
+  repeated BloomFilter bloomFilter = 1;
+}
+
 message Stream {
   // if you add new index stream kinds, you need to make sure to update
   // StreamName to ensure it is added to the stripe in the right area
@@ -97,6 +106,7 @@ message Stream {
     DICTIONARY_COUNT = 4;
     SECONDARY = 5;
     ROW_INDEX = 6;
+    BLOOM_FILTER = 7;
   }
   required Kind kind = 1;
   optional uint32 column = 2;

Modified: hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestFileDump.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestFileDump.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestFileDump.java (original)
+++ hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestFileDump.java Wed Feb 11 17:48:36 2015
@@ -21,19 +21,6 @@ package org.apache.hadoop.hive.ql.io.orc
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 
-import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.fs.FileSystem;
-import org.apache.hadoop.fs.Path;
-import org.apache.hadoop.hive.common.type.HiveChar;
-import org.apache.hadoop.hive.common.type.HiveDecimal;
-import org.apache.hadoop.hive.common.type.HiveVarchar;
-import org.apache.hadoop.hive.conf.HiveConf;
-import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
-import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
-import org.apache.hive.common.util.HiveTestUtils;
-import org.junit.Before;
-import org.junit.Test;
-
 import java.io.BufferedReader;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -49,6 +36,19 @@ import java.util.List;
 import java.util.Map;
 import java.util.Random;
 
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hive.common.type.HiveChar;
+import org.apache.hadoop.hive.common.type.HiveDecimal;
+import org.apache.hadoop.hive.common.type.HiveVarchar;
+import org.apache.hadoop.hive.conf.HiveConf;
+import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
+import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
+import org.apache.hive.common.util.HiveTestUtils;
+import org.junit.Before;
+import org.junit.Test;
+
 public class TestFileDump {
 
   Path workDir = new Path(System.getProperty("test.tmp.dir"));
@@ -303,4 +303,101 @@ public class TestFileDump {
 
     checkOutput(outputFilename, workDir + File.separator + outputFilename);
   }
+
+  @Test
+  public void testBloomFilter() throws Exception {
+    ObjectInspector inspector;
+    synchronized (TestOrcFile.class) {
+      inspector = ObjectInspectorFactory.getReflectionObjectInspector
+          (MyRecord.class, ObjectInspectorFactory.ObjectInspectorOptions.JAVA);
+    }
+    conf.set(HiveConf.ConfVars.HIVE_ORC_ENCODING_STRATEGY.varname, "COMPRESSION");
+    OrcFile.WriterOptions options = OrcFile.writerOptions(conf)
+        .fileSystem(fs)
+        .inspector(inspector)
+        .stripeSize(100000)
+        .compress(CompressionKind.ZLIB)
+        .bufferSize(10000)
+        .rowIndexStride(1000)
+        .bloomFilterColumns("s");
+    Writer writer = OrcFile.createWriter(testFilePath, options);
+    Random r1 = new Random(1);
+    String[] words = new String[]{"It", "was", "the", "best", "of", "times,",
+        "it", "was", "the", "worst", "of", "times,", "it", "was", "the", "age",
+        "of", "wisdom,", "it", "was", "the", "age", "of", "foolishness,", "it",
+        "was", "the", "epoch", "of", "belief,", "it", "was", "the", "epoch",
+        "of", "incredulity,", "it", "was", "the", "season", "of", "Light,",
+        "it", "was", "the", "season", "of", "Darkness,", "it", "was", "the",
+        "spring", "of", "hope,", "it", "was", "the", "winter", "of", "despair,",
+        "we", "had", "everything", "before", "us,", "we", "had", "nothing",
+        "before", "us,", "we", "were", "all", "going", "direct", "to",
+        "Heaven,", "we", "were", "all", "going", "direct", "the", "other",
+        "way"};
+    for(int i=0; i < 21000; ++i) {
+      writer.addRow(new MyRecord(r1.nextInt(), r1.nextLong(),
+          words[r1.nextInt(words.length)]));
+    }
+    writer.close();
+    PrintStream origOut = System.out;
+    String outputFilename = "orc-file-dump-bloomfilter.out";
+    FileOutputStream myOut = new FileOutputStream(workDir + File.separator + outputFilename);
+
+    // replace stdout and run command
+    System.setOut(new PrintStream(myOut));
+    FileDump.main(new String[]{testFilePath.toString(), "--rowindex=3"});
+    System.out.flush();
+    System.setOut(origOut);
+
+
+    checkOutput(outputFilename, workDir + File.separator + outputFilename);
+  }
+
+  @Test
+  public void testBloomFilter2() throws Exception {
+    ObjectInspector inspector;
+    synchronized (TestOrcFile.class) {
+      inspector = ObjectInspectorFactory.getReflectionObjectInspector
+          (MyRecord.class, ObjectInspectorFactory.ObjectInspectorOptions.JAVA);
+    }
+    conf.set(HiveConf.ConfVars.HIVE_ORC_ENCODING_STRATEGY.varname, "COMPRESSION");
+    OrcFile.WriterOptions options = OrcFile.writerOptions(conf)
+        .fileSystem(fs)
+        .inspector(inspector)
+        .stripeSize(100000)
+        .compress(CompressionKind.ZLIB)
+        .bufferSize(10000)
+        .rowIndexStride(1000)
+        .bloomFilterColumns("l")
+        .bloomFilterFpp(0.01);
+    Writer writer = OrcFile.createWriter(testFilePath, options);
+    Random r1 = new Random(1);
+    String[] words = new String[]{"It", "was", "the", "best", "of", "times,",
+        "it", "was", "the", "worst", "of", "times,", "it", "was", "the", "age",
+        "of", "wisdom,", "it", "was", "the", "age", "of", "foolishness,", "it",
+        "was", "the", "epoch", "of", "belief,", "it", "was", "the", "epoch",
+        "of", "incredulity,", "it", "was", "the", "season", "of", "Light,",
+        "it", "was", "the", "season", "of", "Darkness,", "it", "was", "the",
+        "spring", "of", "hope,", "it", "was", "the", "winter", "of", "despair,",
+        "we", "had", "everything", "before", "us,", "we", "had", "nothing",
+        "before", "us,", "we", "were", "all", "going", "direct", "to",
+        "Heaven,", "we", "were", "all", "going", "direct", "the", "other",
+        "way"};
+    for(int i=0; i < 21000; ++i) {
+      writer.addRow(new MyRecord(r1.nextInt(), r1.nextLong(),
+          words[r1.nextInt(words.length)]));
+    }
+    writer.close();
+    PrintStream origOut = System.out;
+    String outputFilename = "orc-file-dump-bloomfilter2.out";
+    FileOutputStream myOut = new FileOutputStream(workDir + File.separator + outputFilename);
+
+    // replace stdout and run command
+    System.setOut(new PrintStream(myOut));
+    FileDump.main(new String[]{testFilePath.toString(), "--rowindex=2"});
+    System.out.flush();
+    System.setOut(origOut);
+
+
+    checkOutput(outputFilename, workDir + File.separator + outputFilename);
+  }
 }

Modified: hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestOrcFile.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestOrcFile.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestOrcFile.java (original)
+++ hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestOrcFile.java Wed Feb 11 17:48:36 2015
@@ -515,6 +515,10 @@ public class TestOrcFile {
       Object row = rows.next(null);
       assertEquals(tslist.get(idx++).getNanos(), ((TimestampWritable) row).getNanos());
     }
+    assertEquals(1, OrcUtils.getFlattenedColumnsCount(inspector));
+    boolean[] expected = new boolean[] {false};
+    boolean[] included = OrcUtils.includeColumns("", "ts", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
   }
 
   @Test
@@ -538,6 +542,19 @@ public class TestOrcFile {
     Reader reader = OrcFile.createReader(testFilePath,
         OrcFile.readerOptions(conf).filesystem(fs));
 
+    assertEquals(3, OrcUtils.getFlattenedColumnsCount(inspector));
+    boolean[] expected = new boolean[] {false, false, true};
+    boolean[] included = OrcUtils.includeColumns("string1", "bytes1,string1", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
+    expected = new boolean[] {false, false, false};
+    included = OrcUtils.includeColumns("", "bytes1,string1", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
+    expected = new boolean[] {false, false, false};
+    included = OrcUtils.includeColumns(null, "bytes1,string1", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
     // check the stats
     ColumnStatistics[] stats = reader.getStatistics();
     assertEquals(4, stats[0].getNumberOfValues());
@@ -634,6 +651,12 @@ public class TestOrcFile {
     writer.close();
     Reader reader = OrcFile.createReader(testFilePath,
         OrcFile.readerOptions(conf).filesystem(fs));
+
+    assertEquals(3, OrcUtils.getFlattenedColumnsCount(inspector));
+    boolean[] expected = new boolean[] {false, true, false};
+    boolean[] included = OrcUtils.includeColumns("int1", "int1,string1", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
     Metadata metadata = reader.getMetadata();
     int numStripes = metadata.getStripeStatistics().size();
     assertEquals(3, numStripes);
@@ -672,7 +695,7 @@ public class TestOrcFile {
     assertEquals(5000, ((StringColumnStatistics)ss3.getColumnStatistics()[2]).getSum());
 
     RecordReaderImpl recordReader = (RecordReaderImpl) reader.rows();
-    OrcProto.RowIndex[] index = recordReader.readRowIndex(0);
+    OrcProto.RowIndex[] index = recordReader.readRowIndex(0, null).getRowGroupIndex();
     assertEquals(3, index.length);
     List<OrcProto.RowIndexEntry> items = index[1].getEntryList();
     assertEquals(1, items.size());
@@ -682,7 +705,7 @@ public class TestOrcFile {
     assertEquals(0, items.get(0).getPositions(2));
     assertEquals(1, 
                  items.get(0).getStatistics().getIntStatistics().getMinimum());
-    index = recordReader.readRowIndex(1);
+    index = recordReader.readRowIndex(1, null).getRowGroupIndex();
     assertEquals(3, index.length);
     items = index[1].getEntryList();
     assertEquals(2, 
@@ -715,6 +738,44 @@ public class TestOrcFile {
     Reader reader = OrcFile.createReader(testFilePath,
         OrcFile.readerOptions(conf).filesystem(fs));
 
+    assertEquals(24, OrcUtils.getFlattenedColumnsCount(inspector));
+    boolean[] expected = new boolean[] {false, false, false, false, false,
+        false, false, false, false, false,
+        false, false, false, false, false,
+        false, false, false, false, false,
+        false, false, false, false};
+    boolean[] included = OrcUtils.includeColumns("",
+        "boolean1,byte1,short1,int1,long1,float1,double1,bytes1,string1,middle,list,map", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
+    expected = new boolean[] {false, true, false, false, false,
+        false, false, false, false, true,
+        true, true, true, true, true,
+        false, false, false, false, true,
+        true, true, true, true};
+    included = OrcUtils.includeColumns("boolean1,string1,middle,map",
+        "boolean1,byte1,short1,int1,long1,float1,double1,bytes1,string1,middle,list,map", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
+    expected = new boolean[] {false, true, false, false, false,
+        false, false, false, false, true,
+        true, true, true, true, true,
+        false, false, false, false, true,
+        true, true, true, true};
+    included = OrcUtils.includeColumns("boolean1,string1,middle,map",
+        "boolean1,byte1,short1,int1,long1,float1,double1,bytes1,string1,middle,list,map", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
+    expected = new boolean[] {false, true, true, true, true,
+        true, true, true, true, true,
+        true, true, true, true, true,
+        true, true, true, true, true,
+        true, true, true, true};
+    included = OrcUtils.includeColumns(
+        "boolean1,byte1,short1,int1,long1,float1,double1,bytes1,string1,middle,list,map",
+        "boolean1,byte1,short1,int1,long1,float1,double1,bytes1,string1,middle,list,map", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
     Metadata metadata = reader.getMetadata();
 
     // check the stats
@@ -1183,6 +1244,20 @@ public class TestOrcFile {
     writer.close();
     Reader reader = OrcFile.createReader(testFilePath,
         OrcFile.readerOptions(conf).filesystem(fs));
+
+    assertEquals(6, OrcUtils.getFlattenedColumnsCount(inspector));
+    boolean[] expected = new boolean[] {false, false, false, false, false, false};
+    boolean[] included = OrcUtils.includeColumns("", "time,union,decimal", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
+    expected = new boolean[] {false, true, false, false, false, true};
+    included = OrcUtils.includeColumns("time,decimal", "time,union,decimal", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
+    expected = new boolean[] {false, false, true, true, true, false};
+    included = OrcUtils.includeColumns("union", "time,union,decimal", inspector);
+    assertEquals(true, Arrays.equals(expected, included));
+
     assertEquals(false, reader.getMetadataKeys().iterator().hasNext());
     assertEquals(5309, reader.getNumberOfRows());
     DecimalColumnStatistics stats =

Modified: hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestRecordReaderImpl.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestRecordReaderImpl.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestRecordReaderImpl.java (original)
+++ hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestRecordReaderImpl.java Wed Feb 11 17:48:36 2015
@@ -23,6 +23,12 @@ import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.FSDataInputStream;
 import org.apache.hadoop.fs.FileStatus;
@@ -31,6 +37,7 @@ import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.fs.PositionedReadable;
 import org.apache.hadoop.fs.Seekable;
 import org.apache.hadoop.hive.common.type.HiveDecimal;
+import org.apache.hadoop.hive.ql.io.filters.BloomFilter;
 import org.apache.hadoop.hive.ql.io.orc.RecordReaderImpl.Location;
 import org.apache.hadoop.hive.ql.io.sarg.PredicateLeaf;
 import org.apache.hadoop.hive.ql.io.sarg.SearchArgument.TruthValue;
@@ -41,11 +48,6 @@ import org.junit.Test;
 import org.mockito.MockSettings;
 import org.mockito.Mockito;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
-
 public class TestRecordReaderImpl {
 
   // can add .verboseLogging() to cause Mockito to log invocations
@@ -287,6 +289,13 @@ public class TestRecordReaderImpl {
     return OrcProto.ColumnStatistics.newBuilder().setDateStatistics(dateStats.build()).build();
   }
 
+  private static OrcProto.ColumnStatistics createTimestampStats(int min, int max) {
+    OrcProto.TimestampStatistics.Builder tsStats = OrcProto.TimestampStatistics.newBuilder();
+    tsStats.setMinimum(min);
+    tsStats.setMaximum(max);
+    return OrcProto.ColumnStatistics.newBuilder().setTimestampStatistics(tsStats.build()).build();
+  }
+
   private static OrcProto.ColumnStatistics createDecimalStats(String min, String max) {
     OrcProto.DecimalStatistics.Builder decStats = OrcProto.DecimalStatistics.newBuilder();
     decStats.setMinimum(min);
@@ -294,6 +303,15 @@ public class TestRecordReaderImpl {
     return OrcProto.ColumnStatistics.newBuilder().setDecimalStatistics(decStats.build()).build();
   }
 
+  private static OrcProto.ColumnStatistics createDecimalStats(String min, String max,
+      boolean hasNull) {
+    OrcProto.DecimalStatistics.Builder decStats = OrcProto.DecimalStatistics.newBuilder();
+    decStats.setMinimum(min);
+    decStats.setMaximum(max);
+    return OrcProto.ColumnStatistics.newBuilder().setDecimalStatistics(decStats.build())
+        .setHasNull(hasNull).build();
+  }
+
   @Test
   public void testGetMax() throws Exception {
     assertEquals(100L, RecordReaderImpl.getMax(ColumnStatisticsImpl.deserialize(createIntStats(10L, 100L))));
@@ -320,27 +338,27 @@ public class TestRecordReaderImpl {
     PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
         PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.INTEGER, "x", 15L, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.FLOAT, "x", 15.0, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "15", null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DATE, "x", new DateWritable(15), null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DECIMAL, "x", HiveDecimal.create(15), null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10, 100), pred, null));
   }
 
   @Test
@@ -348,27 +366,27 @@ public class TestRecordReaderImpl {
     PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
         PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.INTEGER, "x", 15L, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDoubleStats(10.0, 100.0), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDoubleStats(10.0, 100.0), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.FLOAT, "x", 15.0, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDoubleStats(10.0, 100.0), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDoubleStats(10.0, 100.0), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "15", null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDoubleStats(10.0, 100.0), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDoubleStats(10.0, 100.0), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DATE, "x", new DateWritable(15), null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDoubleStats(10.0, 100.0), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDoubleStats(10.0, 100.0), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DECIMAL, "x", HiveDecimal.create(15), null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDoubleStats(10.0, 100.0), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDoubleStats(10.0, 100.0), pred, null));
   }
 
   @Test
@@ -376,27 +394,27 @@ public class TestRecordReaderImpl {
     PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
         PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.INTEGER, "x", 100, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("10", "1000"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("10", "1000"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.FLOAT, "x", 100.0, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("10", "1000"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("10", "1000"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "100", null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("10", "1000"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("10", "1000"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DATE, "x", new DateWritable(100), null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("10", "1000"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("10", "1000"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DECIMAL, "x", HiveDecimal.create(100), null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("10", "1000"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("10", "1000"), pred, null));
   }
 
   @Test
@@ -404,57 +422,57 @@ public class TestRecordReaderImpl {
     PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
         PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.INTEGER, "x", 15L, null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.FLOAT, "x", 15.0, null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "15", null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "1970-01-11", null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "15.1", null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "__a15__1", null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "2000-01-16", null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "1970-01-16", null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DATE, "x", new DateWritable(15), null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DATE, "x", new DateWritable(150), null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DECIMAL, "x", HiveDecimal.create(15), null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDateStats(10, 100), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDateStats(10, 100), pred, null));
 
   }
 
@@ -463,27 +481,27 @@ public class TestRecordReaderImpl {
     PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
         PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.INTEGER, "x", 15L, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDecimalStats("10.0", "100.0"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDecimalStats("10.0", "100.0"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.FLOAT, "x", 15.0, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDecimalStats("10.0", "100.0"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDecimalStats("10.0", "100.0"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.STRING, "x", "15", null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDecimalStats("10.0", "100.0"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDecimalStats("10.0", "100.0"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DATE, "x", new DateWritable(15), null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createDecimalStats("10.0", "100.0"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDecimalStats("10.0", "100.0"), pred, null));
 
     pred = TestSearchArgumentImpl.createPredicateLeaf(PredicateLeaf.Operator.NULL_SAFE_EQUALS,
         PredicateLeaf.Type.DECIMAL, "x", HiveDecimal.create(15), null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createDecimalStats("10.0", "100.0"), pred));
+        RecordReaderImpl.evaluatePredicateProto(createDecimalStats("10.0", "100.0"), pred, null));
 
   }
 
@@ -493,17 +511,17 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.INTEGER,
             "x", 15L, null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(20L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(20L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(15L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(15L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 15L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 15L), pred, null));
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(0L, 10L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(0L, 10L), pred, null));
     assertEquals(TruthValue.YES,
-        RecordReaderImpl.evaluatePredicate(createIntStats(15L, 15L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(15L, 15L), pred, null));
   }
 
   @Test
@@ -512,17 +530,17 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.INTEGER,
             "x", 15L, null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(20L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(20L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(15L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(15L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 15L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 15L), pred, null));
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(0L, 10L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(0L, 10L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(15L, 15L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(15L, 15L), pred, null));
   }
 
   @Test
@@ -531,15 +549,15 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.LESS_THAN, PredicateLeaf.Type.INTEGER,
             "x", 15L, null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(20L, 30L), lessThan));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(20L, 30L), lessThan, null));
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(15L, 30L), lessThan));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(15L, 30L), lessThan, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 30L), lessThan));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 30L), lessThan, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 15L), lessThan));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 15L), lessThan, null));
     assertEquals(TruthValue.YES,
-        RecordReaderImpl.evaluatePredicate(createIntStats(0L, 10L), lessThan));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(0L, 10L), lessThan, null));
   }
 
   @Test
@@ -548,15 +566,15 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.LESS_THAN_EQUALS, PredicateLeaf.Type.INTEGER,
             "x", 15L, null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(20L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(20L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(15L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(15L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 30L), pred, null));
     assertEquals(TruthValue.YES,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 15L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 15L), pred, null));
     assertEquals(TruthValue.YES,
-        RecordReaderImpl.evaluatePredicate(createIntStats(0L, 10L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(0L, 10L), pred, null));
   }
 
   @Test
@@ -568,13 +586,13 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.IN, PredicateLeaf.Type.INTEGER,
             "x", null, args);
     assertEquals(TruthValue.YES,
-        RecordReaderImpl.evaluatePredicate(createIntStats(20L, 20L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(20L, 20L), pred, null));
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(30L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(30L, 30L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 30L), pred, null));
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(12L, 18L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(12L, 18L), pred, null));
   }
 
   @Test
@@ -586,19 +604,19 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.BETWEEN, PredicateLeaf.Type.INTEGER,
             "x", null, args);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(0L, 5L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(0L, 5L), pred, null));
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(30L, 40L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(30L, 40L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(5L, 15L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(5L, 15L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(15L, 25L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(15L, 25L), pred, null));
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(5L, 25L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(5L, 25L), pred, null));
     assertEquals(TruthValue.YES,
-        RecordReaderImpl.evaluatePredicate(createIntStats(10L, 20L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(10L, 20L), pred, null));
     assertEquals(TruthValue.YES,
-        RecordReaderImpl.evaluatePredicate(createIntStats(12L, 18L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(12L, 18L), pred, null));
   }
 
   @Test
@@ -607,7 +625,7 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.IS_NULL, PredicateLeaf.Type.INTEGER,
             "x", null, null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createIntStats(20L, 30L), pred));
+        RecordReaderImpl.evaluatePredicateProto(createIntStats(20L, 30L), pred, null));
   }
 
 
@@ -617,17 +635,17 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.STRING,
             "x", "c", null);
     assertEquals(TruthValue.NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("d", "e", true), pred)); // before
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("d", "e", true), pred, null)); // before
     assertEquals(TruthValue.NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("a", "b", true), pred)); // after
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("a", "b", true), pred, null)); // after
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "c", true), pred)); // max
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "c", true), pred, null)); // max
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "d", true), pred)); // min
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "d", true), pred, null)); // min
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "d", true), pred)); // middle
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "d", true), pred, null)); // middle
     assertEquals(TruthValue.YES_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "c", true), pred)); // same
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "c", true), pred, null)); // same
   }
 
   @Test
@@ -636,17 +654,17 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.STRING,
             "x", "c", null);
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("d", "e", true), pred)); // before
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("d", "e", true), pred, null)); // before
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("a", "b", true), pred)); // after
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("a", "b", true), pred, null)); // after
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "c", true), pred)); // max
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "c", true), pred, null)); // max
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "d", true), pred)); // min
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "d", true), pred, null)); // min
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "d", true), pred)); // middle
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "d", true), pred, null)); // middle
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "c", true), pred)); // same
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "c", true), pred, null)); // same
   }
 
   @Test
@@ -655,17 +673,17 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.LESS_THAN, PredicateLeaf.Type.STRING,
             "x", "c", null);
     assertEquals(TruthValue.NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("d", "e", true), pred)); // before
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("d", "e", true), pred, null)); // before
     assertEquals(TruthValue.YES_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("a", "b", true), pred)); // after
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("a", "b", true), pred, null)); // after
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "c", true), pred)); // max
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "c", true), pred, null)); // max
     assertEquals(TruthValue.NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "d", true), pred)); // min
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "d", true), pred, null)); // min
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "d", true), pred)); // middle
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "d", true), pred, null)); // middle
     assertEquals(TruthValue.NO_NULL, // min, same stats
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "c", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "c", true), pred, null));
   }
 
   @Test
@@ -674,17 +692,17 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.LESS_THAN_EQUALS, PredicateLeaf.Type.STRING,
             "x", "c", null);
     assertEquals(TruthValue.NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("d", "e", true), pred)); // before
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("d", "e", true), pred, null)); // before
     assertEquals(TruthValue.YES_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("a", "b", true), pred)); // after
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("a", "b", true), pred, null)); // after
     assertEquals(TruthValue.YES_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "c", true), pred)); // max
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "c", true), pred, null)); // max
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "d", true), pred)); // min
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "d", true), pred, null)); // min
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "d", true), pred)); // middle
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "d", true), pred, null)); // middle
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "c", true), pred)); // same
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "c", true), pred, null)); // same
   }
 
   @Test
@@ -696,17 +714,17 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.IN, PredicateLeaf.Type.STRING,
             "x", null, args);
     assertEquals(TruthValue.NO_NULL, // before & after
-        RecordReaderImpl.evaluatePredicate(createStringStats("d", "e", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("d", "e", true), pred, null));
     assertEquals(TruthValue.NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("a", "b", true), pred)); // after
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("a", "b", true), pred, null)); // after
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("e", "f", true), pred)); // max
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("e", "f", true), pred, null)); // max
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "d", true), pred)); // min
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "d", true), pred, null)); // min
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "d", true), pred)); // middle
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "d", true), pred, null)); // middle
     assertEquals(TruthValue.YES_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "c", true), pred)); // same
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "c", true), pred, null)); // same
   }
 
   @Test
@@ -718,31 +736,31 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.BETWEEN, PredicateLeaf.Type.STRING,
             "x", null, args);
     assertEquals(TruthValue.YES_NULL, // before & after
-        RecordReaderImpl.evaluatePredicate(createStringStats("d", "e", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("d", "e", true), pred, null));
     assertEquals(TruthValue.YES_NULL, // before & max
-        RecordReaderImpl.evaluatePredicate(createStringStats("e", "f", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("e", "f", true), pred, null));
     assertEquals(TruthValue.NO_NULL, // before & before
-        RecordReaderImpl.evaluatePredicate(createStringStats("h", "g", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("h", "g", true), pred, null));
     assertEquals(TruthValue.YES_NO_NULL, // before & min
-        RecordReaderImpl.evaluatePredicate(createStringStats("f", "g", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("f", "g", true), pred, null));
     assertEquals(TruthValue.YES_NO_NULL, // before & middle
-        RecordReaderImpl.evaluatePredicate(createStringStats("e", "g", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("e", "g", true), pred, null));
 
     assertEquals(TruthValue.YES_NULL, // min & after
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "e", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "e", true), pred, null));
     assertEquals(TruthValue.YES_NULL, // min & max
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "f", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "f", true), pred, null));
     assertEquals(TruthValue.YES_NO_NULL, // min & middle
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "g", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "g", true), pred, null));
 
     assertEquals(TruthValue.NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("a", "b", true), pred)); // after
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("a", "b", true), pred, null)); // after
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("a", "c", true), pred)); // max
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("a", "c", true), pred, null)); // max
     assertEquals(TruthValue.YES_NO_NULL,
-        RecordReaderImpl.evaluatePredicate(createStringStats("b", "d", true), pred)); // middle
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("b", "d", true), pred, null)); // middle
     assertEquals(TruthValue.YES_NULL, // min & after, same stats
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "c", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "c", true), pred, null));
   }
 
   @Test
@@ -751,9 +769,9 @@ public class TestRecordReaderImpl {
         (PredicateLeaf.Operator.IS_NULL, PredicateLeaf.Type.STRING,
             "x", null, null);
     assertEquals(TruthValue.YES_NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "d", true), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "d", true), pred, null));
     assertEquals(TruthValue.NO,
-        RecordReaderImpl.evaluatePredicate(createStringStats("c", "d", false), pred));
+        RecordReaderImpl.evaluatePredicateProto(createStringStats("c", "d", false), pred, null));
   }
 
   @Test
@@ -1131,4 +1149,350 @@ public class TestRecordReaderImpl {
         41000, 51000 + RecordReaderImpl.WORST_UNCOMPRESSED_SLOP,
         51000, 95000, 95000, 97000, 97000, 100000)));
   }
+
+  @Test
+  public void testIntNullSafeEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.INTEGER, "x", 15L, null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong(i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createIntStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong(15);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testIntEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.INTEGER, "x", 15L, null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong(i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createIntStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong(15);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testIntInBloomFilter() throws Exception {
+    List<Object> args = new ArrayList<Object>();
+    args.add(15);
+    args.add(19);
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf
+        (PredicateLeaf.Operator.IN, PredicateLeaf.Type.INTEGER,
+            "x", null, args);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong(i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createIntStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong(19);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong(15);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDoubleNullSafeEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.FLOAT, "x", 15.0, null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addDouble(i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDoubleStats(10.0, 100.0));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addDouble(15.0);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDoubleEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.FLOAT, "x", 15.0, null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addDouble(i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDoubleStats(10.0, 100.0));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addDouble(15.0);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDoubleInBloomFilter() throws Exception {
+    List<Object> args = new ArrayList<Object>();
+    args.add(15.0);
+    args.add(19.0);
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf
+        (PredicateLeaf.Operator.IN, PredicateLeaf.Type.FLOAT,
+            "x", null, args);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addDouble(i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDoubleStats(10.0, 100.0));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addDouble(19.0);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addDouble(15.0);
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testStringNullSafeEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.STRING, "x", "str_15", null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addString("str_" + i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createStringStats("str_10", "str_200"));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString("str_15");
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testStringEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.STRING, "x", "str_15", null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addString("str_" + i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createStringStats("str_10", "str_200"));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString("str_15");
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testStringInBloomFilter() throws Exception {
+    List<Object> args = new ArrayList<Object>();
+    args.add("str_15");
+    args.add("str_19");
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf
+        (PredicateLeaf.Operator.IN, PredicateLeaf.Type.STRING,
+            "x", null, args);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addString("str_" + i);
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createStringStats("str_10", "str_200"));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString("str_19");
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString("str_15");
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDateWritableNullSafeEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.DATE, "x", new DateWritable(15),
+        null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong((new DateWritable(i)).getDays());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDateStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new DateWritable(15)).getDays());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDateWritableEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.DATE, "x", new DateWritable(15), null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong((new DateWritable(i)).getDays());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDateStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new DateWritable(15)).getDays());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDateWritableInBloomFilter() throws Exception {
+    List<Object> args = new ArrayList<Object>();
+    args.add(new DateWritable(15));
+    args.add(new DateWritable(19));
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf
+        (PredicateLeaf.Operator.IN, PredicateLeaf.Type.DATE,
+            "x", null, args);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong((new DateWritable(i)).getDays());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDateStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new DateWritable(19)).getDays());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new DateWritable(15)).getDays());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testTimestampNullSafeEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.TIMESTAMP, "x",
+        new Timestamp(15),
+        null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong((new Timestamp(i)).getTime());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createTimestampStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new Timestamp(15)).getTime());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testTimestampEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.TIMESTAMP, "x", new Timestamp(15), null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong((new Timestamp(i)).getTime());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createTimestampStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new Timestamp(15)).getTime());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testTimestampInBloomFilter() throws Exception {
+    List<Object> args = new ArrayList<Object>();
+    args.add(new Timestamp(15));
+    args.add(new Timestamp(19));
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf
+        (PredicateLeaf.Operator.IN, PredicateLeaf.Type.TIMESTAMP,
+            "x", null, args);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addLong((new Timestamp(i)).getTime());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createTimestampStats(10, 100));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new Timestamp(19)).getTime());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addLong((new Timestamp(15)).getTime());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDecimalNullSafeEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.NULL_SAFE_EQUALS, PredicateLeaf.Type.DECIMAL, "x",
+        HiveDecimal.create(15),
+        null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addString(HiveDecimal.create(i).toString());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDecimalStats("10", "200"));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString(HiveDecimal.create(15).toString());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDecimalEqualsBloomFilter() throws Exception {
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf(
+        PredicateLeaf.Operator.EQUALS, PredicateLeaf.Type.DECIMAL, "x", HiveDecimal.create(15),
+        null);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addString(HiveDecimal.create(i).toString());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDecimalStats("10", "200"));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString(HiveDecimal.create(15).toString());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testDecimalInBloomFilter() throws Exception {
+    List<Object> args = new ArrayList<Object>();
+    args.add(HiveDecimal.create(15));
+    args.add(HiveDecimal.create(19));
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf
+        (PredicateLeaf.Operator.IN, PredicateLeaf.Type.DECIMAL,
+            "x", null, args);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addString(HiveDecimal.create(i).toString());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDecimalStats("10", "200"));
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString(HiveDecimal.create(19).toString());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString(HiveDecimal.create(15).toString());
+    assertEquals(TruthValue.YES_NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
+
+  @Test
+  public void testNullsInBloomFilter() throws Exception {
+    List<Object> args = new ArrayList<Object>();
+    args.add(HiveDecimal.create(15));
+    args.add(null);
+    args.add(HiveDecimal.create(19));
+    PredicateLeaf pred = TestSearchArgumentImpl.createPredicateLeaf
+        (PredicateLeaf.Operator.IN, PredicateLeaf.Type.DECIMAL,
+            "x", null, args);
+    BloomFilter bf = new BloomFilter(10000);
+    for (int i = 20; i < 1000; i++) {
+      bf.addString(HiveDecimal.create(i).toString());
+    }
+    ColumnStatistics cs = ColumnStatisticsImpl.deserialize(createDecimalStats("10", "200"));
+    // hasNull is false, so bloom filter should return NO
+    assertEquals(TruthValue.NO, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    cs = ColumnStatisticsImpl.deserialize(createDecimalStats("10", "200", true));
+    // hasNull is true, so bloom filter should return YES_NO_NULL
+    assertEquals(TruthValue.YES_NO_NULL, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString(HiveDecimal.create(19).toString());
+    assertEquals(TruthValue.YES_NO_NULL, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+
+    bf.addString(HiveDecimal.create(15).toString());
+    assertEquals(TruthValue.YES_NO_NULL, RecordReaderImpl.evaluatePredicate(cs, pred, bf));
+  }
 }

Modified: hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFAddMonths.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFAddMonths.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFAddMonths.java (original)
+++ hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFAddMonths.java Wed Feb 11 17:48:36 2015
@@ -46,6 +46,7 @@ public class TestGenericUDFAddMonths ext
     runAndVerify("2016-02-29", -12, "2015-02-28", udf);
     runAndVerify("2016-01-29", 1, "2016-02-29", udf);
     runAndVerify("2016-02-29", -1, "2016-01-31", udf);
+    runAndVerify("2014-01-32", 1, "2014-03-01", udf);
   }
 
   private void runAndVerify(String str, int months, String expResult, GenericUDF udf)

Modified: hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFLastDay.java
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFLastDay.java?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFLastDay.java (original)
+++ hive/branches/parquet/ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFLastDay.java Wed Feb 11 17:48:36 2015
@@ -43,6 +43,8 @@ public class TestGenericUDFLastDay exten
     runAndVerify("2016-02-03", "2016-02-29", udf);
     runAndVerify("2016-02-28", "2016-02-29", udf);
     runAndVerify("2016-02-29", "2016-02-29", udf);
+    runAndVerify("01/14/2014", null, udf);
+    runAndVerify(null, null, udf);
 
     runAndVerify("2014-01-01 10:30:45", "2014-01-31", udf);
     runAndVerify("2014-01-14 10:30:45", "2014-01-31", udf);
@@ -56,9 +58,9 @@ public class TestGenericUDFLastDay exten
 
   private void runAndVerify(String str, String expResult, GenericUDF udf)
       throws HiveException {
-    DeferredObject valueObj0 = new DeferredJavaObject(new Text(str));
+    DeferredObject valueObj0 = new DeferredJavaObject(str != null ? new Text(str) : null);
     DeferredObject[] args = { valueObj0 };
     Text output = (Text) udf.evaluate(args);
-    assertEquals("last_day() test ", expResult, output.toString());
+    assertEquals("last_day() test ", expResult, output != null ? output.toString() : null);
   }
 }

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/cbo_union.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/cbo_union.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/cbo_union.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/cbo_union.q Wed Feb 11 17:48:36 2015
@@ -7,7 +7,7 @@ set hive.auto.convert.join=false;
 -- SORT_QUERY_RESULTS
 
 -- 11. Union All
-select * from cbo_t1 order by key, c_boolean, value, dt union all select * from cbo_t2 order by key, c_boolean, value, dt;
+select * from (select * from cbo_t1 order by key, c_boolean, value, dt)a union all select * from (select * from cbo_t2 order by key, c_boolean, value, dt)b;
 select key from (select key, c_int from (select * from cbo_t1 union all select * from cbo_t2 where cbo_t2.key >=0)r1 union all select key, c_int from cbo_t3)r2 where key >=0 order by key;
 select r2.key from (select key, c_int from (select key, c_int from cbo_t1 union all select key, c_int from cbo_t3 )r1 union all select key, c_int from cbo_t3)r2 join   (select key, c_int from (select * from cbo_t1 union all select * from cbo_t2 where cbo_t2.key >=0)r1 union all select key, c_int from cbo_t3)r3 on r2.key=r3.key where r3.key >=0 order by r2.key;
 

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/explode_null.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/explode_null.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/explode_null.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/explode_null.q Wed Feb 11 17:48:36 2015
@@ -1,10 +1,10 @@
 SELECT explode(col) AS myCol FROM 
-    (SELECT array(1,2,3) AS col FROM src LIMIT 1 
+    (select * from (SELECT array(1,2,3) AS col FROM src LIMIT 1)ea 
      UNION ALL
-     SELECT IF(false, array(1,2,3), NULL) AS col FROM src LIMIT 1) a;
+     select * from (SELECT IF(false, array(1,2,3), NULL) AS col FROM src LIMIT 1)eb) a;
 
 SELECT explode(col) AS (myCol1,myCol2) FROM
-    (SELECT map(1,'one',2,'two',3,'three') AS col FROM src LIMIT 1
+    (select * from (SELECT map(1,'one',2,'two',3,'three') AS col FROM src LIMIT 1)ea
      UNION ALL
-     SELECT IF(false, map(1,'one',2,'two',3,'three'), NULL) AS col FROM src LIMIT 1) a;
+     select * from (SELECT IF(false, map(1,'one',2,'two',3,'three'), NULL) AS col FROM src LIMIT 1)eb ) a;
      
\ No newline at end of file

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/groupby10.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/groupby10.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/groupby10.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/groupby10.q Wed Feb 11 17:48:36 2015
@@ -36,7 +36,9 @@ INSERT OVERWRITE TABLE dest2 SELECT INPU
 SELECT * from dest1;
 SELECT * from dest2;
 
+set hive.groupby.skewindata=false;
 -- HIVE-3852 Multi-groupby optimization fails when same distinct column is used twice or more
+
 EXPLAIN
 FROM INPUT
 INSERT OVERWRITE TABLE dest1 SELECT INPUT.key, sum(distinct substr(INPUT.value,5)), count(distinct substr(INPUT.value,5)) GROUP BY INPUT.key

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/groupby_multi_insert_common_distinct.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/groupby_multi_insert_common_distinct.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/groupby_multi_insert_common_distinct.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/groupby_multi_insert_common_distinct.q Wed Feb 11 17:48:36 2015
@@ -18,17 +18,3 @@ insert overwrite table dest2 select key+
 select * from dest1 where key < 10;
 select * from dest2 where key < 20 order by key limit 10;
 
-set hive.optimize.multigroupby.common.distincts=false;
-
--- no need to spray by distinct key first
-explain
-from src
-insert overwrite table dest1 select key, count(distinct value) group by key
-insert overwrite table dest2 select key+key, count(distinct value) group by key+key;
-
-from src
-insert overwrite table dest1 select key, count(distinct value) group by key
-insert overwrite table dest2 select key+key, count(distinct value) group by key+key;
-
-select * from dest1 where key < 10;
-select * from dest2 where key < 20 order by key limit 10;

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/input25.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/input25.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/input25.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/input25.q Wed Feb 11 17:48:36 2015
@@ -5,15 +5,15 @@ alter table tst add partition (d='2009-0
 
 explain
 select * from (
-  select * from tst x where x.d='2009-01-01' limit 10
+  select * from (select * from tst x where x.d='2009-01-01' limit 10)a
     union all
-  select * from tst x where x.d='2009-02-02' limit 10
+  select * from (select * from tst x where x.d='2009-02-02' limit 10)b
 ) subq;
 
 select * from (
-  select * from tst x where x.d='2009-01-01' limit 10
+  select * from (select * from tst x where x.d='2009-01-01' limit 10)a
     union all
-  select * from tst x where x.d='2009-02-02' limit 10
+  select * from (select * from tst x where x.d='2009-02-02' limit 10)b
 ) subq;
 
 

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/input26.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/input26.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/input26.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/input26.q Wed Feb 11 17:48:36 2015
@@ -1,12 +1,12 @@
 explain
 select * from (
-  select * from srcpart a where a.ds = '2008-04-08' and a.hr = '11' order by a.key limit 5
+  select * from (select * from srcpart a where a.ds = '2008-04-08' and a.hr = '11' order by a.key limit 5)pa
     union all
-  select * from srcpart b where b.ds = '2008-04-08' and b.hr = '14' limit 5
+  select * from (select * from srcpart b where b.ds = '2008-04-08' and b.hr = '14' limit 5)pb
 )subq;
 
 select * from (
-  select * from srcpart a where a.ds = '2008-04-08' and a.hr = '11' order by a.key limit 5
+  select * from (select * from srcpart a where a.ds = '2008-04-08' and a.hr = '11' order by a.key limit 5)pa
     union all
-  select * from srcpart b where b.ds = '2008-04-08' and b.hr = '14' limit 5
+  select * from (select * from srcpart b where b.ds = '2008-04-08' and b.hr = '14' limit 5)pb
 )subq;

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/load_dyn_part14.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/load_dyn_part14.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/load_dyn_part14.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/load_dyn_part14.q Wed Feb 11 17:48:36 2015
@@ -14,20 +14,20 @@ set hive.exec.dynamic.partition.mode=non
 explain
 insert overwrite table nzhang_part14 partition(value) 
 select key, value from (
-  select 'k1' as key, cast(null as string) as value from src limit 2
+  select * from (select 'k1' as key, cast(null as string) as value from src limit 2)a 
   union all
-  select 'k2' as key, '' as value from src limit 2
+  select * from (select 'k2' as key, '' as value from src limit 2)b
   union all 
-  select 'k3' as key, ' ' as value from src limit 2
+  select * from (select 'k3' as key, ' ' as value from src limit 2)c
 ) T;
 
 insert overwrite table nzhang_part14 partition(value) 
 select key, value from (
-  select 'k1' as key, cast(null as string) as value from src limit 2
+  select * from (select 'k1' as key, cast(null as string) as value from src limit 2)a 
   union all
-  select 'k2' as key, '' as value from src limit 2
+  select * from (select 'k2' as key, '' as value from src limit 2)b
   union all 
-  select 'k3' as key, ' ' as value from src limit 2
+  select * from (select 'k3' as key, ' ' as value from src limit 2)c
 ) T;
 
 

Modified: hive/branches/parquet/ql/src/test/queries/clientpositive/metadataOnlyOptimizer.q
URL: http://svn.apache.org/viewvc/hive/branches/parquet/ql/src/test/queries/clientpositive/metadataOnlyOptimizer.q?rev=1659014&r1=1659013&r2=1659014&view=diff
==============================================================================
--- hive/branches/parquet/ql/src/test/queries/clientpositive/metadataOnlyOptimizer.q (original)
+++ hive/branches/parquet/ql/src/test/queries/clientpositive/metadataOnlyOptimizer.q Wed Feb 11 17:48:36 2015
@@ -33,9 +33,9 @@ UNION all
 SELECT key as key from src
 ) tab group by key;
 
-select k from (SELECT '1' as k from src limit 0 union all select key as k from src limit 1)tab;
+select k from (select * from (SELECT '1' as k from src limit 0)a union all select key as k from src limit 1)tab;
 
-select k from (SELECT '1' as k from src limit 1 union all select key as k from src limit 0)tab;
+select k from (select * from (SELECT '1' as k from src limit 1)a union all select key as k from src limit 0)tab;
 
 select max(ds) from srcpart;