@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 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 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 toBuilder() { KeyRange r = KeyRange.closedOpen(Key.of(1), Key.of(2)); r.toBuilder().setEndType(CLOSED).build(); }
@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 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 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(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 javaSerialization() throws Exception { reserializeAndAssert( KeySet.all() .toBuilder() .addKey(Key.of("a", 1)) .addRange(KeyRange.closedOpen(Key.of("m"), Key.of("p"))) .build()); }
@Test public void serializationMultiWithAll() { KeySet keySet = KeySet.all() .toBuilder() .addKey(Key.of("a", 1)) .addRange(KeyRange.closedOpen(Key.of("m"), Key.of("p"))) .build(); checkProto( keySet, "keys { values { string_value: 'a' } values { string_value: '1' } }" + " ranges { start_closed { values { string_value: 'm' } }" + " end_open { values { string_value: 'p' } } }" + " all:true"); }
@Test public void serialization() throws Exception { reserializeAndAssert(KeyRange.closedOpen(Key.of(1), Key.of(2))); reserializeAndAssert(KeyRange.closedClosed(Key.of(1), Key.of(2))); reserializeAndAssert(KeyRange.openOpen(Key.of(1), Key.of(2))); reserializeAndAssert(KeyRange.openClosed(Key.of(1), Key.of(2))); } }
@Test public void serializationMulti() { KeySet keySet = KeySet.newBuilder() .addKey(Key.of("d", 1)) .addRange(KeyRange.closedOpen(Key.of("m"), Key.of("p"))) .addKey(Key.of("a", 1)) .addRange(KeyRange.closedClosed(Key.of("a"), Key.of("d"))) .build(); checkProto( keySet, "keys { values { string_value: 'd' } values { string_value: '1' } }" + " keys { values { string_value: 'a' } values { string_value:'1' } }" + " ranges { start_closed { values { string_value: 'm' } }" + " end_open { values { string_value: 'p' } } }" + " ranges { start_closed { values { string_value: 'a' } }" + " end_closed { values { string_value: 'd' } } }"); }
@Test public void rangeReads() { checkRange(Source.BASE_TABLE, KeySet.singleKey(Key.of("k1")), 1); checkRange(Source.BASE_TABLE, KeyRange.closedOpen(Key.of("k3"), Key.of("k5")), 3, 4); checkRange(Source.BASE_TABLE, KeyRange.closedClosed(Key.of("k3"), Key.of("k5")), 3, 4, 5); checkRange(Source.BASE_TABLE, KeyRange.openClosed(Key.of("k3"), Key.of("k5")), 4, 5); checkRange(Source.BASE_TABLE, KeyRange.openOpen(Key.of("k3"), Key.of("k5")), 4); // Partial key specification. checkRange(Source.BASE_TABLE, KeyRange.closedClosed(Key.of("k7"), Key.of()), 7, 8, 9); checkRange(Source.BASE_TABLE, KeyRange.openClosed(Key.of("k7"), Key.of()), 8, 9); checkRange(Source.BASE_TABLE, KeyRange.closedOpen(Key.of(), Key.of("k11")), 0, 1, 10); checkRange(Source.BASE_TABLE, KeyRange.closedClosed(Key.of(), Key.of("k11")), 0, 1, 10, 11); // The following produce empty ranges. // TODO(user): Consider a multi-part key to illustrate partial key behavior. checkRange(Source.BASE_TABLE, KeyRange.closedOpen(Key.of("k7"), Key.of())); checkRange(Source.BASE_TABLE, KeyRange.openOpen(Key.of("k7"), Key.of())); checkRange(Source.BASE_TABLE, KeyRange.openOpen(Key.of(), Key.of("k11"))); checkRange(Source.BASE_TABLE, KeyRange.openClosed(Key.of(), Key.of("k11"))); // Prefix is component-wise, not string prefix. checkRange(Source.BASE_TABLE, KeyRange.prefix(Key.of("k1")), 1); checkRange( Source.BASE_TABLE, KeyRange.closedOpen(Key.of("k1"), Key.of("k2")), 1, 10, 11, 12, 13, 14); checkRange(Source.BASE_TABLE, KeySet.all(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14); }
@Test public void indexRangeReads() { checkRange(Source.INDEX, KeySet.singleKey(Key.of("v1")), 1); checkRange(Source.INDEX, KeyRange.closedOpen(Key.of("v3"), Key.of("v5")), 3, 4); checkRange(Source.INDEX, KeyRange.closedClosed(Key.of("v3"), Key.of("v5")), 3, 4, 5); checkRange(Source.INDEX, KeyRange.openClosed(Key.of("v3"), Key.of("v5")), 4, 5); checkRange(Source.INDEX, KeyRange.openOpen(Key.of("v3"), Key.of("v5")), 4); // Partial key specification. checkRange(Source.INDEX, KeyRange.closedClosed(Key.of("v7"), Key.of()), 7, 8, 9); checkRange(Source.INDEX, KeyRange.openClosed(Key.of("v7"), Key.of()), 8, 9); checkRange(Source.INDEX, KeyRange.closedOpen(Key.of(), Key.of("v11")), 0, 1, 10); checkRange(Source.INDEX, KeyRange.closedClosed(Key.of(), Key.of("v11")), 0, 1, 10, 11); // The following produce empty ranges. checkRange(Source.INDEX, KeyRange.closedOpen(Key.of("v7"), Key.of())); checkRange(Source.INDEX, KeyRange.openOpen(Key.of("v7"), Key.of())); checkRange(Source.INDEX, KeyRange.openOpen(Key.of(), Key.of("v11"))); checkRange(Source.INDEX, KeyRange.openClosed(Key.of(), Key.of("v11"))); // Prefix is component-wise, not string prefix. checkRange(Source.INDEX, KeyRange.prefix(Key.of("v1")), 1); checkRange( Source.INDEX, KeyRange.closedOpen(Key.of("v1"), Key.of("v2")), 1, 10, 11, 12, 13, 14); checkRange(Source.INDEX, KeySet.all(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14); // Read from an index with DESC ordering. checkRange(Source.DESC_INDEX, KeySet.all(), 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); }
@Test public void basics() { checkKeyRange(KeyRange.closedOpen(Key.of(1), Key.of(2)), Key.of(1), CLOSED, Key.of(2), OPEN); checkKeyRange( KeyRange.closedClosed(Key.of(1), Key.of(2)), Key.of(1), CLOSED, Key.of(2), CLOSED); checkKeyRange(KeyRange.openOpen(Key.of(1), Key.of(2)), Key.of(1), OPEN, Key.of(2), OPEN); checkKeyRange(KeyRange.openClosed(Key.of(1), Key.of(2)), Key.of(1), OPEN, Key.of(2), CLOSED); }
@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(); }
@Test public void equalsAndHashCode() { EqualsTester tester = new EqualsTester(); // Test factory method vs builder with defaults vs builder with all parts explicit. tester.addEqualityGroup( KeyRange.closedOpen(Key.of(1), Key.of(2)), KeyRange.newBuilder().setStart(Key.of(1)).setEnd(Key.of(2)).build(), KeyRange.newBuilder() .setStart(Key.of(1)) .setStartType(CLOSED) .setEnd(Key.of(2)) .setEndType(OPEN) .build()); // Differing endpoint types. tester.addEqualityGroup(KeyRange.closedClosed(Key.of(1), Key.of(2))); tester.addEqualityGroup(KeyRange.openOpen(Key.of(1), Key.of(2))); tester.addEqualityGroup(KeyRange.openClosed(Key.of(1), Key.of(2))); // Differing start/end keys. tester.addEqualityGroup(KeyRange.closedOpen(Key.of(2), Key.of(1))); tester.addEqualityGroup(KeyRange.closedClosed(Key.of(), Key.of())); // Prefix range. tester.addEqualityGroup( KeyRange.prefix(Key.of(1, 2)), KeyRange.closedClosed(Key.of(1, 2), Key.of(1, 2))); tester.testEquals(); }
"test", KeySet.newBuilder() .addRange(KeyRange.closedOpen(Key.of("one", 2, null), Key.of("two", 3, null))) .build())); reserializeAndAssert(