@Test public void toBuilder() { Key k = Key.of(1, 2).toBuilder().append(3).build(); assertThat(k.size()).isEqualTo(3); assertThat(k.getParts()).containsExactly(1L, 2L, 3L).inOrder(); }
@Test public void testToString() { assertThat(Key.of().toString()).isEqualTo("[]"); assertThat(Key.of(new Object[] {null}).toString()).isEqualTo("[<null>]"); assertThat(Key.of(true).toString()).isEqualTo("[true]"); assertThat(Key.of(32).toString()).isEqualTo("[32]"); assertThat(Key.of(2.0).toString()).isEqualTo("[2.0]"); assertThat(Key.of("xyz").toString()).isEqualTo("[xyz]"); ByteArray b = ByteArray.copyFrom("xyz"); assertThat(Key.of(b).toString()).isEqualTo("[" + b.toString() + "]"); String timestamp = "2015-09-15T00:00:00Z"; assertThat(Key.of(Timestamp.parseTimestamp(timestamp)).toString()) .isEqualTo("[" + timestamp + "]"); String date = "2015-09-15"; assertThat(Key.of(Date.parseDate(date)).toString()).isEqualTo("[" + date + "]"); assertThat(Key.of(1, 2, 3).toString()).isEqualTo("[1,2,3]"); }
@Test public void indexPointReadNotFound() { Struct row = client .singleUse(TimestampBound.strong()) .readRowUsingIndex(TABLE_NAME, INDEX_NAME, Key.of("v999"), ALL_COLUMNS); assertThat(row).isNull(); }
@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 emptyRead() { ResultSet resultSet = client .singleUse(TimestampBound.strong()) .read( TABLE_NAME, KeySet.range(KeyRange.closedOpen(Key.of("k99"), Key.of("z"))), ALL_COLUMNS); assertThat(resultSet.next()).isFalse(); assertThat(resultSet.getType()).isEqualTo(TABLE_TYPE); }
@Test public void indexEmptyRead() { ResultSet resultSet = client .singleUse(TimestampBound.strong()) .readUsingIndex( TABLE_NAME, INDEX_NAME, KeySet.range(KeyRange.closedOpen(Key.of("v99"), Key.of("z"))), ALL_COLUMNS); assertThat(resultSet.next()).isFalse(); assertThat(resultSet.getType()).isEqualTo(TABLE_TYPE); }
@Test public void testToString() { assertThat(KeySet.all().toString()).isEqualTo("{<all>}"); assertThat(KeySet.singleKey(Key.of("x")).toString()).isEqualTo("{[x]}"); assertThat(KeySet.range(KeyRange.closedOpen(Key.of("a"), Key.of("z"))).toString()) .isEqualTo("{[[a],[z])}"); }
@Test public void testToString() { assertThat(KeyRange.closedOpen(Key.of("a"), Key.of("b")).toString()).isEqualTo("[[a],[b])"); assertThat(KeyRange.closedClosed(Key.of("a"), Key.of("b")).toString()).isEqualTo("[[a],[b]]"); assertThat(KeyRange.openOpen(Key.of("a"), Key.of("b")).toString()).isEqualTo("([a],[b])"); assertThat(KeyRange.openClosed(Key.of("a"), Key.of("b")).toString()).isEqualTo("([a],[b]]"); assertThat(KeyRange.closedClosed(Key.of(), Key.of()).toString()).isEqualTo("[[],[]]"); }
@Test public void toBuilder() { KeySet set = KeySet.singleKey(Key.of(1)).toBuilder().addKey(Key.of(2)).build(); assertThat(set.isAll()).isFalse(); assertThat(set.getKeys()).containsExactly(Key.of(1), Key.of(2)).inOrder(); assertThat(set.getRanges()).isEmpty(); set = KeySet.range(KeyRange.closedOpen(Key.of("a"), Key.of("b"))) .toBuilder() .addRange(KeyRange.closedOpen(Key.of("c"), Key.of("d"))) .build(); assertThat(set.isAll()).isFalse(); assertThat(set.getKeys()).isEmpty(); assertThat(set.getRanges()) .containsExactly( KeyRange.closedOpen(Key.of("a"), Key.of("b")), KeyRange.closedOpen(Key.of("c"), Key.of("d"))) .inOrder(); set = KeySet.all().toBuilder().addKey(Key.of(1)).build(); assertThat(set.isAll()).isTrue(); assertThat(set.getKeys()).containsExactly(Key.of(1)); assertThat(set.getRanges()).isEmpty(); }
@Test public void range() { KeySet set = KeySet.range(KeyRange.closedOpen(Key.of("a"), Key.of("b"))); assertThat(set.isAll()).isFalse(); assertThat(set.getKeys()).isEmpty(); assertThat(set.getRanges()).containsExactly(KeyRange.closedOpen(Key.of("a"), Key.of("b"))); }
TransactionRunner runner = client.readWriteTransaction(); runner.run(callable); fail("Expected user exception"); } catch (SpannerException e) { assertThat(e.getErrorCode()).isEqualTo(ErrorCode.UNKNOWN); assertThat(e.getMessage()).contains("failing to commit"); assertThat(e.getCause()).isInstanceOf(UserException.class); .singleUse(TimestampBound.strong()) .read("T", KeySet.range(KeyRange.prefix(Key.of("boo"))), Arrays.asList("K")); assertThat(resultSet.next()).isFalse();
@Test public void builder() { KeySet set = KeySet.newBuilder() .addKey(Key.of("k1")) .addKey(Key.of("k2")) .addRange(KeyRange.closedOpen(Key.of("r1"), Key.of("rr1"))) .addRange(KeyRange.closedOpen(Key.of("r2"), Key.of("rr2"))) .build(); assertThat(set.isAll()).isFalse(); // Order isn't strictly important to the API, but it's helpful to preserve it. assertThat(set.getKeys()).containsExactly(Key.of("k1"), Key.of("k2")).inOrder(); assertThat(set.getRanges()) .containsExactly( KeyRange.closedOpen(Key.of("r1"), Key.of("rr1")), KeyRange.closedOpen(Key.of("r2"), Key.of("rr2"))) .inOrder(); assertThat(set.toString()).isEqualTo("{[k1],[k2],[[r1],[rr1]),[[r2],[rr2])}"); }
@Test public void prefixRange() { KeySet set = KeySet.prefixRange(Key.of("a", "b")); assertThat(set.isAll()).isFalse(); assertThat(set.getKeys()).isEmpty(); assertThat(set.getRanges()).containsExactly(KeyRange.prefix(Key.of("a", "b"))); }
@Test public void rowsAreSnapshots() { List<Struct> rows = new ArrayList<>(); ResultSet resultSet = client .singleUse(TimestampBound.strong()) .read( TABLE_NAME, KeySet.newBuilder() .addKey(Key.of("k2")) .addKey(Key.of("k3")) .addKey(Key.of("k4")) .build(), ALL_COLUMNS); while (resultSet.next()) { rows.add(resultSet.getCurrentRowAsStruct()); } assertThat(rows.size()).isEqualTo(3); assertThat(rows.get(0).getString(0)).isEqualTo("k2"); assertThat(rows.get(0).getString(1)).isEqualTo("v2"); assertThat(rows.get(1).getString(0)).isEqualTo("k3"); assertThat(rows.get(1).getString(1)).isEqualTo("v3"); assertThat(rows.get(2).getString(0)).isEqualTo("k4"); assertThat(rows.get(2).getString(1)).isEqualTo("v4"); }
@Test public void singleKey() { KeySet set = KeySet.singleKey(Key.of("a", "b", "c")); assertThat(set.isAll()).isFalse(); assertThat(set.getKeys()).containsExactly(Key.of("a", "b", "c")); assertThat(set.getRanges()).isEmpty(); }
@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' } } }" + " }" + "} ")); }
@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]})"); }
@Override public Void run(TransactionContext transaction) { long rowCount = transaction.executeUpdate(Statement.of("UPDATE T SET v = v * 2 WHERE k = 'boo2';")); assertThat(rowCount).isEqualTo(1); assertThat(transaction.readRow("T", Key.of("boo2"), Arrays.asList("v")).getLong(0)) .isEqualTo(2 * 2); return null; } };
@Test public void singleUseReadOnlyTransactionDoesntReturnTransactionMetadata() { PartialResultSet resultSet = PartialResultSet.newBuilder() .setMetadata(newMetadata(Type.struct(Type.StructField.of("C", Type.string())))) .build(); mockRead(resultSet); ReadOnlyTransaction txn = session.singleUseReadOnlyTransaction(TimestampBound.strong()); assertThat(txn.readRow("Dummy", Key.of(), Arrays.asList("C"))).isNull(); // For now, getReadTimestamp() will raise an ISE because it hasn't seen a timestamp. It would // be better for the read to fail with an INTERNAL error, but we can't do that until txn // metadata is returned for failed reads (e.g., table-not-found) as well as successful ones. // TODO(user): Fix this. expectedException.expect(IllegalStateException.class); txn.getReadTimestamp(); }