private GenSubqueryParamValuesRewriter(StatementContext context) { this.expressionCompiler = new ExpressionCompiler(context); }
public WhereConditionRewriter(ColumnResolver dataResolver, StatementContext context) throws SQLException { this.dataResolver = dataResolver; this.expressionCompiler = new ExpressionCompiler(context); this.extractedConditions = Lists.<ParseNode> newArrayList(); }
private static Expression compilePostFilterExpression(StatementContext context, List<ParseNode> postFilters) throws SQLException { if (postFilters.isEmpty()) return null; ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); List<Expression> expressions = new ArrayList<Expression>(postFilters.size()); for (ParseNode postFilter : postFilters) { expressionCompiler.reset(); Expression expression = postFilter.accept(expressionCompiler); expressions.add(expression); } if (expressions.size() == 1) return expressions.get(0); return AndExpression.create(expressions); }
ExpressionCompiler lhsCompiler = new ExpressionCompiler(lhsCtx); ExpressionCompiler rhsCompiler = new ExpressionCompiler(rhsCtx); for (EqualParseNode condition : onConditions) { lhsCompiler.reset();
new ExpressionCompiler(context, GroupBy.EMPTY_GROUP_BY); List<Expression> expressions = Lists.newArrayListWithExpectedSize(groupByNodes.size()); for (int i = 0; i < groupByNodes.size(); i++) {
private GenSubqueryParamValuesRewriter(StatementContext context) { this.expressionCompiler = new ExpressionCompiler(context); }
public static Expression compile(StatementContext context, SelectStatement statement, GroupBy groupBy) throws SQLException { ParseNode having = statement.getHaving(); if (having == null) { return null; } ExpressionCompiler expressionBuilder = new ExpressionCompiler(context, groupBy); Expression expression = having.accept(expressionBuilder); if (expression.getDataType() != PBoolean.INSTANCE) { throw TypeMismatchException.newException(PBoolean.INSTANCE, expression.getDataType(), expression.toString()); } if (LiteralExpression.isBooleanFalseOrNull(expression)) { context.setScanRanges(ScanRanges.NOTHING); return null; } else if (LiteralExpression.isTrue(expression)) { return null; } if (!expressionBuilder.isAggregate()) { throw new SQLExceptionInfo.Builder(SQLExceptionCode.ONLY_AGGREGATE_IN_HAVING_CLAUSE).build().buildException(); } return expression; }
public IndexExpressionParseNodeRewriter(PTable index, String alias, PhoenixConnection connection, Map<String, UDFParseNode> udfParseNodes) throws SQLException { indexedParseNodeToColumnParseNodeMap = Maps.newHashMapWithExpectedSize(index.getColumns().size()); NamedTableNode tableNode = NamedTableNode.create(alias, TableName.create(index.getParentSchemaName().getString(), index.getParentTableName().getString()), Collections.<ColumnDef> emptyList()); ColumnResolver dataResolver = FromCompiler.getResolver(tableNode, connection, udfParseNodes); StatementContext context = new StatementContext(new PhoenixStatement(connection), dataResolver); IndexStatementRewriter rewriter = new IndexStatementRewriter(dataResolver, null, true); ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); int indexPosOffset = (index.getBucketNum() == null ? 0 : 1) + (index.isMultiTenant() ? 1 : 0) + (index.getViewIndexId() == null ? 0 : 1); List<PColumn> pkColumns = index.getPKColumns(); for (int i=indexPosOffset; i<pkColumns.size(); ++i) { PColumn column = pkColumns.get(i); String expressionStr = IndexUtil.getIndexColumnExpressionStr(column); ParseNode expressionParseNode = SQLParser.parseCondition(expressionStr); String colName = "\"" + column.getName().getString() + "\""; Expression dataExpression = expressionParseNode.accept(expressionCompiler); PDataType expressionDataType = dataExpression.getDataType(); ParseNode indexedParseNode = expressionParseNode.accept(rewriter); PDataType indexColType = IndexUtil.getIndexColumnDataType(dataExpression.isNullable(), expressionDataType); ParseNode columnParseNode = new ColumnParseNode(alias!=null ? TableName.create(null, alias) : null, colName, null); if ( indexColType != expressionDataType) { columnParseNode = NODE_FACTORY.cast(columnParseNode, expressionDataType, null, null); } indexedParseNodeToColumnParseNodeMap.put(indexedParseNode, columnParseNode); } }
Scan scan = new Scan(); final StatementContext context = new StatementContext(statement, resolver, scan, new SequenceManager(statement)); ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); List<ParseNode> splitNodes = create.getSplitNodes(); if (create.getIndexType() == IndexType.LOCAL) {
public WhereConditionRewriter(ColumnResolver dataResolver, StatementContext context) throws SQLException { this.dataResolver = dataResolver; this.expressionCompiler = new ExpressionCompiler(context); this.extractedConditions = Lists.<ParseNode> newArrayList(); }
public WhereConditionRewriter(ColumnResolver dataResolver, StatementContext context) throws SQLException { this.dataResolver = dataResolver; this.expressionCompiler = new ExpressionCompiler(context); this.extractedConditions = Lists.<ParseNode> newArrayList(); }
StatementContext context = new StatementContext(new PhoenixStatement(conn)); ExpressionCompiler compiler = new ExpressionCompiler(context); ParseNode defaultParseNode = new SQLParser(column.getExpressionStr()).parseExpression(); Expression defaultExpression = defaultParseNode.accept(compiler);
compiler = new ExpressionCompiler(context, GroupBy.EMPTY_GROUP_BY) { @Override protected Expression addExpression(Expression expression) {return expression;} }; } else { compiler = new ExpressionCompiler(context, groupBy);
final byte[][] splits = new byte[splitNodes.size()][]; ImmutableBytesWritable ptr = context.getTempPtr(); ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); for (int i = 0; i < splits.length; i++) { ParseNode node = splitNodes.get(i);
ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); Expression expression = numToAllocateNode.accept(expressionCompiler); ImmutableBytesWritable ptr = context.getTempPtr();
private static Expression compilePostFilterExpression(StatementContext context, List<ParseNode> postFilters) throws SQLException { if (postFilters.isEmpty()) return null; ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); List<Expression> expressions = new ArrayList<Expression>(postFilters.size()); for (ParseNode postFilter : postFilters) { expressionCompiler.reset(); Expression expression = postFilter.accept(expressionCompiler); expressions.add(expression); } if (expressions.size() == 1) return expressions.get(0); return AndExpression.create(expressions); }
private static Expression compilePostFilterExpression(StatementContext context, List<ParseNode> postFilters) throws SQLException { if (postFilters.isEmpty()) return null; ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); List<Expression> expressions = new ArrayList<Expression>(postFilters.size()); for (ParseNode postFilter : postFilters) { expressionCompiler.reset(); Expression expression = postFilter.accept(expressionCompiler); expressions.add(expression); } if (expressions.size() == 1) return expressions.get(0); return AndExpression.create(expressions); }
new StatementContext(new PhoenixStatement(conn)); ExpressionCompiler compiler = new ExpressionCompiler(context); ParseNode defaultParseNode = new SQLParser(column.getExpressionStr()).parseExpression();
ExpressionCompiler expressionCompiler = new ExpressionCompiler(context); final long incrementBy = evalExpression(sequence, context, incrementByNode.accept(expressionCompiler),
return true; ExpressionCompiler compiler = new ExpressionCompiler(context); ParseNode defaultParseNode = new SQLParser(this.getExpression()).parseExpression();