SqlCall cursorCall = call.operand(1); SqlNode query = cursorCall.operand(0); RelNode converted = convertQuery(query, false, false); bb.setRoot(converted, false); datasetStack.pop(); return; replaceSubqueries(bb, call, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN); final RelDataType rowType = table.getRowType(typeFactory); RelOptTable relOptTable = RelOptTableImpl.create(null, rowType, table); RelNode converted = toRel(relOptTable); bb.setRoot(converted, true); return; final List<RelNode> inputs = bb.retrieveCursors(); Set<RelColumnMapping> columnMappings = getColumnMappings(operator); TableFunctionRel callRel = new TableFunctionRel( columnMappings); bb.setRoot(callRel, true); afterTableFunction(bb, call, callRel);
e = adjustInputRef(bb, (RexInputRef) e);
final List<String> targetColumnNames = new ArrayList<String>(); final List<RexNode> columnExprs = new ArrayList<RexNode>(); collectInsertTargets(call, sourceRef, targetColumnNames, columnExprs); final RelOptTable targetTable = getTargetTable(call); final RelDataType targetRowType = targetTable.getRowType(); final List<RelDataTypeField> targetFields = castNullLiteralIfNeeded( sourceExps.get(i), field.getType()));
/** * If subquery is correlated and decorrelation is enabled, performs * decorrelation. * * @param query Query * @param rootRel Root relational expression * @return New root relational expression after decorrelation */ public RelNode decorrelate(SqlNode query, RelNode rootRel) { if (!enableDecorrelation()) { return rootRel; } final RelNode result = decorrelateQuery(rootRel); if (result != rootRel) { checkConvertedType(query, result); } return result; }
RelNode result = convertQueryRecursive(query, top, null); checkConvertedType(query, result);
Blackboard usedBb; if (null != nss) { usedBb = createBlackboard(nss.getScope(), null); } else { usedBb = createBlackboard( new ListScope(bb.scope) { public SqlNode getNode() { list, multisetType.getComponentType()); input = convertQueryOrInList(usedBb, list); } else { input = convertQuery(call.operand(0), false, true); RelNode relNode = (RelNode) joinList.get(i); ret = createJoin( ret, relNode,
public RelNode convert(SqlNode sql) throws RelConversionException { ensure(State.STATE_4_VALIDATED); assert validatedSqlNode != null; this.sqlToRelConverter = new SqlToRelConverter( new ViewExpanderImpl(), validator, createCatalogReader(), planner, createRexBuilder(), convertletTable); sqlToRelConverter.setTrimUnusedFields(false); sqlToRelConverter.enableTableAccessConversion(false); rel = sqlToRelConverter.convertQuery(validatedSqlNode, false, true); rel = sqlToRelConverter.flattenTypes(rel, true); rel = sqlToRelConverter.decorrelate(validatedSqlNode, rel); state = State.STATE_5_CONVERTED; return rel; }
catalogReader, typeFactory); converter.setTrimUnusedFields(true); final SqlNode validatedQuery = validator.validate(sqlQuery); RelNode rel = converter.convertQuery(validatedQuery, false, true); assert rel != null; if (enableDecorrelate || enableTrim) { rel = converter.flattenTypes(rel, true); rel = converter.decorrelate(sqlQuery, rel); converter.setTrimUnusedFields(true); rel = converter.trimUnusedFields(rel);
public RelNode expandView(RelDataType rowType, String queryString, List<String> schemaPath) { SqlParser parser = SqlParser.create(parserFactory, queryString, lex.quoting, lex.unquotedCasing, lex.quotedCasing); SqlNode sqlNode; try { sqlNode = parser.parseQuery(); } catch (SqlParseException e) { throw new RuntimeException("parse failed", e); } final OptiqCatalogReader catalogReader = createCatalogReader().withSchemaPath(schemaPath); SqlValidator validator = new OptiqSqlValidator( operatorTable, catalogReader, typeFactory); SqlNode validatedSqlNode = validator.validate(sqlNode); SqlToRelConverter sqlToRelConverter = new SqlToRelConverter( null, validator, catalogReader, planner, createRexBuilder(), convertletTable); sqlToRelConverter.setTrimUnusedFields(false); return sqlToRelConverter.convertQuery(validatedSqlNode, true, false); } }
/** * If subquery is correlated and decorrelation is enabled, performs * decorrelation. * * @param query Query * @param rootRel Root relational expression * @return New root relational expression after decorrelation */ public RelNode decorrelate(SqlNode query, RelNode rootRel) { RelNode result = rootRel; if (enableDecorrelation() && hasCorrelation()) { result = decorrelateQuery(result); checkConvertedType(query, result); } return result; }
/** * Converts a WITH sub-query into a relational expression. */ public RelNode convertWith(SqlWith with) { return convertQuery(with.body, false, false); }
@Override protected SqlToRelConverter getSqlToRelConverter( SqlValidator validator, CatalogReader catalogReader) { SqlToRelConverter sqlToRelConverter = new SqlToRelConverter( this, validator, catalogReader, planner, rexBuilder, StandardConvertletTable.INSTANCE); sqlToRelConverter.setTrimUnusedFields(true); return sqlToRelConverter; }
private void checkConvertedType(SqlNode query, RelNode result) { if (!query.isA(SqlKind.DML)) { // Verify that conversion from SQL to relational algebra did // not perturb any type information. (We can't do this if the // SQL statement is something like an INSERT which has no // validator type information associated with its result, // hence the namespace check above.) RelDataType convertedRowType = result.getRowType(); if (!checkConvertedRowType(query, convertedRowType)) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); throw Util.newInternal( "Conversion to relational algebra failed to preserve " + "datatypes:\n" + "validated type:\n" + validatedRowType.getFullTypeString() + "\nconverted type:\n" + convertedRowType.getFullTypeString() + "\nrel:\n" + RelOptUtil.toString(result)); } } }
/** * Walks over a tree of relational expressions, replacing each * {@link org.eigenbase.rel.RelNode} with a 'slimmed down' relational * expression that projects * only the columns required by its consumer. * * @param rootRel Relational expression that is at the root of the tree * @return Trimmed relational expression */ protected RelNode trimUnusedFields(RelNode rootRel) { final SqlToRelConverter converter = getSqlToRelConverter( getSqlValidator(), catalogReader); converter.setTrimUnusedFields(TRIM); return converter.trimUnusedFields(rootRel); }
sqlToRelConverter.setIsExplain(sqlExplain.getDynamicParamCount()); sqlToRelConverter.convertQuery(sqlQuery, needsValidation, true);
public RelNode convertSqlToRel(String sql) { Util.pre(sql != null, "sql != null"); final SqlNode sqlQuery; try { sqlQuery = parseQuery(sql); } catch (Exception e) { throw Util.newInternal(e); // todo: better handling } final RelDataTypeFactory typeFactory = getTypeFactory(); final Prepare.CatalogReader catalogReader = createCatalogReader(typeFactory); final SqlValidator validator = createValidator( catalogReader, typeFactory); final SqlToRelConverter converter = createSqlToRelConverter( validator, catalogReader, typeFactory); converter.setTrimUnusedFields(true); final SqlNode validatedQuery = validator.validate(sqlQuery); final RelNode rel = converter.convertQuery(validatedQuery, false, true); Util.post(rel != null, "return != null"); return rel; }
/** Populates a materialization record, converting a table path * (essentially a list of strings, like ["hr", "sales"]) into a table object * that can be used in the planning process. */ void populate(Materialization materialization) { SqlParser parser = SqlParser.create(materialization.sql); SqlNode node; try { node = parser.parseStmt(); } catch (SqlParseException e) { throw new RuntimeException("parse failed", e); } SqlToRelConverter sqlToRelConverter2 = getSqlToRelConverter(getSqlValidator(), catalogReader); materialization.queryRel = sqlToRelConverter2.convertQuery(node, true, true); // Identify and substitute a StarTable in queryRel. // // It is possible that no StarTables match. That is OK, but the // materialization patterns that are recognized will not be as rich. // // It is possible that more than one StarTable matches. TBD: should we // take the best (whatever that means), or all of them? useStar(schema, materialization); RelOptTable table = this.catalogReader.getTable(materialization.materializedTable.path()); materialization.tableRel = sqlToRelConverter2.toRel(table); }
if ((sqlNode instanceof SqlCall) && containsInOperator(sqlNode)) { SqlCall sqlCall = (SqlCall) sqlNode; if ((sqlCall.getOperator() == SqlStdOperatorTable.AND) SqlNode[] sqlOperands = ((SqlBasicCall) sqlCall).operands; for (int i = 0; i < sqlOperands.length; i++) { sqlOperands[i] = pushDownNotForIn(sqlOperands[i]); orOperands[i] = pushDownNotForIn(orOperands[i]); andOperands[i] = pushDownNotForIn(andOperands[i]); SqlNode[] notOperands = childSqlCall.getOperands(); assert notOperands.length == 1; return pushDownNotForIn(notOperands[0]); } else if (childSqlCall.getOperator() instanceof SqlInOperator) { SqlNode[] inOperands = childSqlCall.getOperands();
/** Populates a materialization record, converting a table path * (essentially a list of strings, like ["hr", "sales"]) into a table object * that can be used in the planning process. */ void populate(Materialization materialization) { SqlParser parser = new SqlParser(materialization.sql); SqlNode node; try { node = parser.parseStmt(); } catch (SqlParseException e) { throw new RuntimeException("parse failed", e); } SqlToRelConverter sqlToRelConverter2 = getSqlToRelConverter(getSqlValidator(), catalogReader); materialization.queryRel = sqlToRelConverter2.convertQuery(node, true, true); RelOptTable table = catalogReader.getTable(materialization.materializedTable.path()); materialization.tableRel = table.toRel(sqlToRelConverter2.makeToRelContext()); } }
protected SqlToRelConverter createSqlToRelConverter( final SqlValidator validator, final Prepare.CatalogReader catalogReader, final RelDataTypeFactory typeFactory) { return new SqlToRelConverter( null, validator, catalogReader, getPlanner(), new RexBuilder(typeFactory)); }