feat: add support for lazy bytes arrays

Author: olavloite

google-cloud-spanner/src/main/java/com/google/cloud/spanner/AbstractResultSet.java

@@ -32,6 +32,7 @@
 import com.google.cloud.spanner.spi.v1.SpannerRpc;
 import com.google.cloud.spanner.v1.stub.SpannerStubSettings;
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
 import com.google.common.collect.AbstractIterator;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
@@ -62,13 +63,16 @@
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 /** Implementation of {@link ResultSet}. */
@@ -357,19 +361,42 @@ private boolean isMergeable(KindCase kind) {
     }
   }
 
-  static class LazyByteArray implements Serializable {
+  static final class LazyByteArray implements Serializable {
+    private static final Base64.Encoder ENCODER = Base64.getEncoder();
     private static final Base64.Decoder DECODER = Base64.getDecoder();
     private final String base64String;
-    private final transient AbstractLazyInitializer<ByteArray> byteArray =
-        new AbstractLazyInitializer<ByteArray>() {
-          @Override
-          protected ByteArray initialize() {
-            return ByteArray.copyFrom(DECODER.decode(base64String));
-          }
-        };
+    private transient AbstractLazyInitializer<ByteArray> byteArray;
+
+    LazyByteArray(@Nonnull String base64String) {
+      this.base64String = Preconditions.checkNotNull(base64String);
+      byteArray = defaultInitializer();
+    }
+
+    LazyByteArray(@Nonnull ByteArray byteArray) {
+      this.base64String =
+          ENCODER.encodeToString(Preconditions.checkNotNull(byteArray).toByteArray());
+      this.byteArray =
+          new AbstractLazyInitializer<ByteArray>() {
+            @Override
+            protected ByteArray initialize() {
+              return byteArray;
+            }
+          };
+    }
+
+    private AbstractLazyInitializer<ByteArray> defaultInitializer() {
+      return new AbstractLazyInitializer<ByteArray>() {
+        @Override
+        protected ByteArray initialize() {
+          return ByteArray.copyFrom(DECODER.decode(base64String));
+        }
+      };
+    }
 
-    LazyByteArray(String base64String) {
-      this.base64String = base64String;
+    private void readObject(java.io.ObjectInputStream in)
+        throws IOException, ClassNotFoundException {
+      in.defaultReadObject();
+      byteArray = defaultInitializer();
     }
 
     ByteArray getByteArray() {
@@ -388,6 +415,23 @@ String getBase64String() {
     public String toString() {
       return getBase64String();
     }
+
+    @Override
+    public int hashCode() {
+      return base64String.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (o instanceof LazyByteArray) {
+        return lazyByteArraysEqual((LazyByteArray) o);
+      }
+      return false;
+    }
+
+    private boolean lazyByteArraysEqual(LazyByteArray other) {
+      return Objects.equals(getBase64String(), other.getBase64String());
+    }
   }
 
   static class GrpcStruct extends Struct implements Serializable {
@@ -435,9 +479,8 @@ private Object writeReplace() {
             builder
                 .set(fieldName)
                 .to(
-                    value instanceof LazyByteArray
-                        ? ((LazyByteArray) value).getByteArray()
-                        : (ByteArray) value);
+                    Value.bytesFromBase64(
+                        value == null ? null : ((LazyByteArray) value).getBase64String()));
             break;
           case TIMESTAMP:
             builder.set(fieldName).to((Timestamp) value);
@@ -473,7 +516,17 @@ private Object writeReplace() {
                 builder.set(fieldName).toPgJsonbArray((Iterable<String>) value);
                 break;
               case BYTES:
-                builder.set(fieldName).toBytesArray((Iterable<ByteArray>) value);
+                builder
+                    .set(fieldName)
+                    .toBytesArrayFromBase64(
+                        value == null
+                            ? null
+                            : ((List<LazyByteArray>) value)
+                                .stream()
+                                    .map(
+                                        element ->
+                                            element == null ? null : element.getBase64String())
+                                    .collect(Collectors.toList()));
                 break;
               case TIMESTAMP:
                 builder.set(fieldName).toTimestampArray((Iterable<Timestamp>) value);
@@ -720,7 +773,7 @@ protected Value getValueInternal(int columnIndex) {
         case PG_JSONB:
           return Value.pgJsonb(isNull ? null : getPgJsonbInternal(columnIndex));
         case BYTES:
-          return Value.lazyBytes(isNull ? null : getLazyBytesInternal(columnIndex));
+          return Value.internalBytes(isNull ? null : getLazyBytesInternal(columnIndex));
         case TIMESTAMP:
           return Value.timestamp(isNull ? null : getTimestampInternal(columnIndex));
         case DATE:

google-cloud-spanner/src/main/java/com/google/cloud/spanner/Value.java

@@ -29,6 +29,7 @@
 import com.google.protobuf.ListValue;
 import com.google.protobuf.NullValue;
 import com.google.protobuf.Value.KindCase;
+import java.io.IOException;
 import java.io.Serializable;
 import java.math.BigDecimal;
 import java.util.ArrayList;
@@ -227,16 +228,22 @@ public static Value pgJsonb(@Nullable String v) {
    * @param v the value, which may be null
    */
   public static Value bytes(@Nullable ByteArray v) {
-    return new BytesImpl(v == null, v);
+    return new LazyBytesImpl(v == null, v);
   }
 
   /**
-   * Returns a {@code BYTES} value that is lazily constructed when needed.
+   * Returns a {@code BYTES} value.
    *
-   * @param v the value, which may be null
+   * @param base64String the value in Base64 encoding, which may be null. This value must be a valid
+   *     base64 string.
    */
-  static Value lazyBytes(@Nullable LazyByteArray v) {
-    return new LazyBytesImpl(v == null, v);
+  public static Value bytesFromBase64(@Nullable String base64String) {
+    return new LazyBytesImpl(
+        base64String == null, base64String == null ? null : new LazyByteArray(base64String));
+  }
+
+  static Value internalBytes(@Nullable LazyByteArray bytes) {
+    return new LazyBytesImpl(bytes == null, bytes);
   }
 
   /** Returns a {@code TIMESTAMP} value. */
@@ -441,11 +448,37 @@ public static Value pgJsonbArray(@Nullable Iterable<String> v) {
    *     {@code isNull()} is {@code true}. Individual elements may also be {@code null}.
    */
   public static Value bytesArray(@Nullable Iterable<ByteArray> v) {
-    return new BytesArrayImpl(v == null, v == null ? null : immutableCopyOf(v));
+    return new LazyBytesArrayImpl(v == null, v == null ? null : byteArraysToLazyByteArrayList(v));
   }
 
-  static Value lazyBytesArray(@Nullable Iterable<LazyByteArray> v) {
-    return new LazyBytesArrayImpl(v == null, v == null ? null : immutableCopyOf(v));
+  private static List<LazyByteArray> byteArraysToLazyByteArrayList(Iterable<ByteArray> byteArrays) {
+    List<LazyByteArray> list = new ArrayList<>();
+    for (ByteArray byteArray : byteArrays) {
+      list.add(byteArray == null ? null : new LazyByteArray(byteArray));
+    }
+    return Collections.unmodifiableList(list);
+  }
+
+  /**
+   * Returns an {@code ARRAY<BYTES>} value.
+   *
+   * @param base64Strings the source of element values. This may be {@code null} to produce a value
+   *     for which {@code isNull()} is {@code true}. Individual elements may also be {@code null}.
+   *     Non-null values must be a valid Base64 string.
+   */
+  public static Value bytesArrayFromBase64(@Nullable Iterable<String> base64Strings) {
+    return new LazyBytesArrayImpl(
+        base64Strings == null,
+        base64Strings == null ? null : base64StringsToLazyByteArrayList(base64Strings));
+  }
+
+  private static List<LazyByteArray> base64StringsToLazyByteArrayList(
+      Iterable<String> base64Strings) {
+    List<LazyByteArray> list = new ArrayList<>();
+    for (String base64 : base64Strings) {
+      list.add(base64 == null ? null : new LazyByteArray(base64));
+    }
+    return Collections.unmodifiableList(list);
   }
 
   /**
@@ -1400,41 +1433,16 @@ void valueToString(StringBuilder b) {
     }
   }
 
-  private static class BytesImpl extends AbstractObjectValue<ByteArray> {
-
-    private BytesImpl(boolean isNull, ByteArray value) {
-      super(isNull, Type.bytes(), value);
-    }
-
-    @Override
-    public ByteArray getBytes() {
-      checkNotNull();
-      return value;
-    }
-
-    @Override
-    com.google.protobuf.Value valueToProto() {
-      return com.google.protobuf.Value.newBuilder().setStringValue(value.toBase64()).build();
-    }
-
-    @Nonnull
-    @Override
-    public String getAsString() {
-      return value == null ? NULL_STRING : value.toBase64();
-    }
-
-    @Override
-    void valueToString(StringBuilder b) {
-      b.append(value.toString());
-    }
-  }
-
   private static class LazyBytesImpl extends AbstractObjectValue<LazyByteArray> {
 
     private LazyBytesImpl(boolean isNull, LazyByteArray value) {
       super(isNull, Type.bytes(), value);
     }
 
+    private LazyBytesImpl(boolean isNull, ByteArray value) {
+      super(isNull, Type.bytes(), value == null ? null : new LazyByteArray(value));
+    }
+
     @Override
     public ByteArray getBytes() {
       checkNotNull();
@@ -1449,12 +1457,12 @@ com.google.protobuf.Value valueToProto() {
     @Nonnull
     @Override
     public String getAsString() {
-      return value.getBase64String();
+      return value == null ? NULL_STRING : value.getBase64String();
     }
 
     @Override
     void valueToString(StringBuilder b) {
-      b.append(value.toString());
+      b.append(value == null ? null : value.toString());
     }
   }
 
@@ -1906,39 +1914,28 @@ void appendElement(StringBuilder b, String element) {
     }
   }
 
-  private static class BytesArrayImpl extends AbstractArrayValue<ByteArray> {
-    private BytesArrayImpl(boolean isNull, @Nullable List<ByteArray> values) {
-      super(isNull, Type.bytes(), values);
-    }
-
-    @Override
-    public List<ByteArray> getBytesArray() {
-      checkNotNull();
-      return value;
-    }
+  private static class LazyBytesArrayImpl extends AbstractArrayValue<LazyByteArray> {
+    private transient AbstractLazyInitializer<List<ByteArray>> bytesArray = defaultInitializer();
 
-    @Override
-    String elementToString(ByteArray element) {
-      return element.toBase64();
+    private LazyBytesArrayImpl(boolean isNull, @Nullable List<LazyByteArray> values) {
+      super(isNull, Type.bytes(), values);
     }
 
-    @Override
-    void appendElement(StringBuilder b, ByteArray element) {
-      b.append(elementToString(element));
+    private AbstractLazyInitializer<List<ByteArray>> defaultInitializer() {
+      return new AbstractLazyInitializer<List<ByteArray>>() {
+        @Override
+        protected List<ByteArray> initialize() {
+          return value.stream()
+              .map(element -> element == null ? null : element.getByteArray())
+              .collect(Collectors.toList());
+        }
+      };
     }
-  }
-
-  private static class LazyBytesArrayImpl extends AbstractArrayValue<LazyByteArray> {
-    private final AbstractLazyInitializer<List<ByteArray>> bytesArray =
-        new AbstractLazyInitializer<List<ByteArray>>() {
-          @Override
-          protected List<ByteArray> initialize() {
-            return value.stream().map(LazyByteArray::getByteArray).collect(Collectors.toList());
-          }
-        };
 
-    private LazyBytesArrayImpl(boolean isNull, @Nullable List<LazyByteArray> values) {
-      super(isNull, Type.bytes(), values);
+    private void readObject(java.io.ObjectInputStream in)
+        throws IOException, ClassNotFoundException {
+      in.defaultReadObject();
+      bytesArray = defaultInitializer();
     }
 
     @Override

google-cloud-spanner/src/main/java/com/google/cloud/spanner/ValueBinder.java

@@ -95,7 +95,11 @@ public R to(@Nullable String value) {
     return handle(Value.string(value));
   }
 
-  /** Binds to {@code Value.bytes(value)} */
+  /**
+   * Binds to {@code Value.bytes(value)}. Use {@link #to(Value)} in combination with {@link
+   * Value#bytes(String)} if you already have the value that you want to bind in base64 format. This
+   * prevents unnecessary decoding and encoding of base64 strings.
+   */
   public R to(@Nullable ByteArray value) {
     return handle(Value.bytes(value));
   }
@@ -198,6 +202,15 @@ public R toBytesArray(@Nullable Iterable<ByteArray> values) {
     return handle(Value.bytesArray(values));
   }
 
+  /**
+   * Binds to {@code Value.bytesArray(values)}. The given strings must be valid base64 encoded
+   * strings. Use this method instead of {@link #toBytesArray(Iterable)} if you already have the
+   * values in base64 format to prevent unnecessary decoding and encoding to/from base64.
+   */
+  public R toBytesArrayFromBase64(@Nullable Iterable<String> valuesAsBase64Strings) {
+    return handle(Value.bytesArrayFromBase64(valuesAsBase64Strings));
+  }
+
   /** Binds to {@code Value.timestampArray(values)} */
   public R toTimestampArray(@Nullable Iterable<Timestamp> values) {
     return handle(Value.timestampArray(values));