Examples with AbstractPlanNode org.voltdb.plannodes.AbstractPlanNode used on opensource projects

Example 61 with AbstractPlanNode

use of org.voltdb.plannodes.AbstractPlanNode in project voltdb by VoltDB.

the class TestPlansGroupBy method testGroupByAliasNegativeCases.

public void testGroupByAliasNegativeCases() {
    List<AbstractPlanNode> pns;
    // Group by aggregate expression
    try {
        pns = compileInvalidToFragments("SELECT abs(PKEY) as sp, count(*) as ct FROM P1 GROUP BY count(*)");
        fail("Did not expect invalid GROUP BY query to succeed.");
    } catch (Exception ex) {
        assertTrue(ex.getMessage().contains("invalid GROUP BY expression:  COUNT()"));
    }
    try {
        pns = compileInvalidToFragments("SELECT abs(PKEY) as sp, count(*) as ct FROM P1 GROUP BY ct");
        fail("Did not expect invalid GROUP BY alias query to succeed.");
    } catch (Exception ex) {
        assertTrue(ex.getMessage().contains("invalid GROUP BY expression:  COUNT()"));
    }
    try {
        pns = compileInvalidToFragments("SELECT abs(PKEY) as sp, (count(*) +1 ) as ct FROM P1 GROUP BY ct");
        fail("Did not expect invalid GROUP BY expression alias query to succeed.");
    } catch (Exception ex) {
        assertTrue(ex.getMessage().contains("invalid GROUP BY expression:  COUNT()"));
    }
    // Group by alias and expression
    try {
        pns = compileInvalidToFragments("SELECT abs(PKEY) as sp, count(*) as ct FROM P1 GROUP BY sp + 1");
        fail("Did not expect invalid GROUP BY alias expression query to succeed.");
    } catch (Exception ex) {
        assertTrue(ex.getMessage().contains("user lacks privilege or object not found: SP"));
    }
    // Having
    try {
        pns = compileInvalidToFragments("SELECT ABS(A1), count(*) as ct FROM P1 GROUP BY ABS(A1) having ct > 3");
        fail("Did not expect invalid HAVING condition on alias query to succeed.");
    } catch (Exception ex) {
        assertTrue(ex.getMessage().contains("user lacks privilege or object not found: CT"));
    }
    // Group by column.alias
    try {
        pns = compileInvalidToFragments("SELECT abs(PKEY) as sp, count(*) as ct FROM P1 GROUP BY P1.sp");
        fail("Did not expect invalid GROUP BY qualified alias query to succeed.");
    } catch (Exception ex) {
        assertTrue(ex.getMessage().contains("user lacks privilege or object not found: P1.SP"));
    }
    //
    // ambiguous group by query because of A1 is a column name and a select alias
    //
    pns = compileToFragments("SELECT ABS(A1) AS A1, count(*) as ct FROM P1 GROUP BY A1");
    //* enable to debug */ printExplainPlan(pns);
    AbstractPlanNode p = pns.get(1).getChild(0);
    assertTrue(p instanceof AbstractScanPlanNode);
    AggregatePlanNode agg = AggregatePlanNode.getInlineAggregationNode(p);
    assertNotNull(agg);
    // group by column, instead of the ABS(A1) expression
    assertEquals(agg.getGroupByExpressions().get(0).getExpressionType(), ExpressionType.VALUE_TUPLE);
}

Example 62 with AbstractPlanNode

use of org.voltdb.plannodes.AbstractPlanNode in project voltdb by VoltDB.

the class TestPlansGroupBy method testInlineSerialAgg_noGroupBy_special.

// AVG is optimized with SUM / COUNT, generating extra projection node
// In future, inline projection for aggregation.
public void testInlineSerialAgg_noGroupBy_special() {
    AbstractPlanNode p;
    List<AbstractPlanNode> pns;
    pns = compileToFragments("SELECT AVG(A1) from T1");
    //* enable to debug */ printExplainPlan(pns);
    p = pns.get(0).getChild(0);
    assertTrue(p instanceof ProjectionPlanNode);
    assertTrue(p.getChild(0) instanceof AggregatePlanNode);
    assertTrue(p.getChild(0).getChild(0) instanceof ReceivePlanNode);
    p = pns.get(1).getChild(0);
    assertTrue(p instanceof SeqScanPlanNode);
    assertNotNull(p.getInlinePlanNode(PlanNodeType.PROJECTION));
    assertNotNull(p.getInlinePlanNode(PlanNodeType.AGGREGATE));
}

Example 63 with AbstractPlanNode

use of org.voltdb.plannodes.AbstractPlanNode in project voltdb by VoltDB.

the class TestPlansGroupBy method checkHavingClause.

private void checkHavingClause(String sql, boolean aggInline, Object aggPostFilters) {
    List<AbstractPlanNode> pns;
    pns = compileToFragments(sql);
    AbstractPlanNode p = pns.get(0);
    AggregatePlanNode aggNode;
    ArrayList<AbstractPlanNode> nodesList = p.findAllNodesOfType(PlanNodeType.AGGREGATE);
    assertEquals(1, nodesList.size());
    p = nodesList.get(0);
    boolean isInline = p.isInline();
    assertEquals(aggInline, isInline);
    assertTrue(p instanceof AggregatePlanNode);
    aggNode = (AggregatePlanNode) p;
    String aggNodeStr = aggNode.toExplainPlanString().toLowerCase();
    if (aggPostFilters != null) {
        String[] aggFilterStrings = null;
        if (aggPostFilters instanceof String) {
            aggFilterStrings = new String[] { (String) aggPostFilters };
        } else {
            aggFilterStrings = (String[]) aggPostFilters;
        }
        for (String aggFilter : aggFilterStrings) {
            assertTrue(aggNodeStr.contains(aggFilter.toLowerCase()));
        }
    } else {
        assertNull(aggNode.getPostPredicate());
    }
}

Example 64 with AbstractPlanNode

use of org.voltdb.plannodes.AbstractPlanNode in project voltdb by VoltDB.

the class TestPlansGroupBy method checkMVReaggregateFeature.

// topNode, reAggNode
private void checkMVReaggregateFeature(List<AbstractPlanNode> pns, boolean needFix, int numGroupByOfTopAggNode, int numAggsOfTopAggNode, int numGroupByOfReaggNode, int numAggsOfReaggNode, boolean aggPushdown, boolean aggInline) {
    assertEquals(2, pns.size());
    AbstractPlanNode p = pns.get(0);
    assertTrue(p instanceof SendPlanNode);
    p = p.getChild(0);
    if (p instanceof ProjectionPlanNode) {
        p = p.getChild(0);
    }
    if (p instanceof LimitPlanNode) {
        // No limit pushed down.
        p = p.getChild(0);
    }
    if (p instanceof OrderByPlanNode) {
        p = p.getChild(0);
    }
    HashAggregatePlanNode reAggNode = null;
    List<AbstractPlanNode> nodes = p.findAllNodesOfClass(AbstractReceivePlanNode.class);
    assertEquals(1, nodes.size());
    AbstractPlanNode receiveNode = nodes.get(0);
    // Indicates that there is no top aggregation node.
    if (numGroupByOfTopAggNode == -1) {
        if (needFix) {
            p = receiveNode.getParent(0);
            assertTrue(p instanceof HashAggregatePlanNode);
            reAggNode = (HashAggregatePlanNode) p;
            assertEquals(numGroupByOfReaggNode, reAggNode.getGroupByExpressionsSize());
            assertEquals(numAggsOfReaggNode, reAggNode.getAggregateTypesSize());
            p = p.getChild(0);
        }
        assertTrue(p instanceof ReceivePlanNode);
        p = pns.get(1);
        assertTrue(p instanceof SendPlanNode);
        p = p.getChild(0);
        assertTrue(p instanceof AbstractScanPlanNode);
        return;
    }
    if (p instanceof ProjectionPlanNode) {
        p = p.getChild(0);
    }
    //
    // Hash top aggregate node
    //
    AggregatePlanNode topAggNode = null;
    if (p instanceof AbstractJoinPlanNode) {
        // Inline aggregation with join
        topAggNode = AggregatePlanNode.getInlineAggregationNode(p);
    } else {
        assertTrue(p instanceof AggregatePlanNode);
        topAggNode = (AggregatePlanNode) p;
        p = p.getChild(0);
    }
    assertEquals(numGroupByOfTopAggNode, topAggNode.getGroupByExpressionsSize());
    assertEquals(numAggsOfTopAggNode, topAggNode.getAggregateTypesSize());
    if (needFix) {
        p = receiveNode.getParent(0);
        assertTrue(p instanceof HashAggregatePlanNode);
        reAggNode = (HashAggregatePlanNode) p;
        assertEquals(numGroupByOfReaggNode, reAggNode.getGroupByExpressionsSize());
        assertEquals(numAggsOfReaggNode, reAggNode.getAggregateTypesSize());
        p = p.getChild(0);
    }
    assertTrue(p instanceof ReceivePlanNode);
    // Test the second part
    p = pns.get(1);
    assertTrue(p instanceof SendPlanNode);
    p = p.getChild(0);
    if (aggPushdown) {
        assertTrue(!needFix);
        if (aggInline) {
            assertNotNull(AggregatePlanNode.getInlineAggregationNode(p));
        } else {
            assertTrue(p instanceof AggregatePlanNode);
            p = p.getChild(0);
        }
    }
    if (needFix) {
        assertTrue(p instanceof AbstractScanPlanNode);
    } else {
        assertTrue(p instanceof AbstractScanPlanNode || p instanceof AbstractJoinPlanNode);
    }
}

Example 65 with AbstractPlanNode

use of org.voltdb.plannodes.AbstractPlanNode in project voltdb by VoltDB.

the class TestPlansJoin method testIndexJoinConditions.

public void testIndexJoinConditions() {
    String query;
    AbstractPlanNode pn;
    IndexScanPlanNode indexScan;
    AbstractExpression predicate;
    //TODO: These are not even join queries. They should
    // probably be moved to some other test class.
    query = "SELECT * FROM R3 WHERE R3.A = 0";
    pn = compileToTopDownTree(query, 2, PlanNodeType.SEND, PlanNodeType.INDEXSCAN);
    indexScan = (IndexScanPlanNode) pn.getChild(0);
    assertEquals(IndexLookupType.EQ, indexScan.getLookupType());
    predicate = indexScan.getEndExpression();
    assertExprTopDownTree(predicate, ExpressionType.COMPARE_EQUAL, ExpressionType.VALUE_TUPLE, ExpressionType.VALUE_CONSTANT);
    assertNull(indexScan.getPredicate());
    query = "SELECT * FROM R3 WHERE R3.A > 0 AND R3.A < 5 AND R3.C = 4";
    pn = compileToTopDownTree(query, 2, PlanNodeType.SEND, PlanNodeType.INDEXSCAN);
    indexScan = (IndexScanPlanNode) pn.getChild(0);
    assertEquals(IndexLookupType.GT, indexScan.getLookupType());
    predicate = indexScan.getEndExpression();
    assertExprTopDownTree(predicate, ExpressionType.COMPARE_LESSTHAN, ExpressionType.VALUE_TUPLE, ExpressionType.VALUE_CONSTANT);
    predicate = indexScan.getPredicate();
    assertExprTopDownTree(predicate, ExpressionType.COMPARE_EQUAL, ExpressionType.VALUE_TUPLE, ExpressionType.VALUE_CONSTANT);
    for (JoinOp joinOp : JoinOp.JOIN_OPS) {
        if (joinOp != JoinOp.EQUAL) {
            // weaken test for now
            continue;
        }
        perJoinOpTestIndexJoinConditions(joinOp);
    }
}