@Override public String getString(String columnName) { return getCurrentRowAsStruct().getString(columnName); }
@Override public String getString(int columnIndex) { return getCurrentRowAsStruct().getString(columnIndex); }
/** Example of single use. */ // [TARGET singleUse()] // [VARIABLE my_singer_id] public String singleUse(long singerId) { // [START singleUse] String column = "FirstName"; Struct row = dbClient.singleUse().readRow("Singers", Key.of(singerId), Collections.singleton(column)); String firstName = row.getString(column); // [END singleUse] return firstName; }
/** Example of single use read only transaction. */ // [TARGET singleUseReadOnlyTransaction()] // [VARIABLE my_singer_id] public Timestamp singleUseReadOnlyTransaction(long singerId) { // [START singleUseReadOnlyTransaction] String column = "FirstName"; ReadOnlyTransaction txn = dbClient.singleUseReadOnlyTransaction(); Struct row = txn.readRow("Singers", Key.of(singerId), Collections.singleton(column)); row.getString(column); Timestamp timestamp = txn.getReadTimestamp(); // [END singleUseReadOnlyTransaction] return timestamp; }
/** Example of single use with timestamp bound. */ // [TARGET singleUse(TimestampBound)] // [VARIABLE my_singer_id] public String singleUseStale(long singerId) { // [START singleUseStale] String column = "FirstName"; Struct row = dbClient .singleUse(TimestampBound.ofMaxStaleness(10, TimeUnit.SECONDS)) .readRow("Singers", Key.of(singerId), Collections.singleton(column)); String firstName = row.getString(column); // [END singleUseStale] return firstName; }
@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; } });
/** Example of single use read only transaction with timestamp bound. */ // [TARGET singleUseReadOnlyTransaction(TimestampBound)] // [VARIABLE my_singer_id] public Timestamp singleUseReadOnlyTransactionTimestamp(long singerId) { // [START singleUseReadOnlyTransactionTimestamp] String column = "FirstName"; ReadOnlyTransaction txn = dbClient.singleUseReadOnlyTransaction(TimestampBound.ofMaxStaleness(10, TimeUnit.SECONDS)); Struct row = txn.readRow("Singers", Key.of(singerId), Collections.singleton(column)); row.getString(column); Timestamp timestamp = txn.getReadTimestamp(); // [END singleUseReadOnlyTransactionTimestamp] return timestamp; }
@Test public void singleStrong() { History expected = history.get(history.size() - 1); ReadOnlyTransaction readContext = client.singleUseReadOnlyTransaction(); Struct row = readRow(readContext); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); assertThat(readContext.getReadTimestamp()).isAtLeast(expected.timestamp); row = readRow(client.singleUse()); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); }
private void insertAndReadAgain( ReadOnlyTransaction readContext, Timestamp expectedTimestamp, @Nullable String expectedValue) { writeNewValue(client, history.size(), null); Struct row = readRow(readContext); if (expectedValue == null) { assertThat(row).isNull(); } else { assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expectedValue); } assertThat(readContext.getReadTimestamp()).isEqualTo(expectedTimestamp); }
@Test public void singleReadTimestamp() { History expected = history.get(2); TimestampBound bound = TimestampBound.ofReadTimestamp(expected.timestamp); ReadOnlyTransaction readContext = client.singleUseReadOnlyTransaction(bound); Struct row = readRow(readContext); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); assertThat(readContext.getReadTimestamp()).isEqualTo(expected.timestamp); row = readRow(client.singleUse(bound)); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); }
@Test public void multiStrong() { setUpPrivateDatabase(); History expected = history.get(history.size() - 1); try (ReadOnlyTransaction readContext = client.readOnlyTransaction()) { Struct row = readRow(readContext); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); assertThat(readContext.getReadTimestamp()).isAtLeast(expected.timestamp); insertAndReadAgain(readContext, readContext.getReadTimestamp(), expected.value); } }
@Test public void pointRead() { Struct row = client.singleUse(TimestampBound.strong()).readRow(TABLE_NAME, Key.of("k1"), ALL_COLUMNS); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo("k1"); assertThat(row.getString(1)).isEqualTo("v1"); // Ensure that the Struct implementation supports equality properly. assertThat(row) .isEqualTo(Struct.newBuilder().set("Key").to("k1").set("StringValue").to("v1").build()); }
@Test public void multiReadTimestamp() { setUpPrivateDatabase(); History expected = history.get(2); try (ReadOnlyTransaction readContext = client.readOnlyTransaction(TimestampBound.ofReadTimestamp(expected.timestamp))) { Struct row = readRow(readContext); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); assertThat(readContext.getReadTimestamp()).isEqualTo(expected.timestamp); insertAndReadAgain(readContext, readContext.getReadTimestamp(), expected.value); } }
@Test public void bindString() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to("abc"), Type.string()); assertThat(row.isNull(0)).isFalse(); assertThat(row.getString(0)).isEqualTo("abc"); }
@Test public void writeString() { write(baseInsert().set("StringValue").to("V1").build()); Struct row = readLastRow("StringValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getString(0)).isEqualTo("V1"); }
@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"); }
@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(); }
@Test public void duplicateFields() { // Duplicate fields are allowed - some SQL queries produce this type of value. Struct struct = Struct.newBuilder().set("").to("x").set("").to(Value.int64(2)).build(); assertThat(struct.getType()) .isEqualTo( Type.struct( Type.StructField.of("", Type.string()), Type.StructField.of("", Type.int64()))); assertThat(struct.isNull(0)).isFalse(); assertThat(struct.isNull(1)).isFalse(); assertThat(struct.getString(0)).isEqualTo("x"); assertThat(struct.getLong(1)).isEqualTo(2); }
@Test public void bindStructWithStructField() { Struct nestedStruct = Struct.newBuilder().set("ff1").to("abc").build(); Struct p = Struct.newBuilder().set("f1").to(nestedStruct).build(); Struct row = executeWithRowResultType( Statement.newBuilder("SELECT @p.f1.ff1").bind("p").to(p).build(), nestedStruct.getType()); assertThat(row.getString(0)).isEqualTo("abc"); }