Example #1
0
TEST_F(FilterTest, AndFilter) {
    // WHERE id <= 20 AND val1=0

    // shared_ptr<AbstractExpression> equal1
    //     = ComparisonExpression::getInstance(EXPRESSION_TYPE_COMPARE_LESSTHANOREQUALTO, TupleValueExpression::getInstance(0), ConstantValueExpression::getInstance(voltdb::Value::newBigIntValue(20)));
    //
    // shared_ptr<AbstractExpression> equal2
    //     = ComparisonExpression::getInstance(EXPRESSION_TYPE_COMPARE_EQUAL, TupleValueExpression::getInstance(1), ConstantValueExpression::getInstance(voltdb::Value::newBigIntValue(0)));
    //
    // ConjunctionExpression predicate(EXPRESSION_TYPE_CONJUNCTION_AND, equal1, equal2);

    TupleValueExpression *tup_val_a = new TupleValueExpression(0, std::string("tablename"), std::string("colname"));
    ConstantValueExpression *const_val_a = new ConstantValueExpression(ValueFactory::getBigIntValue(20));
    AbstractExpression *comp_a = comparisonFactory(EXPRESSION_TYPE_COMPARE_LESSTHANOREQUALTO, tup_val_a, const_val_a);

    TupleValueExpression *tup_val_b = new TupleValueExpression(1, std::string("tablename"), std::string("colname"));
    ConstantValueExpression *const_val_b = new ConstantValueExpression(ValueFactory::getBigIntValue(0));
    AbstractExpression *comp_b = comparisonFactory(EXPRESSION_TYPE_COMPARE_EQUAL, tup_val_b, const_val_b);

    ConjunctionExpression<ConjunctionAnd> *predicate = new ConjunctionExpression<ConjunctionAnd>
                                                               (EXPRESSION_TYPE_CONJUNCTION_AND,
                                                                comp_a,
                                                                comp_b);

    // ::printf("\nFilter:%s\n", predicate->debug().c_str());

    int count = 0;
    TableIterator iter = table->iterator();
    TableTuple match(table->schema());
    while (iter.next(match)) {
        if (predicate->eval(&match, NULL).isTrue()) {
            //::printf("  match:%s\n", match->debug(table).c_str());
            ++count;
        }
    }
    ASSERT_EQ(10, count);

    // delete root to cleanup the full tree
    delete predicate;
}
Example #2
0
TEST_F(FilterTest, OrFilter) {
    // WHERE id = 20 OR id=30

    // shared_ptr<AbstractExpression> equal1
    //     = ComparisonExpression::getInstance(EXPRESSION_TYPE_COMPARE_EQUAL, TupleValueExpression::getInstance(0), ConstantValueExpression::getInstance(voltdb::Value::newBigIntValue(20)));
    // shared_ptr<AbstractExpression> equal2
    //     = ComparisonExpression::getInstance(EXPRESSION_TYPE_COMPARE_EQUAL, TupleValueExpression::getInstance(0), ConstantValueExpression::getInstance(voltdb::Value::newBigIntValue(30)));

    // ConjunctionExpression predicate(EXPRESSION_TYPE_CONJUNCTION_OR, equal1, equal2);

    TupleValueExpression *tup_val_a = new TupleValueExpression(0, 0);
    ConstantValueExpression *const_val_a = new ConstantValueExpression(ValueFactory::getBigIntValue(20));
    ComparisonExpression<CmpEq> *comp_a = new ComparisonExpression<CmpEq>(EXPRESSION_TYPE_COMPARE_EQUAL, tup_val_a, const_val_a);

    TupleValueExpression *tup_val_b = new TupleValueExpression(0, 0);
    ConstantValueExpression *const_val_b = new ConstantValueExpression(ValueFactory::getBigIntValue(30));
    ComparisonExpression<CmpEq> *comp_b = new ComparisonExpression<CmpEq>(EXPRESSION_TYPE_COMPARE_EQUAL, tup_val_b, const_val_b);

    ConjunctionExpression<ConjunctionOr> *predicate = new ConjunctionExpression<ConjunctionOr>(EXPRESSION_TYPE_CONJUNCTION_OR, comp_a, comp_b);

    // ::printf("\nFilter:%s\n", predicate->debug().c_str());

    int count = 0;
    TableIterator iter = table->iterator();
    TableTuple match(table->schema());
    while (iter.next(match)) {
        if (predicate->eval(&match, NULL).isTrue()) {
            //::printf("  match:%s\n", match->debug(table).c_str());
            ++count;
        }
    }
    ASSERT_EQ(2, count);

    // delete the root to cleanup the full tree
    delete predicate;
}