@Override public Status insert(String table, String key, Map<String, ByteIterator> values) { if (bufferedMutations.size() < batchInserts) { 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()); } bufferedMutations.add(m.build()); } else { LOGGER.log(Level.INFO, "Limit of cached mutations reached. The given mutation with key " + key + " is ignored. Is this a retry?"); } if (bufferedMutations.size() < batchInserts) { return Status.BATCHED_OK; } try { dbClient.writeAtLeastOnce(bufferedMutations); bufferedMutations.clear(); } catch (Exception e) { LOGGER.log(Level.INFO, "insert()", e); return Status.ERROR; } return Status.OK; }
@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; }
private static void writeNewValue( DatabaseClient client, int i, @Nullable ImmutableList.Builder<History> historyBuilder) { String value = "v" + i; Mutation m = Mutation.newInsertOrUpdateBuilder(TABLE_NAME).set("StringValue").to(value).build(); long minCommitNanoTime = System.nanoTime(); Timestamp timestamp = client.writeAtLeastOnce(Arrays.asList(m)); if (historyBuilder != null) { historyBuilder.add(new History(timestamp, value, minCommitNanoTime)); } }
private Mutation.WriteBuilder baseInsert() { return Mutation.newInsertOrUpdateBuilder("T").set("K").to(lastKey = uniqueString()); }
@Override public Void run(TransactionContext transaction) throws UserException { transaction.buffer(Mutation.newInsertOrUpdateBuilder("T").set("K").to(key).build()); throw new UserException("User failure"); } };
@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{})"); }
@Override public Void run(TransactionContext transaction) { transaction.buffer(Mutation.newInsertOrUpdateBuilder("T").set("K").to(key).build()); throw newSpannerException(ErrorCode.OUT_OF_RANGE, "User failure"); } };
@Test public void insertOrUpdate() { Mutation m = Mutation.newInsertOrUpdateBuilder("T1").set("C1").to(true).build(); assertThat(m.getTable()).isEqualTo("T1"); assertThat(m.getOperation()).isEqualTo(Mutation.Op.INSERT_OR_UPDATE); assertThat(m.getColumns()).containsExactly("C1"); assertThat(m.getValues()).containsExactly(Value.bool(true)); assertThat(m.toString()).isEqualTo("insert_or_update(T1{C1=true})"); }
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"))));
@Test public void writeAtLeastOnce() { client.writeAtLeastOnce( Arrays.asList( Mutation.newInsertOrUpdateBuilder("T") .set("K") .to(lastKey = uniqueString()) .set("StringValue") .to("v1") .build())); Struct row = readLastRow("StringValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getString(0)).isEqualTo("v1"); }
@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; } };
expected.put(key, value); write( Mutation.newInsertOrUpdateBuilder("T") .set("K") .to(key)
@BeforeClass public static void setUpDatabase() { db = env.getTestHelper() .createTestDatabase( "CREATE TABLE TestTable (" + " Key STRING(MAX) NOT NULL," + " StringValue STRING(MAX)," + ") PRIMARY KEY (Key)", "CREATE INDEX TestTableByValue ON TestTable(StringValue)"); // Includes k0..k14. Note that strings k{10,14} sort between k1 and k2. List<Mutation> mutations = new ArrayList<>(); for (int i = 0; i < 15; ++i) { mutations.add( Mutation.newInsertOrUpdateBuilder(TABLE_NAME) .set("Key") .to("k" + i) .set("StringValue") .to("v" + i) .build()); } env.getTestHelper().getDatabaseClient(db).write(mutations); }
@BeforeClass public static void setUpDatabase() { db = env.getTestHelper() .createTestDatabase( "CREATE TABLE TestTable (" + " Key STRING(MAX) NOT NULL," + " StringValue STRING(MAX)," + ") PRIMARY KEY (Key)", "CREATE INDEX TestTableByValue ON TestTable(StringValue)", "CREATE INDEX TestTableByValueDesc ON TestTable(StringValue DESC)"); client = env.getTestHelper().getDatabaseClient(db); // Includes k0..k14. Note that strings k{10,14} sort between k1 and k2. List<Mutation> mutations = new ArrayList<>(); for (int i = 0; i < 15; ++i) { mutations.add( Mutation.newInsertOrUpdateBuilder(TABLE_NAME) .set("Key") .to("k" + i) .set("StringValue") .to("v" + i) .build()); } client.write(mutations); }
rnd.nextBytes(data); mutations.add( Mutation.newInsertOrUpdateBuilder(TABLE_NAME) .set("Key") .to(i)
RANDOM.nextBytes(data); mutations.add( Mutation.newInsertOrUpdateBuilder(TABLE_NAME) .set("Key") .to(i)
@ProcessElement public void processElement(ProcessContext c) { Album album = c.element(); c.output(Mutation.newInsertOrUpdateBuilder("albums") .set("singerId").to(album.singerId) .set("albumId").to(album.albumId) .set("albumTitle").to(album.albumTitle) .build()); } }))
@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(); }
@ProcessElement public void processElement(ProcessContext c) { Singer singer = c.element(); c.output(Mutation.newInsertOrUpdateBuilder("singers") .set("singerId").to(singer.singerId) .set("firstName").to(singer.firstName) .set("lastName").to(singer.lastName) .build()); } }))
reserializeAndAssert(appendAllTypes(Mutation.newUpdateBuilder("test")).build()); reserializeAndAssert(appendAllTypes(Mutation.newReplaceBuilder("test")).build()); reserializeAndAssert(appendAllTypes(Mutation.newInsertOrUpdateBuilder("test")).build());