Add unmodfied and Reused versions for creating a Binary. Add copy() to Binary.

asingh · asingh · commit 0d127a76a03e · 2015-06-29T12:31:02.000-07:00
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.fromByteArray((byte[]) value));
+        recordConsumer.addBinary(Binary.fromUnmodifiedByteArray((byte[]) value));
       } else {
-        recordConsumer.addBinary(Binary.fromByteBuffer((ByteBuffer) value));
+        recordConsumer.addBinary(Binary.fromUnmodifiedByteBuffer((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.fromByteArray(((GenericFixed) value).bytes()));
+      recordConsumer.addBinary(Binary.fromUnmodifiedByteArray(((GenericFixed) value).bytes()));
     }
   }
 
   private Binary fromAvroString(Object value) {
     if (value instanceof Utf8) {
       Utf8 utf8 = (Utf8) value;
-      return Binary.fromByteArray(utf8.getBytes(), 0, utf8.getByteLength());
+      return Binary.fromUnmodifiedByteArray(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
@@ -362,7 +362,8 @@ public void write(Map<String, Object> record) {
         recordConsumer.endField("mydouble", index++);
 
         recordConsumer.startField("mybytes", index);
-        recordConsumer.addBinary(Binary.fromByteBuffer((ByteBuffer) record.get("mybytes")));
+        recordConsumer.addBinary(
+            Binary.fromUnmodifiedByteBuffer((ByteBuffer) record.get("mybytes")));
         recordConsumer.endField("mybytes", index++);
 
         recordConsumer.startField("mystring", index);
@@ -457,7 +458,7 @@ public void write(Map<String, Object> record) {
         recordConsumer.endField("mymap", index++);
 
         recordConsumer.startField("myfixed", index);
-        recordConsumer.addBinary(Binary.fromByteArray((byte[]) record.get("myfixed")));
+        recordConsumer.addBinary(Binary.fromUnmodifiedByteArray((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.fromByteArray(new byte[12]))
+          .append("int96_field", Binary.fromUnmodifiedByteArray(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.fromByteArray(maxBytes);
-    min = Binary.fromByteArray(minBytes);
+    max = Binary.fromUnmodifiedByteArray(maxBytes);
+    min = Binary.fromUnmodifiedByteArray(minBytes);
     this.markAsNotEmpty();
   }
 
@@ -72,13 +72,13 @@ else if (!this.isEmpty())
   }
 
   public void updateStats(Binary min_value, Binary max_value) {
-    if (min.compareTo(min_value) > 0) { min = Binary.fromByteArray(min_value.getBytes()); }
-    if (max.compareTo(max_value) < 0) { max = Binary.fromByteArray(max_value.getBytes()); }
+    if (min.compareTo(min_value) > 0) { min = min_value.copy(); }
+    if (max.compareTo(max_value) < 0) { max = max_value.copy(); }
   }
 
   public void initializeStats(Binary min_value, Binary max_value) {
-      min = Binary.fromByteArray(min_value.getBytes());
-      max = Binary.fromByteArray(max_value.getBytes());
+      min = min_value.copy();
+      max = max_value.copy();
       this.markAsNotEmpty();
   }
 
diff --git a/parquet-column/src/main/java/org/apache/parquet/column/values/deltalengthbytearray/DeltaLengthByteArrayValuesReader.java b/parquet-column/src/main/java/org/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.fromByteArray(in, start, length);
+    return Binary.fromUnmodifiedByteArray(in, start, length);
   }
 
   @Override
diff --git a/parquet-column/src/main/java/org/apache/parquet/column/values/deltastrings/DeltaByteArrayReader.java b/parquet-column/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.fromByteArray(new byte[0]);
+    this.previous = Binary.fromUnmodifiedByteArray(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.fromByteArray(out);
+      previous =  Binary.fromUnmodifiedByteArray(out);
     } else {
       previous = suffix;
     }
diff --git a/parquet-column/src/main/java/org/apache/parquet/column/values/deltastrings/DeltaByteArrayWriter.java b/parquet-column/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.fromByteArray(vb, i, vb.length - i));
+    suffixWriter.writeBytes(Binary.fromUnmodifiedByteArray(vb, i, vb.length - i));
     previous = vb;
   }
 }
diff --git a/parquet-column/src/main/java/org/apache/parquet/column/values/dictionary/DictionaryValuesWriter.java b/parquet-column/src/main/java/org/apache/parquet/column/values/dictionary/DictionaryValuesWriter.java
@@ -235,7 +235,7 @@ public void writeBytes(Binary v) {
       int id = binaryDictionaryContent.getInt(v);
       if (id == -1) {
         id = binaryDictionaryContent.size();
-        binaryDictionaryContent.put(copy(v), id);
+        binaryDictionaryContent.put(v.copy(), id);
         // length as int (4 bytes) + actual bytes
         dictionaryByteSize += 4 + v.length();
       }
@@ -283,10 +283,6 @@ public void fallBackDictionaryEncodedData(ValuesWriter writer) {
         writer.writeBytes(reverseDictionary[id]);
       }
     }
-
-    protected static Binary copy(Binary binary) {
-      return Binary.fromByteArray(binary.getBytes());
-    }
   }
 
   /**
@@ -310,7 +306,7 @@ public void writeBytes(Binary value) {
       int id = binaryDictionaryContent.getInt(value);
       if (id == -1) {
         id = binaryDictionaryContent.size();
-        binaryDictionaryContent.put(copy(value), id);
+        binaryDictionaryContent.put(value.copy(), id);
         dictionaryByteSize += length;
       }
       encodedValues.add(id);
diff --git a/parquet-column/src/main/java/org/apache/parquet/column/values/dictionary/PlainValuesDictionary.java b/parquet-column/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.fromByteArray(dictionaryBytes, offset, len);
+          binaryDictionaryContent[i] = Binary.fromUnmodifiedByteArray(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.fromByteArray(
+          binaryDictionaryContent[i] = Binary.fromUnmodifiedByteArray(
               dictionaryBytes, offset, length);
           // increment to the next value
           offset += length;
diff --git a/parquet-column/src/main/java/org/apache/parquet/column/values/plain/BinaryPlainValuesReader.java b/parquet-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.fromByteArray(in, start, length);
+      return Binary.fromUnmodifiedByteArray(in, start, length);
     } catch (IOException e) {
       throw new ParquetDecodingException("could not read bytes at offset " + offset, e);
     } catch (RuntimeException e) {
diff --git a/parquet-column/src/main/java/org/apache/parquet/column/values/plain/FixedLenByteArrayPlainValuesReader.java b/parquet-column/src/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.fromByteArray(in, start, length);
+      return Binary.fromUnmodifiedByteArray(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.fromByteBuffer(buf);
+    return Binary.fromUnmodifiedByteBuffer(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,10 +33,12 @@
 
 abstract public class Binary implements Comparable<Binary>, Serializable {
 
+  private boolean isUnmodifiable;
+
   // this isn't really something others should extend
   private Binary() { }
 
-  public static final Binary EMPTY = fromByteArray(new byte[0]);
+  public static final Binary EMPTY = fromUnmodifiedByteArray(new byte[0]);
 
   abstract public String toStringUsingUTF8();
 
@@ -80,15 +82,28 @@ public String toString() {
     return "Binary{" + length() + " bytes, " + Arrays.toString(getBytesUnsafe()) + "}";
   }
 
+  public Binary copy() {
+    if (isUnmodifiable) {
+      return this;
+    } else {
+      return Binary.fromReusedByteArray(getBytes());
+    }
+  }
+
+  protected void setUnmodifiable(boolean isUnmodifiable) {
+    this.isUnmodifiable = isUnmodifiable;
+  }
+
   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) {
+    public ByteArraySliceBackedBinary(byte[] value, int offset, int length, boolean isUnmodifiable) {
       this.value = value;
       this.offset = offset;
       this.length = length;
+      setUnmodifiable(isUnmodifiable);
     }
 
     @Override
@@ -159,7 +174,7 @@ public void writeTo(DataOutput out) throws IOException {
 
   private static class FromStringBinary extends ByteArrayBackedBinary {
     public FromStringBinary(byte[] value) {
-      super(value);
+      super(value, true);
     }
 
     @Override
@@ -168,15 +183,26 @@ public String toString() {
     }
   }
 
-  public static Binary fromByteArray(final byte[] value, final int offset, final int length) {
-    return new ByteArraySliceBackedBinary(value, offset, length);
+  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);
+  }
+
+  public static Binary fromUnmodifiedByteArray(final byte[] value, final int offset,
+                                               final int length) {
+    return fromByteArray(value, offset, length, true);
   }
 
   private static class ByteArrayBackedBinary extends Binary {
     private final byte[] value;
 
-    public ByteArrayBackedBinary(byte[] value) {
+    public ByteArrayBackedBinary(byte[] value, boolean isUnmodifiable) {
       this.value = value;
+      setUnmodifiable(isUnmodifiable);
     }
 
     @Override
@@ -241,15 +267,24 @@ public void writeTo(DataOutput out) throws IOException {
 
   }
 
-  public static Binary fromByteArray(final byte[] value) {
-    return new ByteArrayBackedBinary(value);
+  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);
+  }
+
+  public static Binary fromUnmodifiedByteArray(final byte[] value) {
+    return fromByteArray(value, true);
   }
 
   private static class ByteBufferBackedBinary extends Binary {
     private transient ByteBuffer value;
 
-    public ByteBufferBackedBinary(ByteBuffer value) {
+    public ByteBufferBackedBinary(ByteBuffer value, boolean isUnmodifiable) {
       this.value = value;
+      setUnmodifiable(isUnmodifiable);
     }
 
     @Override
@@ -362,8 +397,16 @@ private void readObjectNoData() throws ObjectStreamException {
 
   }
 
-  public static Binary fromByteBuffer(final ByteBuffer value) {
-    return new ByteBufferBackedBinary(value);
+  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);
+  }
+
+  public static Binary fromUnmodifiedByteBuffer(final ByteBuffer value) {
+    return fromByteBuffer(value, true);
   }
 
   public static Binary fromString(final String value) {
diff --git a/parquet-column/src/test/java/org/apache/parquet/column/statistics/TestStatistics.java b/parquet-column/src/test/java/org/apache/parquet/column/statistics/TestStatistics.java
@@ -388,13 +388,13 @@ public void testBinaryMinMaxForReusedBackingByteArray() {
     BinaryStatistics stats = new BinaryStatistics();
 
     byte[] bytes = new byte[] { 10 };
-    stats.updateStats(Binary.fromByteArray(bytes));
+    stats.updateStats(Binary.fromReusedByteArray(bytes));
 
     bytes[0] = 20;
-    stats.updateStats(Binary.fromByteArray(bytes));
+    stats.updateStats(Binary.fromReusedByteArray(bytes));
 
     bytes[0] = 15;
-    stats.updateStats(Binary.fromByteArray(bytes));
+    stats.updateStats(Binary.fromReusedByteArray(bytes));
 
     assertArrayEquals(new byte[] { 20 }, stats.getMaxBytes());
     assertArrayEquals(new byte[] { 10 }, stats.getMinBytes());
diff --git a/parquet-column/src/test/java/org/apache/parquet/column/values/dictionary/TestDictionary.java b/parquet-column/src/test/java/org/apache/parquet/column/values/dictionary/TestDictionary.java
@@ -519,7 +519,7 @@ private void writeRepeatedWithReuse(int COUNT, ValuesWriter cw,
     for (int i = 0; i < COUNT; i++) {
       Binary content = Binary.fromString(prefix + i % 10);
       System.arraycopy(content.getBytesUnsafe(), 0, reused, 0, reused.length);
-      cw.writeBytes(Binary.fromByteArray(reused));
+      cw.writeBytes(Binary.fromReusedByteArray(reused));
     }
   }
 
diff --git a/parquet-hadoop/src/main/java/org/apache/parquet/filter2/compat/RowGroupFilter.java b/parquet-hadoop/src/main/java/org/apache/parquet/filter2/compat/RowGroupFilter.java
@@ -58,9 +58,14 @@ private RowGroupFilter(ParquetMetadata footer, MessageType schema) {
   }
 
   private static boolean shouldIgnoreStatistics(String createdBy) {
-    final String[] tokens = createdBy.split(" ");
-    final String app = tokens[0];
-    final String version = tokens[2].substring(0, 5).replaceAll("\\.", "");
+    final String[] versionTokens = createdBy.split(" ");
+
+    if (versionTokens.length < 3) {
+      return true;
+    }
+
+    final String app = versionTokens[0];
+    final String version = versionTokens[2].substring(0, 5).replaceAll("\\.", "");
 
     if (app.equalsIgnoreCase("parquet-mr")) {
       return Integer.parseInt(version) < STATISTICS_FIXED_VERSION;
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
@@ -95,7 +95,7 @@ public void test() throws Exception {
               .append("float_field", 1.0f)
               .append("double_field", 2.0d)
               .append("flba_field", "foo")
-              .append("int96_field", Binary.fromByteArray(new byte[12])));
+              .append("int96_field", Binary.fromUnmodifiedByteArray(new byte[12])));
         }
         writer.close();
         ParquetReader<Group> reader = ParquetReader.builder(new GroupReadSupport(), file).withConf(conf).build();
@@ -108,7 +108,8 @@ 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.fromByteArray(new byte[12]), group.getInt96("int96_field", 0));
+          assertEquals(Binary.fromUnmodifiedByteArray(new byte[12]), group.getInt96("int96_field",
+              0));
         }
         reader.close();
         ParquetMetadata footer = readFooter(conf, file, NO_FILTER);
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
diff --git a/parquet-hive/parquet-hive-storage-handler/src/main/java/org/apache/hadoop/hive/ql/io/parquet/writable/BinaryWritable.java b/parquet-hive/parquet-hive-storage-handler/src/main/java/org/apache/hadoop/hive/ql/io/parquet/writable/BinaryWritable.java
diff --git a/parquet-hive/parquet-hive-storage-handler/src/main/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/ParquetStringInspector.java b/parquet-hive/parquet-hive-storage-handler/src/main/java/org/apache/hadoop/hive/serde2/objectinspector/primitive/ParquetStringInspector.java
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
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
diff --git a/parquet-protobuf/src/test/java/org/apache/parquet/proto/ProtoWriteSupportTest.java b/parquet-protobuf/src/test/java/org/apache/parquet/proto/ProtoWriteSupportTest.java
diff --git a/parquet-thrift/src/main/java/org/apache/parquet/thrift/ParquetWriteProtocol.java b/parquet-thrift/src/main/java/org/apache/parquet/thrift/ParquetWriteProtocol.java

Original file line number	Diff line number	Diff line change
`@@ -252,9 +252,9 @@ private void writeValue(Type type, Schema avroSchema, Object value) {`
`252`	`252`	`recordConsumer.addDouble(((Number) value).doubleValue());`
`253`	`253`	`} else if (avroType.equals(Schema.Type.BYTES)) {`
`254`	`254`	`if (value instanceof byte[]) {`
`255`		`- recordConsumer.addBinary(Binary.fromByteArray((byte[]) value));`
	`255`	`+ recordConsumer.addBinary(Binary.fromUnmodifiedByteArray((byte[]) value));`
`256`	`256`	`} else {`
`257`		`- recordConsumer.addBinary(Binary.fromByteBuffer((ByteBuffer) value));`
	`257`	`+ recordConsumer.addBinary(Binary.fromUnmodifiedByteBuffer((ByteBuffer) value));`
`258`	`258`	`}`
`259`	`259`	`} else if (avroType.equals(Schema.Type.STRING)) {`
`260`	`260`	`recordConsumer.addBinary(fromAvroString(value));`
`@@ -269,14 +269,14 @@ private void writeValue(Type type, Schema avroSchema, Object value) {`
`269`	`269`	`} else if (avroType.equals(Schema.Type.UNION)) {`
`270`	`270`	`writeUnion(type.asGroupType(), nonNullAvroSchema, value);`
`271`	`271`	`} else if (avroType.equals(Schema.Type.FIXED)) {`
`272`		`- recordConsumer.addBinary(Binary.fromByteArray(((GenericFixed) value).bytes()));`
	`272`	`+ recordConsumer.addBinary(Binary.fromUnmodifiedByteArray(((GenericFixed) value).bytes()));`
`273`	`273`	`}`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`private Binary fromAvroString(Object value) {`
`277`	`277`	`if (value instanceof Utf8) {`
`278`	`278`	`Utf8 utf8 = (Utf8) value;`
`279`		`- return Binary.fromByteArray(utf8.getBytes(), 0, utf8.getByteLength());`
	`279`	`+ return Binary.fromUnmodifiedByteArray(utf8.getBytes(), 0, utf8.getByteLength());`
`280`	`280`	`}`
`281`	`281`	`return Binary.fromString(value.toString());`
`282`	`282`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ public void generateData(Path outFile, Configuration configuration, ParquetPrope`
`107`	`107`	`.append("float_field", 1.0f)`
`108`	`108`	`.append("double_field", 2.0d)`
`109`	`109`	`.append("flba_field", new String(chars))`
`110`		`- .append("int96_field", Binary.fromByteArray(new byte[12]))`
	`110`	`+ .append("int96_field", Binary.fromUnmodifiedByteArray(new byte[12]))`
`111`	`111`	`);`
`112`	`112`	`}`
`113`	`113`	`writer.close();`
Original file line number	Diff line number	Diff line change
`@@ -46,8 +46,8 @@ public void mergeStatisticsMinMax(Statistics stats) {`
`46`	`46`
`47`	`47`	`@Override`
`48`	`48`	`public void setMinMaxFromBytes(byte[] minBytes, byte[] maxBytes) {`
`49`		`- max = Binary.fromByteArray(maxBytes);`
`50`		`- min = Binary.fromByteArray(minBytes);`
	`49`	`+ max = Binary.fromUnmodifiedByteArray(maxBytes);`
	`50`	`+ min = Binary.fromUnmodifiedByteArray(minBytes);`
`51`	`51`	`this.markAsNotEmpty();`
`52`	`52`	`}`
`53`	`53`
`@@ -72,13 +72,13 @@ else if (!this.isEmpty())`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`public void updateStats(Binary min_value, Binary max_value) {`
`75`		`- if (min.compareTo(min_value) > 0) { min = Binary.fromByteArray(min_value.getBytes()); }`
`76`		`- if (max.compareTo(max_value) < 0) { max = Binary.fromByteArray(max_value.getBytes()); }`
	`75`	`+ if (min.compareTo(min_value) > 0) { min = min_value.copy(); }`
	`76`	`+ if (max.compareTo(max_value) < 0) { max = max_value.copy(); }`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public void initializeStats(Binary min_value, Binary max_value) {`
`80`		`- min = Binary.fromByteArray(min_value.getBytes());`
`81`		`- max = Binary.fromByteArray(max_value.getBytes());`
	`80`	`+ min = min_value.copy();`
	`81`	`+ max = max_value.copy();`
`82`	`82`	`this.markAsNotEmpty();`
`83`	`83`	`}`
`84`	`84`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public Binary readBytes() {`
`59`	`59`	`int length = lengthReader.readInteger();`
`60`	`60`	`int start = offset;`
`61`	`61`	`offset = start + length;`
`62`		`- return Binary.fromByteArray(in, start, length);`
	`62`	`+ return Binary.fromUnmodifiedByteArray(in, start, length);`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ public void writeBytes(Binary v) {`
`87`	`87`	`int length = previous.length < vb.length ? previous.length : vb.length;`
`88`	`88`	`for(i = 0; (i < length) && (previous[i] == vb[i]); i++);`
`89`	`89`	`prefixLengthWriter.writeInteger(i);`
`90`		`- suffixWriter.writeBytes(Binary.fromByteArray(vb, i, vb.length - i));`
	`90`	`+ suffixWriter.writeBytes(Binary.fromUnmodifiedByteArray(vb, i, vb.length - i));`
`91`	`91`	`previous = vb;`
`92`	`92`	`}`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -235,7 +235,7 @@ public void writeBytes(Binary v) {`
`235`	`235`	`int id = binaryDictionaryContent.getInt(v);`
`236`	`236`	`if (id == -1) {`
`237`	`237`	`id = binaryDictionaryContent.size();`
`238`		`- binaryDictionaryContent.put(copy(v), id);`
	`238`	`+ binaryDictionaryContent.put(v.copy(), id);`
`239`	`239`	`// length as int (4 bytes) + actual bytes`
`240`	`240`	`dictionaryByteSize += 4 + v.length();`
`241`	`241`	`}`
`@@ -283,10 +283,6 @@ public void fallBackDictionaryEncodedData(ValuesWriter writer) {`
`283`	`283`	`writer.writeBytes(reverseDictionary[id]);`
`284`	`284`	`}`
`285`	`285`	`}`
`286`		`-`
`287`		`- protected static Binary copy(Binary binary) {`
`288`		`- return Binary.fromByteArray(binary.getBytes());`
`289`		`- }`
`290`	`286`	`}`
`291`	`287`
`292`	`288`	`/**`
`@@ -310,7 +306,7 @@ public void writeBytes(Binary value) {`
`310`	`306`	`int id = binaryDictionaryContent.getInt(value);`
`311`	`307`	`if (id == -1) {`
`312`	`308`	`id = binaryDictionaryContent.size();`
`313`		`- binaryDictionaryContent.put(copy(value), id);`
	`309`	`+ binaryDictionaryContent.put(value.copy(), id);`
`314`	`310`	`dictionaryByteSize += length;`
`315`	`311`	`}`
`316`	`312`	`encodedValues.add(id);`