@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)); } }
@Test public void bindReplacement() { String sql = "SELECT Name FROM Users WHERE Id = @id"; Statement stmt = Statement.newBuilder(sql).bind("id").to(1).bind("id").to(2).build(); assertThat(stmt.hasBinding("id")).isTrue(); assertThat(stmt.getSql()).isEqualTo(sql); assertThat(stmt.getParameters()).isEqualTo(ImmutableMap.of("id", Value.int64(2))); assertThat(stmt.toString()).isEqualTo(sql + " {id: 2}"); }
@Test public void bindCommitTimestampFails() { ValueBinder<Statement.Builder> binder = Statement.newBuilder("SELECT @v").bind("v"); expectedException.expect(IllegalArgumentException.class); binder.to(Value.COMMIT_TIMESTAMP); }
@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 update() { Mutation m = Mutation.newUpdateBuilder("T1").set("C1").to(true).set("C2").to(1234).build(); assertThat(m.getTable()).isEqualTo("T1"); assertThat(m.getOperation()).isEqualTo(Mutation.Op.UPDATE); assertThat(m.getColumns()).containsExactly("C1", "C2").inOrder(); assertThat(m.getValues()).containsExactly(Value.bool(true), Value.int64(1234)).inOrder(); assertThat(m.toString()).isEqualTo("update(T1{C1=true,C2=1234})"); }
@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(); }
@Test public void bindBytesNull() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to((ByteArray) null), Type.bytes()); assertThat(row.isNull(0)).isTrue(); }
@Test public void bindTimestampNull() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to((Timestamp) null), Type.timestamp()); assertThat(row.isNull(0)).isTrue(); }
@Test public void bindInt64() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to(1234), Type.int64()); assertThat(row.isNull(0)).isFalse(); assertThat(row.getLong(0)).isEqualTo(1234); }
@Test public void bindFloat64Null() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to((Double) null), Type.float64()); assertThat(row.isNull(0)).isTrue(); }
@Test public void bindDateNull() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to((Date) null), Type.date()); assertThat(row.isNull(0)).isTrue(); }
@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})"); }
@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 writeInt64() { write(baseInsert().set("Int64Value").to(1234).build()); Struct row = readLastRow("Int64Value"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getLong(0)).isEqualTo(1234L); }
@Test public void bindBool() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to(true).build(), Type.bool()); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBoolean(0)).isEqualTo(true); }
@Test public void writeBoolNull() { write(baseInsert().set("BoolValue").to((Boolean) null).build()); Struct row = readLastRow("BoolValue"); assertThat(row.isNull(0)).isTrue(); }
@Test public void bindEmptyStruct() { Struct p = Struct.newBuilder().build(); Struct row = execute(Statement.newBuilder("SELECT @p IS NULL").bind("p").to(p).build(), Type.bool()); assertThat(row.getBoolean(0)).isFalse(); }
@Test public void incorrectType() { expectedException.expect(isSpannerException(ErrorCode.FAILED_PRECONDITION)); expectedException.expectMessage("Expected STRING"); // Attempt to set 'V' to INT64, not STRING. // NOTE: an interest effect of not sending type metadata is that BYTES and INT64 are accepted // here... write(baseInsert().set("StringValue").to(1.234).build()); }
@Test public void bindStructWithUnnamedFields() { Struct p = Struct.newBuilder().add(Value.int64(1337)).add(Value.int64(7331)).build(); Struct row = executeWithRowResultType( Statement.newBuilder("SELECT * FROM UNNEST([@p])").bind("p").to(p).build(), p.getType()); assertThat(row.getLong(0)).isEqualTo(1337); assertThat(row.getLong(1)).isEqualTo(7331); }