Fix

Author: brfrn169

core/src/main/java/com/scalar/db/transaction/consensuscommit/Coordinator.java

@@ -342,7 +342,7 @@ Put createPutWith(Coordinator.State state) {
             .condition(ConditionBuilder.putIfNotExists());
 
     if (!childIds.isEmpty()) {
-      builder.textValue(Attribute.CHILD_IDS, childIds);
+      builder = builder.textValue(Attribute.CHILD_IDS, childIds);
     }
     return builder.build();
   }

core/src/main/java/com/scalar/db/transaction/consensuscommit/Snapshot.java

@@ -8,7 +8,6 @@
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ComparisonChain;
 import com.google.common.collect.Iterators;
-import com.google.common.collect.Streams;
 import com.scalar.db.api.ConditionSetBuilder;
 import com.scalar.db.api.Delete;
 import com.scalar.db.api.DistributedStorage;
@@ -165,14 +164,16 @@ public void putIntoWriteSet(Key key, Put put) {
       // merge the previous put in the write set and the new put
       Put originalPut = writeSet.get(key);
       PutBuilder.BuildableFromExisting putBuilder = Put.newBuilder(originalPut);
-      put.getColumns().values().forEach(putBuilder::value);
+      for (Column<?> value : put.getColumns().values()) {
+        putBuilder = putBuilder.value(value);
+      }
 
       // If the implicit pre-read is enabled for the new put, it should also be enabled for the
       // merged put. However, if the previous put is in insert mode, this doesn’t apply. This is
       // because, in insert mode, the read set is not used during the preparation phase. Therefore,
       // we only need to enable the implicit pre-read if the previous put is not in insert mode
       if (isImplicitPreReadEnabled(put) && !isInsertModeEnabled(originalPut)) {
-        putBuilder.enableImplicitPreRead();
+        putBuilder = putBuilder.enableImplicitPreRead();
       }
 
       writeSet.put(key, putBuilder.build());
@@ -598,10 +599,12 @@ private void validateScanResults(
       ScanBuilder.BuildableScanOrScanAllFromExisting builder =
           Scan.newBuilder(scan).clearProjections().projection(Attribute.ID);
       TableMetadata tableMetadata = getTableMetadata(scan);
-      Streams.concat(
-              tableMetadata.getPartitionKeyNames().stream(),
-              tableMetadata.getClusteringKeyNames().stream())
-          .forEach(builder::projection);
+      for (String partitionKeyName : tableMetadata.getPartitionKeyNames()) {
+        builder = builder.projection(partitionKeyName);
+      }
+      for (String clusteringKeyName : tableMetadata.getClusteringKeyNames()) {
+        builder = builder.projection(clusteringKeyName);
+      }
       scan = builder.build();
 
       if (scan.getLimit() == 0) {

core/src/main/java/com/scalar/db/util/ScalarDbUtils.java

@@ -74,10 +74,10 @@ public static Get copyAndSetTargetToIfNot(
       Get get, Optional<String> namespace, Optional<String> tableName) {
     GetBuilder.BuildableGetOrGetWithIndexFromExisting builder = Get.newBuilder(get); // copy
     if (!get.forNamespace().isPresent() && namespace.isPresent()) {
-      builder.namespace(namespace.get());
+      builder = builder.namespace(namespace.get());
     }
     if (!get.forTable().isPresent() && tableName.isPresent()) {
-      builder.table(tableName.get());
+      builder = builder.table(tableName.get());
     }
     Get ret = builder.build();
     checkIfTargetIsSet(ret);
@@ -88,10 +88,10 @@ public static Scan copyAndSetTargetToIfNot(
       Scan scan, Optional<String> namespace, Optional<String> tableName) {
     ScanBuilder.BuildableScanOrScanAllFromExisting builder = Scan.newBuilder(scan); // copy
     if (!scan.forNamespace().isPresent() && namespace.isPresent()) {
-      builder.namespace(namespace.get());
+      builder = builder.namespace(namespace.get());
     }
     if (!scan.forTable().isPresent() && tableName.isPresent()) {
-      builder.table(tableName.get());
+      builder = builder.table(tableName.get());
     }
     Scan ret = builder.build();
     checkIfTargetIsSet(ret);
@@ -118,10 +118,10 @@ public static Put copyAndSetTargetToIfNot(
       Put put, Optional<String> namespace, Optional<String> tableName) {
     PutBuilder.BuildableFromExisting builder = Put.newBuilder(put); // copy
     if (!put.forNamespace().isPresent() && namespace.isPresent()) {
-      builder.namespace(namespace.get());
+      builder = builder.namespace(namespace.get());
     }
     if (!put.forTable().isPresent() && tableName.isPresent()) {
-      builder.table(tableName.get());
+      builder = builder.table(tableName.get());
     }
     Put ret = builder.build();
     checkIfTargetIsSet(ret);
@@ -132,10 +132,10 @@ public static Delete copyAndSetTargetToIfNot(
       Delete delete, Optional<String> namespace, Optional<String> tableName) {
     DeleteBuilder.BuildableFromExisting builder = Delete.newBuilder(delete); // copy
     if (!delete.forNamespace().isPresent() && namespace.isPresent()) {
-      builder.namespace(namespace.get());
+      builder = builder.namespace(namespace.get());
     }
     if (!delete.forTable().isPresent() && tableName.isPresent()) {
-      builder.table(tableName.get());
+      builder = builder.table(tableName.get());
     }
     Delete ret = builder.build();
     checkIfTargetIsSet(ret);
@@ -146,10 +146,10 @@ public static Insert copyAndSetTargetToIfNot(
       Insert insert, Optional<String> namespace, Optional<String> tableName) {
     InsertBuilder.BuildableFromExisting builder = Insert.newBuilder(insert); // copy
     if (!insert.forNamespace().isPresent() && namespace.isPresent()) {
-      builder.namespace(namespace.get());
+      builder = builder.namespace(namespace.get());
     }
     if (!insert.forTable().isPresent() && tableName.isPresent()) {
-      builder.table(tableName.get());
+      builder = builder.table(tableName.get());
     }
     Insert ret = builder.build();
     checkIfTargetIsSet(ret);
@@ -160,10 +160,10 @@ public static Upsert copyAndSetTargetToIfNot(
       Upsert upsert, Optional<String> namespace, Optional<String> tableName) {
     UpsertBuilder.BuildableFromExisting builder = Upsert.newBuilder(upsert); // copy
     if (!upsert.forNamespace().isPresent() && namespace.isPresent()) {
-      builder.namespace(namespace.get());
+      builder = builder.namespace(namespace.get());
     }
     if (!upsert.forTable().isPresent() && tableName.isPresent()) {
-      builder.table(tableName.get());
+      builder = builder.table(tableName.get());
     }
     Upsert ret = builder.build();
     checkIfTargetIsSet(ret);
@@ -174,10 +174,10 @@ public static Update copyAndSetTargetToIfNot(
       Update update, Optional<String> namespace, Optional<String> tableName) {
     UpdateBuilder.BuildableFromExisting builder = Update.newBuilder(update); // copy
     if (!update.forNamespace().isPresent() && namespace.isPresent()) {
-      builder.namespace(namespace.get());
+      builder = builder.namespace(namespace.get());
     }
     if (!update.forTable().isPresent() && tableName.isPresent()) {
-      builder.table(tableName.get());
+      builder = builder.table(tableName.get());
     }
     Update ret = builder.build();
     checkIfTargetIsSet(ret);
@@ -316,9 +316,11 @@ public static Get copyAndPrepareForDynamicFiltering(Get get) {
     List<String> projections = get.getProjections();
     if (!projections.isEmpty()) {
       // Add columns in conditions into projections to use them in dynamic filtering
-      ScalarDbUtils.getColumnNamesUsedIn(get.getConjunctions()).stream()
-          .filter(columnName -> !projections.contains(columnName))
-          .forEach(builder::projection);
+      for (String columnName : getColumnNamesUsedIn(get.getConjunctions())) {
+        if (!projections.contains(columnName)) {
+          builder = builder.projection(columnName);
+        }
+      }
     }
     return builder.build();
   }
@@ -329,14 +331,16 @@ public static Scan copyAndPrepareForDynamicFiltering(Scan scan) {
     List<String> projections = scan.getProjections();
     if (!projections.isEmpty()) {
       // Add columns in conditions into projections to use them in dynamic filtering
-      ScalarDbUtils.getColumnNamesUsedIn(scan.getConjunctions()).stream()
-          .filter(columnName -> !projections.contains(columnName))
-          .forEach(builder::projection);
+      for (String columnName : getColumnNamesUsedIn(scan.getConjunctions())) {
+        if (!projections.contains(columnName)) {
+          builder = builder.projection(columnName);
+        }
+      }
     }
     return builder.build();
   }
 
-  public static Set<String> getColumnNamesUsedIn(Set<Conjunction> conjunctions) {
+  private static Set<String> getColumnNamesUsedIn(Set<Conjunction> conjunctions) {
     Set<String> columns = new HashSet<>();
     conjunctions.forEach(
         conjunction ->