Examples with RecordQueryPlanner com.apple.foundationdb.record.query.plan.RecordQueryPlanner used on opensource projects

Example 11 with RecordQueryPlanner

use of com.apple.foundationdb.record.query.plan.RecordQueryPlanner in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method testInQueryOrMultipleIndexes.

/**
 * Verify an IN clause prevents index usage because the IN loop is not compatible with index ordering in the old
 * planner but causes an IN-UNION to be created in the new planner.
 */
@DualPlannerTest
void testInQueryOrMultipleIndexes() throws Exception {
    complexQuerySetup(NO_HOOK);
    planner.setConfiguration(InAsOrUnionMode.AS_UNION.configure(planner.getConfiguration().asBuilder()).build());
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.or(Query.field("str_value_indexed").equalsValue("odd"), Query.field("num_value_3_indexed").in(Arrays.asList(1, 3)))).build();
    RecordQueryPlan plan = planner.plan(query);
    if (planner instanceof RecordQueryPlanner) {
        // Two ordinary equals single-column index scans would be compatible on the following primary key, but
        // the IN loop inside one branch prevents that here. A regular filter would not.
        assertMatchesExactly(plan, unorderedPrimaryKeyDistinctPlan(unorderedUnionPlan(indexPlan().where(indexName("MySimpleRecord$str_value_indexed")).and(scanComparisons(range("[[odd],[odd]]"))), inValuesJoinPlan(indexPlan().where(indexName("MySimpleRecord$num_value_3_indexed")).and(scanComparisons(range("[EQUALS $__in_num_value_3_indexed__0]")))).where(inValuesList(equalsObject(Arrays.asList(1, 3)))))));
        assertEquals(-1310248168, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(1826025907, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(-1395411845, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    } else {
        assertMatchesExactly(plan, fetchFromPartialRecordPlan(unionPlan(coveringIndexPlan().where(indexPlanOf(indexPlan().where(indexName("MySimpleRecord$str_value_indexed")))), inUnionPlan(coveringIndexPlan().where(indexPlanOf(indexPlan().where(indexName("MySimpleRecord$num_value_3_indexed")).and(scanComparisons(equalities(exactly(anyParameterComparison()))))))).where(inUnionComparisonKey(primaryKey("MySimpleRecord"))).and(inUnionValuesSources(exactly(inUnionInValues(equalsObject(ImmutableList.of(1, 3)))))))));
        assertEquals(2086306995, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(527952105, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(626043938, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    }
    Set<Long> dupes = new HashSet<>();
    assertEquals(50 + 10 + 10, querySimpleRecordStore(NO_HOOK, plan, EvaluationContext::empty, record -> {
        assertTrue(dupes.add(record.getRecNo()), "should not have duplicated records");
        assertTrue(record.getStrValueIndexed().equals("odd") || record.getNumValue3Indexed() == 1 || record.getNumValue3Indexed() == 3);
    }, context -> TestHelpers.assertDiscardedAtMost(20, context)));
}

Example 12 with RecordQueryPlanner

use of com.apple.foundationdb.record.query.plan.RecordQueryPlanner 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)));
}

Example 13 with RecordQueryPlanner

use of com.apple.foundationdb.record.query.plan.RecordQueryPlanner in project fdb-record-layer by FoundationDB.

the class FDBNestedFieldQueryTest method nestedThenWithAndPartial.

/**
 * Verify that matching part of a nested field only uses part of the index.
 */
@DualPlannerTest
public void nestedThenWithAndPartial() throws Exception {
    final RecordMetaDataHook hook = metaData -> {
        metaData.addIndex("RestaurantReviewer", "hometownEmail", concat(field("stats").nest(concatenateFields("hometown", "school_name", "start_date")), field("email")));
    };
    nestedWithAndSetup(hook);
    RecordQuery query = RecordQuery.newBuilder().setRecordType("RestaurantReviewer").setFilter(Query.and(Query.field("stats").matches(Query.and(Query.field("hometown").equalsValue("Home Town"), Query.field("school_name").equalsValue("University of Learning"))), Query.field("email").equalsValue("pmp@example.com"))).build();
    RecordQueryPlan plan = planner.plan(query);
    assertThat(plan, filter(Query.field("email").equalsValue("pmp@example.com"), indexScan(allOf(indexName("hometownEmail"), bounds(hasTupleString("[[Home Town, University of Learning],[Home Town, University of Learning]]"))))));
    if (planner instanceof RecordQueryPlanner) {
        assertEquals(895882018, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(146214617, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(1382626015, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    } else {
        assertEquals(-1385621911, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(945827751, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(-2112728147, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    }
    assertEquals(Collections.singletonList(1L), fetchResultValues(plan, TestRecords4Proto.RestaurantReviewer.ID_FIELD_NUMBER, context -> openNestedRecordStore(context, hook), TestHelpers::assertDiscardedNone));
}

Example 14 with RecordQueryPlanner

use of com.apple.foundationdb.record.query.plan.RecordQueryPlanner in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method inQueryWithSortBySecondFieldOfCompoundIndex.

/**
 * Verify that an IN query with a sort can be implemented as an ordered union of compound indexes that can satisfy
 * the sort once the equality predicates from the IN have been pushed onto the indexes.
 * @see com.apple.foundationdb.record.query.plan.planning.InExtractor#asOr()
 */
@ParameterizedTest
@EnumSource(InAsOrUnionMode.class)
void inQueryWithSortBySecondFieldOfCompoundIndex(InAsOrUnionMode inAsOrMode) throws Exception {
    RecordMetaDataHook hook = metaData -> metaData.addIndex("MySimpleRecord", "compoundIndex", concat(field("num_value_3_indexed"), field("str_value_indexed")));
    complexQuerySetup(hook);
    final List<Integer> inList = asList(1, 4, 2);
    final QueryComponent filter = Query.field("num_value_3_indexed").in(inList);
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(filter).setSort(field("str_value_indexed")).build();
    // The configuration is planner-specific.
    assertTrue(planner instanceof RecordQueryPlanner);
    planner.setConfiguration(inAsOrMode.configure(planner.getConfiguration().asBuilder()).build());
    // Index(MySimpleRecord$str_value_indexed <,>) | num_value_3_indexed IN [1, 4, 2]
    // Index(compoundIndex [[1],[1]]) ∪[Field { 'str_value_indexed' None}, Field { 'rec_no' None}] Index(compoundIndex [[4],[4]]) ∪[Field { 'str_value_indexed' None}, Field { 'rec_no' None}] Index(compoundIndex [[2],[2]])
    // ∪(__in_num_value_3_indexed__0 IN [1, 4, 2]) Index(compoundIndex [EQUALS $__in_num_value_3_indexed__0])
    RecordQueryPlan plan = planner.plan(query);
    if (inAsOrMode == InAsOrUnionMode.AS_OR) {
        assertMatchesExactly(plan, unionPlan(inList.stream().map(number -> indexPlan().where(indexName("compoundIndex")).and(scanComparisons(range(String.format("[[%d],[%d]]", number, number))))).collect(ImmutableList.toImmutableList())).where(comparisonKey(concat(field("str_value_indexed"), primaryKey("MySimpleRecord")))));
        assertEquals(-1813975352, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(-1188407258, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(2089555085, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    } else if (inAsOrMode == InAsOrUnionMode.AS_UNION) {
        assertMatchesExactly(plan, inUnionPlan(indexPlan().where(indexName("compoundIndex")).and(scanComparisons(range("[EQUALS $__in_num_value_3_indexed__0]")))).where(inUnionComparisonKey(concat(field("str_value_indexed"), primaryKey("MySimpleRecord")))).and(inUnionValuesSources(exactly(inUnionInValues(equalsObject(inList)).and(inUnionBindingName("__in_num_value_3_indexed__0"))))));
        assertEquals(406364040, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(494706693, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(-628125702, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    } else {
        assertMatchesExactly(plan, filterPlan(indexPlan().where(indexName("MySimpleRecord$str_value_indexed")).and(scanComparisons(unbounded()))).where(queryComponents(exactly(equalsObject(filter)))));
        assertEquals(1775865786, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(972267, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(212572525, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    }
    assertEquals(60, querySimpleRecordStore(hook, plan, EvaluationContext::empty, record -> assertThat(record.getNumValue3Indexed(), anyOf(is(1), is(2), is(4))), context -> TestHelpers.assertDiscardedAtMost(40, context)));
}

Example 15 with RecordQueryPlanner

use of com.apple.foundationdb.record.query.plan.RecordQueryPlanner in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method testInQueryOrCompound.

/**
 * Verify that a complex query involving IN, AND, and OR is planned using a union of scans and joins on a
 * multi-field index, where the left subset has equality and the final field has an IN plus inequality on that same
 * field.
 */
@DualPlannerTest
void testInQueryOrCompound() throws Exception {
    RecordMetaDataHook hook = complexQuerySetupHook();
    complexQuerySetup(hook);
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.and(Query.field("str_value_indexed").equalsValue("odd"), Query.field("num_value_2").equalsValue(0), Query.or(Query.field("num_value_3_indexed").in(Arrays.asList(1, 3)), Query.field("num_value_3_indexed").greaterThanOrEquals(4)))).build();
    // Index(multi_index [EQUALS odd, EQUALS 0, EQUALS $__in_num_value_3_indexed__0]) WHERE __in_num_value_3_indexed__0 IN [1, 3] SORTED ∪[Field { 'num_value_3_indexed' None}, Field { 'rec_no' None}] Index(multi_index [[odd, 0, 4],[odd, 0]])
    RecordQueryPlan plan = planner.plan(query);
    if (planner instanceof RecordQueryPlanner) {
        assertMatchesExactly(plan, unionPlan(inValuesJoinPlan(indexPlan().where(indexName("multi_index")).and(scanComparisons(range("[EQUALS odd, EQUALS 0, EQUALS $__in_num_value_3_indexed__0]")))).where(inValuesList(equalsObject(Arrays.asList(1, 3)))), indexPlan().where(indexName("multi_index")).and(scanComparisons(range("[[odd, 0, 4],[odd, 0]]")))));
        assertEquals(468569345, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(1312398381, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(1327693258, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    } else {
        assertMatchesExactly(plan, fetchFromPartialRecordPlan(unionPlan(coveringIndexPlan().where(indexPlanOf(indexPlan().where(indexName("multi_index")))), inValuesJoinPlan(coveringIndexPlan().where(indexPlanOf(indexPlan().where(indexName("multi_index")).and(scanComparisons(equalities(exactly(equalsObject(new Comparisons.SimpleComparison(Comparisons.Type.EQUALS, "odd")), equalsObject(new Comparisons.SimpleComparison(Comparisons.Type.EQUALS, 0)), anyParameterComparison()))))))).where(inValuesList(equalsObject(Arrays.asList(1, 3))))).where(comparisonKey(concat(field("num_value_3_indexed"), primaryKey("MySimpleRecord"))))));
        assertEquals(687944558, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(-913554911, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(-137232979, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    }
    assertEquals(3 + 4 + 4, querySimpleRecordStore(hook, plan, EvaluationContext::empty, record -> {
        assertThat(record.getStrValueIndexed(), is("odd"));
        assertThat(record.getNumValue2(), is(0));
        assertThat(record.getNumValue3Indexed(), anyOf(is(1), is(3), greaterThanOrEqualTo(4)));
    }, TestHelpers::assertDiscardedNone));
}