@Test public void writeBoolNull() { write(baseInsert().set("BoolValue").to((Boolean) null).build()); Struct row = readLastRow("BoolValue"); assertThat(row.isNull(0)).isTrue(); }
/** * Returns a newly created {@code Mutation} based on the contents of the {@code Builder}. * * @throws IllegalStateException if any duplicate columns are present. Duplicate detection is * case-insensitive. */ public Mutation build() { checkBindingInProgress(false); ImmutableList<String> columnNames = columns.build(); checkDuplicateColumns(columnNames); return new Mutation(table, operation, columnNames, values.build(), null); }
@Test public void writeBool() { write(baseInsert().set("BoolValue").to(true).build()); Struct row = readLastRow("BoolValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBoolean(0)).isTrue(); }
@Test public void writeBoolArrayEmpty() { write(baseInsert().set("BoolArrayValue").toBoolArray(new boolean[] {}).build()); Struct row = readLastRow("BoolArrayValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBooleanList(0)).containsExactly(); }
@Test public void writeInt64ArrayNoNulls() { write(baseInsert().set("Int64ArrayValue").toInt64Array(Arrays.asList(1L, 2L)).build()); Struct row = readLastRow("Int64ArrayValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getLongArray(0)).isEqualTo(new long[] {1, 2}); }
@Test public void writeFloat64ArrayEmpty() { write(baseInsert().set("Float64ArrayValue").toFloat64Array(new double[] {}).build()); Struct row = readLastRow("Float64ArrayValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getDoubleList(0)).containsExactly(); }
@Test public void simpleInsert() { TransactionManager manager = client.transactionManager(); TransactionContext txn = manager.begin(); assertThat(manager.getState()).isEqualTo(TransactionState.STARTED); txn.buffer( Mutation.newInsertBuilder("T").set("K").to("Key1").set("BoolValue").to(true).build()); manager.commit(); assertThat(manager.getState()).isEqualTo(TransactionState.COMMITTED); Struct row = client.singleUse().readRow("T", Key.of("Key1"), Arrays.asList("K", "BoolValue")); assertThat(row.getString(0)).isEqualTo("Key1"); assertThat(row.getBoolean(1)).isTrue(); }
Arrays.asList(Mutation.newInsertBuilder("T").set("K").to(key).set("V").to(0).build())); assertThat(results).hasSize(numThreads); List<Long> expectedResults = new ArrayList<>(); for (int i = 0; i < numThreads; ++i) { expectedResults.add(i + 1L); assertThat(results).containsAllIn(expectedResults); assertThat(Sets.newHashSet(commitTimestamps)).hasSize(numThreads); assertThat( .singleUse(TimestampBound.strong()) .readRow("T", Key.of(key), Arrays.asList("V")) .getLong(0)) .isEqualTo(Long.valueOf(numThreads));
client.writeAtLeastOnce( asList( Mutation.newInsertBuilder("T").set("K").to("k1").set("V").to("v1").build(), Mutation.newInsertBuilder("T").set("K").to("k2").set("V").to("v2").build(), Mutation.newInsertBuilder("T").set("K").to("k3").set("V").to("v3").build(), Mutation.newInsertBuilder("T").set("K").to("k4").set("V").to("v4").build())); .build(); ResultSet resultSet = statement.executeQuery(client.singleUse(TimestampBound.strong())); assertThat(resultSet.next()).isTrue(); assertThat(resultSet.getType()) .isEqualTo( Type.struct(StructField.of("K", Type.string()), StructField.of("V", Type.string()))); assertThat(resultSet.getString(0)).isEqualTo("k2"); assertThat(resultSet.getString(1)).isEqualTo("v2"); assertThat(resultSet.next()).isTrue(); assertThat(resultSet.getString("K")).isEqualTo("k3"); assertThat(resultSet.getString("V")).isEqualTo("v3"); assertThat(resultSet.next()).isFalse();
@Test public void toProtoCoalescingChangeOfColumn() { List<Mutation> mutations = Arrays.asList( Mutation.newInsertBuilder("T").set("C1").to("V1").build(), Mutation.newInsertBuilder("T").set("C1").to("V2").build(), Mutation.newInsertBuilder("T").set("C1").to("V3").build(), Mutation.newInsertBuilder("T").set("C2").to("V4").build(), Mutation.newInsertBuilder("T").set("C2").to("V5").build()); List<com.google.spanner.v1.Mutation> proto = new ArrayList<>(); Mutation.toProto(mutations, proto); assertThat(proto.size()).isEqualTo(2); MatcherAssert.assertThat( proto.get(0), matchesProto( "insert { table: 'T' columns: 'C1' values { values { string_value: 'V1' } }" + " values { values { string_value: 'V2' } }" + " values { values { string_value: 'V3' } } }")); MatcherAssert.assertThat( proto.get(1), matchesProto( "insert { table: 'T' columns: 'C2' values { values { string_value: 'V4' } }" + " values { values { string_value: 'V5' } } }")); }
@Test public void writeBytesArrayNull() { write(baseInsert().set("BytesArrayValue").toBytesArray(null).build()); Struct row = readLastRow("BytesArrayValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void writeStringArrayNull() { write(baseInsert().set("StringArrayValue").toStringArray(null).build()); Struct row = readLastRow("StringArrayValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void writeTimestampArrayNull() { write(baseInsert().set("TimestampArrayValue").toTimestampArray(null).build()); Struct row = readLastRow("TimestampArrayValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void writeDateArrayNull() { write(baseInsert().set("DateArrayValue").toDateArray(null).build()); Struct row = readLastRow("DateArrayValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void writeFloat64NonNumbers() { write(baseInsert().set("Float64Value").to(Double.NEGATIVE_INFINITY).build()); Struct row = readLastRow("Float64Value"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getDouble(0)).isNegativeInfinity(); write(baseInsert().set("Float64Value").to(Double.POSITIVE_INFINITY).build()); row = readLastRow("Float64Value"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getDouble(0)).isPositiveInfinity(); write(baseInsert().set("Float64Value").to(Double.NaN).build()); row = readLastRow("Float64Value"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getDouble(0)).isNaN(); }
@Test public void writeInt64ArrayNull() { write(baseInsert().set("Int64ArrayValue").toInt64Array((long[]) null).build()); Struct row = readLastRow("Int64ArrayValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void writeFloat64ArrayNull() { write(baseInsert().set("Float64ArrayValue").toFloat64Array((double[]) null).build()); Struct row = readLastRow("Float64ArrayValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void writeBoolArrayNull() { write(baseInsert().set("BoolArrayValue").toBoolArray((boolean[]) null).build()); Struct row = readLastRow("BoolArrayValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void writeBytesArrayEmpty() { write(baseInsert().set("BytesArrayValue").toBytesArray(Arrays.<ByteArray>asList()).build()); Struct row = readLastRow("BytesArrayValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBytesList(0)).containsExactly(); }
@Test public void writeStringArrayEmpty() { write(baseInsert().set("StringArrayValue").toStringArray(Arrays.<String>asList()).build()); Struct row = readLastRow("StringArrayValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getStringList(0)).containsExactly(); }