final QueryMaker queryMaker = new QueryMaker(queryLifecycleFactory, plannerContext, jsonMapper); final SqlToRelConverter.Config sqlToRelConverterConfig = SqlToRelConverter .configBuilder() .withExpand(false) .withDecorrelationEnabled(false)
/** * Converts a WITH sub-query into a relational expression. */ public RelRoot convertWith(SqlWith with, boolean top) { return convertQuery(with.body, false, top); }
@Override protected SqlToRelConverter getSqlToRelConverter( SqlValidator validator, CatalogReader catalogReader, SqlToRelConverter.Config config) { final RelOptCluster cluster = prepare.createCluster(planner, rexBuilder); return new SqlToRelConverter(this, validator, catalogReader, cluster, convertletTable, config); }
/** * If sub-query 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; }
localConfig = SqlToRelConverter.configBuilder() .withTrimUnusedFields(true).withExpand(enableExpand).build(); } else { converter.convertQuery(validatedQuery, false, true); assert root != null; if (enableDecorrelate || enableTrim) { root = root.withRel(converter.flattenTypes(root.rel, true)); root = root.withRel(converter.decorrelate(sqlQuery, root.rel)); root = root.withRel(converter.trimUnusedFields(true, root.rel));
public RelRoot rel(SqlNode sql) throws RelConversionException { ensure(State.STATE_4_VALIDATED); assert validatedSqlNode != null; final RexBuilder rexBuilder = createRexBuilder(); final RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder); final SqlToRelConverter.Config config = SqlToRelConverter.configBuilder() .withConfig(sqlToRelConverterConfig) .withTrimUnusedFields(false) .withConvertTableAccess(false) .build(); final SqlToRelConverter sqlToRelConverter = new SqlToRelConverter(this, validator, createCatalogReader(), cluster, convertletTable, config); root = sqlToRelConverter.convertQuery(validatedSqlNode, false, true); root = root.withRel(sqlToRelConverter.flattenTypes(root.rel, true)); final RelBuilder relBuilder = config.getRelBuilderFactory().create(cluster, null); root = root.withRel( RelDecorrelator.decorrelateQuery(root.rel, relBuilder)); state = State.STATE_5_CONVERTED; return root; }
SqlCall cursorCall = call.operand(1); SqlNode query = cursorCall.operand(0); RelNode converted = convertQuery(query, false, false).rel; bb.setRoot(converted, false); datasetStack.pop(); return; replaceSubQueries(bb, call, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN); RelOptTable relOptTable = RelOptTableImpl.create(null, rowType, table, udf.getNameAsId().names); RelNode converted = toRel(relOptTable); bb.setRoot(converted, true); return; final List<RelNode> inputs = bb.retrieveCursors(); Set<RelColumnMapping> columnMappings = getColumnMappings(operator); LogicalTableFunctionScan callRel = LogicalTableFunctionScan.create( columnMappings); bb.setRoot(callRel, true); afterTableFunction(bb, call, callRel);
@Override public RelRoot expandView(RelDataType rowType, String queryString, List<String> schemaPath, List<String> viewPath) { expansionDepth++; SqlParser parser = prepare.createParser(queryString); SqlNode sqlNode; try { sqlNode = parser.parseQuery(); } catch (SqlParseException e) { throw new RuntimeException("parse failed", e); } // View may have different schema path than current connection. final CatalogReader catalogReader = this.catalogReader.withSchemaPath(schemaPath); SqlValidator validator = createSqlValidator(catalogReader); final SqlToRelConverter.Config config = SqlToRelConverter.configBuilder() .withTrimUnusedFields(true).build(); SqlToRelConverter sqlToRelConverter = getSqlToRelConverter(validator, catalogReader, config); RelRoot root = sqlToRelConverter.convertQuery(sqlNode, true, false); --expansionDepth; return root; }
RelNode result = convertQueryRecursive(query, top, null).rel; if (top) { if (isStream(query)) { result = new LogicalDelta(cluster, result.getTraitSet(), result); if (isOrdered(query)) { collation = requiredCollation(result); checkConvertedType(query, result); RelRoot origResult = RelRoot.of(result, validatedRowType, query.getKind()) .withCollation(collation); return hackSelectStar(origQuery, origResult);
final List<String> targetColumnNames = new ArrayList<>(); final List<RexNode> columnExprs = new ArrayList<>(); collectInsertTargets(call, sourceRef, targetColumnNames, columnExprs); final RelOptTable targetTable = getTargetTable(call); final RelDataType targetRowType = RelOptTableImpl.realRowType(targetTable); final List<RelDataTypeField> targetFields = targetRowType.getFieldList(); getInitializerFactory(validator.getNamespace(call).getTable()); createInsertBlackboard(targetTable, sourceRef, targetColumnNames); castNullLiteralIfNeeded(sourceExps.get(i), field.getType()));
Blackboard usedBb; if (null != nss) { usedBb = createBlackboard(nss.getScope(), null, false); } else { usedBb = createBlackboard(new ListScope(bb.scope) { public SqlNode getNode() { return call; ((SqlValidatorImpl) validator).setValidatedNodeType(list, multisetType.getComponentType()); input = convertQueryOrInList(usedBb, list, null); break; case MULTISET_QUERY_CONSTRUCTOR: case ARRAY_QUERY_CONSTRUCTOR: final RelRoot root = convertQuery(call.operand(0), false, true); input = root.rel; break;
public RelRoot sqlToRel(SqlNode sqlNode) { assert sqlNode != null; RexBuilder rexBuilder = this.createRexBuilder(); RelOptCluster cluster = RelOptCluster.create(this.planner, rexBuilder); SqlToRelConverter sqlToRelConverter = new SqlToRelConverter( new ViewExpanderImpl(), this.validator, this.createCatalogReader(), cluster, this.convertletTable, SqlToRelConverter.Config.DEFAULT); RelRoot tempRoot = sqlToRelConverter.convertQuery(sqlNode, false, true); tempRoot = tempRoot.withRel(sqlToRelConverter.flattenTypes(tempRoot.project(), true)); tempRoot = tempRoot.withRel(RelDecorrelator.decorrelateQuery(tempRoot.project())); return tempRoot; }
/** 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); } final SqlToRelConverter.Config config = SqlToRelConverter.configBuilder() .withTrimUnusedFields(true).build(); SqlToRelConverter sqlToRelConverter2 = getSqlToRelConverter(getSqlValidator(), catalogReader, config); materialization.queryRel = sqlToRelConverter2.convertQuery(node, true, true).rel; // 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); }
/** * Returns a rel root that defers materialization of scans via {@link com.dremio.exec.planner.logical.ConvertibleScan} * * Used for serialization. */ public RelRootPlus toConvertibleRelRoot(final SqlNode validatedNode, boolean expand) { final OptionManager o = settings.getOptions(); final boolean useLegacyDecorrelator = o.getOption(PlannerSettings.USE_LEGACY_DECORRELATOR); final long inSubQueryThreshold = o.getOption(ExecConstants.FAST_OR_ENABLE) ? o.getOption(ExecConstants.FAST_OR_MAX_THRESHOLD) : settings.getOptions().getOption(ExecConstants.PLANNER_IN_SUBQUERY_THRESHOLD); final SqlToRelConverter.Config config = SqlToRelConverter.configBuilder() .withInSubQueryThreshold((int) inSubQueryThreshold) .withTrimUnusedFields(true) .withConvertTableAccess(false) .withExpand(expand) .build(); final ReflectionAllowedMonitoringConvertletTable convertletTable = new ReflectionAllowedMonitoringConvertletTable(new ConvertletTable(functionContext.getContextInformation())); final SqlToRelConverter sqlToRelConverter = new DremioSqlToRelConverter(this, validator, convertletTable, config); // Previously we had "top" = !innerQuery, but calcite only adds project if it is not a top query. final RelRoot rel = sqlToRelConverter.convertQuery(validatedNode, false /* needs validate */, false /* top */); final RelNode rel2 = sqlToRelConverter.flattenTypes(rel.rel, true); final RelNode rel3; rel3 = expand ? rel2 : rel2.accept(new RelsWithRexSubQueryFlattener(sqlToRelConverter)); final RelNode rel4 = RelDecorrelator.decorrelateQuery(rel3, useLegacyDecorrelator); if (logger.isDebugEnabled()) { logger.debug("ConvertQuery with expand = {}:\n{}", expand, RelOptUtil.toString(rel4, SqlExplainLevel.ALL_ATTRIBUTES)); } return RelRootPlus.of(rel4, rel.kind, convertletTable.isReflectionDisallowed()); }
SqlToRelConverter.configBuilder() .withTrimUnusedFields(true) .withExpand(THREAD_EXPAND.get()) sqlToRelConverter.setDynamicParamCountInExplain( sqlExplain.getDynamicParamCount()); sqlToRelConverter.convertQuery(sqlQuery, needsValidation, true); Hook.CONVERTED.run(root.rel);
/** * Walks over a tree of relational expressions, replacing each * {@link org.apache.calcite.rel.RelNode} with a 'slimmed down' relational * expression that projects * only the columns required by its consumer. * * @param root Root of relational expression tree * @return Trimmed relational expression */ protected RelRoot trimUnusedFields(RelRoot root) { final SqlToRelConverter.Config config = SqlToRelConverter.configBuilder() .withTrimUnusedFields(shouldTrim(root.rel)) .withExpand(THREAD_EXPAND.get()) .build(); final SqlToRelConverter converter = getSqlToRelConverter(getSqlValidator(), catalogReader, config); final boolean ordered = !root.collation.getFieldCollations().isEmpty(); final boolean dml = SqlKind.DML.contains(root.kind); return root.withRel(converter.trimUnusedFields(dml || ordered, root.rel)); }
/** * Converts a set operation (UNION, INTERSECT, MINUS) into relational * expressions. * * @param call Call to set operator * @return Relational expression */ protected RelNode convertSetOp(SqlCall call) { final RelNode left = convertQueryRecursive(call.operand(0), false, null).project(); final RelNode right = convertQueryRecursive(call.operand(1), false, null).project(); switch (call.getKind()) { case UNION: return LogicalUnion.create(ImmutableList.of(left, right), all(call)); case INTERSECT: return LogicalIntersect.create(ImmutableList.of(left, right), all(call)); case EXCEPT: return LogicalMinus.create(ImmutableList.of(left, right), all(call)); default: throw Util.unexpected(call.getKind()); } }
@Override public RexNode visitSubQuery(RexSubQuery subQuery) { final RelNode transformed = converter.flattenTypes(subQuery.rel, true); final RelNode transformed2 = transformed.accept(new RelsWithRexSubQueryFlattener(converter)); return subQuery.clone(transformed2); } }
@Override protected RelNode decorrelate(SqlToRelConverter sqlToRelConverter, SqlNode query, RelNode rootRel) { return sqlToRelConverter.decorrelate(query, rootRel); }
e = adjustInputRef(bb, (RexInputRef) e); if (pv != null) { e = RexPatternFieldRef.of(pv, (RexInputRef) e);