Java ExpressionColumn類代碼示例

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
private static void addColumnData(ArrayList<String> columns,
        ArrayList<String> data, Expression expr) {
    if (expr instanceof ConditionAndOr) {
        ConditionAndOr and = (ConditionAndOr) expr;
        Expression left = and.getExpression(true);
        Expression right = and.getExpression(false);
        addColumnData(columns, data, left);
        addColumnData(columns, data, right);
    } else {
        Comparison comp = (Comparison) expr;
        ExpressionColumn ec = (ExpressionColumn) comp.getExpression(true);
        ValueExpression ev = (ValueExpression) comp.getExpression(false);
        String columnName = ec.getColumnName();
        columns.add(columnName);
        if (ev == null) {
            data.add(null);
        } else {
            data.add(ev.getValue(null).getString());
        }
    }
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
private Expression prepareUpdateCondition(Index foundIndex) {
    Expression condition = null;
    for (Column column : foundIndex.getColumns()) {
        ExpressionColumn expr = new ExpressionColumn(session.getDatabase(),
                table.getSchema().getName(), table.getName(), column.getName());
        for (int i = 0; i < columns.length; i++) {
            if (expr.getColumnName().equals(columns[i].getName())) {
                if (condition == null) {
                    condition = new Comparison(session, Comparison.EQUAL,
                            expr, list.get(getCurrentRowNumber() - 1)[i++]);
                } else {
                    condition = new ConditionAndOr(ConditionAndOr.AND, condition,
                            new Comparison(session, Comparison.EQUAL,
                            expr, list.get(0)[i++]));
                }
            }
        }
    }
    return condition;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
/**
 * Get the column for the given table filter, if the sort column is for this
 * filter.
 *
 * @param index the column index (0, 1,..)
 * @param filter the table filter
 * @return the column, or null
 */
public Column getColumn(int index, TableFilter filter) {
    if (orderList == null) {
        return null;
    }
    SelectOrderBy order = orderList.get(index);
    Expression expr = order.expression;
    if (expr == null) {
        return null;
    }
    expr = expr.getNonAliasExpression();
    if (expr.isConstant()) {
        return null;
    }
    if (!(expr instanceof ExpressionColumn)) {
        return null;
    }
    ExpressionColumn exprCol = (ExpressionColumn) expr;
    if (exprCol.getTableFilter() != filter) {
        return null;
    }
    return exprCol.getColumn();
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
/**
 * @param compareType the comparison type, see constants in
 *            {@link Comparison}
 */
private IndexCondition(int compareType, ExpressionColumn column,
        Expression expression) {
    this.compareType = compareType;
    this.column = column == null ? null : column.getColumn();
    this.expression = expression;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
private boolean isGroupSortedIndex(TableFilter tableFilter, Index index) {
    // check that all the GROUP BY expressions are part of the index
    Column[] indexColumns = index.getColumns();
    // also check that the first columns in the index are grouped
    boolean[] grouped = new boolean[indexColumns.length];
    outerLoop:
    for (int i = 0, size = expressions.size(); i < size; i++) {
        if (!groupByExpression[i]) {
            continue;
        }
        Expression expr = expressions.get(i).getNonAliasExpression();
        if (!(expr instanceof ExpressionColumn)) {
            return false;
        }
        ExpressionColumn exprCol = (ExpressionColumn) expr;
        for (int j = 0; j < indexColumns.length; ++j) {
            if (tableFilter == exprCol.getTableFilter()) {
                if (indexColumns[j].equals(exprCol.getColumn())) {
                    grouped[j] = true;
                    continue outerLoop;
                }
            }
        }
        // We didn't find a matching index column
        // for one group by expression
        return false;
    }
    // check that the first columns in the index are grouped
    // good: index(a, b, c); group by b, a
    // bad: index(a, b, c); group by a, c
    for (int i = 1; i < grouped.length; i++) {
        if (!grouped[i - 1] && grouped[i]) {
            return false;
        }
    }
    return true;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
private int expandColumnList(TableFilter filter, int index) {
    Table t = filter.getTable();
    String alias = filter.getTableAlias();
    Column[] columns = t.getColumns();
    for (Column c : columns) {
        if (filter.isNaturalJoinColumn(c)) {
            continue;
        }
        ExpressionColumn ec = new ExpressionColumn(
                session.getDatabase(), null, alias, c.getName());
        expressions.add(index++, ec);
    }
    return index;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
@Override
public void prepare() {
    if (isPrepared) {
        // sometimes a subquery is prepared twice (CREATE TABLE AS SELECT)
        return;
    }
    if (SysProperties.CHECK && !checkInit) {
        DbException.throwInternalError("not initialized");
    }
    isPrepared = true;
    left.prepare();
    right.prepare();
    int len = left.getColumnCount();
    // set the correct expressions now
    expressions = New.arrayList();
    ArrayList<Expression> le = left.getExpressions();
    ArrayList<Expression> re = right.getExpressions();
    for (int i = 0; i < len; i++) {
        Expression l = le.get(i);
        Expression r = re.get(i);
        int type = Value.getHigherOrder(l.getType(), r.getType());
        long prec = Math.max(l.getPrecision(), r.getPrecision());
        int scale = Math.max(l.getScale(), r.getScale());
        int displaySize = Math.max(l.getDisplaySize(), r.getDisplaySize());
        Column col = new Column(l.getAlias(), type, prec, scale, displaySize);
        Expression e = new ExpressionColumn(session.getDatabase(), col);
        expressions.add(e);
    }
    if (orderList != null) {
        initOrder(session, expressions, null, orderList, getColumnCount(), true, null);
        sort = prepareOrder(orderList, expressions.size());
        orderList = null;
    }
    expressionArray = new Expression[expressions.size()];
    expressions.toArray(expressionArray);
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
/**
 * @param f Table filter.
 * @param expCol Expression column.
 * @param validate Query validation flag.
 * @return {@code true} It it is an affinity column.
 */
private static boolean isAffinityColumn(TableFilter f, ExpressionColumn expCol, boolean validate) {
    Column col = expCol.getColumn();

    if (col == null)
        return false;

    Table t = col.getTable();

    if (t.isView()) {
        Query qry;

        if (f.getIndex() != null)
            qry = getSubQuery(f);
        else
            qry = GridSqlQueryParser.VIEW_QUERY.get((TableView)t);

        return isAffinityColumn(qry, expCol, validate);
    }

    if (t instanceof GridH2Table) {
        if (validate && ((GridH2Table)t).rowDescriptor().context().customAffinityMapper())
            throw customAffinityError(((GridH2Table)t).cacheName());

        IndexColumn affCol = ((GridH2Table)t).getAffinityKeyColumn();

        return affCol != null && col.getColumnId() == affCol.column.getColumnId();
    }

    return false;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
/**
 * Do the search.
 *
 * @param conn the database connection
 * @param text the query
 * @param limit the limit
 * @param offset the offset
 * @param data whether the raw data should be returned
 * @return the result set
 */
protected static ResultSet search(Connection conn, String text,
        int limit, int offset, boolean data) throws SQLException {
    SimpleResultSet result = createResultSet(data);
    if (conn.getMetaData().getURL().startsWith("jdbc:columnlist:")) {
        // this is just to query the result set columns
        return result;
    }
    if (text == null || text.trim().length() == 0) {
        return result;
    }
    try {
        IndexAccess access = getIndexAccess(conn);
        // take a reference as the searcher may change
        Searcher searcher = access.searcher;
        // reuse the same analyzer; it's thread-safe;
        // also allows subclasses to control the analyzer used.
        Analyzer analyzer = access.writer.getAnalyzer();
        QueryParser parser = new QueryParser(Version.LUCENE_30,
                LUCENE_FIELD_DATA, analyzer);
        Query query = parser.parse(text);
        // Lucene 3 insists on a hard limit and will not provide
        // a total hits value. Take at least 100 which is
        // an optimal limit for Lucene as any more
        // will trigger writing results to disk.
        int maxResults = (limit == 0 ? 100 : limit) + offset;
        TopDocs docs = searcher.search(query, maxResults);
        if (limit == 0) {
            limit = docs.totalHits;
        }
        for (int i = 0, len = docs.scoreDocs.length;
                i < limit && i + offset < docs.totalHits
                && i + offset < len; i++) {
            ScoreDoc sd = docs.scoreDocs[i + offset];
            Document doc = searcher.doc(sd.doc);
            float score = sd.score;
            String q = doc.get(LUCENE_FIELD_QUERY);
            if (data) {
                int idx = q.indexOf(" WHERE ");
                JdbcConnection c = (JdbcConnection) conn;
                Session session = (Session) c.getSession();
                Parser p = new Parser(session);
                String tab = q.substring(0, idx);
                ExpressionColumn expr = (ExpressionColumn) p.parseExpression(tab);
                String schemaName = expr.getOriginalTableAliasName();
                String tableName = expr.getColumnName();
                q = q.substring(idx + " WHERE ".length());
                Object[][] columnData = parseKey(conn, q);
                result.addRow(
                        schemaName,
                        tableName,
                        columnData[0],
                        columnData[1],
                        score);
            } else {
                result.addRow(q, score);
            }
        }
    } catch (Exception e) {
        throw convertException(e);
    }
    return result;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
@Override
public Expression optimize(ExpressionColumn expressionColumn, Column col) {
    return expressionColumn;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
@Override
public Expression optimize(ExpressionColumn expressionColumn, Column column) {
    return expressionColumn;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
@Override
public Expression optimize(ExpressionColumn expressionColumn, Column column) {
    return expressions[column.getColumnId()];
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
private LocalResult createResult() {
    Expression[] expressions = { new ExpressionColumn(
            session.getDatabase(), new Column("SCRIPT", Value.STRING)) };
    return new LocalResult(session, expressions, 1);
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
/**
 * @param f Filter.
 * @return Affinity join type.
 */
@SuppressWarnings("ForLoopReplaceableByForEach")
private Affinity joinedWithCollocated(int f) {
    TableFilter tf = childFilters[f];

    GridH2Table tbl = (GridH2Table)tf.getTable();

    if (validate) {
        if (tbl.rowDescriptor().context().customAffinityMapper())
            throw customAffinityError(tbl.cacheName());

        if (F.isEmpty(tf.getIndexConditions())) {
            throw new CacheException("Failed to prepare distributed join query: " +
                "join condition does not use index [joinedCache=" + tbl.cacheName() +
                ", plan=" + tf.getSelect().getPlanSQL() + ']');
        }
    }

    IndexColumn affCol = tbl.getAffinityKeyColumn();

    boolean affKeyCondFound = false;

    if (affCol != null) {
        ArrayList<IndexCondition> idxConditions = tf.getIndexConditions();

        int affColId = affCol.column.getColumnId();

        for (int i = 0; i < idxConditions.size(); i++) {
            IndexCondition c = idxConditions.get(i);
            int colId = c.getColumn().getColumnId();
            int cmpType = c.getCompareType();

            if ((cmpType == Comparison.EQUAL || cmpType == Comparison.EQUAL_NULL_SAFE) &&
                (colId == affColId || tbl.rowDescriptor().isKeyColumn(colId)) && c.isEvaluatable()) {
                affKeyCondFound = true;

                Expression exp = c.getExpression();
                exp = exp.getNonAliasExpression();

                if (exp instanceof ExpressionColumn) {
                    ExpressionColumn expCol = (ExpressionColumn)exp;

                    // This is one of our previous joins.
                    TableFilter prevJoin = expCol.getTableFilter();

                    if (prevJoin != null) {
                        GridH2CollocationModel cm = child(indexOf(prevJoin), true);

                        // If the previous joined model is a subquery (view), we can not be sure that
                        // the found affinity column is the needed one, since we can select multiple
                        // different affinity columns from different tables.
                        if (cm != null && !cm.view) {
                            Type t = cm.type(true);

                            if (t.isPartitioned() && t.isCollocated() && isAffinityColumn(prevJoin, expCol, validate))
                                return Affinity.COLLOCATED_JOIN;
                        }
                    }
                }
            }
        }
    }

    return affKeyCondFound ? Affinity.HAS_AFFINITY_CONDITION : Affinity.NONE;
}
 

import org.h2.expression.ExpressionColumn; //導入依賴的package包/類
/**
 * Create an index condition with the compare type IN_LIST and with the
 * given parameters.
 *
 * @param column the column
 * @param list the expression list
 * @return the index condition
 */
public static IndexCondition getInList(ExpressionColumn column,
        List<Expression> list) {
    IndexCondition cond = new IndexCondition(Comparison.IN_LIST, column,
            null);
    cond.expressionList = list;
    return cond;
}