@Override public void cleanup() { try { if (bufferedMutations.size() > 0) { dbClient.writeAtLeastOnce(bufferedMutations); bufferedMutations.clear(); } } catch (Exception e) { LOGGER.log(Level.INFO, "cleanup()", e); } }
@Override public Status delete(String table, String key) { try { dbClient.writeAtLeastOnce(Arrays.asList(Mutation.delete(table, Key.of(key)))); } catch (Exception e) { LOGGER.log(Level.INFO, "delete()", 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; }
@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; }
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)); } }
/** Example of unprotected blind write. */ // [TARGET writeAtLeastOnce(Iterable)] // [VARIABLE my_singer_id] public void writeAtLeastOnce(long singerId) { // [START writeAtLeastOnce] Mutation mutation = Mutation.newInsertBuilder("Singers") .set("SingerId") .to(singerId) .set("FirstName") .to("Billy") .set("LastName") .to("Joel") .build(); dbClient.writeAtLeastOnce(Collections.singletonList(mutation)); // [END writeAtLeastOnce] }
@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"); }
"CREATE TABLE T ( K STRING(MAX) NOT NULL, V STRING(MAX) ) PRIMARY KEY (K)"); DatabaseClient client = env.getTestHelper().getDatabaseClient(populatedDb); client.writeAtLeastOnce( asList( Mutation.newInsertBuilder("T").set("K").to("k1").set("V").to("v1").build(),
private void verifyBatches(Iterable<Mutation>... batches) { for (Iterable<Mutation> b : batches) { verify(serviceFactory.mockDatabaseClient(), times(1)).writeAtLeastOnce(mutationsInNoOrder(b)); } }
mutationGroupBatchesCounter.inc(); Iterable<Mutation> batch = Iterables.concat(mutations); spannerAccessor.getDatabaseClient().writeAtLeastOnce(batch); mutationGroupWriteSuccessCounter.inc(Iterables.size(mutations)); return; for (MutationGroup mg : mutations) { try { spannerAccessor.getDatabaseClient().writeAtLeastOnce(mg); mutationGroupWriteSuccessCounter.inc(); } catch (SpannerException e) {
@Before @SuppressWarnings("unchecked") public void setUp() throws Exception { MockitoAnnotations.initMocks(this); serviceFactory = new FakeServiceFactory(); ReadOnlyTransaction tx = mock(ReadOnlyTransaction.class); when(serviceFactory.mockDatabaseClient().readOnlyTransaction()).thenReturn(tx); // Capture batches sent to writeAtLeastOnce. when(serviceFactory.mockDatabaseClient().writeAtLeastOnce(mutationBatchesCaptor.capture())) .thenReturn(null); // Simplest schema: a table with int64 key preparePkMetadata(tx, Arrays.asList(pkMetadata("tEsT", "key", "ASC"))); prepareColumnMetadata(tx, Arrays.asList(columnMetadata("tEsT", "key", "INT64", CELLS_PER_KEY))); }
private void makeTestData() { DatabaseClient databaseClient = getDatabaseClient(); List<Mutation> mutations = new ArrayList<>(); for (int i = 0; i < 5L; i++) { mutations.add( Mutation.newInsertOrUpdateBuilder(options.getTable()) .set("key") .to((long) i) .set("value") .to(RandomUtils.randomAlphaNumeric(100)) .build()); } databaseClient.writeAtLeastOnce(mutations); }
when(serviceFactory.mockDatabaseClient().writeAtLeastOnce(any())) .thenAnswer( invocationOnMock -> { verify(serviceFactory.mockDatabaseClient(), times(20)).writeAtLeastOnce(any());