Examples with EvaluationContext com.apple.foundationdb.record.EvaluationContext used on opensource projects

Example 6 with EvaluationContext

use of com.apple.foundationdb.record.EvaluationContext in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method testOneOfThemIn.

/**
 * Verify that one-of-them queries work with IN.
 */
@Test
void testOneOfThemIn() throws Exception {
    RecordMetaDataHook recordMetaDataHook = metadata -> metadata.addIndex("MySimpleRecord", "ind", field("repeater", FanType.FanOut));
    setupSimpleRecordStore(recordMetaDataHook, (i, builder) -> builder.setRecNo(i).addAllRepeater(Arrays.asList(10 + i % 4, 20 + i % 4)));
    List<Integer> ls = Arrays.asList(13, 22);
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.field("repeater").oneOfThem().in(ls)).build();
    // Index(ind [EQUALS $__in_repeater__0]) | UnorderedPrimaryKeyDistinct() WHERE __in_repeater__0 IN [13, 22]
    RecordQueryPlan plan = planner.plan(query);
    assertMatchesExactly(plan, inValuesJoinPlan(unorderedPrimaryKeyDistinctPlan(indexPlan().where(indexName("ind")).and(scanComparisons(range("[EQUALS $__in_repeater__0]"))))).where(inValuesList(equalsObject(ls))));
    assertEquals(503365581, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
    assertEquals(77841121, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
    assertEquals(77839705, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    assertEquals(50, querySimpleRecordStore(recordMetaDataHook, plan, EvaluationContext::empty, record -> assertThat(record.getRecNo() % 4, anyOf(is(3L), is(2L))), TestHelpers::assertDiscardedNone));
}

Example 7 with EvaluationContext

use of com.apple.foundationdb.record.EvaluationContext in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method testRecordFunctionInUngrouped.

/**
 * Verify that IN works with ungrouped rank indexes.
 */
@Test
void testRecordFunctionInUngrouped() throws Exception {
    RecordMetaDataHook recordMetaDataHook = metadata -> metadata.addIndex("MySimpleRecord", new Index("rank", field("num_value_2").ungrouped(), IndexTypes.RANK));
    setupSimpleRecordStore(recordMetaDataHook, (i, builder) -> builder.setRecNo(i).setStrValueIndexed("str" + i % 4).setNumValue2(i + 100));
    List<Long> ls = Arrays.asList(1L, 3L, 5L);
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.rank("num_value_2").in(ls)).build();
    // Index(rank [EQUALS $__in_rank(Field { 'num_value_2' None} group 1)__0] BY_RANK) WHERE __in_rank(Field { 'num_value_2' None} group 1)__0 IN [1, 3, 5]
    RecordQueryPlan plan = planner.plan(query);
    assertMatchesExactly(plan, inValuesJoinPlan(indexPlan().where(indexName("rank")).and(RecordQueryPlanMatchers.indexScanType(IndexScanType.BY_RANK))).where(inValuesList(equalsObject(ls))));
    assertEquals(1518925028, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
    assertEquals(-1422629447, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
    assertEquals(-1422660327, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    List<Long> recNos = new ArrayList<>();
    querySimpleRecordStore(recordMetaDataHook, plan, EvaluationContext::empty, record -> recNos.add(record.getRecNo()), TestHelpers::assertDiscardedNone);
    assertEquals(Arrays.asList(1L, 3L, 5L), recNos);
}

Example 8 with EvaluationContext

use of com.apple.foundationdb.record.EvaluationContext in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method testInQueryOr.

/**
 * Verify that IN queries can be planned using index scans, then used in a UNION to implement OR with an inequality
 * on the same field, and that the resulting union will be ordered by that field.
 */
@DualPlannerTest
void testInQueryOr() throws Exception {
    complexQuerySetup(NO_HOOK);
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.or(Query.field("num_value_unique").in(Arrays.asList(903, 905, 901)), Query.field("num_value_unique").greaterThan(950))).build();
    RecordQueryPlan plan = planner.plan(query);
    if (planner instanceof RecordQueryPlanner) {
        // Index(MySimpleRecord$num_value_unique [EQUALS $__in_num_value_unique__0]) WHERE __in_num_value_unique__0 IN [901, 903, 905] SORTED ∪[Field { 'num_value_unique' None}, Field { 'rec_no' None}] Index(MySimpleRecord$num_value_unique ([950],>)
        assertMatchesExactly(plan, unionPlan(indexPlan().where(indexName("MySimpleRecord$num_value_unique")), inValuesJoinPlan(indexPlan().where(indexName("MySimpleRecord$num_value_unique")).and(scanComparisons(range("[EQUALS $__in_num_value_unique__0]")))).where(inValuesList(equalsObject(Arrays.asList(901, 903, 905))))).where(comparisonKey(concat(field("num_value_unique"), primaryKey("MySimpleRecord")))));
        assertEquals(1116661716, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(-924293640, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(713030732, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    } else {
        assertMatchesExactly(plan, fetchFromPartialRecordPlan(unionPlan(coveringIndexPlan().where(indexPlanOf(indexPlan().where(indexName("MySimpleRecord$num_value_unique")))), inValuesJoinPlan(coveringIndexPlan().where(indexPlanOf(indexPlan().where(indexName("MySimpleRecord$num_value_unique")).and(scanComparisons(equalities(exactly(anyParameterComparison()))))))).where(inValuesList(equalsObject(Arrays.asList(901, 903, 905))))).where(comparisonKey(concat(field("num_value_unique"), primaryKey("MySimpleRecord"))))));
        assertEquals(874214575, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(-1101003320, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(-1557397237, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    }
    assertEquals(53, querySimpleRecordStore(NO_HOOK, plan, EvaluationContext::empty, record -> assertThat(record.getNumValueUnique(), anyOf(is(901), is(903), is(905), greaterThan(950))), TestHelpers::assertDiscardedNone));
}

Example 9 with EvaluationContext

use of com.apple.foundationdb.record.EvaluationContext in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method testInQueryOrDifferentCondition.

/**
 * Verify that an IN requires an unordered union due to incompatible ordering.
 */
@DualPlannerTest
void testInQueryOrDifferentCondition() throws Exception {
    complexQuerySetup(NO_HOOK);
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(Query.or(Query.field("num_value_unique").lessThan(910), Query.and(Query.field("num_value_unique").greaterThan(990), Query.field("num_value_2").in(Arrays.asList(2, 0))))).build();
    RecordQueryPlan plan = planner.plan(query);
    if (planner instanceof RecordQueryPlanner) {
        // Without the join, these would be using the same index and so compatible, even though inequalities.
        // TODO: IN join in filter can prevent index scan merging (https://github.com/FoundationDB/fdb-record-layer/issues/9)
        assertMatchesExactly(plan, unorderedPrimaryKeyDistinctPlan(unorderedUnionPlan(indexPlan().where(indexName("MySimpleRecord$num_value_unique")).and(scanComparisons(range("([null],[910])"))), inValuesJoinPlan(filterPlan(indexPlan().where(indexName("MySimpleRecord$num_value_unique")).and(scanComparisons(range("([990],>"))))).where(inValuesList(equalsObject(Arrays.asList(0, 2)))))));
        assertEquals(-97067043, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(942676960, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(417180157, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    } else {
        // Cascades planner avoids IN-JOIN causing a primary scan and a UNION-ALL
        unionPlan(indexPlan().where(indexName("MySimpleRecord$num_value_unique")).and(scanComparisons(range("([null],[910])"))), predicatesFilterPlan(indexPlan().where(indexName("MySimpleRecord$num_value_unique")).and(scanComparisons(range("([990],>")))).where(predicates(valuePredicate(fieldValue("num_value_2"), new Comparisons.ListComparison(Comparisons.Type.IN, ImmutableList.of(0, 2)))))).where(comparisonKey(concat(field("num_value_unique"), primaryKey("MySimpleRecord"))));
        assertEquals(-1933328656, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(1747054907, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(-1932097284, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    }
    assertEquals(16, querySimpleRecordStore(NO_HOOK, plan, EvaluationContext::empty, record -> {
        assertThat(record.getNumValueUnique(), anyOf(lessThan(910), greaterThan(990)));
        if (record.getNumValue3Indexed() > 990) {
            assertThat(record.getNumValue2(), anyOf(is(2), is(0)));
        }
    }, context -> TestHelpers.assertDiscardedAtMost(13, context)));
}

Example 10 with EvaluationContext

use of com.apple.foundationdb.record.EvaluationContext in project fdb-record-layer by FoundationDB.

the class FDBInQueryTest method testInQueryIndexSortedDifferently.

/**
 * Verify that an IN against an unsorted list with an index is not implemented as an IN JOIN when the query sort is
 * not by the field with an IN filter.
 */
@DualPlannerTest
void testInQueryIndexSortedDifferently() throws Exception {
    complexQuerySetup(NO_HOOK);
    final QueryComponent filter = Query.field("num_value_3_indexed").in(asList(1, 4, 2));
    RecordQuery query = RecordQuery.newBuilder().setRecordType("MySimpleRecord").setFilter(filter).setSort(field("str_value_indexed")).build();
    // Index(MySimpleRecord$str_value_indexed <,>) | num_value_3_indexed IN [1, 4, 2]
    RecordQueryPlan plan = planner.plan(query);
    // IN join is cancelled on account of incompatible sorting.
    if (planner instanceof RecordQueryPlanner) {
        assertMatchesExactly(plan, filterPlan(selfOrDescendantPlans(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));
    } else {
        assertMatchesExactly(plan, predicatesFilterPlan(selfOrDescendantPlans(indexPlan().where(indexName("MySimpleRecord$str_value_indexed")).and(scanComparisons(unbounded())))).where(predicates(valuePredicate(fieldValue("num_value_3_indexed"), new Comparisons.ListComparison(Comparisons.Type.IN, ImmutableList.of(1, 4, 2))))));
        assertEquals(1470982333, plan.planHash(PlanHashable.PlanHashKind.LEGACY));
        assertEquals(800585401, plan.planHash(PlanHashable.PlanHashKind.FOR_CONTINUATION));
        assertEquals(1012185659, plan.planHash(PlanHashable.PlanHashKind.STRUCTURAL_WITHOUT_LITERALS));
    }
    assertEquals(60, querySimpleRecordStore(NO_HOOK, plan, EvaluationContext::empty, record -> assertThat(record.getNumValue3Indexed(), anyOf(is(1), is(2), is(4))), context -> TestHelpers.assertDiscardedAtMost(40, context)));
}