Examples with TupleValueExpression org.voltdb.expressions.TupleValueExpression used on opensource projects

Example 41 with TupleValueExpression

use of org.voltdb.expressions.TupleValueExpression in project voltdb by VoltDB.

the class StmtTargetTableScan method findPartitioningColumns.

private List<SchemaColumn> findPartitioningColumns() {
    if (m_partitioningColumns != null) {
        return m_partitioningColumns;
    }
    if (getIsReplicated()) {
        return null;
    }
    Column partitionCol = m_table.getPartitioncolumn();
    // because it has no recognized partitioning join key.
    if (partitionCol == null) {
        return null;
    }
    String tbName = m_table.getTypeName();
    TupleValueExpression tve = new TupleValueExpression(tbName, m_tableAlias, partitionCol, partitionCol.getIndex());
    String colName = partitionCol.getTypeName();
    SchemaColumn scol = new SchemaColumn(tbName, m_tableAlias, colName, colName, tve);
    m_partitioningColumns = new ArrayList<SchemaColumn>();
    m_partitioningColumns.add(scol);
    return m_partitioningColumns;
}

Example 42 with TupleValueExpression

use of org.voltdb.expressions.TupleValueExpression in project voltdb by VoltDB.

the class AbstractReceivePlanNode method resolveColumnIndexes.

protected void resolveColumnIndexes(NodeSchema outputSchema) {
    // Need to order and resolve indexes of output columns
    assert (m_children.size() == 1);
    AbstractPlanNode childNode = m_children.get(0);
    childNode.resolveColumnIndexes();
    NodeSchema inputSchema = childNode.getOutputSchema();
    assert (inputSchema.equals(outputSchema));
    for (SchemaColumn col : outputSchema.getColumns()) {
        AbstractExpression colExpr = col.getExpression();
        // At this point, they'd better all be TVEs.
        assert (colExpr instanceof TupleValueExpression);
        TupleValueExpression tve = (TupleValueExpression) colExpr;
        tve.setColumnIndexUsingSchema(inputSchema);
    }
// output schema for ReceivePlanNode should never be re-sorted
}

Example 43 with TupleValueExpression

use of org.voltdb.expressions.TupleValueExpression in project voltdb by VoltDB.

the class AbstractScanPlanNode method setScanColumns.

protected void setScanColumns(List<SchemaColumn> scanColumns) {
    assert (scanColumns != null);
    int i = 0;
    for (SchemaColumn col : scanColumns) {
        TupleValueExpression tve = (TupleValueExpression) col.getExpression();
        int difftor = tve.getDifferentiator();
        m_differentiatorMap.put(difftor, i);
        SchemaColumn clonedCol = col.clone();
        clonedCol.setDifferentiator(i);
        m_tableScanSchema.addColumn(clonedCol);
        ++i;
    }
}

Example 44 with TupleValueExpression

use of org.voltdb.expressions.TupleValueExpression in project voltdb by VoltDB.

the class StmtTableScan method resolveTVE.

public AbstractExpression resolveTVE(TupleValueExpression tve) {
    AbstractExpression resolvedExpr = processTVE(tve, tve.getColumnName());
    List<TupleValueExpression> tves = ExpressionUtil.getTupleValueExpressions(resolvedExpr);
    for (TupleValueExpression subqTve : tves) {
        resolveLeafTve(subqTve);
    }
    return resolvedExpr;
}

Example 45 with TupleValueExpression

use of org.voltdb.expressions.TupleValueExpression in project voltdb by VoltDB.

the class AbstractParsedStmt method parseTable.

/**
     *
     * @param tableNode
     */
private void parseTable(VoltXMLElement tableNode) {
    String tableName = tableNode.attributes.get("table");
    assert (tableName != null);
    String tableAlias = tableNode.attributes.get("tablealias");
    if (tableAlias == null) {
        tableAlias = tableName;
    }
    // Hsql rejects name conflicts in a single query
    m_tableAliasListAsJoinOrder.add(tableAlias);
    VoltXMLElement subqueryElement = null;
    // Possible sub-query
    for (VoltXMLElement childNode : tableNode.children) {
        if (!childNode.name.equals("tablesubquery")) {
            continue;
        }
        if (childNode.children.isEmpty()) {
            continue;
        }
        // sub-query FROM (SELECT ...)
        subqueryElement = childNode.children.get(0);
        break;
    }
    // add table to the query cache before processing the JOIN/WHERE expressions
    // The order is important because processing sub-query expressions assumes that
    // the sub-query is already registered
    StmtTableScan tableScan = null;
    Table table = null;
    // In case of a subquery we need to preserve its filter expressions
    AbstractExpression simplifiedSubqueryFilter = null;
    if (subqueryElement == null) {
        table = getTableFromDB(tableName);
        assert (table != null);
        tableScan = addTableToStmtCache(table, tableAlias);
        m_tableList.add(table);
    } else {
        AbstractParsedStmt subquery = parseFromSubQuery(subqueryElement);
        StmtSubqueryScan subqueryScan = addSubqueryToStmtCache(subquery, tableAlias);
        tableScan = subqueryScan;
        StmtTargetTableScan simpler = simplifierForSubquery(subquery);
        if (simpler != null) {
            tableScan = addSimplifiedSubqueryToStmtCache(subqueryScan, simpler);
            table = simpler.getTargetTable();
            // Extract subquery's filters
            assert (subquery.m_joinTree != null);
            // Adjust the table alias in all TVEs from the eliminated
            // subquery expressions. Example:
            // SELECT TA2.CA FROM (SELECT C CA FROM T TA1 WHERE C > 0) TA2
            // The table alias TA1 from the original TVE (T)TA1.C from the
            // subquery WHERE condition needs to be replaced with the alias
            // TA2. The new TVE will be (T)TA2.C.
            // The column alias does not require an adjustment.
            simplifiedSubqueryFilter = subquery.m_joinTree.getAllFilters();
            List<TupleValueExpression> tves = ExpressionUtil.getTupleValueExpressions(simplifiedSubqueryFilter);
            for (TupleValueExpression tve : tves) {
                tve.setTableAlias(tableScan.getTableAlias());
                tve.setOrigStmtId(m_stmtId);
            }
        }
    }
    AbstractExpression joinExpr = parseJoinCondition(tableNode);
    AbstractExpression whereExpr = parseWhereCondition(tableNode);
    if (simplifiedSubqueryFilter != null) {
        // Add subqueruy's expressions as JOIN filters to make sure they will
        // stay at the node level in case of an OUTER joins and won't affect
        // the join simplification process:
        // select * from T LEFT JOIN (select C FROM T1 WHERE C > 2) S ON T.C = S.C;
        joinExpr = (joinExpr != null) ? ExpressionUtil.combine(joinExpr, simplifiedSubqueryFilter) : simplifiedSubqueryFilter;
    }
    // The join type of the leaf node is always INNER
    // For a new tree its node's ids start with 0 and keep incrementing by 1
    int nodeId = (m_joinTree == null) ? 0 : m_joinTree.getId() + 1;
    JoinNode leafNode;
    if (table != null) {
        assert (tableScan instanceof StmtTargetTableScan);
        leafNode = new TableLeafNode(nodeId, joinExpr, whereExpr, (StmtTargetTableScan) tableScan);
    } else {
        assert (tableScan instanceof StmtSubqueryScan);
        leafNode = new SubqueryLeafNode(nodeId, joinExpr, whereExpr, (StmtSubqueryScan) tableScan);
        leafNode.updateContentDeterminismMessage(((StmtSubqueryScan) tableScan).calculateContentDeterminismMessage());
    }
    if (m_joinTree == null) {
        // this is the first table
        m_joinTree = leafNode;
    } else {
        // Build the tree by attaching the next table always to the right
        // The node's join type is determined by the type of its right node
        JoinType joinType = JoinType.get(tableNode.attributes.get("jointype"));
        assert (joinType != JoinType.INVALID);
        JoinNode joinNode = new BranchNode(nodeId + 1, joinType, m_joinTree, leafNode);
        m_joinTree = joinNode;
    }
}