use of com.apple.foundationdb.record.query.RecordQuery in project fdb-record-layer by FoundationDB.
the class FDBMultiFieldIndexSelectionTest method testPrefixScalar.
/**
* Verify that a two field index can be used for queries on both the first field alone and both fields.
*/
@DualPlannerTest
void testPrefixScalar() {
RecordMetaDataHook hook = metaData -> metaData.addIndex("MySimpleRecord", "prefix_scalar", concat(field("num_value_2"), field("num_value_3_indexed")));
try (FDBRecordContext context = openContext()) {
openSimpleRecordStore(context, hook);
TestRecords1Proto.MySimpleRecord.Builder recordBuilder = TestRecords1Proto.MySimpleRecord.newBuilder();
recordBuilder.setRecNo(1).setNumValue2(1).setNumValue3Indexed(1);
recordStore.saveRecord(recordBuilder.build());
recordBuilder.setRecNo(2).setNumValue2(2).setNumValue3Indexed(2);
recordStore.saveRecord(recordBuilder.build());
recordBuilder.setRecNo(3).setNumValue2(1).clearNumValue3Indexed();
recordStore.saveRecord(recordBuilder.build());
commit(context);
}
RecordQuery query1 = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.field("num_value_2").equalsValue(1)).build();
// Index(prefix_scalar [[1],[1]])
RecordQueryPlan plan1 = planner.plan(query1);
assertThat(plan1, indexScan(allOf(indexName("prefix_scalar"), bounds(hasTupleString("[[1],[1]]")))));
assertEquals(339959201, plan1.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(1160014595, plan1.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(1504375084, plan1.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
RecordQuery query2 = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.and(Query.field("num_value_2").equalsValue(1), Query.field("num_value_3_indexed").equalsValue(1))).build();
RecordQueryPlan plan2 = planner.plan(query2);
assertThat(plan2, indexScan(allOf(indexName("prefix_scalar"), bounds(hasTupleString("[[1, 1],[1, 1]]")))));
assertEquals(-447322749, plan2.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(-1253390298, plan2.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(1176210758, plan2.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
try (FDBRecordContext context = openContext()) {
openSimpleRecordStore(context, hook);
List<Long> recnos = recordStore.executeQuery(plan1).map(r -> TestRecords1Proto.MySimpleRecord.newBuilder().mergeFrom(r.getRecord()).getRecNo()).asList().join();
assertEquals(Arrays.asList(3L, 1L), recnos);
TestHelpers.assertDiscardedNone(context);
clearStoreCounter(context);
recnos = recordStore.executeQuery(plan2).map(r -> TestRecords1Proto.MySimpleRecord.newBuilder().mergeFrom(r.getRecord()).getRecNo()).asList().join();
assertEquals(ImmutableList.of(1L), recnos);
TestHelpers.assertDiscardedNone(context);
}
}
use of com.apple.foundationdb.record.query.RecordQuery in project fdb-record-layer by FoundationDB.
the class FDBNestedFieldQueryTest method hierarchical.
/**
* Verify that simple queries on nested fields can use bounds on a record scan.
*/
@DualPlannerTest
public void hierarchical() throws Exception {
try (FDBRecordContext context = openContext()) {
openHierarchicalRecordStore(context);
TestRecords3Proto.MyHierarchicalRecord.Builder recBuilder = TestRecords3Proto.MyHierarchicalRecord.newBuilder();
recBuilder.setChildName("photos");
recBuilder.setNumValueIndexed(1);
recordStore.saveRecord(recBuilder.build());
recBuilder.setChildName("music");
recBuilder.setNumValueIndexed(2);
recordStore.saveRecord(recBuilder.build());
recBuilder.setParentPath("photos");
recBuilder.setChildName("vacations");
recBuilder.setNumValueIndexed(11);
recordStore.saveRecord(recBuilder.build());
recBuilder.setChildName("pets");
recBuilder.setNumValueIndexed(12);
recordStore.saveRecord(recBuilder.build());
recBuilder.setParentPath("photos/vacations");
recBuilder.setChildName("paris");
recBuilder.setNumValueIndexed(111);
recordStore.saveRecord(recBuilder.build());
recBuilder.setChildName("london");
recBuilder.setNumValueIndexed(112);
recordStore.saveRecord(recBuilder.build());
recBuilder.setParentPath("photos/vacations/paris");
recBuilder.setChildName("seine");
recBuilder.setNumValueIndexed(1111);
recordStore.saveRecord(recBuilder.build());
commit(context);
}
try (FDBRecordContext context = openContext()) {
openHierarchicalRecordStore(context);
FDBStoredRecord<Message> rec = recordStore.loadRecord(Tuple.from(null, "photos"));
assertNotNull(rec);
TestRecords3Proto.MyHierarchicalRecord.Builder myrec = TestRecords3Proto.MyHierarchicalRecord.newBuilder();
myrec.mergeFrom(rec.getRecord());
assertEquals(1, myrec.getNumValueIndexed());
}
RecordQuery query = RecordQuery.newBuilder().setRecordType("MyHierarchicalRecord").setFilter(Query.field("parent_path").equalsValue("photos")).build();
// Scan([[photos],[photos]])
RecordQueryPlan plan = planner.plan(query);
assertThat(plan, scan(bounds(hasTupleString("[[photos],[photos]]"))));
assertEquals(1063779424, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(-623055281, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(568511736, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
assertEquals(Arrays.asList(12, 11), fetchResultValues(plan, TestRecords3Proto.MyHierarchicalRecord.NUM_VALUE_INDEXED_FIELD_NUMBER, this::openHierarchicalRecordStore, TestHelpers::assertDiscardedNone));
query = RecordQuery.newBuilder().setRecordType("MyHierarchicalRecord").setFilter(Query.field("parent_path").startsWith("photos")).build();
// Scan({[photos],[photos]})
plan = planner.plan(query);
assertThat(plan, scan(bounds(hasTupleString("{[photos],[photos]}"))));
assertEquals(224213141, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(1663787616, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(1347957217, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
assertEquals(Arrays.asList(12, 11, 112, 111, 1111), fetchResultValues(plan, TestRecords3Proto.MyHierarchicalRecord.NUM_VALUE_INDEXED_FIELD_NUMBER, this::openHierarchicalRecordStore, TestHelpers::assertDiscardedNone));
}
use of com.apple.foundationdb.record.query.RecordQuery in project fdb-record-layer by FoundationDB.
the class FDBNestedFieldQueryTest method nestedRankMap.
/**
* Verify that a rank index on a map-like repeated nested message can be scanned for rank comparisons.
*/
@Test
public void nestedRankMap() throws Exception {
final GroupingKeyExpression rankGroup = new GroupingKeyExpression(concat(field("other_id"), field("map").nest(field("entry", KeyExpression.FanType.FanOut).nest(concatenateFields("key", "value")))), 1);
final RecordMetaDataBuilder metaDataBuilder = RecordMetaData.newBuilder().setRecords(TestRecordsNestedMapProto.getDescriptor());
metaDataBuilder.addIndex("OuterRecord", new Index("rank_value_by_key", rankGroup, IndexTypes.RANK));
// TODO: This is not a very obvious way to specify this. But we don't have correlation names.
final QueryComponent keyCondition = Query.field("map").matches(Query.field("entry").oneOfThem().matches(Query.field("key").equalsValue("alpha")));
final QueryRecordFunction<Long> rank = Query.rank(rankGroup).withAdditionalCondition(keyCondition);
try (FDBRecordContext context = openContext()) {
createOrOpenRecordStore(context, metaDataBuilder.getRecordMetaData());
TestRecordsNestedMapProto.OuterRecord.Builder builder = TestRecordsNestedMapProto.OuterRecord.newBuilder().setOtherId(1);
TestRecordsNestedMapProto.MapRecord.Builder mapBuilder = builder.getMapBuilder();
builder.setRecId(1);
mapBuilder.addEntryBuilder().setKey("alpha").setValue("abc");
mapBuilder.addEntryBuilder().setKey("beta").setValue("bcd");
recordStore.saveRecord(builder.build());
builder.setRecId(2);
mapBuilder.clear();
mapBuilder.addEntryBuilder().setKey("alpha").setValue("aaa");
mapBuilder.addEntryBuilder().setKey("beta").setValue("bbb");
recordStore.saveRecord(builder.build());
commit(context);
}
RecordQuery query = RecordQuery.newBuilder().setRecordType("OuterRecord").setFilter(Query.and(Query.field("other_id").equalsValue(1L), Query.rank(rankGroup).lessThan(10L), keyCondition)).build();
RecordQueryPlan plan = planner.plan(query);
assertThat(plan, primaryKeyDistinct(indexScan(allOf(indexName("rank_value_by_key"), indexScanType(IndexScanType.BY_RANK), bounds(hasTupleString("([1, alpha, null],[1, alpha, 10])"))))));
assertEquals(1307013946, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(-1725407749, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(825274646, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
try (FDBRecordContext context = openContext()) {
createOrOpenRecordStore(context, metaDataBuilder.getRecordMetaData());
try (RecordCursor<FDBQueriedRecord<Message>> cursor = recordStore.executeQuery(plan)) {
RecordCursorResult<FDBQueriedRecord<Message>> result = cursor.getNext();
assertTrue(result.hasNext());
assertEquals(Tuple.from(2), result.get().getPrimaryKey());
result = cursor.getNext();
assertTrue(result.hasNext());
assertEquals(Tuple.from(1), result.get().getPrimaryKey());
assertEquals(1, rank.eval(recordStore, EvaluationContext.EMPTY, result.get().getStoredRecord()).get());
result = cursor.getNext();
assertFalse(result.hasNext());
}
}
}
use of com.apple.foundationdb.record.query.RecordQuery in project fdb-record-layer by FoundationDB.
the class FDBNestedFieldQueryTest method doublyNested.
/**
* Verify that queries on doubly nested records with fanout on the inner field work properly.
*/
@DualPlannerTest
public void doublyNested() throws Exception {
try (FDBRecordContext context = openContext()) {
openDoublyNestedRecordStore(context);
TestRecords5Proto.CalendarEvent.Builder eventBuilder = TestRecords5Proto.CalendarEvent.newBuilder();
eventBuilder.setPath("ev1");
TestRecords5Proto.CalendarEventIndex.Builder indexBuilder = eventBuilder.getEventIndexBuilder();
TestRecords5Proto.Recurrence.Builder occurBuilder = indexBuilder.addRecurrenceBuilder();
occurBuilder.setStart(2);
occurBuilder.setEnd(2);
occurBuilder = indexBuilder.addRecurrenceBuilder();
occurBuilder.setStart(12);
occurBuilder.setEnd(12);
recordStore.saveRecord(eventBuilder.build());
eventBuilder = TestRecords5Proto.CalendarEvent.newBuilder();
eventBuilder.setPath("ev2");
indexBuilder = eventBuilder.getEventIndexBuilder();
occurBuilder = indexBuilder.addRecurrenceBuilder();
occurBuilder.setStart(5);
occurBuilder.setEnd(5);
recordStore.saveRecord(eventBuilder.build());
eventBuilder = TestRecords5Proto.CalendarEvent.newBuilder();
eventBuilder.setPath("ev3");
indexBuilder = eventBuilder.getEventIndexBuilder();
occurBuilder = indexBuilder.addRecurrenceBuilder();
occurBuilder.setStart(15);
occurBuilder.setEnd(15);
occurBuilder = indexBuilder.addRecurrenceBuilder();
occurBuilder.setStart(25);
occurBuilder.setEnd(25);
recordStore.saveRecord(eventBuilder.build());
commit(context);
}
// TODO this was originally:
// QueryExpression.field("eventIndex").matches(
// QueryExpression.field("recurrence").matches(
// QueryExpression.field("start").greaterThan(10L))),
// which should have failed validate
RecordQuery query = RecordQuery.newBuilder().setRecordType("CalendarEvent").setFilter(Query.field("eventIndex").matches(Query.field("recurrence").oneOfThem().matches(Query.field("start").greaterThan(10L)))).build();
// Index(event_start ([10],>) | UnorderedPrimaryKeyDistinct()
RecordQueryPlan plan = planner.plan(query);
if (planner instanceof RecordQueryPlanner) {
assertThat(plan, primaryKeyDistinct(indexScan(allOf(indexName("event_start"), bounds(hasTupleString("([10],>"))))));
assertEquals(667993366, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(-1217457303, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(-1297919931, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
} else {
assertThat(plan, fetch(primaryKeyDistinct(coveringIndexScan(indexScan(allOf(indexName("event_start"), bounds(hasTupleString("([10],>"))))))));
assertEquals(380986279, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(-721491332, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(-801953960, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
}
assertEquals(Arrays.asList("ev1", "ev3"), fetchResultValues(plan, TestRecords5Proto.CalendarEvent.PATH_FIELD_NUMBER, this::openDoublyNestedRecordStore, context -> TestHelpers.assertDiscardedAtMost(1, context)));
}
use of com.apple.foundationdb.record.query.RecordQuery in project fdb-record-layer by FoundationDB.
the class FDBNestedFieldQueryTest method nestedWithBetween.
/**
* Verify that BETWEEN-style AND on nested fields merge properly.
*/
@DualPlannerTest
public void nestedWithBetween() throws Exception {
final RecordMetaDataHook hook = metaData -> {
metaData.removeIndex("stats$school");
metaData.addIndex("RestaurantReviewer", "stats$school", concat(field("name"), field("stats").nest(field("start_date"))));
metaData.getIndex("stats$school").setSubspaceKey("stats$school_2");
};
nestedWithAndSetup(hook);
RecordQuery query = RecordQuery.newBuilder().setRecordType("RestaurantReviewer").setFilter(Query.and(Query.field("name").equalsValue("Newt A. Robot"), Query.field("stats").matches(Query.field("start_date").greaterThan(100L)), Query.field("stats").matches(Query.field("start_date").lessThan(2000L)))).build();
// Index(stats$school ([Newt A. Robot, 100],[Newt A. Robot, 2000]))
RecordQueryPlan plan = planner.plan(query);
assertThat(plan, indexScan(allOf(indexName("stats$school"), bounds(hasTupleString("([Newt A. Robot, 100],[Newt A. Robot, 2000])")))));
assertEquals(1355996214, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
assertEquals(669950614, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
assertEquals(-1690206997, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
assertEquals(Collections.singletonList(2L), fetchResultValues(plan, TestRecords4Proto.RestaurantReviewer.ID_FIELD_NUMBER, ctx -> openNestedRecordStore(ctx, hook), TestHelpers::assertDiscardedNone));
}
Aggregations