Rename unmodified to constant and isReused instead of isUnmodifiable

tangyuxiaoyao · Jun 29, 2015 · 860adf7 · 860adf7
1 parent 0d127a7
commit 860adf7
Show file tree

Hide file tree

Showing 19 changed files with 55 additions and 69 deletions.
diff --git a/parquet-avro/src/main/java/org/apache/parquet/avro/AvroWriteSupport.java b/parquet-avro/src/main/java/org/apache/parquet/avro/AvroWriteSupport.java
@@ -252,9 +252,9 @@ private void writeValue(Type type, Schema avroSchema, Object value) {
       recordConsumer.addDouble(((Number) value).doubleValue());
     } else if (avroType.equals(Schema.Type.BYTES)) {
       if (value instanceof byte[]) {
-        recordConsumer.addBinary(Binary.fromUnmodifiedByteArray((byte[]) value));
+        recordConsumer.addBinary(Binary.fromConstantByteArray((byte[]) value));
       } else {
-        recordConsumer.addBinary(Binary.fromUnmodifiedByteBuffer((ByteBuffer) value));
+        recordConsumer.addBinary(Binary.fromConstantByteBuffer((ByteBuffer) value));
       }
     } else if (avroType.equals(Schema.Type.STRING)) {
       recordConsumer.addBinary(fromAvroString(value));
@@ -269,14 +269,14 @@ private void writeValue(Type type, Schema avroSchema, Object value) {
     } else if (avroType.equals(Schema.Type.UNION)) {
       writeUnion(type.asGroupType(), nonNullAvroSchema, value);
     } else if (avroType.equals(Schema.Type.FIXED)) {
-      recordConsumer.addBinary(Binary.fromUnmodifiedByteArray(((GenericFixed) value).bytes()));
+      recordConsumer.addBinary(Binary.fromConstantByteArray(((GenericFixed) value).bytes()));
     }
   }
 
   private Binary fromAvroString(Object value) {
     if (value instanceof Utf8) {
       Utf8 utf8 = (Utf8) value;
-      return Binary.fromUnmodifiedByteArray(utf8.getBytes(), 0, utf8.getByteLength());
+      return Binary.fromConstantByteArray(utf8.getBytes(), 0, utf8.getByteLength());
     }
     return Binary.fromString(value.toString());
   }

diff --git a/parquet-avro/src/test/java/org/apache/parquet/avro/TestReadWrite.java b/parquet-avro/src/test/java/org/apache/parquet/avro/TestReadWrite.java
@@ -363,7 +363,7 @@ public void write(Map<String, Object> record) {
 
         recordConsumer.startField("mybytes", index);
         recordConsumer.addBinary(
-            Binary.fromUnmodifiedByteBuffer((ByteBuffer) record.get("mybytes")));
+            Binary.fromConstantByteBuffer((ByteBuffer) record.get("mybytes")));
         recordConsumer.endField("mybytes", index++);
 
         recordConsumer.startField("mystring", index);
@@ -458,7 +458,7 @@ public void write(Map<String, Object> record) {
         recordConsumer.endField("mymap", index++);
 
         recordConsumer.startField("myfixed", index);
-        recordConsumer.addBinary(Binary.fromUnmodifiedByteArray((byte[]) record.get("myfixed")));
+        recordConsumer.addBinary(Binary.fromConstantByteArray((byte[]) record.get("myfixed")));
         recordConsumer.endField("myfixed", index++);
 
         recordConsumer.endMessage();

diff --git a/parquet-benchmarks/src/main/java/org/apache/parquet/benchmarks/DataGenerator.java b/parquet-benchmarks/src/main/java/org/apache/parquet/benchmarks/DataGenerator.java
@@ -107,7 +107,7 @@ public void generateData(Path outFile, Configuration configuration, ParquetPrope
           .append("float_field", 1.0f)
           .append("double_field", 2.0d)
           .append("flba_field", new String(chars))
-          .append("int96_field", Binary.fromUnmodifiedByteArray(new byte[12]))
+          .append("int96_field", Binary.fromConstantByteArray(new byte[12]))
       );
     }
     writer.close();

diff --git a/parquet-column/src/main/java/org/apache/parquet/column/statistics/BinaryStatistics.java b/parquet-column/src/main/java/org/apache/parquet/column/statistics/BinaryStatistics.java
@@ -46,8 +46,8 @@ public void mergeStatisticsMinMax(Statistics stats) {
 
   @Override
   public void setMinMaxFromBytes(byte[] minBytes, byte[] maxBytes) {
-    max = Binary.fromUnmodifiedByteArray(maxBytes);
-    min = Binary.fromUnmodifiedByteArray(minBytes);
+    max = Binary.fromConstantByteArray(maxBytes);
+    min = Binary.fromConstantByteArray(minBytes);
     this.markAsNotEmpty();
   }
 

diff --git a/...g/apache/parquet/column/values/deltalengthbytearray/DeltaLengthByteArrayValuesReader.java b/...g/apache/parquet/column/values/deltalengthbytearray/DeltaLengthByteArrayValuesReader.java
@@ -59,7 +59,7 @@ public Binary readBytes() {
     int length = lengthReader.readInteger();
     int start = offset;
     offset = start + length;
-    return Binary.fromUnmodifiedByteArray(in, start, length);
+    return Binary.fromConstantByteArray(in, start, length);
   }
 
   @Override

diff --git a/...umn/src/main/java/org/apache/parquet/column/values/deltastrings/DeltaByteArrayReader.java b/...umn/src/main/java/org/apache/parquet/column/values/deltastrings/DeltaByteArrayReader.java
@@ -40,7 +40,7 @@ public class DeltaByteArrayReader extends ValuesReader {
   public DeltaByteArrayReader() {
     this.prefixLengthReader = new DeltaBinaryPackingValuesReader();
     this.suffixReader = new DeltaLengthByteArrayValuesReader();
-    this.previous = Binary.fromUnmodifiedByteArray(new byte[0]);
+    this.previous = Binary.fromConstantByteArray(new byte[0]);
   }
 
   @Override
@@ -69,7 +69,7 @@ public Binary readBytes() {
       byte[] out = new byte[length];
       System.arraycopy(previous.getBytesUnsafe(), 0, out, 0, prefixLength);
       System.arraycopy(suffix.getBytesUnsafe(), 0, out, prefixLength, suffix.length());
-      previous =  Binary.fromUnmodifiedByteArray(out);
+      previous =  Binary.fromConstantByteArray(out);
     } else {
       previous = suffix;
     }

diff --git a/...umn/src/main/java/org/apache/parquet/column/values/deltastrings/DeltaByteArrayWriter.java b/...umn/src/main/java/org/apache/parquet/column/values/deltastrings/DeltaByteArrayWriter.java
@@ -87,7 +87,7 @@ public void writeBytes(Binary v) {
     int length = previous.length < vb.length ? previous.length : vb.length;
     for(i = 0; (i < length) && (previous[i] == vb[i]); i++);
     prefixLengthWriter.writeInteger(i);
-    suffixWriter.writeBytes(Binary.fromUnmodifiedByteArray(vb, i, vb.length - i));
+    suffixWriter.writeBytes(Binary.fromConstantByteArray(vb, i, vb.length - i));
     previous = vb;
   }
 }
diff --git a/...lumn/src/main/java/org/apache/parquet/column/values/dictionary/PlainValuesDictionary.java b/...lumn/src/main/java/org/apache/parquet/column/values/dictionary/PlainValuesDictionary.java
@@ -96,7 +96,7 @@ public PlainBinaryDictionary(DictionaryPage dictionaryPage, Integer length) thro
           // read the length
           offset += 4;
           // wrap the content in a binary
-          binaryDictionaryContent[i] = Binary.fromUnmodifiedByteArray(dictionaryBytes, offset, len);
+          binaryDictionaryContent[i] = Binary.fromConstantByteArray(dictionaryBytes, offset, len);
           // increment to the next value
           offset += len;
         }
@@ -106,7 +106,7 @@ public PlainBinaryDictionary(DictionaryPage dictionaryPage, Integer length) thro
             "Invalid byte array length: " + length);
         for (int i = 0; i < binaryDictionaryContent.length; i++) {
           // wrap the content in a Binary
-          binaryDictionaryContent[i] = Binary.fromUnmodifiedByteArray(
+          binaryDictionaryContent[i] = Binary.fromConstantByteArray(
               dictionaryBytes, offset, length);
           // increment to the next value
           offset += length;

diff --git a/...-column/src/main/java/org/apache/parquet/column/values/plain/BinaryPlainValuesReader.java b/...-column/src/main/java/org/apache/parquet/column/values/plain/BinaryPlainValuesReader.java
@@ -39,7 +39,7 @@ public Binary readBytes() {
       int length = BytesUtils.readIntLittleEndian(in, offset);
       int start = offset + 4;
       offset = start + length;
-      return Binary.fromUnmodifiedByteArray(in, start, length);
+      return Binary.fromConstantByteArray(in, start, length);
     } catch (IOException e) {
       throw new ParquetDecodingException("could not read bytes at offset " + offset, e);
     } catch (RuntimeException e) {

diff --git a/.../main/java/org/apache/parquet/column/values/plain/FixedLenByteArrayPlainValuesReader.java b/.../main/java/org/apache/parquet/column/values/plain/FixedLenByteArrayPlainValuesReader.java
@@ -46,7 +46,7 @@ public Binary readBytes() {
     try {
       int start = offset;
       offset = start + length;
-      return Binary.fromUnmodifiedByteArray(in, start, length);
+      return Binary.fromConstantByteArray(in, start, length);
     } catch (RuntimeException e) {
       throw new ParquetDecodingException("could not read bytes at offset " + offset, e);
     }

diff --git a/parquet-column/src/main/java/org/apache/parquet/example/data/simple/NanoTime.java b/parquet-column/src/main/java/org/apache/parquet/example/data/simple/NanoTime.java
@@ -61,7 +61,7 @@ public Binary toBinary() {
     buf.putLong(timeOfDayNanos);
     buf.putInt(julianDay);
     buf.flip();
-    return Binary.fromUnmodifiedByteBuffer(buf);
+    return Binary.fromConstantByteBuffer(buf);
   }
 
   public Int96Value toInt96() {

diff --git a/parquet-column/src/main/java/org/apache/parquet/io/api/Binary.java b/parquet-column/src/main/java/org/apache/parquet/io/api/Binary.java
@@ -33,12 +33,12 @@
 
 abstract public class Binary implements Comparable<Binary>, Serializable {
 
-  private boolean isUnmodifiable;
+  protected boolean isReused;
 
   // this isn't really something others should extend
   private Binary() { }
 
-  public static final Binary EMPTY = fromUnmodifiedByteArray(new byte[0]);
+  public static final Binary EMPTY = fromConstantByteArray(new byte[0]);
 
   abstract public String toStringUsingUTF8();
 
@@ -83,27 +83,27 @@ public String toString() {
   }
 
   public Binary copy() {
-    if (isUnmodifiable) {
-      return this;
+    if (isReused) {
+      return Binary.fromConstantByteArray(getBytes());
     } else {
-      return Binary.fromReusedByteArray(getBytes());
+      return this;
     }
   }
 
-  protected void setUnmodifiable(boolean isUnmodifiable) {
-    this.isUnmodifiable = isUnmodifiable;
+  public boolean isReused() {
+    return isReused;
   }
 
   private static class ByteArraySliceBackedBinary extends Binary {
     private final byte[] value;
     private final int offset;
     private final int length;
 
-    public ByteArraySliceBackedBinary(byte[] value, int offset, int length, boolean isUnmodifiable) {
+    public ByteArraySliceBackedBinary(byte[] value, int offset, int length, boolean isReused) {
       this.value = value;
       this.offset = offset;
       this.length = length;
-      setUnmodifiable(isUnmodifiable);
+      this.isReused = isReused;
     }
 
     @Override
@@ -183,26 +183,21 @@ public String toString() {
     }
   }
 
-  private static Binary fromByteArray(final byte[] value, final int offset, final int length,
-                                      final boolean isUnmodifiable) {
-    return new ByteArraySliceBackedBinary(value, offset, length, isUnmodifiable);
-  }
-
   public static Binary fromReusedByteArray(final byte[] value, final int offset, final int length) {
-    return fromByteArray(value, offset, length, false);
+    return new ByteArraySliceBackedBinary(value, offset, length, true);
   }
 
-  public static Binary fromUnmodifiedByteArray(final byte[] value, final int offset,
-                                               final int length) {
-    return fromByteArray(value, offset, length, true);
+  public static Binary fromConstantByteArray(final byte[] value, final int offset,
+                                             final int length) {
+    return new ByteArraySliceBackedBinary(value, offset, length, false);
   }
 
   private static class ByteArrayBackedBinary extends Binary {
     private final byte[] value;
 
-    public ByteArrayBackedBinary(byte[] value, boolean isUnmodifiable) {
+    public ByteArrayBackedBinary(byte[] value, boolean isReused) {
       this.value = value;
-      setUnmodifiable(isUnmodifiable);
+      this.isReused = isReused;
     }
 
     @Override
@@ -267,24 +262,20 @@ public void writeTo(DataOutput out) throws IOException {
 
   }
 
-  private static Binary fromByteArray(final byte[] value, final boolean isUnmodifiable) {
-    return new ByteArrayBackedBinary(value, isUnmodifiable);
-  }
-
   public static Binary fromReusedByteArray(final byte[] value) {
-    return fromByteArray(value, false);
+    return new ByteArrayBackedBinary(value, true);
   }
 
-  public static Binary fromUnmodifiedByteArray(final byte[] value) {
-    return fromByteArray(value, true);
+  public static Binary fromConstantByteArray(final byte[] value) {
+    return new ByteArrayBackedBinary(value, false);
   }
 
   private static class ByteBufferBackedBinary extends Binary {
     private transient ByteBuffer value;
 
-    public ByteBufferBackedBinary(ByteBuffer value, boolean isUnmodifiable) {
+    public ByteBufferBackedBinary(ByteBuffer value, boolean isReused) {
       this.value = value;
-      setUnmodifiable(isUnmodifiable);
+      this.isReused = isReused;
     }
 
     @Override
@@ -397,16 +388,12 @@ private void readObjectNoData() throws ObjectStreamException {
 
   }
 
-  private static Binary fromByteBuffer(final ByteBuffer value, final boolean isUnmodifiable) {
-    return new ByteBufferBackedBinary(value, isUnmodifiable);
-  }
-
   public static Binary fromReusedByteBuffer(final ByteBuffer value) {
-    return fromByteBuffer(value, false);
+    return new ByteBufferBackedBinary(value, true);
   }
 
-  public static Binary fromUnmodifiedByteBuffer(final ByteBuffer value) {
-    return fromByteBuffer(value, true);
+  public static Binary fromConstantByteBuffer(final ByteBuffer value) {
+    return new ByteBufferBackedBinary(value, false);
   }
 
   public static Binary fromString(final String value) {

diff --git a/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/TestParquetWriter.java b/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/TestParquetWriter.java
@@ -37,7 +37,6 @@
 import java.util.Map;
 
 import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
 import org.junit.Test;
 
@@ -95,7 +94,7 @@ public void test() throws Exception {
               .append("float_field", 1.0f)
               .append("double_field", 2.0d)
               .append("flba_field", "foo")
-              .append("int96_field", Binary.fromUnmodifiedByteArray(new byte[12])));
+              .append("int96_field", Binary.fromConstantByteArray(new byte[12])));
         }
         writer.close();
         ParquetReader<Group> reader = ParquetReader.builder(new GroupReadSupport(), file).withConf(conf).build();
@@ -108,7 +107,7 @@ public void test() throws Exception {
           assertEquals(1.0f, group.getFloat("float_field", 0), 0.001);
           assertEquals(2.0d, group.getDouble("double_field", 0), 0.001);
           assertEquals("foo", group.getBinary("flba_field", 0).toStringUsingUTF8());
-          assertEquals(Binary.fromUnmodifiedByteArray(new byte[12]), group.getInt96("int96_field",
+          assertEquals(Binary.fromConstantByteArray(new byte[12]), group.getInt96("int96_field",
               0));
         }
         reader.close();

diff --git a/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/TestParquetWriterNewPage.java b/parquet-hadoop/src/test/java/org/apache/parquet/hadoop/TestParquetWriterNewPage.java
@@ -99,7 +99,7 @@ public void test() throws Exception {
               .append("float_field", 1.0f)
               .append("double_field", 2.0d)
               .append("flba_field", "foo")
-              .append("int96_field", Binary.fromUnmodifiedByteArray(new byte[12])));
+              .append("int96_field", Binary.fromConstantByteArray(new byte[12])));
         }
         writer.close();
 
@@ -113,7 +113,7 @@ public void test() throws Exception {
           assertEquals(1.0f, group.getFloat("float_field", 0), 0.001);
           assertEquals(2.0d, group.getDouble("double_field", 0), 0.001);
           assertEquals("foo", group.getBinary("flba_field", 0).toStringUsingUTF8());
-          assertEquals(Binary.fromUnmodifiedByteArray(new byte[12]), group.getInt96("int96_field",
+          assertEquals(Binary.fromConstantByteArray(new byte[12]), group.getInt96("int96_field",
               0));
           assertEquals(0, group.getFieldRepetitionCount("null_field"));
         }

diff --git a/...e-handler/src/main/java/org/apache/hadoop/hive/ql/io/parquet/writable/BinaryWritable.java b/...e-handler/src/main/java/org/apache/hadoop/hive/ql/io/parquet/writable/BinaryWritable.java
@@ -57,7 +57,7 @@ public String getString() {
   public void readFields(DataInput input) throws IOException {
     byte[] bytes = new byte[input.readInt()];
     input.readFully(bytes);
-    binary = Binary.fromUnmodifiedByteArray(bytes);
+    binary = Binary.fromConstantByteArray(bytes);
   }
 
   @Override

diff --git a/.../java/org/apache/hadoop/hive/serde2/objectinspector/primitive/ParquetStringInspector.java b/.../java/org/apache/hadoop/hive/serde2/objectinspector/primitive/ParquetStringInspector.java
@@ -77,7 +77,7 @@ public String getPrimitiveJavaObject(final Object o) {
 
   @Override
   public Object set(final Object o, final Text text) {
-    return new BinaryWritable(text == null ? null : Binary.fromUnmodifiedByteArray(text.getBytes
+    return new BinaryWritable(text == null ? null : Binary.fromConstantByteArray(text.getBytes
         ()));
   }
 

diff --git a/parquet-pig/src/main/java/org/apache/parquet/pig/TupleWriteSupport.java b/parquet-pig/src/main/java/org/apache/parquet/pig/TupleWriteSupport.java
@@ -172,7 +172,7 @@ private void writeValue(Type type, FieldSchema pigType, Tuple t, int i) {
           } else {
             throw new UnsupportedOperationException("can not convert from " + DataType.findTypeName(pigType.type) + " to BINARY ");
           }
-          recordConsumer.addBinary(Binary.fromUnmodifiedByteArray(bytes));
+          recordConsumer.addBinary(Binary.fromConstantByteArray(bytes));
           break;
         case BOOLEAN:
           recordConsumer.addBoolean((Boolean)t.get(i));

diff --git a/parquet-protobuf/src/main/java/org/apache/parquet/proto/ProtoWriteSupport.java b/parquet-protobuf/src/main/java/org/apache/parquet/proto/ProtoWriteSupport.java
@@ -318,7 +318,7 @@ class BinaryWriter extends FieldWriter {
     @Override
     final void writeRawValue(Object value) {
       ByteString byteString = (ByteString) value;
-      Binary binary = Binary.fromUnmodifiedByteArray(byteString.toByteArray());
+      Binary binary = Binary.fromConstantByteArray(byteString.toByteArray());
       recordConsumer.addBinary(binary);
     }
   }