String rhsTableAlias = ParseNodeFactory.createTempAlias(); JoinConditionExtractor conditionExtractor = new JoinConditionExtractor(subquery, resolver, connection, rhsTableAlias); ParseNode where = subquery.getWhere() == null ? null : subquery.getWhere().accept(conditionExtractor); if (where == subquery.getWhere()) { // non-correlated EXISTS subquery, add LIMIT 1 subquery = NODE_FACTORY.select(subquery, NODE_FACTORY.limit(NODE_FACTORY.literal(1))); subqueryNode = NODE_FACTORY.subquery(subquery, false); node = NODE_FACTORY.exists(subqueryNode, node.isNegate()); return super.visitLeave(node, Collections.<ParseNode> singletonList(subqueryNode)); selectNodes.add(NODE_FACTORY.aliasedNode(ParseNodeFactory.createTempAlias(), LiteralParseNode.ONE)); selectNodes.addAll(additionalSelectNodes); subquery = NODE_FACTORY.select(subquery, true, selectNodes, where); ParseNode onNode = conditionExtractor.getJoinCondition(); TableNode rhsTable = NODE_FACTORY.derivedTable(rhsTableAlias, subquery); JoinType joinType = isTopNode ? (node.isNegate() ? JoinType.Anti : JoinType.Semi) : JoinType.Left; ParseNode ret = isTopNode ? null : NODE_FACTORY.isNull(NODE_FACTORY.column(NODE_FACTORY.table(null, rhsTableAlias), selectNodes.get(0).getAlias(), null), !node.isNegate()); tableNode = NODE_FACTORY.join(joinType, tableNode, rhsTable, onNode, false);
@Override public ParseNode createNode(List<ParseNode> children) { return NODE_FACTORY.add(children); } });
/** * Reflect this class and populate static structures from it. * Don't initialize in static block because we have a circular dependency */ private synchronized static void initBuiltInFunctionMap() { if (!BUILT_IN_FUNCTION_MAP.isEmpty()) { return; } Class<? extends FunctionExpression> f = null; try { // Reflection based parsing which yields direct explicit function evaluation at runtime for (int i = 0; i < CLIENT_SIDE_BUILT_IN_FUNCTIONS.size(); i++) { f = CLIENT_SIDE_BUILT_IN_FUNCTIONS.get(i); addBuiltInFunction(f); } for (ExpressionType et : ExpressionType.values()) { Class<? extends Expression> ec = et.getExpressionClass(); if (FunctionExpression.class.isAssignableFrom(ec)) { @SuppressWarnings("unchecked") Class<? extends FunctionExpression> c = (Class<? extends FunctionExpression>)ec; addBuiltInFunction(f = c); } } } catch (Exception e) { throw new RuntimeException("Failed initialization of built-in functions at class '" + f + "'", e); } }
private List<AliasedNode> fixAliasedNodes(List<AliasedNode> nodes, boolean addSelectOne) { List<AliasedNode> normNodes = Lists.<AliasedNode> newArrayListWithExpectedSize(nodes.size() + (addSelectOne ? 1 : 0)); if (addSelectOne) { normNodes.add(NODE_FACTORY.aliasedNode(ParseNodeFactory.createTempAlias(), LiteralParseNode.ONE)); } for (int i = 0; i < nodes.size(); i++) { AliasedNode aliasedNode = nodes.get(i); normNodes.add(NODE_FACTORY.aliasedNode( ParseNodeFactory.createTempAlias(), aliasedNode.getNode())); } return normNodes; }
/** * Returns all the basic select nodes, no aggregation. */ public List<AliasedNode> getSelectNodes() { if (isWildCardSelect()) { return Collections.singletonList(NODE_FACTORY.aliasedNode(null, NODE_FACTORY.wildcard())); } List<AliasedNode> ret = new ArrayList<AliasedNode>(); for (Map.Entry<ColumnRef, ColumnParseNode> entry : columnNodes.entrySet()) { if (tableRef.equals(entry.getKey().getTableRef())) { ret.add(NODE_FACTORY.aliasedNode(null, entry.getValue())); } } if (ret.isEmpty()) { ret.add(NODE_FACTORY.aliasedNode(null, NODE_FACTORY.literal(1))); } return ret; }
String rhsTableAlias = ParseNodeFactory.createTempAlias(); JoinConditionExtractor conditionExtractor = new JoinConditionExtractor(subquery, resolver, connection, rhsTableAlias); ParseNode where = subquery.getWhere() == null ? null : subquery.getWhere().accept(conditionExtractor); if (where == subquery.getWhere()) { // non-correlated comparison subquery, add LIMIT 2, expectSingleRow = true subquery = NODE_FACTORY.select(subquery, NODE_FACTORY.limit(NODE_FACTORY.literal(2))); subqueryNode = NODE_FACTORY.subquery(subquery, true); l = Lists.newArrayList(l.get(0), subqueryNode); node = NODE_FACTORY.comparison(node.getFilterOp(), l.get(0), l.get(1)); return super.visitLeave(node, l); nodes.add(aliasedNode.getNode()); rhsNode = NODE_FACTORY.rowValueConstructor(nodes); selectNodes.add(NODE_FACTORY.aliasedNode(ParseNodeFactory.createTempAlias(), rhsNode)); selectNodes.addAll(additionalSelectNodes); subquery = NODE_FACTORY.select(subquery, subquery.isDistinct(), selectNodes, where); } else { List<ParseNode> groupbyNodes = Lists.newArrayListWithExpectedSize(additionalSelectNodes.size() + subquery.getGroupBy().size()); subquery = NODE_FACTORY.select(subquery, subquery.isDistinct(), selectNodes, where, groupbyNodes, true); TableNode rhsTable = NODE_FACTORY.derivedTable(rhsTableAlias, subquery); JoinType joinType = isTopNode ? JoinType.Inner : JoinType.Left; ParseNode ret = NODE_FACTORY.comparison(node.getFilterOp(), l.get(0), NODE_FACTORY.column(NODE_FACTORY.table(null, rhsTableAlias), selectNodes.get(0).getAlias(), null)); tableNode = NODE_FACTORY.join(joinType, tableNode, rhsTable, onNode, !isAggregate || isGroupby);
String rhsTableAlias = ParseNodeFactory.createTempAlias(); JoinConditionExtractor conditionExtractor = new JoinConditionExtractor(subquery, resolver, connection, rhsTableAlias); ParseNode where = subquery.getWhere() == null ? null : subquery.getWhere().accept(conditionExtractor); String derivedTableAlias = null; if (!subquery.getGroupBy().isEmpty()) { derivedTableAlias = ParseNodeFactory.createTempAlias(); aliasedNodes = fixAliasedNodes(aliasedNodes, false); rhsNode = derivedTableAlias == null ? aliasedNodes.get(0).getNode() : NODE_FACTORY.column(NODE_FACTORY.table(null, derivedTableAlias), aliasedNodes.get(0).getAlias(), null); } else { List<ParseNode> nodes = Lists.<ParseNode> newArrayListWithExpectedSize(aliasedNodes.size()); for (AliasedNode aliasedNode : aliasedNodes) { nodes.add(derivedTableAlias == null ? aliasedNode.getNode() : NODE_FACTORY.column(NODE_FACTORY.table(null, derivedTableAlias), aliasedNode.getAlias(), null)); rhsNode = NODE_FACTORY.rowValueConstructor(nodes); rhsNode = NODE_FACTORY.function(DistinctValueAggregateFunction.NAME, Collections.singletonList(rhsNode)); selectNodes.add(NODE_FACTORY.aliasedNode(ParseNodeFactory.createTempAlias(), rhsNode)); selectNodes.addAll(additionalSelectNodes); List<ParseNode> groupbyNodes = Lists.newArrayListWithExpectedSize(additionalSelectNodes.size()); subquery = NODE_FACTORY.select(subquery, false, selectNodes, where, groupbyNodes, true); } else { List<ParseNode> derivedTableGroupBy = Lists.newArrayListWithExpectedSize(subquery.getGroupBy().size() + groupbyNodes.size()); for (int i = 1; i < selectNodes.size(); i++) { AliasedNode aliasedNode = selectNodes.get(i);
@Override public ParseNode visitLeave(InParseNode node, List<ParseNode> l) throws SQLException { boolean isTopNode = topNode == node; if (isTopNode) { topNode = null; } SubqueryParseNode subqueryNode = (SubqueryParseNode) l.get(1); SelectStatement subquery = fixSubqueryStatement(subqueryNode.getSelectNode()); String rhsTableAlias = ParseNodeFactory.createTempAlias(); List<AliasedNode> selectNodes = fixAliasedNodes(subquery.getSelect(), true); subquery = NODE_FACTORY.select(subquery, !node.isSubqueryDistinct(), selectNodes); ParseNode onNode = getJoinConditionNode(l.get(0), selectNodes, rhsTableAlias); TableNode rhsTable = NODE_FACTORY.derivedTable(rhsTableAlias, subquery); JoinType joinType = isTopNode ? (node.isNegate() ? JoinType.Anti : JoinType.Semi) : JoinType.Left; ParseNode ret = isTopNode ? null : NODE_FACTORY.isNull(NODE_FACTORY.column(NODE_FACTORY.table(null, rhsTableAlias), selectNodes.get(0).getAlias(), null), !node.isNegate()); tableNode = NODE_FACTORY.join(joinType, tableNode, rhsTable, onNode, false); return ret; }
TableNode table = FACTORY.namedTable(alias, FACTORY.table(schemaName, tableName),select.getTableSamplingRate()); SelectStatement indexSelect = FACTORY.select(select, table); ColumnResolver resolver = FromCompiler.getResolverForQuery(indexSelect, statement.getConnection()); PDataType dataColType = column.getDataType(); if (indexColType != dataColType) { indexColNode = FACTORY.cast(indexColNode, dataColType, null, null); aliasedNodes.add(FACTORY.aliasedNode(null, indexColNode)); nodes.add(new ColumnParseNode(null, '"' + column.getName().getString() + '"')); SelectStatement innerSelect = FACTORY.select(indexSelect.getFrom(), indexSelect.getHint(), false, aliasedNodes, where, null, null, null, null, null, indexSelect.getBindCount(), false, indexSelect.hasSequence(), Collections.<SelectStatement>emptyList(), indexSelect.getUdfParseNodes()); ParseNode outerWhere = FACTORY.in(nodes.size() == 1 ? nodes.get(0) : FACTORY.rowValueConstructor(nodes), FACTORY.subquery(innerSelect, false), false, true); ParseNode extractedCondition = whereRewriter.getExtractedCondition(); if (extractedCondition != null) { outerWhere = FACTORY.and(Lists.newArrayList(outerWhere, extractedCondition)); HintNode hint = HintNode.combine(HintNode.subtract(indexSelect.getHint(), new Hint[] {Hint.INDEX, Hint.NO_CHILD_PARENT_JOIN_OPTIMIZATION}), FACTORY.hint("NO_INDEX")); SelectStatement query = FACTORY.select(dataSelect, hint, outerWhere); ColumnResolver queryResolver = FromCompiler.getResolverForQuery(query, statement.getConnection()); query = SubqueryRewriter.transform(query, queryResolver, statement.getConnection());
public SelectStatement select(List<SelectStatement> statements, List<OrderByNode> orderBy, LimitNode limit, OffsetNode offset, int bindCount, boolean isAggregate) { if (statements.size() == 1) return select(statements.get(0), orderBy, limit, offset, bindCount, isAggregate); alias = SchemaUtil.normalizeIdentifier(aliasedNode.getNode().getAlias()); aliases.add(alias == null ? createTempAlias() : alias); aliasedNodes = Lists.newArrayList(aliasedNode(null, wildcard())); } else { aliasedNodes = Lists.newArrayListWithExpectedSize(aliases.size()); for (String alias : aliases) { aliasedNodes.add(aliasedNode(alias, column(null, alias, alias))); return select(null, HintNode.EMPTY_HINT_NODE, false, aliasedNodes, null, null, null, orderBy, limit,offset, bindCount, false, false, statements, udfParseNodes);
String alias = ParseNodeFactory.createTempAlias(); this.additionalSelectNodes.add(NODE_FACTORY.aliasedNode(alias, node.getLHS())); ParseNode lhsNode = NODE_FACTORY.column(tableName, alias, null); this.joinConditions.add(NODE_FACTORY.equal(lhsNode, node.getRHS())); return null; String alias = ParseNodeFactory.createTempAlias(); this.additionalSelectNodes.add(NODE_FACTORY.aliasedNode(alias, node.getRHS())); ParseNode rhsNode = NODE_FACTORY.column(tableName, alias, null); this.joinConditions.add(NODE_FACTORY.equal(node.getLHS(), rhsNode)); return null;
private SelectStatement fixSubqueryStatement(SelectStatement select) { if (!select.isUnion()) return select; // Wrap as a derived table. return NODE_FACTORY.select(NODE_FACTORY.derivedTable(ParseNodeFactory.createTempAlias(), select), HintNode.EMPTY_HINT_NODE, false, select.getSelect(), null, null, null, null, null, null, select.getBindCount(), false, false, Collections.<SelectStatement> emptyList(), select.getUdfParseNodes()); }
private ParseNode getJoinConditionNode(ParseNode lhs, List<AliasedNode> rhs, String rhsTableAlias) throws SQLException { List<ParseNode> lhsNodes; if (lhs instanceof RowValueConstructorParseNode) { lhsNodes = ((RowValueConstructorParseNode) lhs).getChildren(); } else { lhsNodes = Collections.singletonList(lhs); } if (lhsNodes.size() != (rhs.size() - 1)) throw new SQLExceptionInfo.Builder(SQLExceptionCode.SUBQUERY_RETURNS_DIFFERENT_NUMBER_OF_FIELDS).build().buildException(); int count = lhsNodes.size(); TableName rhsTableName = NODE_FACTORY.table(null, rhsTableAlias); List<ParseNode> equalNodes = Lists.newArrayListWithExpectedSize(count); for (int i = 0; i < count; i++) { ParseNode rhsNode = NODE_FACTORY.column(rhsTableName, rhs.get(i + 1).getAlias(), null); equalNodes.add(NODE_FACTORY.equal(lhsNodes.get(i), rhsNode)); } return count == 1 ? equalNodes.get(0) : NODE_FACTORY.and(equalNodes); }
TableWildcardParseNode node = NODE_FACTORY.tableWildcard(tableName); normSelectNodes.add(NODE_FACTORY.aliasedNode(null, node)); statement = NODE_FACTORY.select(statement.getFrom(), statement.getHint(), statement.isDistinct(), normSelectNodes, statement.getWhere(), statement.getGroupBy(), statement.getHaving(), statement.getOrderBy(), statement.getLimit(), statement.getOffset(), statement.getBindCount(), statement.isAggregate(), statement.hasSequence(), statement.getSelects(), statement.getUdfParseNodes());
if ( state.backtracking==0 ) { PTableType tt = v==null ? (QueryConstants.SYSTEM_SCHEMA_NAME.equals(t.getSchemaName()) ? PTableType.SYSTEM : PTableType.TABLE) : PTableType.VIEW; ret = ( c == null ? factory.addColumn(factory.namedTable(null,t), tt, d, ex!=null, p) : factory.dropColumn(factory.namedTable(null,t), tt, c, ex!=null) ); }
ParseNodeFactory factory = new ParseNodeFactory(); LiteralParseNode literal = factory.literal(listFiles.next().getPath().toString()); LiteralExpression expression = LiteralExpression.newConstant(literal.getValue(), PVarchar.INSTANCE,
if ( state.backtracking==0 ) {ret = factory.alterIndex(factory.namedTable(null, TableName.create(t.getSchemaName(), i.getName())), t.getTableName(), ex!=null, PIndexState.valueOf(SchemaUtil.normalizeIdentifier(s.getText())), async!=null, p); }
@Override public ParseNode createNode(List<ParseNode> children) { return NODE_FACTORY.and(children); } });
if ( state.backtracking==0 ) { ret = factory.aliasedNode(a, field); } match(input,DOT,FOLLOW_DOT_in_selectable5558); if (state.failed) return ret; match(input,ASTERISK,FOLLOW_ASTERISK_in_selectable5560); if (state.failed) return ret; if ( state.backtracking==0 ) { ret = factory.aliasedNode(null, factory.family(familyName));} match(input,DOT,FOLLOW_DOT_in_selectable5583); if (state.failed) return ret; match(input,ASTERISK,FOLLOW_ASTERISK_in_selectable5585); if (state.failed) return ret; if ( state.backtracking==0 ) { ret = factory.aliasedNode(null, factory.tableWildcard(factory.table(s, t))); }