Refine search
@Test public void delete() { KeySet keySet = KeySet.singleKey(Key.of("k1")); Mutation m = Mutation.delete("T1", keySet); assertThat(m.getOperation()).isEqualTo(Mutation.Op.DELETE); assertThat(m.getKeySet()).isEqualTo(keySet); assertThat(m.toString()).isEqualTo("delete(T1{[k1]})"); }
@Test public void insertOrUpdateEmpty() { Mutation m = Mutation.newInsertOrUpdateBuilder("T2").build(); assertThat(m.getTable()).isEqualTo("T2"); assertThat(m.getOperation()).isEqualTo(Mutation.Op.INSERT_OR_UPDATE); assertThat(m.getColumns()).isEmpty(); assertThat(m.getValues()).isEmpty(); assertThat(m.toString()).isEqualTo("insert_or_update(T2{})"); }
@Test public void toProtoCoalescingChangeOfOperation() { List<Mutation> mutations = Arrays.asList( Mutation.newInsertBuilder("T").set("C").to("V1").build(), Mutation.newInsertBuilder("T").set("C").to("V2").build(), Mutation.newInsertBuilder("T").set("C").to("V3").build(), Mutation.newUpdateBuilder("T").set("C").to("V4").build(), Mutation.newUpdateBuilder("T").set("C").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: 'C' values { values { string_value: 'V1' } }" + " values { values { string_value: 'V2' } }" + " values { values { string_value: 'V3' } } }")); MatcherAssert.assertThat( proto.get(1), matchesProto( "update { table: 'T' columns: 'C' values { values { string_value: 'V4' } }" + " values { values { string_value: 'V5' } } }")); }
@Test public void replaceEmpty() { Mutation m = Mutation.newReplaceBuilder("T2").build(); assertThat(m.getTable()).isEqualTo("T2"); assertThat(m.getOperation()).isEqualTo(Mutation.Op.REPLACE); assertThat(m.getColumns()).isEmpty(); assertThat(m.getValues()).isEmpty(); assertThat(m.toString()).isEqualTo("replace(T2{})"); }
@Test public void rollback() { TransactionManager manager = client.transactionManager(); TransactionContext txn = manager.begin(); txn.buffer( Mutation.newInsertBuilder("T").set("K").to("Key2").set("BoolValue").to(true).build()); manager.rollback(); assertThat(manager.getState()).isEqualTo(TransactionState.ROLLED_BACK); // Row should not have been inserted. assertThat(client.singleUse().readRow("T", Key.of("Key2"), Arrays.asList("K", "BoolValue"))) .isNull(); }
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();
@Test public void updateEmpty() { Mutation m = Mutation.newUpdateBuilder("T2").build(); assertThat(m.getTable()).isEqualTo("T2"); assertThat(m.getOperation()).isEqualTo(Mutation.Op.UPDATE); assertThat(m.getColumns()).isEmpty(); assertThat(m.getValues()).isEmpty(); assertThat(m.toString()).isEqualTo("update(T2{})"); }
@Test public void insertEmpty() { Mutation m = Mutation.newInsertBuilder("T1").build(); assertThat(m.getTable()).isEqualTo("T1"); assertThat(m.getOperation()).isEqualTo(Mutation.Op.INSERT); assertThat(m.getColumns()).isEmpty(); assertThat(m.getValues()).isEmpty(); assertThat(m.toString()).isEqualTo("insert(T1{})"); }
@Override public Void run(TransactionContext transaction) { // DML long rowCount = transaction.executeUpdate( Statement.of("INSERT INTO T (k, v) VALUES ('" + key1 + "', 1)")); assertThat(rowCount).isEqualTo(1); // Mutations transaction.buffer( Mutation.newInsertOrUpdateBuilder("T").set("K").to(key2).set("V").to(2).build()); return null; } };
List<Mutation> mutations = Arrays.asList( Mutation.newInsertBuilder("T").set("C").to("V").build(), Mutation.newUpdateBuilder("T").set("C").to("V").build(), Mutation.newInsertOrUpdateBuilder("T").set("C").to("V").build(), Mutation.newReplaceBuilder("T").set("C").to("V").build(), Mutation.delete("T", KeySet.singleKey(Key.of("k")))); proto.add(existingProto); Mutation.toProto(mutations, proto); assertThat(proto.size()).isAtLeast(1); assertThat(proto.get(0)).isSameAs(existingProto); proto.remove(0); assertThat(proto.size()).isEqualTo(5); MatcherAssert.assertThat( proto.get(0),
List<Mutation> mutations = Arrays.asList( Mutation.newInsertBuilder("T1").set("C").to("V1").build(), Mutation.delete("T1", Key.of("k1")), Mutation.delete("T1", Key.of("k2")), Mutation.delete("T2", Key.of("k3")), Mutation.delete("T2", Key.of("k4")), Mutation.newInsertBuilder("T2").set("C").to("V1").build()); Mutation.toProto(mutations, proto); assertThat(proto.size()).isEqualTo(4); MatcherAssert.assertThat( proto.get(0),
@Test public void asMap() { Mutation m = Mutation.newInsertBuilder("T").build(); assertThat(m.asMap()).isEqualTo(ImmutableMap.of()); m = Mutation.newInsertBuilder("T").set("C1").to(true).set("C2").to(1234).build(); assertThat(m.asMap()) .isEqualTo(ImmutableMap.of("C1", Value.bool(true), "C2", Value.int64(1234))); }
@Test public void toProtoCoalescingDelete() { List<Mutation> mutations = Arrays.asList( Mutation.delete("T", Key.of("k1")), Mutation.delete("T", Key.of("k2")), Mutation.delete("T", KeySet.range(KeyRange.closedOpen(Key.of("ka"), Key.of("kb")))), Mutation.delete("T", KeySet.range(KeyRange.closedClosed(Key.of("kc"), Key.of("kd"))))); List<com.google.spanner.v1.Mutation> proto = new ArrayList<>(); Mutation.toProto(mutations, proto); assertThat(proto.size()).isEqualTo(1); MatcherAssert.assertThat( proto.get(0), matchesProto( "delete {" + " table: 'T'" + " key_set {" + " keys { values { string_value: 'k1' } }" + " keys { values { string_value: 'k2' } }" + " ranges { start_closed { values { string_value: 'ka' } } " + " end_open { values { string_value: 'kb' } } }" + " ranges { start_closed { values { string_value: 'kc' } } " + " end_closed { values { string_value: 'kd' } } }" + " }" + "} ")); }
expected.put(key, value); write( Mutation.newInsertOrUpdateBuilder("T") .set("K") .to(key) .set("BytesValue") .to(value) .build()); keys.addKey(Key.of(key)); String key = resultSet.getString(0); ByteArray value = resultSet.getBytes(1); assertThat(expected).containsKey(key); ByteArray expectedValue = expected.remove(key); assertThat(value).isEqualTo(expectedValue); assertThat(expected).isEmpty(); pass = true; } finally {
@Override public Status update(String table, String key, Map<String, ByteIterator> values) { Mutation.WriteBuilder m = Mutation.newInsertOrUpdateBuilder(table); m.set(PRIMARY_KEY_COLUMN).to(key); for (Map.Entry<String, ByteIterator> e : values.entrySet()) { m.set(e.getKey()).to(e.getValue().toString()); } try { dbClient.writeAtLeastOnce(Arrays.asList(m.build())); } catch (Exception e) { LOGGER.log(Level.INFO, "update()", e); return Status.ERROR; } return Status.OK; }
@Test public void equalsAndHashCode() { EqualsTester tester = new EqualsTester(); // Equality, not identity. tester.addEqualityGroup( Mutation.newInsertBuilder("T1").build(), Mutation.newInsertBuilder("T1").build()); // Operation types are distinguished. tester.addEqualityGroup(Mutation.newInsertOrUpdateBuilder("T1").build()); tester.addEqualityGroup(Mutation.newUpdateBuilder("T1").build()); tester.addEqualityGroup(Mutation.newReplaceBuilder("T1").build()); // Table is distinguished. tester.addEqualityGroup(Mutation.newInsertBuilder("T2").build()); // Columns/values are distinguished (but by equality, not identity). tester.addEqualityGroup( Mutation.newInsertBuilder("T1").set("C").to("V").build(), Mutation.newInsertBuilder("T1").set("C").to("V").build()); // Deletes consider the key set. tester.addEqualityGroup(Mutation.delete("T1", KeySet.all())); tester.addEqualityGroup( Mutation.delete("T1", KeySet.singleKey(Key.of("k"))), Mutation.delete("T1", Key.of("k"))); tester.testEquals(); }
public Mutation apply(GenericRecord record) { Schema schema = record.getSchema(); List<Schema.Field> fields = schema.getFields(); Mutation.WriteBuilder builder = Mutation.newInsertOrUpdateBuilder(table.name()); builder.set(column.name()).to(readBool(record, avroType, fieldName).orElse(null)); break; case INT64: builder.set(column.name()).to(readInt64(record, avroType, fieldName).orElse(null)); break; case FLOAT64: builder.set(column.name()).to(readFloat64(record, avroType, fieldName).orElse(null)); break; case STRING:
/** Example of blind write. */ // [TARGET write(Iterable)] // [VARIABLE my_singer_id] public void write(long singerId) { // [START write] Mutation mutation = Mutation.newInsertBuilder("Singer") .set("SingerId") .to(singerId) .set("FirstName") .to("Billy") .set("LastName") .to("Joel") .build(); dbClient.write(Collections.singletonList(mutation)); // [END write] }
@Override public Void run(TransactionContext transaction) throws Exception { String column = "FirstName"; Struct row = transaction.readRow("Singers", Key.of(singerId), Collections.singleton(column)); String name = row.getString(column); transaction.buffer( Mutation.newUpdateBuilder("Singers").set(column).to(name.toUpperCase()).build()); return null; } });