void TestMergeCombinations()

in src/kudu/common/column_predicate-test.cc [123:797]

• 331 lines of code
• 1 McCabe index (conditional complexity)

  void TestMergeCombinations(const ColumnSchema& column, vector<T> values) {
    // Range + Range

    // [--------) AND
    // [--------)
    // =
    // [--------)
    TestMerge(ColumnPredicate::Range(column, &values[0], &values[4]),
              ColumnPredicate::Range(column, &values[0], &values[4]),
              ColumnPredicate::Range(column, &values[0], &values[4]),
              PredicateType::Range);

    // [--------) AND
    // [----)
    // =
    // [----)
    TestMerge(ColumnPredicate::Range(column, &values[0], &values[4]),
              ColumnPredicate::Range(column, &values[0], &values[2]),
              ColumnPredicate::Range(column, &values[0], &values[2]),
              PredicateType::Range);

    // [--------) AND
    //   [----)
    // =
    //   [----)
    TestMerge(ColumnPredicate::Range(column, &values[0], &values[4]),
              ColumnPredicate::Range(column, &values[1], &values[3]),
              ColumnPredicate::Range(column, &values[1], &values[3]),
              PredicateType::Range);

    // [-----) AND
    //   [------)
    // =
    //   [---)
    TestMerge(ColumnPredicate::Range(column, &values[0], &values[3]),
              ColumnPredicate::Range(column, &values[1], &values[4]),
              ColumnPredicate::Range(column, &values[1], &values[3]),
              PredicateType::Range);

    // [--) AND
    //    [---)
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, &values[0], &values[2]),
              ColumnPredicate::Range(column, &values[2], &values[5]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // [--) AND
    //       [---)
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, &values[0], &values[2]),
              ColumnPredicate::Range(column, &values[4], &values[6]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // [---> AND
    // [--->
    // =
    // [--->
    TestMerge(ColumnPredicate::Range(column, &values[1], nullptr),
              ColumnPredicate::Range(column, &values[1], nullptr),
              ColumnPredicate::Range(column, &values[1], nullptr),
              PredicateType::Range);

    // [-----> AND
    //   [--->
    // =
    //   [--->
    TestMerge(ColumnPredicate::Range(column, &values[1], nullptr),
              ColumnPredicate::Range(column, &values[2], nullptr),
              ColumnPredicate::Range(column, &values[2], nullptr),
              PredicateType::Range);

    // <---) AND
    // <---)
    // =
    // <---)
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[4]),
              ColumnPredicate::Range(column, nullptr, &values[4]),
              ColumnPredicate::Range(column, nullptr, &values[4]),
              PredicateType::Range);

    //   <---) AND
    // <---)
    // =
    // <---)
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[6]),
              ColumnPredicate::Range(column, nullptr, &values[4]),
              ColumnPredicate::Range(column, nullptr, &values[4]),
              PredicateType::Range);

    // <---) AND
    // [--->
    // =
    // [---)
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[4]),
              ColumnPredicate::Range(column, &values[1], nullptr),
              ColumnPredicate::Range(column, &values[1], &values[4]),
              PredicateType::Range);

    // <---)     AND
    //     [--->
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[4]),
              ColumnPredicate::Range(column, &values[4], nullptr),
              ColumnPredicate::None(column),
              PredicateType::None);

    // <---)       AND
    //       [--->
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[2]),
              ColumnPredicate::Range(column, &values[4], nullptr),
              ColumnPredicate::None(column),
              PredicateType::None);

    // Range + Equality

    //   [---) AND
    // |
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, &values[3], &values[5]),
              ColumnPredicate::Equality(column, &values[1]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // [---) AND
    // |
    // =
    // |
    TestMerge(ColumnPredicate::Range(column, &values[1], &values[5]),
              ColumnPredicate::Equality(column, &values[1]),
              ColumnPredicate::Equality(column, &values[1]),
              PredicateType::Equality);

    // [---) AND
    //   |
    // =
    //   |
    TestMerge(ColumnPredicate::Range(column, &values[1], &values[5]),
              ColumnPredicate::Equality(column, &values[3]),
              ColumnPredicate::Equality(column, &values[3]),
              PredicateType::Equality);

    // [---) AND
    //     |
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, &values[1], &values[5]),
              ColumnPredicate::Equality(column, &values[5]),
              ColumnPredicate::None(column),
              PredicateType::None);


    // [---) AND
    //       |
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, &values[1], &values[4]),
              ColumnPredicate::Equality(column, &values[5]),
              ColumnPredicate::None(column),
              PredicateType::None);

    //   [---> AND
    // |
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, &values[3], nullptr),
              ColumnPredicate::Equality(column, &values[1]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // [---> AND
    // |
    // =
    // |
    TestMerge(ColumnPredicate::Range(column, &values[1], nullptr),
              ColumnPredicate::Equality(column, &values[1]),
              ColumnPredicate::Equality(column, &values[1]),
              PredicateType::Equality);

    // [-----> AND
    //   |
    // =
    //   |
    TestMerge(ColumnPredicate::Range(column, &values[0], nullptr),
              ColumnPredicate::Equality(column, &values[2]),
              ColumnPredicate::Equality(column, &values[2]),
              PredicateType::Equality);

    // <---) AND
    //   |
    // =
    //   |
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[3]),
              ColumnPredicate::Equality(column, &values[1]),
              ColumnPredicate::Equality(column, &values[1]),
              PredicateType::Equality);

    // <---) AND
    //     |
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[3]),
              ColumnPredicate::Equality(column, &values[3]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // <---)    AND
    //       |
    // =
    // None
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[1]),
              ColumnPredicate::Equality(column, &values[3]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // InList + InList

    vector<const void*> top_list;
    vector<const void*> bot_list;
    vector<const void*> res_list;

    //   | | |  AND
    //   | | |
    // = | | |
    top_list = { &values[1], &values[3], &values[5] };
    bot_list = { &values[1], &values[3], &values[5] };
    res_list = { &values[1], &values[3], &values[5] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    //   | | |  AND
    //   | |
    // = | |
    top_list = { &values[1], &values[3], &values[6] };
    bot_list = { &values[1], &values[3] };
    res_list = { &values[1], &values[3] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    //   | | |  AND
    //     | |
    // =   | |
    top_list = { &values[1], &values[3], &values[6] };
    bot_list = { &values[3], &values[6] };
    res_list = { &values[6], &values[3] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    //     | | |  AND
    //   | | |
    // =   | |
    top_list = { &values[2], &values[3], &values[4] };
    bot_list = { &values[1], &values[2], &values[3] };
    res_list = { &values[2], &values[3] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    //      | | |  AND
    //   | | |
    // = NONE
    top_list = { &values[3], &values[5], &values[6] };
    bot_list = { &values[0], &values[2], &values[4] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //       | | |  AND
    //   | | |
    // =     |
    top_list = { &values[1], &values[2], &values[3] };
    bot_list = { &values[3], &values[4], &values[5] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::Equality(column, &values[3]),
              PredicateType::Equality);

    //         | | |  AND
    //   | | |
    // = None
    top_list = { &values[4], &values[5], &values[6] };
    bot_list = { &values[1], &values[2], &values[3] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //     | | |  AND
    //    |||||
    // =   | |
    top_list = { &values[1], &values[3], &values[5] };
    bot_list = { &values[0], &values[1], &values[2], &values[3], &values[4] };
    res_list = { &values[1], &values[3] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    //    | | |  AND
    //     | |
    // =  none
    top_list = { &values[1], &values[3], &values[5] };
    bot_list = { &values[2], &values[4] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //    | | |  AND
    //     |||
    // =    |
    top_list = { &values[1], &values[3], &values[5] };
    bot_list = { &values[2], &values[3], &values[4] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::Equality(column, &values[3]),
              PredicateType::Equality);

    //   | |   AND
    //    | |
    // = none
    top_list = { &values[1], &values[3] };
    bot_list = { &values[2], &values[4] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //   | |   AND
    //       | |
    // = none
    top_list = { &values[0], &values[2] };
    bot_list = { &values[3], &values[5] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);


    // InList + Equality

    //   | | |  AND
    // |
    // = none
    top_list = { &values[2], &values[3], &values[4] };
    bot_list = { &values[1] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);


    //   | | | AND
    //   |
    // = |
    top_list = { &values[1], &values[3], &values[6] };
    bot_list = { &values[1] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::Equality(column, &values[1]),
              PredicateType::Equality);

    //  | | | AND
    //    |
    // =  |
    top_list = { &values[1], &values[3], &values[6] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::Equality(column, &values[3]),
              ColumnPredicate::Equality(column, &values[3]),
              PredicateType::Equality);

    //  | | | AND
    //     |
    // = none
    top_list = { &values[1], &values[3], &values[6] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::Equality(column, &values[4]),
              ColumnPredicate::None(column),
              PredicateType::None);

    //  | | |  AND
    //         |
    // =  none
    top_list = { &values[1], &values[3], &values[5] };
    TestMerge(ColumnPredicate::InList(column, &top_list),
              ColumnPredicate::Equality(column, &values[6]),
              ColumnPredicate::None(column),
              PredicateType::None);


    // InList + Range

    //     [---) AND
    //   | | | | |
    // =   | |
    bot_list = { &values[0], &values[1], &values[2], &values[3], &values[4] };
    res_list = { &values[1], &values[2] };
    TestMerge(ColumnPredicate::Range(column, &values[1], &values[3]),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    //    [------) AND
    //  |        | |
    // = None
    bot_list = { &values[1], &values[4], &values[5] };
    TestMerge(ColumnPredicate::Range(column, &values[2], &values[4]),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //  [------) AND
    //            | |
    // =
    // None
    bot_list = { &values[5], &values[6] };
    TestMerge(ColumnPredicate::Range(column, &values[1], &values[4]),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //       [------) AND
    //   | |
    // =
    // None
    bot_list = { &values[0], &values[1] };
    TestMerge(ColumnPredicate::Range(column, &values[3], &values[6]),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //   [------) AND
    //        | |
    // =
    // None
    bot_list = { &values[0], &values[1] };
    TestMerge(ColumnPredicate::Range(column, &values[3], &values[6]),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    //      [-----------> AND
    //    | |  |
    // =    |  |
    bot_list = { &values[2], &values[3], &values[4] };
    res_list = { &values[3], &values[4] };
    TestMerge(ColumnPredicate::Range(column, &values[3], nullptr),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    // <----) AND
    //   |  |  |
    // = |
    bot_list = { &values[2], &values[3], &values[4] };
    res_list = { &values[3], &values[4] };
    TestMerge(ColumnPredicate::Range(column, nullptr, &values[3]),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::Equality(column, &values[2]),
              PredicateType::Equality);

    // None

    // None AND
    // [----)
    // =
    // None
    TestMerge(ColumnPredicate::None(column),
              ColumnPredicate::Range(column, &values[1], &values[5]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // None AND
    // <----)
    // =
    // None
    TestMerge(ColumnPredicate::None(column),
              ColumnPredicate::Range(column, nullptr, &values[5]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // None AND
    // [---->
    // =
    // None
    TestMerge(ColumnPredicate::None(column),
              ColumnPredicate::Range(column, &values[1], nullptr),
              ColumnPredicate::None(column),
              PredicateType::None);

    // None AND
    //  |
    // =
    // None
    TestMerge(ColumnPredicate::None(column),
              ColumnPredicate::Equality(column, &values[1]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // None AND
    // None
    // =
    // None
    TestMerge(ColumnPredicate::None(column),
              ColumnPredicate::None(column),
              ColumnPredicate::None(column),
              PredicateType::None);

    // None AND
    // | | |
    // =
    // None
    bot_list = { &values[2], &values[3], &values[4] };
    TestMerge(ColumnPredicate::None(column),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NOT NULL

    // IS NOT NULL AND
    // IS NOT NULL
    // =
    // IS NOT NULL
    TestMerge(ColumnPredicate::IsNotNull(column),
              ColumnPredicate::IsNotNull(column),
              ColumnPredicate::IsNotNull(column),
              PredicateType::IsNotNull);

    // IS NOT NULL AND
    // None
    // =
    // None
    TestMerge(ColumnPredicate::IsNotNull(column),
              ColumnPredicate::None(column),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NOT NULL AND
    // |
    // =
    // |
    TestMerge(ColumnPredicate::IsNotNull(column),
              ColumnPredicate::Equality(column, &values[0]),
              ColumnPredicate::Equality(column, &values[0]),
              PredicateType::Equality);

    // IS NOT NULL AND
    // [------)
    // =
    // [------)
    TestMerge(ColumnPredicate::IsNotNull(column),
              ColumnPredicate::Range(column, &values[0], &values[2]),
              ColumnPredicate::Range(column, &values[0], &values[2]),
              PredicateType::Range);

    // IS NOT NULL AND
    // <------)
    // =
    // <------)
    TestMerge(ColumnPredicate::IsNotNull(column),
              ColumnPredicate::Range(column, nullptr, &values[2]),
              ColumnPredicate::Range(column, nullptr, &values[2]),
              PredicateType::Range);

    // IS NOT NULL AND
    // [------>
    // =
    // [------>
    TestMerge(ColumnPredicate::IsNotNull(column),
              ColumnPredicate::Range(column, &values[2], nullptr),
              ColumnPredicate::Range(column, &values[2], nullptr),
              PredicateType::Range);

    // IS NOT NULL AND
    // | | |
    // =
    // | | |
    bot_list = { &values[2], &values[3], &values[4] };
    res_list = { &values[2], &values[3], &values[4] };
    TestMerge(ColumnPredicate::IsNotNull(column),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::InList(column, &res_list),
              PredicateType::InList);

    // IS NULL

    // IS NULL AND
    // None
    // =
    // None
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::None(column),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NULL AND
    // |
    // =
    // None
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::Equality(column, &values[0]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NULL AND
    // [-------)
    // =
    // None
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::Range(column, &values[0], &values[2]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NULL AND
    // [------->
    // =
    // None
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::Range(column, &values[0], nullptr),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NULL AND
    // <-------)
    // =
    // None
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::Range(column, nullptr, &values[2]),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NULL AND
    // | | |
    // =
    // None
    bot_list = { &values[1], &values[3], &values[6] };
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::InList(column, &bot_list),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NULL AND
    // IS NOT NULL
    // =
    // None
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::IsNotNull(column),
              ColumnPredicate::None(column),
              PredicateType::None);

    // IS NULL AND
    // IS NULL
    // =
    // IS NULL
    TestMerge(ColumnPredicate::IsNull(column),
              ColumnPredicate::IsNull(column),
              ColumnPredicate::IsNull(column),
              PredicateType::IsNull);
  }