/** * Creates a key set that covers all keys where the first {@code prefix.size()} components match * {@code prefix} exactly. */ public static KeySet prefixRange(Key prefix) { return range(KeyRange.prefix(prefix)); }
private void checkRange(Source source, KeyRange range, int... expectedRows) { checkRange(source, KeySet.range(range), expectedRows); }
private void checkRangeWithLimit(Source source, long limit, KeyRange range, int... expectedRows) { checkReadRange(source, KeySet.range(range), limit, expectedRows); } }
@Test public void serializationSingleRangeClosedClosed() { KeySet keySet = KeySet.range(KeyRange.closedClosed(Key.of("a"), Key.of("z"))); checkProto( keySet, "ranges { start_closed { values { string_value: 'a' } }" + " end_closed { values { string_value: 'z' } } }"); }
@Test public void serializationSingleRangeClosedOpen() { KeySet keySet = KeySet.range(KeyRange.closedOpen(Key.of("a"), Key.of("z"))); checkProto( keySet, "ranges { start_closed { values { string_value: 'a' } }" + " end_open { values { string_value: 'z' } } }"); }
@Test public void serializationSingleRangeOpenOpen() { KeySet keySet = KeySet.range(KeyRange.openOpen(Key.of("a"), Key.of("z"))); checkProto( keySet, "ranges { start_open { values { string_value: 'a' } }" + " end_open { values { string_value: 'z' } } }"); }
@Test public void serializationSingleRangeOpenClosed() { KeySet keySet = KeySet.range(KeyRange.openClosed(Key.of("a"), Key.of("z"))); checkProto( keySet, "ranges { start_open { values { string_value: 'a' } }" + " end_closed { values { string_value: 'z' } } }"); }
@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"))); }
@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 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 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 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])}"); }
client .singleUse(TimestampBound.strong()) .read("T", KeySet.range(KeyRange.prefix(Key.of("boo"))), Arrays.asList("K")); assertThat(resultSet.next()).isFalse();
@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 equalsAndHashCode() { EqualsTester tester = new EqualsTester(); tester.addEqualityGroup(KeySet.newBuilder().build()); tester.addEqualityGroup(KeySet.all(), KeySet.newBuilder().setAll().build()); tester.addEqualityGroup( KeySet.singleKey(Key.of("a")), KeySet.newBuilder().addKey(Key.of("a")).build()); tester.addEqualityGroup( KeySet.range(KeyRange.closedOpen(Key.of("a"), Key.of("b"))), KeySet.newBuilder().addRange(KeyRange.closedOpen(Key.of("a"), Key.of("b"))).build()); tester.addEqualityGroup(KeySet.newBuilder().addKey(Key.of(1)).addKey(Key.of(2)).build()); // We currently consider order, although this doesn't affect visible results. tester.addEqualityGroup(KeySet.newBuilder().addKey(Key.of(2)).addKey(Key.of(1)).build()); tester.addEqualityGroup(KeySet.newBuilder().setAll().addKey(Key.of("a")).build()); tester.addEqualityGroup( KeySet.newBuilder() .addKey(Key.of("a")) .addRange(KeyRange.closedOpen(Key.of("a"), Key.of("b"))) .build()); tester.testEquals(); }
/** * Creates a key set that covers all keys where the first {@code prefix.size()} components match * {@code prefix} exactly. */ public static KeySet prefixRange(Key prefix) { return range(KeyRange.prefix(prefix)); }
private static Mutation delRange(Long start, Long end) { return Mutation.delete("test", KeySet.range(KeyRange.closedClosed(Key.of(start), Key.of(end)))); }
Mutation range = Mutation.delete( "test", KeySet.range(KeyRange.openOpen(Key.of(1L), Key.newBuilder().build()))); MutationGroup[] mutationGroups = new MutationGroup[] {
Mutation range = Mutation.delete( "test", KeySet.range(KeyRange.openOpen(Key.of(1L), Key.newBuilder().build()))); MutationGroup[] mutationGroups = new MutationGroup[] {