import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Returns true if the AbstractPlanNode contains a range query
 * @param rootNode
 * @return
 */
public static boolean isRangeQuery(AbstractPlanNode rootNode) {
    for (ExpressionType expType : getScanExpressionTypes(rootNode)) {
        switch (expType) {
            case COMPARE_GREATERTHAN:
            case COMPARE_GREATERTHANOREQUALTO:
            case COMPARE_IN:
            case COMPARE_LESSTHAN:
            case COMPARE_LESSTHANOREQUALTO:
            case COMPARE_LIKE:
            case CONJUNCTION_OR:
                return (true);
        } // SWITCH
    } // FOR
    return (false);
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Handy method for creating a comparison expression between a tuple value
 * and a constant.
 *
 * @param <T>
 *            The type of the constant.
 * @param type
 *            The type of comparison.
 * @param left
 *            The name of the column of the left operand.
 * @param right
 *            The constant.
 * @return The expression representing the comparison operation.
 */
public static <T> Expression compareWithConstant(ExpressionType type,
                                                 String left,
                                                 T right) {
    switch (type) {
    case COMPARE_EQUAL:
        return new CompareEqual(value(left), constant(right));
    case COMPARE_NOTEQUAL:
        return new CompareNotEqual(value(left), constant(right));
    case COMPARE_GREATERTHAN:
        return new CompareGreaterThan(value(left), constant(right));
    case COMPARE_GREATERTHANOREQUALTO:
        return new CompareGreaterThanOrEqualTo(value(left), constant(right));
    case COMPARE_LESSTHAN:
        return new CompareLessThan(value(left), constant(right));
    case COMPARE_LESSTHANOREQUALTO:
        return new CompareLessThanOrEqualTo(value(left), constant(right));
    default:
        throw new IllegalArgumentException("Type must be a comparison type");
    }
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Handy method for creating a comparison expression between two tuple
 * values.
 *
 * @param type
 *            The type of comparison.
 * @param left
 *            The name of the column of the left operand.
 * @param right
 *            The name of the column of the right operand.
 * @return The expression representing the comparison operation.
 */
public static Expression compareTupleValues(ExpressionType type,
                                            String left,
                                            String right) {
    switch (type) {
    case COMPARE_EQUAL:
        return new CompareEqual(value(left), value(right));
    case COMPARE_NOTEQUAL:
        return new CompareNotEqual(value(left), value(right));
    case COMPARE_GREATERTHAN:
        return new CompareGreaterThan(value(left), value(right));
    case COMPARE_GREATERTHANOREQUALTO:
        return new CompareGreaterThanOrEqualTo(value(left), value(right));
    case COMPARE_LESSTHAN:
        return new CompareLessThan(value(left), value(right));
    case COMPARE_LESSTHANOREQUALTO:
        return new CompareLessThanOrEqualTo(value(left), value(right));
    default:
        throw new IllegalArgumentException("Type must be a comparison type");
    }
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
@Override
public void validate() throws Exception {
    super.validate();
    //
    // We need to have an aggregate type and column
    // We're not checking that it's a valid ExpressionType because this plannode is a temporary hack
    //
    if (m_aggregateTypes.size() != m_aggregateColumnNames.size() ||
        m_aggregateColumnNames.size() != m_aggregateOutputColumns.size())
    {
        throw new Exception("ERROR: Mismatched number of aggregate expression column attributes for PlanNode '" + this + "'");
    } else if (m_aggregateTypes.isEmpty()|| m_aggregateTypes.contains(ExpressionType.INVALID)) {
        throw new Exception("ERROR: Invalid Aggregate ExpressionType or No Aggregate Expression types for PlanNode '" + this + "'");
    } else if (m_aggregateColumnNames.isEmpty()) {
        throw new Exception("ERROR: No Aggregate Columns for PlanNode '" + this + "'");
    }
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Handy method for creating a conjunction expression. Multiple expressions
 * can be given and they will all be joined with the same type.
 *
 * @param type
 *            The type of conjunction.
 * @param exps
 *            The expressions to conjunct.
 * @return The expression representing the conjunction.
 */
public static Expression conjunction(ExpressionType type, Expression... exps) {
    Expression prev = null;

    for (Expression exp : exps) {
        if (prev != null) {
            if (type == ExpressionType.CONJUNCTION_AND)
                prev = new ConjunctionAnd(prev, exp);
            else if (type == ExpressionType.CONJUNCTION_OR)
                prev = new ConjunctionOr(prev, exp);
            else
                throw new IllegalArgumentException("Type must be a conjunction type");
        } else {
            prev = exp;
        }
    }

    return prev;
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
@Override
protected void loadFromJSONObject(JSONObject obj, Database db) throws JSONException {
    JSONArray aggregateColumns = obj.getJSONArray(Members.AGGREGATE_COLUMNS.name());
    for (int ii = 0; ii < aggregateColumns.length(); ii++) {
        JSONObject aggregateColumn = aggregateColumns.getJSONObject(ii);
        m_aggregateTypes.add(ExpressionType.valueOf(aggregateColumn.getString(Members.AGGREGATE_TYPE.name())));
        m_aggregateColumnNames.add(aggregateColumn.getString(Members.AGGREGATE_NAME.name()));
        m_aggregateColumnGuids.add(aggregateColumn.getInt(Members.AGGREGATE_GUID.name()));
        m_aggregateOutputColumns.add(aggregateColumn.getInt(Members.AGGREGATE_OUTPUT_COLUMN.name()));
    }
    
    try {
        JSONArray groupbyColumnGuids = obj.getJSONArray(Members.GROUPBY_COLUMNS.name());
        for (int ii = 0; ii < groupbyColumnGuids.length(); ii++) {
            JSONObject jsonObject = groupbyColumnGuids.getJSONObject(ii);
            PlanColumn column = PlanColumn.fromJSONObject(jsonObject, db);
            m_groupByColumnGuids.add(column.guid());
        }
    } catch (JSONException e) {
        //okay not to be there.
    }
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Return all the ExpressionTypes used for scan predicates in the given PlanNode
 * @param node
 * @return
 */
public static Collection<ExpressionType> getScanExpressionTypes(AbstractPlanNode root) {
    final Set<ExpressionType> found = new HashSet<ExpressionType>();
    new PlanNodeTreeWalker(true) {
        @Override
        protected void callback(AbstractPlanNode node) {
            Set<AbstractExpression> exps = new HashSet<AbstractExpression>();
            switch (node.getPlanNodeType()) {
                // SCANS
                case INDEXSCAN: {
                    IndexScanPlanNode idx_node = (IndexScanPlanNode) node;
                    exps.add(idx_node.getEndExpression());
                    exps.addAll(idx_node.getSearchKeyExpressions());
                }
                case SEQSCAN: {
                    AbstractScanPlanNode scan_node = (AbstractScanPlanNode) node;
                    exps.add(scan_node.getPredicate());
                    break;
                }
                // JOINS
                case NESTLOOP:
                case NESTLOOPINDEX: {
                    AbstractJoinPlanNode cast_node = (AbstractJoinPlanNode) node;
                    exps.add(cast_node.getPredicate());
                    break;
                }
                default:
                    // Do nothing...
            } // SWITCH

            for (AbstractExpression exp : exps) {
                if (exp == null)
                    continue;
                found.addAll(ExpressionUtil.getExpressionTypes(exp));
            } // FOR
            return;
        }
    }.traverse(root);
    return (found);
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
public static CatalogPair factory(CatalogType element0, CatalogType element1, ExpressionType comparison_exp, QueryType... query_types) {
    // Sort them!
    if (element0.compareTo(element1) > 0) {
        CatalogType temp = element0;
        element0 = element1;
        element1 = temp;
    }
    return (new CatalogPair(element0, element1, comparison_exp, query_types));
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Returns true if the given query is an equality predicate (with all the columns)
 * on a unique index. This essentially means that the query will only return
 * one row at runtime.
 * <B>WARNING:</B> This is wildly inaccurate and should not used by to make runtime decisions.
 * @param catalog_stmt
 * @return
 */
public static boolean isEqualityIndexScan(Statement catalog_stmt) {
    Collection<Table> tables = getReferencedTables(catalog_stmt);
    PredicatePairs cset = extractStatementPredicates(catalog_stmt, false, tables.toArray(new Table[0]));
    
    Collection<Index> indexes = getReferencedIndexes(catalog_stmt);
    
    for (CatalogPair cp : cset) {
        if (cp.getComparisonExp() != ExpressionType.COMPARE_EQUAL) {
            return (false);
        }
        
        CatalogType ctypes[] = { cp.getFirst(), cp.getSecond() };
        for (int i = 0; i < ctypes.length; i++) {
            if (ctypes[i] instanceof Column) {
                Column target_col = (Column)ctypes[i];
                Table target_tbl = target_col.getParent();

                // Find what index it's using
                // This is a rough approximation...
                Index target_idx = null;
                for (Index idx : indexes) {
                    if (idx.getParent().equals(target_tbl)) {
                        for (Column col : CatalogUtil.getColumns(idx.getColumns())) {
                            if (col.equals(target_col)) {
                                target_idx = idx;
                                break;
                            }
                        } // FOR
                    }
                } // FOR
                if (target_idx == null) {
                    return (false);
                }
            }
        } // FOR

    } // FOR
    return (true);
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Create a temporary column expression that can be used with
 * extractExpressionColumnSet
 * 
 * @param catalog_col
 * @param exp
 * @return
 */
private static AbstractExpression createTempExpression(Column catalog_col, AbstractExpression exp) {
    Table catalog_tbl = (Table) catalog_col.getParent();

    TupleValueExpression tuple_exp = new TupleValueExpression();
    tuple_exp.setTableName(catalog_tbl.getName());
    tuple_exp.setColumnIndex(catalog_col.getIndex());
    tuple_exp.setColumnAlias(catalog_col.getName());
    tuple_exp.setColumnName(catalog_col.getName());

    return (new ComparisonExpression(ExpressionType.COMPARE_EQUAL, tuple_exp, exp));
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * Get all of the ExpressionTypes used in the tree below the given root
 * 
 * @param root
 * @return
 */
public static Collection<ExpressionType> getExpressionTypes(AbstractExpression root) {
    final Set<ExpressionType> found = new HashSet<ExpressionType>();
    new ExpressionTreeWalker() {
        @Override
        protected void callback(AbstractExpression element) {
            found.add(element.getExpressionType());
        }
    }.traverse(root);
    return (found);
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * @param element0
 * @param element1
 * @param comparison_exp
 * @param catalog_stmts
 * @return
 */
public boolean add(CatalogType element0, CatalogType element1, ExpressionType comparison_exp, Statement... catalog_stmts) {
    Set<Statement> stmts = new HashSet<Statement>();
    for (Statement stmt : catalog_stmts) {
        stmts.add(stmt);
    }
    return (this.add(element0, element1, comparison_exp, stmts));
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 * 
 * @param key
 * @param param
 * @param expType
 * @param catalog_tbl
 */
public void put(Column key, CatalogType param, ExpressionType expType, Table catalog_tbl) {
    assert(param instanceof StmtParameter || param instanceof ConstantValue);
    List<Pair<ExpressionType, CatalogType>> params = this.predicates.get(key);
    if (params == null) {
        params = new ArrayList<Pair<ExpressionType, CatalogType>>();
        this.predicates.put(key, params);
    }
    params.add(Pair.of(expType, param));
    this.table_keys.add(CatalogKey.createKey(catalog_tbl));
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
protected void buildConstraints() {
    Expression constraint = null;

    // PlayRound table 0: 0 <= C4 < 100 (max round is 100)
    constraint = Verification.inRange("C4", 0L, 99L);
    addConstraint("PlayRound", 0, constraint);

    // PlayRound table 1: 0 <= R_POT < 900 (because the max round is 100, we
    // only add at most 9 each time)
    Expression r_pot = Verification.inRange("R_POT", 0, 899);
    Expression t_id = Verification.compareWithConstant(ExpressionType.COMPARE_GREATERTHANOREQUALTO,
                                                       "T_ID", 0);
    Expression b_id = Verification.compareWithConstant(ExpressionType.COMPARE_GREATERTHANOREQUALTO,
                                                       "B_ID", 0);
    Expression r_id = Verification.compareWithConstant(ExpressionType.COMPARE_GREATERTHANOREQUALTO,
                                                       "R_ID", 0);
    constraint = Verification.conjunction(ExpressionType.CONJUNCTION_AND,
                                          r_pot, t_id, b_id, r_id);
    addConstraint("PlayRound", 1, constraint);

    // For the tables
    addConstraint("T", 0, t_id);

    constraint = Verification.conjunction(ExpressionType.CONJUNCTION_AND,
                                          t_id, b_id);
    addConstraint("B", 0, constraint);

    constraint = Verification.conjunction(ExpressionType.CONJUNCTION_AND,
                                          r_pot, t_id, r_id);
    addConstraint("R", 0, constraint);
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 *
 * @param db
 * @param expr
 * @param tables
 */
void getTablesForExpression(Database db, AbstractExpression expr, HashSet<Table> tables) {
    if (expr.getLeft() != null)
        getTablesForExpression(db, expr.getLeft(), tables);
    if (expr.getRight() != null)
        getTablesForExpression(db, expr.getRight(), tables);
    if (expr.getExpressionType() == ExpressionType.VALUE_TUPLE) {
        TupleValueExpression tupleExpr = (TupleValueExpression)expr;
        String tableName = tupleExpr.getTableName();
        Table table = db.getTables().getIgnoreCase(tableName);
        tables.add(table);
    }
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
public void validate() throws Exception {
    //
    // Validate our children first
    //
    if (m_left != null) {
        m_left.validate();
    }
    if (m_right != null) {
        m_right.validate();
    }
    //
    // Expression Type
    //
    if (m_type == null) {
        throw new Exception("ERROR: The ExpressionType for '" + this + "' is NULL");
    } else if (m_type == ExpressionType.INVALID) {
        throw new Exception("ERROR: The ExpressionType for '" + this + "' is " + m_type);
    //
    // Output Type
    //
    } else if (m_valueType == null) {
        throw new Exception("ERROR: The output VoltType for '" + this + "' is NULL");
    } else if (m_valueType == VoltType.INVALID) {
        throw new Exception("ERROR: The output VoltType for '" + this + "' is " + m_valueType);
    }
    //
    // Since it is possible for an AbstractExpression to be stored with
    // any ExpressionType, we do a simple check to make sure that it is the right class
    //
    Class<?> check_class = m_type.getExpressionClass();
    if (!check_class.isInstance(this)) {
        throw new Exception("ERROR: Expression '" + this + "' is class type '" + getClass().getSimpleName() + "' but needs to be '" + check_class.getSimpleName() + "'");
    }
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
ParsedSelectStmt.ParsedColInfo
removeAggregation(ParsedSelectStmt.ParsedColInfo column)
{
    ParsedSelectStmt.ParsedColInfo retval =
        new ParsedSelectStmt.ParsedColInfo();
    retval.alias = column.alias;
    retval.columnName = column.columnName;
    retval.tableName = column.tableName;
    retval.finalOutput = column.finalOutput;
    retval.ascending = column.ascending;
    retval.index = column.index;
    retval.orderBy = column.orderBy;
    retval.ascending = column.ascending;
    retval.groupBy = column.groupBy;

    if ((column.expression.getExpressionType() ==
            ExpressionType.AGGREGATE_AVG) ||
        (column.expression.getExpressionType() ==
            ExpressionType.AGGREGATE_COUNT) ||
        (column.expression.getExpressionType() ==
            ExpressionType.AGGREGATE_COUNT_STAR) ||
        (column.expression.getExpressionType() ==
            ExpressionType.AGGREGATE_MAX) ||
        (column.expression.getExpressionType() ==
            ExpressionType.AGGREGATE_MIN) ||
        (column.expression.getExpressionType() ==
            ExpressionType.AGGREGATE_SUM))
    {
        retval.expression = column.expression.getLeft();
    }
    else
    {
        retval.expression = column.expression;
    }

    return retval;
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 *
 * @param left
 * @param right
 * @return Both expressions passed in combined by an And conjunction.
 */
public static AbstractExpression combine(AbstractExpression left, AbstractExpression right) {
    AbstractExpression ret = null;
    ret = new ConjunctionExpression(ExpressionType.CONJUNCTION_AND);
    ret.setLeft(left);
    ret.setRight(right);
    return ret;
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
protected Column
getColumnForFilterExpressionRecursive(Table table, AbstractExpression expr) {
    // stopping steps:
    //
    if (expr == null)
        return null;

    if (expr.getExpressionType() == ExpressionType.VALUE_TUPLE) {
        TupleValueExpression tve = (TupleValueExpression)expr;
        return getTableColumn(table, tve.getColumnName());
    }

    // recursive step
    //
    Column leftCol = getColumnForFilterExpressionRecursive(table, expr.getLeft());
    Column rightCol = getColumnForFilterExpressionRecursive(table, expr.getRight());

    assert(leftCol == null ||
           getTableColumn(table, leftCol.getTypeName()) != null);

    assert(rightCol == null ||
           getTableColumn(table, rightCol.getTypeName()) != null);

    // Left and right columns must not be from the same table,
    // e.g. where t.a = t.b is really a self join.
    if (leftCol != null && rightCol != null) {
        return null;
    }

    if (leftCol != null)
        return leftCol;

    if (rightCol != null)
        return rightCol;

    return null;
}
 

import org.voltdb.types.ExpressionType; //导入依赖的package包/类
/**
 *
 * @param exps
 */
public static AbstractExpression combine(List<AbstractExpression> exps) {
    Stack<AbstractExpression> stack = new Stack<AbstractExpression>();
    stack.addAll(exps);

    if (stack.isEmpty()) {
        return null;
    } else if (stack.size() == 1) {
        return stack.pop();
    }
    AbstractExpression ret = null;
    while (stack.size() > 1) {
        AbstractExpression child_exp = stack.pop();
        //
        // If our return node is null, then we need to make a new one
        //
        if (ret == null) {
            ret = new ConjunctionExpression(ExpressionType.CONJUNCTION_AND);
            ret.setLeft(child_exp);
        //
        // Check whether we can add it to the right side
        //
        } else if (ret.getRight() == null) {
            ret.setRight(child_exp);
            stack.push(ret);
            ret = null;
        }
    }
    if (ret == null) {
        ret = stack.pop();
    } else {
        ret.setRight(stack.pop());
    }
    return ret;
}