@Override protected void enterParseNode(ParseNode node) { if (topNode == null) { topNode = node; } super.enterParseNode(node); }
@Override public ParseNode visitLeave(CaseParseNode node, List<ParseNode> nodes) throws SQLException { return leaveCompoundNode(node, nodes, new CompoundNodeFactory() { @Override public ParseNode createNode(List<ParseNode> children) { return NODE_FACTORY.caseWhen(children); } }); }
public static ParseNode rewrite(ParseNode where, ParseNodeRewriter rewriter) throws SQLException { if (where == null) { return null; } rewriter.reset(); return where.accept(rewriter); }
@Override public ParseNode visitLeave(ComparisonParseNode node, List<ParseNode> l) throws SQLException { if (!(l.get(1) instanceof SubqueryParseNode)) { super.visitLeave(node, l); } ParseNode lhs = l.get(0); List<ParseNode> rhs = generateDummyValues(lhs, false); List<ParseNode> children = new ArrayList<ParseNode>(); children.add(lhs); children.add(rhs.get(0)); return super.visitLeave(node, children); }
Map<String,ParseNode> aliasMap = rewriter.getAliasMap(); TableNode from = statement.getFrom(); TableNode normFrom = from == null ? null : from.accept(new TableNodeRewriter(rewriter)); ParseNode normWhere = where; if (where != null) { rewriter.reset(); normWhere = where.accept(rewriter); ParseNode normHaving= having; if (having != null) { rewriter.reset(); normHaving = having.accept(rewriter); AliasedNode aliasedNode = selectNodes.get(i); ParseNode selectNode = aliasedNode.getNode(); rewriter.reset(); ParseNode normSelectNode = selectNode.accept(rewriter); if (selectNode == normSelectNode) { for (int i = 0; i < groupByNodes.size(); i++) { ParseNode groupByNode = groupByNodes.get(i); rewriter.reset(); ParseNode normGroupByNode = groupByNode.accept(rewriter); if (groupByNode == normGroupByNode) { OrderByNode orderByNode = orderByNodes.get(i); ParseNode node = orderByNode.getNode(); rewriter.reset();
for (TableRef indexTableRef : replacement.values()) { indexSelect = ParseNodeRewriter.rewrite(indexSelect, new IndexExpressionParseNodeRewriter(indexTableRef.getTable(), indexTableRef.getTableAlias(), connection, indexSelect.getUdfParseNodes()));
@Override public ParseNode visitLeave(ArrayAnyComparisonNode node, List<ParseNode> l) throws SQLException { List<ParseNode> children = leaveArrayComparisonNode(node, l); if (children == l) return super.visitLeave(node, l); node = NODE_FACTORY.arrayAny(children.get(0), (ComparisonParseNode) children.get(1)); return node; }
Map<String,ParseNode> aliasMap = rewriter.getAliasMap(); TableNode from = statement.getFrom(); TableNode normFrom = from == null ? null : from.accept(new TableNodeRewriter(rewriter)); ParseNode normWhere = where; if (where != null) { rewriter.reset(); normWhere = where.accept(rewriter); ParseNode normHaving= having; if (having != null) { rewriter.reset(); normHaving = having.accept(rewriter); AliasedNode aliasedNode = selectNodes.get(i); ParseNode selectNode = aliasedNode.getNode(); rewriter.reset(); ParseNode normSelectNode = selectNode.accept(rewriter); if (selectNode == normSelectNode) { for (int i = 0; i < groupByNodes.size(); i++) { ParseNode groupByNode = groupByNodes.get(i); rewriter.reset(); ParseNode normGroupByNode = groupByNode.accept(rewriter); if (groupByNode == normGroupByNode) { OrderByNode orderByNode = orderByNodes.get(i); ParseNode node = orderByNode.getNode(); rewriter.reset();
@Override public ParseNode visit(ColumnParseNode node) throws SQLException { if (node.getTableName() == null) return super.visit(node); if (removeAlias) { if (node.getTableName().equals(tableAlias)) { return NODE_FACTORY.column(null, node.getName(), node.getAlias()); } return super.visit(node); } ParseNode aliasedNode = aliasMap.get(node.getFullName()); if (aliasedNode != null) { return aliasedNode; } return node; }
@Override public ParseNode visitLeave(NotParseNode node, List<ParseNode> nodes) throws SQLException { return leaveCompoundNode(node, nodes, new CompoundNodeFactory() { @Override public ParseNode createNode(List<ParseNode> children) { return NODE_FACTORY.not(children.get(0)); } }); }
@Override public ParseNode visitLeave(ComparisonParseNode node, List<ParseNode> nodes) throws SQLException { if (nodes.get(0).isStateless() && !nodes.get(1).isStateless() && !(nodes.get(1) instanceof ArrayElemRefNode)) { List<ParseNode> normNodes = Lists.newArrayListWithExpectedSize(2); normNodes.add(nodes.get(1)); normNodes.add(nodes.get(0)); nodes = normNodes; node = NODE_FACTORY.comparison(node.getInvertFilterOp(), nodes.get(0), nodes.get(1)); } return super.visitLeave(node, nodes); }
Map<String,ParseNode> aliasMap = rewriter.getAliasMap(); TableNode from = statement.getFrom(); TableNode normFrom = from == null ? null : from.accept(new TableNodeRewriter(rewriter)); ParseNode normWhere = where; if (where != null) { rewriter.reset(); normWhere = where.accept(rewriter); ParseNode normHaving= having; if (having != null) { rewriter.reset(); normHaving = having.accept(rewriter); AliasedNode aliasedNode = selectNodes.get(i); ParseNode selectNode = aliasedNode.getNode(); rewriter.reset(); ParseNode normSelectNode = selectNode.accept(rewriter); if (selectNode == normSelectNode) { for (int i = 0; i < groupByNodes.size(); i++) { ParseNode groupByNode = groupByNodes.get(i); rewriter.reset(); ParseNode normGroupByNode = groupByNode.accept(rewriter); if (groupByNode == normGroupByNode) { OrderByNode orderByNode = orderByNodes.get(i); ParseNode node = orderByNode.getNode(); rewriter.reset();
@Override public ParseNode visit(ColumnParseNode node) throws SQLException { if (multiTable && node.getAlias() != null && node.getTableName() != null && SchemaUtil.normalizeIdentifier(node.getAlias()).equals(node.getName())) { node = NODE_FACTORY.column(TableName.create(node.getSchemaName(), node.getTableName()), node.isCaseSensitive() ? '"' + node.getName() + '"' : node.getName(), node.isCaseSensitive() ? '"' + node.getFullName() + '"' : node.getFullName()); } return super.visit(node); }
try { indexSelect = ParseNodeRewriter.rewrite(indexSelect, new IndexExpressionParseNodeRewriter(index, null, statement.getConnection(), indexSelect.getUdfParseNodes())); QueryCompiler compiler = new QueryCompiler(statement, indexSelect, resolver, targetColumns, parallelIteratorFactory, dataPlan.getContext().getSequenceManager(), isProjected, true, dataPlans);
@Override public TableNode visit(JoinTableNode joinNode) throws SQLException { TableNode lhsNode = joinNode.getLHS(); TableNode rhsNode = joinNode.getRHS(); ParseNode onNode = joinNode.getOnNode(); TableNode normLhsNode = lhsNode.accept(this); TableNode normRhsNode = rhsNode.accept(this); parseNodeRewriter.reset(); ParseNode normOnNode = onNode == null ? null : onNode.accept(parseNodeRewriter); if (lhsNode == normLhsNode && rhsNode == normRhsNode && onNode == normOnNode) return joinNode; return NODE_FACTORY.join(joinNode.getType(), normLhsNode, normRhsNode, normOnNode, joinNode.isSingleValueOnly()); }
@Override protected void enterParseNode(ParseNode node) { if (topNode == null) { topNode = node; } super.enterParseNode(node); }
@Override public ParseNode visitLeave(ArrayAnyComparisonNode node, final List<ParseNode> nodes) throws SQLException { ParseNode normNode = leaveCompoundNode(node, nodes, new CompoundNodeFactory() { @Override public ParseNode createNode(List<ParseNode> children) { return NODE_FACTORY.arrayAny(nodes.get(0), (ComparisonParseNode) nodes.get(1)); } }); return normNode; }
@Override public ParseNode visitLeave(ArrayAllComparisonNode node, List<ParseNode> l) throws SQLException { List<ParseNode> children = leaveArrayComparisonNode(node, l); if (children == l) return super.visitLeave(node, l); node = NODE_FACTORY.arrayAll(children.get(0), (ComparisonParseNode) children.get(1)); return node; }