Collaboration diagram for org.apache.calcite.sql2rel.SqlToRelConverter:

Classes
class	Blackboard

class	DeferredLookup

class	NoOpSubQueryConverter

class	RexAccessShuttle

Public Member Functions
	SqlToRelConverter (RelOptTable.ViewExpander viewExpander, SqlValidator validator, Prepare.CatalogReader catalogReader, RelOptPlanner planner, RexBuilder rexBuilder, SqlRexConvertletTable convertletTable)

	SqlToRelConverter (RelOptTable.ViewExpander viewExpander, SqlValidator validator, Prepare.CatalogReader catalogReader, RelOptCluster cluster, SqlRexConvertletTable convertletTable)

	SqlToRelConverter (RelOptTable.ViewExpander viewExpander, SqlValidator validator, Prepare.CatalogReader catalogReader, RelOptCluster cluster, SqlRexConvertletTable convertletTable, Config config)

RelOptCluster	getCluster ()

RexBuilder	getRexBuilder ()

int	getDynamicParamCount ()

RelDataType	getDynamicParamType (int index)

int	getDynamicParamCountInExplain (boolean increment)

Map< SqlNode, RexNode >	getMapConvertedNonCorrSubqs ()

void	addConvertedNonCorrSubqs (Map< SqlNode, RexNode > alreadyConvertedNonCorrSubqs)

void	setSubQueryConverter (SubQueryConverter converter)

void	setDynamicParamCountInExplain (int explainParamCount)

RelNode	flattenTypes (RelNode rootRel, boolean restructure)

RelNode	decorrelate (SqlNode query, RelNode rootRel)

RelNode	trimUnusedFields (boolean ordered, RelNode rootRel)

RelRoot	convertQuery (SqlNode query, final boolean needsValidation, final boolean top)

RelNode	convertSelect (SqlSelect select, boolean top)

RelNode	convertToSingleValueSubq (SqlNode query, RelNode plan)

RexNode	convertExpression (SqlNode node)

RexNode	convertExpression (SqlNode node, Map< String, RexNode > nameToNodeMap)

RexDynamicParam	convertDynamicParam (final SqlDynamicParam dynamicParam)

boolean	isTrimUnusedFields ()

RelNode	toRel (final RelOptTable table, final List< RelHint > hints)

RelRoot	convertWith (SqlWith with, boolean top)

RelNode	convertValues (SqlCall values, RelDataType targetRowType)

Static Public Member Functions
static boolean	isOrdered (SqlNode query)

Public Attributes
final SqlToRelConverter.Config	config

final RelOptTable.ViewExpander	viewExpander

Static Public Attributes
static final int	DEFAULT_IN_SUB_QUERY_THRESHOLD = 20

static final int	DEFAULT_IN_SUBQUERY_THRESHOLD = DEFAULT_IN_SUB_QUERY_THRESHOLD

Protected Member Functions
RelFieldTrimmer	newFieldTrimmer ()

Blackboard	createBlackboard (SqlValidatorScope scope, Map< String, RexNode > nameToNodeMap, boolean top)

void	convertSelectImpl (final Blackboard bb, SqlSelect select)

void	convertOrder (SqlSelect select, Blackboard bb, RelCollation collation, List< SqlNode > orderExprList, SqlNode offset, SqlNode fetch)

int	getInSubqueryThreshold ()

RexNode	convertExtendedExpression (SqlNode node, Blackboard bb)

void	convertFrom (Blackboard bb, SqlNode from)

void	convertFrom (Blackboard bb, SqlNode from, List< String > fieldNames)

void	convertMatchRecognize (Blackboard bb, SqlCall call)

void	convertCollectionTable (Blackboard bb, SqlCall call)

void	afterTableFunction (SqlToRelConverter.Blackboard bb, SqlCall call, LogicalTableFunctionScan callRel)

RelNode	createJoin (Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType)

List< RelDataTypeField >	getSystemFields ()

void	convertAgg (Blackboard bb, SqlSelect select, List< SqlNode > orderExprList)

final void	createAggImpl (Blackboard bb, final AggConverter aggConverter, SqlNodeList selectList, SqlNodeList groupList, SqlNode having, List< SqlNode > orderExprList)

RelNode	createAggregate (Blackboard bb, ImmutableBitSet groupSet, ImmutableList< ImmutableBitSet > groupSets, List< AggregateCall > aggCalls)

void	gatherOrderExprs (Blackboard bb, SqlSelect select, SqlNodeList orderList, List< SqlNode > extraOrderExprs, List< RelFieldCollation > collationList)

RelFieldCollation	convertOrderItem (SqlSelect select, SqlNode orderItem, List< SqlNode > extraExprs, RelFieldCollation.Direction direction, RelFieldCollation.NullDirection nullDirection)

boolean	enableDecorrelation ()

RelNode	decorrelateQuery (RelNode rootRel)

RelRoot	convertQueryRecursive (SqlNode query, boolean top, RelDataType targetRowType)

RelNode	convertSetOp (SqlCall call)

RelNode	convertInsert (SqlInsert call)

RelOptTable	getTargetTable (SqlNode call)

RelNode	convertColumnList (final SqlInsert call, RelNode source)

void	collectInsertTargets (SqlInsert call, final RexNode sourceRef, final List< String > targetColumnNames, List< RexNode > columnExprs)

RexNode	adjustInputRef (Blackboard bb, RexInputRef inputRef)

void	extraSelectItems (Blackboard bb, SqlSelect select, List< RexNode > exprList, List< String > nameList, Collection< String > aliasList, List< SqlMonotonicity > columnMonotonicityList)

Protected Attributes
final SqlValidator	validator

final RexBuilder	rexBuilder

final Prepare.CatalogReader	catalogReader

final RelOptCluster	cluster

final Map< RelNode, Integer >	leaves = new HashMap<>()

final RelDataTypeFactory	typeFactory

Static Protected Attributes
static final Logger	SQL2REL_LOGGER = CalciteTrace.getSqlToRelTracer()

Private Member Functions
void	checkConvertedType (SqlNode query, RelNode result)

RelCollation	requiredCollation (RelNode r)

void	distinctify (Blackboard bb, boolean checkForDupExprs)

void	convertWhere (final Blackboard bb, final SqlNode where)

void	replaceSubQueries (final Blackboard bb, final SqlNode expr, RelOptUtil.Logic logic)

void	substituteSubQuery (Blackboard bb, SubQuery subQuery)

RexNode	translateIn (RelOptUtil.Logic logic, RelNode root, final RexNode rex)

boolean	convertNonCorrelatedSubQuery (SubQuery subQuery, Blackboard bb, RelNode converted, boolean isExists)

RexNode	convertInToOr (final Blackboard bb, final List< RexNode > leftKeys, SqlNodeList valuesList, SqlInOperator op)

RexNode	ensureSqlType (RelDataType type, RexNode node)

RelOptUtil.Exists	convertExists (SqlNode seek, RelOptUtil.SubQueryType subQueryType, RelOptUtil.Logic logic, boolean notIn, RelDataType targetDataType)

RelNode	convertQueryOrInList (Blackboard bb, SqlNode seek, RelDataType targetRowType)

RelNode	convertRowValues (Blackboard bb, SqlNode rowList, Collection< SqlNode > rows, boolean allowLiteralsOnly, RelDataType targetRowType)

RexLiteral	convertLiteralInValuesList (SqlNode sqlNode, Blackboard bb, RelDataType rowType, int iField)

boolean	isRowConstructor (SqlNode node)

void	findSubQueries (Blackboard bb, SqlNode node, RelOptUtil.Logic logic, boolean registerOnlyScalarSubQueries)

RexNode	convertOver (Blackboard bb, SqlNode node)

void	convertUnnest (Blackboard bb, SqlCall call, List< String > fieldNames)

void	convertIdentifier (Blackboard bb, SqlIdentifier id, SqlNodeList extendedColumns, SqlNodeList tableHints)

void	convertTemporalTable (Blackboard bb, SqlCall call)

Set< RelColumnMapping >	getColumnMappings (SqlOperator op)

CorrelationUse	getCorrelationUse (Blackboard bb, final RelNode r0)

boolean	isSubQueryNonCorrelated (RelNode subq, Blackboard bb)

RexNode	convertJoinCondition (Blackboard bb, SqlValidatorNamespace leftNamespace, SqlValidatorNamespace rightNamespace, SqlNode condition, JoinConditionType conditionType, RelNode leftRel, RelNode rightRel)

RexNode	convertUsing (SqlValidatorNamespace leftNamespace, SqlValidatorNamespace rightNamespace, List< String > nameList)

RelNode	rewriteAggregateWithGroupId (Blackboard bb, AggregatingSelectScope.Resolved r, AggConverter converter)

boolean	all (SqlCall call)

RelNode	createModify (RelOptTable targetTable, RelNode source)

RelNode	createSource (RelOptTable targetTable, RelNode source, ModifiableView modifiableView, RelDataType delegateRowType)

RelOptTable.ToRelContext	createToRelContext (List< RelHint > hints)

Blackboard	createInsertBlackboard (RelOptTable targetTable, RexNode sourceRef, List< String > targetColumnNames)

InitializerExpressionFactory	getInitializerFactory (SqlValidatorTable validatorTable)

RexNode	castNullLiteralIfNeeded (RexNode node, RelDataType type)

RelNode	convertDelete (SqlDelete call)

RelNode	convertUpdate (SqlUpdate call)

RelNode	convertMerge (SqlMerge call)

RexNode	convertIdentifier (Blackboard bb, SqlIdentifier identifier)

RelNode	convertRowConstructor (Blackboard bb, SqlCall rowConstructor)

RelNode	convertCursor (Blackboard bb, SubQuery subQuery)

RelNode	convertMultisets (final List< SqlNode > operands, Blackboard bb)

void	convertSelectList (Blackboard bb, SqlSelect select, List< SqlNode > orderList)

String	deriveAlias (final SqlNode node, Collection< String > aliases, final int ordinal)

void	convertValuesImpl (Blackboard bb, SqlCall values, RelDataType targetRowType)

SqlQuantifyOperator	negate (SqlQuantifyOperator operator)

Static Private Member Functions
static boolean	isStream (SqlNode query)

static boolean	containsInOperator (SqlNode node)

static SqlNode	pushDownNotForIn (SqlValidatorScope scope, SqlNode sqlNode)

static SqlNode	reg (SqlValidatorScope scope, SqlNode e)

static boolean	containsNullLiteral (SqlNodeList valueList)

static JoinRelType	convertJoinType (JoinType joinType)

static boolean	desc (RelFieldCollation.Direction direction)

static< T > T	unwrap (Object o, Class< T > clazz)

Private Attributes
SubQueryConverter	subQueryConverter

final List< SqlDynamicParam >	dynamicParamSqlNodes = new ArrayList<>()

final SqlOperatorTable	opTab

final SqlNodeToRexConverter	exprConverter

final HintStrategyTable	hintStrategies

int	explainParamCount

final RelBuilder	relBuilder

final Map< CorrelationId, DeferredLookup >	mapCorrelToDeferred = new HashMap<>()

final Deque< String >	datasetStack = new ArrayDeque<>()

final Map< SqlNode, RexNode >	mapConvertedNonCorrSubqs = new HashMap<>()

Detailed Description

Converts a SQL parse tree (consisting of org.apache.calcite.sql.SqlNode objects) into a relational algebra expression (consisting of org.apache.calcite.rel.RelNode objects).

The public entry points are: convertQuery, convertExpression(SqlNode).

Definition at line 233 of file SqlToRelConverter.java.

Constructor & Destructor Documentation

org.apache.calcite.sql2rel.SqlToRelConverter.SqlToRelConverter	(	RelOptTable.ViewExpander	viewExpander,
		SqlValidator	validator,
		Prepare.CatalogReader	catalogReader,
		RelOptPlanner	planner,
		RexBuilder	rexBuilder,
		SqlRexConvertletTable	convertletTable
	)

inline

Creates a converter.

Parameters

viewExpander	Preparing statement
validator	Validator
catalogReader	Schema
planner	Planner
rexBuilder	Rex builder
convertletTable	Expression converter

Definition at line 296 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder, org.apache.calcite.sql2rel.SqlToRelConverter.validator, and org.apache.calcite.sql2rel.SqlToRelConverter.viewExpander.

                                                  {
     this(viewExpander,
             validator,
             catalogReader,
             RelOptCluster.create(planner, rexBuilder),
             convertletTable,
             Config.DEFAULT);
   }

org.apache.calcite.sql2rel.SqlToRelConverter.SqlToRelConverter	(	RelOptTable.ViewExpander	viewExpander,
		SqlValidator	validator,
		Prepare.CatalogReader	catalogReader,
		RelOptCluster	cluster,
		SqlRexConvertletTable	convertletTable
	)

inline

Definition at line 311 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.cluster, org.apache.calcite.sql2rel.SqlToRelConverter.validator, and org.apache.calcite.sql2rel.SqlToRelConverter.viewExpander.

                                                  {
     this(viewExpander,
             validator,
             catalogReader,
             cluster,
             convertletTable,
             Config.DEFAULT);
   }

org.apache.calcite.sql2rel.SqlToRelConverter.SqlToRelConverter	(	RelOptTable.ViewExpander	viewExpander,
		SqlValidator	validator,
		Prepare.CatalogReader	catalogReader,
		RelOptCluster	cluster,
		SqlRexConvertletTable	convertletTable,
		Config	config
	)

inline

Definition at line 325 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.cluster, org.apache.calcite.sql2rel.SqlToRelConverter.config, File_Namespace.create(), org.apache.calcite.sql2rel.SqlToRelConverter.validator, and org.apache.calcite.sql2rel.SqlToRelConverter.viewExpander.

                          {
     this.viewExpander = viewExpander;
     this.opTab = (validator == null) ? SqlStdOperatorTable.instance()
                                      : validator.getOperatorTable();
     this.validator = validator;
     this.catalogReader = catalogReader;
     this.subQueryConverter = new NoOpSubQueryConverter();
     this.rexBuilder = cluster.getRexBuilder();
     this.typeFactory = rexBuilder.getTypeFactory();
     this.exprConverter = new SqlNodeToRexConverterImpl(convertletTable);
     this.explainParamCount = 0;
     this.config = new ConfigBuilder().withConfig(config).build();
     this.relBuilder = config.getRelBuilderFactory()
                               .create(cluster, null)
                               .transform(config.getRelBuilderConfigTransform());
     this.hintStrategies = config.getHintStrategyTable();
 
     cluster.setHintStrategies(this.hintStrategies);
     this.cluster = Objects.requireNonNull(cluster);
   }

Here is the call graph for this function:

Member Function Documentation

void org.apache.calcite.sql2rel.SqlToRelConverter.addConvertedNonCorrSubqs ( Map< SqlNode, RexNode > alreadyConvertedNonCorrSubqs )

inline

Adds to the current map of non-correlated converted sub-queries the elements from another map that contains non-correlated sub-queries that have been converted by another SqlToRelConverter.

Parameters

alreadyConvertedNonCorrSubqs the other map

Definition at line 419 of file SqlToRelConverter.java.

                                                               {
     mapConvertedNonCorrSubqs.putAll(alreadyConvertedNonCorrSubqs);
   }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.adjustInputRef	(	Blackboard	bb,
		RexInputRef	inputRef
	)

inlineprotected

Adjusts the type of a reference to an input field to account for nulls introduced by outer joins; and adjusts the offset to match the physical implementation.

Parameters

bb	Blackboard
inputRef	Input ref

Returns: Adjusted input ref

Definition at line 3830 of file SqlToRelConverter.java.

References field().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier().

                                                                         {
     RelDataTypeField field = bb.getRootField(inputRef);
     if (field != null) {
       return rexBuilder.makeInputRef(field.getType(), inputRef.getIndex());
     }
     return inputRef;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.afterTableFunction	(	SqlToRelConverter.Blackboard	bb,
		SqlCall	call,
		LogicalTableFunctionScan	callRel
	)

inlineprotected

Definition at line 2399 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable().

2401 {}

Here is the caller graph for this function:

boolean org.apache.calcite.sql2rel.SqlToRelConverter.all ( SqlCall call )

inlineprivate

Definition at line 3292 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSetOp().

                                     {
     return ((SqlSetOperator) call.getOperator()).isAll();
   }

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.castNullLiteralIfNeeded	(	RexNode	node,
		RelDataType	type
	)

inlineprivate

Definition at line 3561 of file SqlToRelConverter.java.

References run_benchmark_import.type.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList().

                                                                           {
     if (!RexLiteral.isNullLiteral(node)) {
       return node;
     }
     return rexBuilder.makeCast(type, node);
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.checkConvertedType	(	SqlNode	query,
		RelNode	result
	)

inlineprivate

Definition at line 444 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery(), and org.apache.calcite.sql2rel.SqlToRelConverter.decorrelate().

                                                                  {
     if (query.isA(SqlKind.DML)) {
       return;
     }
     // 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.)
     final List<RelDataTypeField> validatedFields =
             validator.getValidatedNodeType(query).getFieldList();
     final RelDataType validatedRowType =
             validator.getTypeFactory().createStructType(Pair.right(validatedFields),
                     SqlValidatorUtil.uniquify(Pair.left(validatedFields),
                             catalogReader.nameMatcher().isCaseSensitive()));
 
     final List<RelDataTypeField> convertedFields =
             result.getRowType().getFieldList().subList(0, validatedFields.size());
     final RelDataType convertedRowType =
             validator.getTypeFactory().createStructType(convertedFields);
 
     if (!RelOptUtil.equal("validated row type",
                 validatedRowType,
                 "converted row type",
                 convertedRowType,
                 Litmus.IGNORE)) {
       throw new AssertionError("Conversion to relational algebra failed to "
               + "preserve datatypes:\n"
               + "validated type:\n" + validatedRowType.getFullTypeString()
               + "\nconverted type:\n" + convertedRowType.getFullTypeString() + "\nrel:\n"
               + RelOptUtil.toString(result));
     }
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.collectInsertTargets	(	SqlInsert	call,
		final RexNode	sourceRef,
		final List< String >	targetColumnNames,
		List< RexNode >	columnExprs
	)

inlineprotected

Given an INSERT statement, collects the list of names to be populated and the expressions to put in them.

Parameters

call	Insert statement
sourceRef	Expression representing a row from the source relational expression
targetColumnNames	List of target column names, to be populated
columnExprs	List of expressions, to be populated

Definition at line 3578 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.createInsertBlackboard(), f(), field(), org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable(), Fragmenter_Namespace.indexOf(), org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory, and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList().

                                      {
     final RelOptTable targetTable = getTargetTable(call);
     final RelDataType tableRowType = targetTable.getRowType();
     SqlNodeList targetColumnList = call.getTargetColumnList();
     if (targetColumnList == null) {
       if (validator.config().sqlConformance().isInsertSubsetColumnsAllowed()) {
         final RelDataType targetRowType =
                 typeFactory.createStructType(tableRowType.getFieldList().subList(
                         0, sourceRef.getType().getFieldCount()));
         targetColumnNames.addAll(targetRowType.getFieldNames());
       } else {
         targetColumnNames.addAll(tableRowType.getFieldNames());
       }
     } else {
       for (int i = 0; i < targetColumnList.size(); i++) {
         SqlIdentifier id = (SqlIdentifier) targetColumnList.get(i);
         RelDataTypeField field = SqlValidatorUtil.getTargetField(
                 tableRowType, typeFactory, id, catalogReader, targetTable);
         assert field != null : "column " + id.toString() + " not found";
         targetColumnNames.add(field.getName());
       }
     }
 
     final Blackboard bb =
             createInsertBlackboard(targetTable, sourceRef, targetColumnNames);
 
     // Next, assign expressions for generated columns.
     final List<ColumnStrategy> strategies = targetTable.getColumnStrategies();
     for (String columnName : targetColumnNames) {
       final int i = tableRowType.getFieldNames().indexOf(columnName);
       final RexNode expr;
       switch (strategies.get(i)) {
         case STORED:
           final InitializerExpressionFactory f =
                   Util.first(targetTable.unwrap(InitializerExpressionFactory.class),
                           NullInitializerExpressionFactory.INSTANCE);
           expr = f.newColumnDefaultValue(targetTable, i, bb);
           break;
         case VIRTUAL:
           expr = null;
           break;
         default:
           expr = bb.nameToNodeMap.get(columnName);
       }
       columnExprs.add(expr);
     }
 
     // Remove virtual columns from the list.
     for (int i = 0; i < targetColumnNames.size(); i++) {
       if (columnExprs.get(i) == null) {
         columnExprs.remove(i);
         targetColumnNames.remove(i);
         --i;
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.containsInOperator ( SqlNode node )

inlinestaticprivate

Returns whether a given node contains a SqlInOperator.

Parameters

node	a RexNode tree

Definition at line 855 of file SqlToRelConverter.java.

References Void.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.pushDownNotForIn().

                                                           {
     try {
       SqlVisitor<Void> visitor = new SqlBasicVisitor<Void>() {
         public Void visit(SqlCall call) {
           if (call.getOperator() instanceof SqlInOperator) {
             throw new Util.FoundOne(call);
           }
           return super.visit(call);
         }
       };
       node.accept(visitor);
       return false;
     } catch (Util.FoundOne e) {
       Util.swallow(e, null);
       return true;
     }
   }

Here is the caller graph for this function:

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.containsNullLiteral ( SqlNodeList valueList )

inlinestaticprivate

Definition at line 1340 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                     {
     for (SqlNode node : valueList.getList()) {
       if (node instanceof SqlLiteral) {
         SqlLiteral lit = (SqlLiteral) node;
         if (lit.getValue() == null) {
           return true;
         }
       }
     }
     return false;
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertAgg	(	Blackboard	bb,
		SqlSelect	select,
		List< SqlNode >	orderExprList
	)

inlineprotected

Converts the SELECT, GROUP BY and HAVING clauses of an aggregate query.

This method extracts SELECT, GROUP BY and HAVING clauses, and creates an AggConverter, then delegates to createAggImpl. Derived class may override this method to change any of those clauses or specify a different AggConverter.

Parameters

bb	Scope within which to resolve identifiers
select	Query
orderExprList	Additional expressions needed to implement ORDER BY

Definition at line 2770 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl().

                                                                         {
     assert bb.root != null : "precondition: child != null";
     SqlNodeList groupList = select.getGroup();
     SqlNodeList selectList = select.getSelectList();
     SqlNode having = select.getHaving();
 
     final AggConverter aggConverter = new AggConverter(bb, select);
     createAggImpl(bb, aggConverter, selectList, groupList, having, orderExprList);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable	(	Blackboard	bb,
		SqlCall	call
	)

inlineprotected

Definition at line 2348 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                                                      {
     final SqlOperator operator = call.getOperator();
     if (operator == SqlStdOperatorTable.TABLESAMPLE) {
       final String sampleName =
               SqlLiteral.unchain(call.operand(0)).getValueAs(String.class);
       datasetStack.push(sampleName);
       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);
 
     // Expand table macro if possible. It's more efficient than
     // LogicalTableFunctionScan.
     final SqlCallBinding callBinding =
             new SqlCallBinding(bb.scope.getValidator(), bb.scope, call);
     if (operator instanceof SqlUserDefinedTableMacro) {
       final SqlUserDefinedTableMacro udf = (SqlUserDefinedTableMacro) operator;
       final TranslatableTable table = udf.getTable(callBinding);
       final RelDataType rowType = table.getRowType(typeFactory);
       RelOptTable relOptTable =
               RelOptTableImpl.create(null, rowType, table, udf.getNameAsId().names);
       RelNode converted = toRel(relOptTable, ImmutableList.of());
       bb.setRoot(converted, true);
       return;
     }
 
     Type elementType;
     if (operator instanceof SqlUserDefinedTableFunction) {
       SqlUserDefinedTableFunction udtf = (SqlUserDefinedTableFunction) operator;
       elementType = udtf.getElementType(callBinding);
     } else {
       elementType = null;
     }
 
     RexNode rexCall = bb.convertExpression(call);
     final List<RelNode> inputs = bb.retrieveCursors();
     Set<RelColumnMapping> columnMappings = getColumnMappings(operator);
     LogicalTableFunctionScan callRel = LogicalTableFunctionScan.create(cluster,
             inputs,
             rexCall,
             elementType,
             validator.getValidatedNodeType(call),
             columnMappings);
     bb.setRoot(callRel, true);
     afterTableFunction(bb, call, callRel);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList	(	final SqlInsert	call,
		RelNode	source
	)

inlineprotected

Creates a source for an INSERT statement.

If the column list is not specified, source expressions match target columns in order.

If the column list is specified, Source expressions are mapped to target columns by name via targetColumnList, and may not cover the entire target table. So, we'll make up a full row, using a combination of default values and the source expressions provided.

Parameters

call	Insert expression
source	Source relational expression

Returns: Converted INSERT statement

Definition at line 3465 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.castNullLiteralIfNeeded(), org.apache.calcite.sql2rel.SqlToRelConverter.collectInsertTargets(), org.apache.calcite.sql2rel.SqlToRelConverter.createInsertBlackboard(), field(), org.apache.calcite.sql2rel.SqlToRelConverter.getInitializerFactory(), org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable(), and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertInsert().

                                                                             {
     RelDataType sourceRowType = source.getRowType();
     final RexNode sourceRef = rexBuilder.makeRangeReference(sourceRowType, 0, false);
     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();
     final List<RexNode> sourceExps =
             new ArrayList<>(Collections.nCopies(targetFields.size(), null));
     final List<String> fieldNames =
             new ArrayList<>(Collections.nCopies(targetFields.size(), null));
 
     final InitializerExpressionFactory initializerFactory =
             getInitializerFactory(validator.getNamespace(call).getTable());
 
     // Walk the name list and place the associated value in the
     // expression list according to the ordinal value returned from
     // the table construct, leaving nulls in the list for columns
     // that are not referenced.
     final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
     for (Pair<String, RexNode> p : Pair.zip(targetColumnNames, columnExprs)) {
       RelDataTypeField field = nameMatcher.field(targetRowType, p.left);
       assert field != null : "column " + p.left + " not found";
       sourceExps.set(field.getIndex(), p.right);
     }
 
     // Lazily create a blackboard that contains all non-generated columns.
     final Supplier<Blackboard> bb =
             () -> createInsertBlackboard(targetTable, sourceRef, targetColumnNames);
 
     // Walk the expression list and get default values for any columns
     // that were not supplied in the statement. Get field names too.
     for (int i = 0; i < targetFields.size(); ++i) {
       final RelDataTypeField field = targetFields.get(i);
       final String fieldName = field.getName();
       fieldNames.set(i, fieldName);
       if (sourceExps.get(i) == null || sourceExps.get(i).getKind() == SqlKind.DEFAULT) {
         sourceExps.set(
                 i, initializerFactory.newColumnDefaultValue(targetTable, i, bb.get()));
 
         // bare nulls are dangerous in the wrong hands
         sourceExps.set(i, castNullLiteralIfNeeded(sourceExps.get(i), field.getType()));
       }
     }
 
     return relBuilder.push(source).projectNamed(sourceExps, fieldNames, false).build();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertCursor	(	Blackboard	bb,
		SubQuery	subQuery
	)

inlineprivate

Definition at line 3851 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                   {
     final SqlCall cursorCall = (SqlCall) subQuery.node;
     assert cursorCall.operandCount() == 1;
     SqlNode query = cursorCall.operand(0);
     RelNode converted = convertQuery(query, false, false).rel;
     int iCursor = bb.cursors.size();
     bb.cursors.add(converted);
     subQuery.expr = new RexInputRef(iCursor, converted.getRowType());
     return converted;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertDelete ( SqlDelete call )

inlineprivate

Definition at line 3638 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.convertSelect(), and org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive().

                                                 {
     RelOptTable targetTable = getTargetTable(call);
     RelNode sourceRel = convertSelect(call.getSourceSelect(), false);
     return LogicalTableModify.create(targetTable,
             catalogReader,
             sourceRel,
             LogicalTableModify.Operation.DELETE,
             null,
             null,
             false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexDynamicParam org.apache.calcite.sql2rel.SqlToRelConverter.convertDynamicParam ( final SqlDynamicParam dynamicParam )

inline

Definition at line 3078 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamType().

                                                                                  {
     // REVIEW jvs 8-Jan-2005: dynamic params may be encountered out of
     // order. Should probably cross-check with the count from the parser
     // at the end and make sure they all got filled in. Why doesn't List
     // have a resize() method?!? Make this a utility.
     while (dynamicParam.getIndex() >= dynamicParamSqlNodes.size()) {
       dynamicParamSqlNodes.add(null);
     }
 
     dynamicParamSqlNodes.set(dynamicParam.getIndex(), dynamicParam);
     return rexBuilder.makeDynamicParam(
             getDynamicParamType(dynamicParam.getIndex()), dynamicParam.getIndex());
   }

Here is the call graph for this function:

RelOptUtil.Exists org.apache.calcite.sql2rel.SqlToRelConverter.convertExists	(	SqlNode	seek,
		RelOptUtil.SubQueryType	subQueryType,
		RelOptUtil.Logic	logic,
		boolean	notIn,
		RelDataType	targetDataType
	)

inlineprivate

Converts an EXISTS or IN predicate into a join. For EXISTS, the sub-query produces an indicator variable, and the result is a relational expression which outer joins that indicator to the original query. After performing the outer join, the condition will be TRUE if the EXISTS condition holds, NULL otherwise.

Parameters

seek	A query, for example 'select * from emp' or 'values (1,2,3)' or '('Foo', 34)'.
subQueryType	Whether sub-query is IN, EXISTS or scalar
logic	Whether the answer needs to be in full 3-valued logic (TRUE, FALSE, UNKNOWN) will be required, or whether we can accept an approximation (say representing UNKNOWN as FALSE)
notIn	Whether the operation is NOT IN

Returns: join expression

Definition at line 1534 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryOrInList(), org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(), org.apache.calcite.sql2rel.SqlToRelConverter.relBuilder, and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                       {
     final SqlValidatorScope seekScope = (seek instanceof SqlSelect)
             ? validator.getSelectScope((SqlSelect) seek)
             : null;
     final Blackboard seekBb = createBlackboard(seekScope, null, false);
     RelNode seekRel = convertQueryOrInList(seekBb, seek, targetDataType);
 
     return RelOptUtil.createExistsPlan(seekRel, subQueryType, logic, notIn, relBuilder);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertExpression ( SqlNode node )

inline

Converts an expression from SqlNode to RexNode format.

Parameters

node	Expression to translate

Returns: Converted expression

Definition at line 1801 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(), and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertOrder().

                                                  {
     Map<String, RelDataType> nameToTypeMap = Collections.emptyMap();
     final ParameterScope scope =
             new ParameterScope((SqlValidatorImpl) validator, nameToTypeMap);
     final Blackboard bb = createBlackboard(scope, null, false);
     return bb.convertExpression(node);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertExpression	(	SqlNode	node,
		Map< String, RexNode >	nameToNodeMap
	)

inline

Converts an expression from SqlNode to RexNode format, mapping identifier references to predefined expressions.

Parameters

node	Expression to translate
nameToNodeMap	map from String to RexNode; when an SqlIdentifier is encountered, it is used as a key and translated to the corresponding value from this map

Returns: Converted expression

Definition at line 1820 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(), and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

                                                                                      {
     final Map<String, RelDataType> nameToTypeMap = new HashMap<>();
     for (Map.Entry<String, RexNode> entry : nameToNodeMap.entrySet()) {
       nameToTypeMap.put(entry.getKey(), entry.getValue().getType());
     }
     final ParameterScope scope =
             new ParameterScope((SqlValidatorImpl) validator, nameToTypeMap);
     final Blackboard bb = createBlackboard(scope, nameToNodeMap, false);
     return bb.convertExpression(node);
   }

Here is the call graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertExtendedExpression	(	SqlNode	node,
		Blackboard	bb
	)

inlineprotected

Converts a non-standard expression.

This method is an extension-point that derived classes can override. If this method returns a null result, the normal expression translation process will proceed. The default implementation always returns null.

Parameters

node	Expression
bb	Blackboard

Returns: null to proceed with the usual expression translation process

Definition at line 1843 of file SqlToRelConverter.java.

                                                                            {
     return null;
   }

void org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom	(	Blackboard	bb,
		SqlNode	from
	)

inlineprotected

Definition at line 1939 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMatchRecognize(), org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertTemporalTable().

                                                           {
     convertFrom(bb, from, Collections.emptyList());
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom	(	Blackboard	bb,
		SqlNode	from,
		List< String >	fieldNames
	)

inlineprotected

Converts a FROM clause into a relational expression.

Parameters

bb Scope within which to resolve identifiers

from

FROM clause of a query. Examples include:

              <ul>
              <li>a single table ("SALES.EMP"),
              <li>an aliased table ("EMP AS E"),
              <li>a list of tables ("EMP, DEPT"),
              <li>an ANSI Join expression ("EMP JOIN DEPT ON EMP.DEPTNO =
              DEPT.DEPTNO"),
              <li>a VALUES clause ("VALUES ('Fred', 20)"),
              <li>a query ("(SELECT * FROM EMP WHERE GENDER = 'F')"),
              <li>or any combination of the above.
              </ul>

fieldNames Field aliases, usually come from AS clause

Definition at line 1961 of file SqlToRelConverter.java.

                                                                                    {
     if (from == null) {
       bb.setRoot(LogicalValues.createOneRow(cluster), false);
       return;
     }
 
     final SqlCall call;
     final SqlNode[] operands;
     switch (from.getKind()) {
       case MATCH_RECOGNIZE:
         convertMatchRecognize(bb, (SqlCall) from);
         return;
 
       case AS:
         call = (SqlCall) from;
         SqlNode firstOperand = call.operand(0);
         final List<String> fieldNameList = new ArrayList<>();
         if (call.operandCount() > 2) {
           for (SqlNode node : Util.skip(call.getOperandList(), 2)) {
             fieldNameList.add(((SqlIdentifier) node).getSimple());
           }
         }
         convertFrom(bb, firstOperand, fieldNameList);
         return;
 
       case WITH_ITEM:
         convertFrom(bb, ((SqlWithItem) from).query);
         return;
 
       case WITH:
         convertFrom(bb, ((SqlWith) from).body);
         return;
 
       case TABLESAMPLE:
         operands = ((SqlBasicCall) from).getOperands();
         SqlSampleSpec sampleSpec = SqlLiteral.sampleValue(operands[1]);
         if (sampleSpec instanceof SqlSampleSpec.SqlSubstitutionSampleSpec) {
           String sampleName =
                   ((SqlSampleSpec.SqlSubstitutionSampleSpec) sampleSpec).getName();
           datasetStack.push(sampleName);
           convertFrom(bb, operands[0]);
           datasetStack.pop();
         } else if (sampleSpec instanceof SqlSampleSpec.SqlTableSampleSpec) {
           SqlSampleSpec.SqlTableSampleSpec tableSampleSpec =
                   (SqlSampleSpec.SqlTableSampleSpec) sampleSpec;
           convertFrom(bb, operands[0]);
           RelOptSamplingParameters params =
                   new RelOptSamplingParameters(tableSampleSpec.isBernoulli(),
                           tableSampleSpec.getSamplePercentage(),
                           tableSampleSpec.isRepeatable(),
                           tableSampleSpec.getRepeatableSeed());
           bb.setRoot(new Sample(cluster, bb.root, params), false);
         } else {
           throw new AssertionError("unknown TABLESAMPLE type: " + sampleSpec);
         }
         return;
 
       case TABLE_REF:
         call = (SqlCall) from;
         convertIdentifier(bb, call.operand(0), null, call.operand(1));
         return;
 
       case IDENTIFIER:
         convertIdentifier(bb, (SqlIdentifier) from, null, null);
         return;
 
       case EXTEND:
         call = (SqlCall) from;
         final SqlNode operand0 = call.getOperandList().get(0);
         final SqlIdentifier id = operand0.getKind() == SqlKind.TABLE_REF
                 ? ((SqlCall) operand0).operand(0)
                 : (SqlIdentifier) operand0;
         SqlNodeList extendedColumns = (SqlNodeList) call.getOperandList().get(1);
         convertIdentifier(bb, id, extendedColumns, null);
         return;
 
       case SNAPSHOT:
         convertTemporalTable(bb, (SqlCall) from);
         return;
 
       case JOIN:
         final SqlJoin join = (SqlJoin) from;
         final SqlValidatorScope scope = validator.getJoinScope(from);
         final Blackboard fromBlackboard = createBlackboard(scope, null, false);
         SqlNode left = join.getLeft();
         SqlNode right = join.getRight();
         final boolean isNatural = join.isNatural();
         final JoinType joinType = join.getJoinType();
         final SqlValidatorScope leftScope = Util.first(
                 validator.getJoinScope(left), ((DelegatingScope) bb.scope).getParent());
         final Blackboard leftBlackboard = createBlackboard(leftScope, null, false);
         final SqlValidatorScope rightScope = Util.first(
                 validator.getJoinScope(right), ((DelegatingScope) bb.scope).getParent());
         final Blackboard rightBlackboard = createBlackboard(rightScope, null, false);
         convertFrom(leftBlackboard, left);
         RelNode leftRel = leftBlackboard.root;
         convertFrom(rightBlackboard, right);
         RelNode rightRel = rightBlackboard.root;
         JoinRelType convertedJoinType = convertJoinType(joinType);
         RexNode conditionExp;
         final SqlValidatorNamespace leftNamespace = validator.getNamespace(left);
         final SqlValidatorNamespace rightNamespace = validator.getNamespace(right);
         if (isNatural) {
           final RelDataType leftRowType = leftNamespace.getRowType();
           final RelDataType rightRowType = rightNamespace.getRowType();
           final List<String> columnList = SqlValidatorUtil.deriveNaturalJoinColumnList(
                   catalogReader.nameMatcher(), leftRowType, rightRowType);
           conditionExp = convertUsing(leftNamespace, rightNamespace, columnList);
         } else {
           conditionExp = convertJoinCondition(fromBlackboard,
                   leftNamespace,
                   rightNamespace,
                   join.getCondition(),
                   join.getConditionType(),
                   leftRel,
                   rightRel);
         }
 
         final RelNode joinRel = createJoin(
                 fromBlackboard, leftRel, rightRel, conditionExp, convertedJoinType);
         bb.setRoot(joinRel, false);
         return;
 
       case SELECT:
       case INTERSECT:
       case EXCEPT:
       case UNION:
         final RelNode rel = convertQueryRecursive(from, false, null).project();
         bb.setRoot(rel, true);
         return;
 
       case VALUES:
         convertValuesImpl(bb, (SqlCall) from, null);
         if (fieldNames.size() > 0) {
           bb.setRoot(relBuilder.push(bb.root).rename(fieldNames).build(), true);
         }
         return;
 
       case UNNEST:
         convertUnnest(bb, (SqlCall) from, fieldNames);
         return;
 
       case COLLECTION_TABLE:
         call = (SqlCall) from;
 
         // Dig out real call; TABLE() wrapper is just syntactic.
         assert call.getOperandList().size() == 1;
         final SqlCall call2 = call.operand(0);
         convertCollectionTable(bb, call2);
         return;
 
       default:
         throw new AssertionError("not a join operator " + from);
     }
   }

Here is the call graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier	(	Blackboard	bb,
		SqlIdentifier	id,
		SqlNodeList	extendedColumns,
		SqlNodeList	tableHints
	)

inlineprivate

Definition at line 2315 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.cluster, org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), org.apache.calcite.sql2rel.SqlToRelConverter.datasetStack, org.apache.calcite.sql2rel.SqlToRelConverter.hintStrategies, org.apache.calcite.sql2rel.SqlToRelConverter.toRel(), and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                   {
     final SqlValidatorNamespace fromNamespace = validator.getNamespace(id).resolve();
     if (fromNamespace.getNode() != null) {
       convertFrom(bb, fromNamespace.getNode());
       return;
     }
     final String datasetName = datasetStack.isEmpty() ? null : datasetStack.peek();
     final boolean[] usedDataset = {false};
     RelOptTable table = SqlValidatorUtil.getRelOptTable(
             fromNamespace, catalogReader, datasetName, usedDataset);
     if (extendedColumns != null && extendedColumns.size() > 0) {
       assert table != null;
       final SqlValidatorTable validatorTable = table.unwrap(SqlValidatorTable.class);
       final List<RelDataTypeField> extendedFields = SqlValidatorUtil.getExtendedColumns(
               validator, validatorTable, extendedColumns);
       table = table.extend(extendedFields);
     }
     final RelNode tableRel;
     // Review Danny 2020-01-13: hacky to construct a new table scan
     // in order to apply the hint strategies.
     final List<RelHint> hints =
             hintStrategies.apply(SqlUtil.getRelHint(hintStrategies, tableHints),
                     LogicalTableScan.create(cluster, table, ImmutableList.of()));
     tableRel = toRel(table, hints);
     bb.setRoot(tableRel, true);
     if (usedDataset[0]) {
       bb.setDataset(datasetName);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier	(	Blackboard	bb,
		SqlIdentifier	identifier
	)

inlineprivate

Converts an identifier into an expression in a given scope. For example, the "empno" in "select empno from emp join dept" becomes "emp.empno".

Definition at line 3771 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.adjustInputRef(), org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.isPatternVarRef, setup.name, and org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.scope.

                                                                              {
     // first check for reserved identifiers like CURRENT_USER
     final SqlCall call = bb.getValidator().makeNullaryCall(identifier);
     if (call != null) {
       return bb.convertExpression(call);
     }
 
     String pv = null;
     if (bb.isPatternVarRef && identifier.names.size() > 1) {
       pv = identifier.names.get(0);
     }
 
     final SqlQualified qualified;
     if (bb.scope != null) {
       qualified = bb.scope.fullyQualify(identifier);
     } else {
       qualified = SqlQualified.create(null, 1, null, identifier);
     }
     final Pair<RexNode, Map<String, Integer>> e0 = bb.lookupExp(qualified);
     RexNode e = e0.left;
     for (String name : qualified.suffix()) {
       if (e == e0.left && e0.right != null) {
         int i = e0.right.get(name);
         e = rexBuilder.makeFieldAccess(e, i);
       } else {
         final boolean caseSensitive = true; // name already fully-qualified
         if (identifier.isStar() && bb.scope instanceof MatchRecognizeScope) {
           e = rexBuilder.makeFieldAccess(e, 0);
         } else {
           e = rexBuilder.makeFieldAccess(e, name, caseSensitive);
         }
       }
     }
     if (e instanceof RexInputRef) {
       // adjust the type to account for nulls introduced by outer joins
       e = adjustInputRef(bb, (RexInputRef) e);
       if (pv != null) {
         e = RexPatternFieldRef.of(pv, (RexInputRef) e);
       }
     }
 
     if (e0.left instanceof RexCorrelVariable) {
       assert e instanceof RexFieldAccess;
       final RexNode prev = bb.mapCorrelateToRex.put(
               ((RexCorrelVariable) e0.left).id, (RexFieldAccess) e);
       assert prev == null;
     }
     return e;
   }

Here is the call graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertInsert ( SqlInsert call )

inlineprotected

Definition at line 3296 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList(), org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive(), org.apache.calcite.sql2rel.SqlToRelConverter.createModify(), and org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertMerge(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive().

                                                   {
     RelOptTable targetTable = getTargetTable(call);
 
     final RelDataType targetRowType = validator.getValidatedNodeType(call);
     assert targetRowType != null;
     RelNode sourceRel =
             convertQueryRecursive(call.getSource(), true, targetRowType).project();
     RelNode massagedRel = convertColumnList(call, sourceRel);
 
     return createModify(targetTable, massagedRel);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertInToOr	(	final Blackboard	bb,
		final List< RexNode >	leftKeys,
		SqlNodeList	valuesList,
		SqlInOperator	op
	)

inlineprivate

Converts "x IN (1, 2, ...)" to "x=1 OR x=2 OR ...".

Parameters

leftKeys	LHS
valuesList	RHS
op	The operator (IN, NOT IN, > SOME, ...)

Returns: converted expression

Definition at line 1440 of file SqlToRelConverter.java.

References QueryRunner.ALL, org.apache.calcite.sql2rel.SqlToRelConverter.ensureSqlType(), and org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                             {
     final List<RexNode> comparisons = new ArrayList<>();
     for (SqlNode rightVals : valuesList) {
       RexNode rexComparison;
       final SqlOperator comparisonOp;
       if (op instanceof SqlQuantifyOperator) {
         comparisonOp = RelOptUtil.op(
                 ((SqlQuantifyOperator) op).comparisonKind, SqlStdOperatorTable.EQUALS);
       } else {
         comparisonOp = SqlStdOperatorTable.EQUALS;
       }
       if (leftKeys.size() == 1) {
         rexComparison = rexBuilder.makeCall(comparisonOp,
                 leftKeys.get(0),
                 ensureSqlType(
                         leftKeys.get(0).getType(), bb.convertExpression(rightVals)));
       } else {
         assert rightVals instanceof SqlCall;
         final SqlBasicCall call = (SqlBasicCall) rightVals;
         assert (call.getOperator() instanceof SqlRowOperator)
                 && call.operandCount() == leftKeys.size();
         rexComparison = RexUtil.composeConjunction(rexBuilder,
                 Iterables.transform(Pair.zip(leftKeys, call.getOperandList()),
                         pair
                         -> rexBuilder.makeCall(comparisonOp,
                                 pair.left,
                                 ensureSqlType(pair.left.getType(),
                                         bb.convertExpression(pair.right)))));
       }
       comparisons.add(rexComparison);
     }
 
     switch (op.kind) {
       case ALL:
         return RexUtil.composeConjunction(rexBuilder, comparisons, true);
       case NOT_IN:
         return rexBuilder.makeCall(SqlStdOperatorTable.NOT,
                 RexUtil.composeDisjunction(rexBuilder, comparisons, true));
       case IN:
       case SOME:
         return RexUtil.composeDisjunction(rexBuilder, comparisons, true);
       default:
         throw new AssertionError();
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertJoinCondition	(	Blackboard	bb,
		SqlValidatorNamespace	leftNamespace,
		SqlValidatorNamespace	rightNamespace,
		SqlNode	condition,
		JoinConditionType	conditionType,
		RelNode	leftRel,
		RelNode	rightRel
	)

inlineprivate

Definition at line 2680 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertUsing(), setup.name, and org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                             {
     if (condition == null) {
       return rexBuilder.makeLiteral(true);
     }
     bb.setRoot(ImmutableList.of(leftRel, rightRel));
     replaceSubQueries(bb, condition, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
     switch (conditionType) {
       case ON:
         bb.setRoot(ImmutableList.of(leftRel, rightRel));
         return bb.convertExpression(condition);
       case USING:
         final SqlNodeList list = (SqlNodeList) condition;
         final List<String> nameList = new ArrayList<>();
         for (SqlNode columnName : list) {
           final SqlIdentifier id = (SqlIdentifier) columnName;
           String name = id.getSimple();
           nameList.add(name);
         }
         return convertUsing(leftNamespace, rightNamespace, nameList);
       default:
         throw Util.unexpected(conditionType);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static JoinRelType org.apache.calcite.sql2rel.SqlToRelConverter.convertJoinType ( JoinType joinType )

inlinestaticprivate

Definition at line 2740 of file SqlToRelConverter.java.

References INNER, and LEFT.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                                                 {
     switch (joinType) {
       case COMMA:
       case INNER:
       case CROSS:
         return JoinRelType.INNER;
       case FULL:
         return JoinRelType.FULL;
       case LEFT:
         return JoinRelType.LEFT;
       case RIGHT:
         return JoinRelType.RIGHT;
       default:
         throw Util.unexpected(joinType);
     }
   }

Here is the caller graph for this function:

RexLiteral org.apache.calcite.sql2rel.SqlToRelConverter.convertLiteralInValuesList	(	SqlNode	sqlNode,
		Blackboard	bb,
		RelDataType	rowType,
		int	iField
	)

inlineprivate

Definition at line 1638 of file SqlToRelConverter.java.

References field(), and run_benchmark_import.type.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertRowValues().

                                                                            {
     if (!(sqlNode instanceof SqlLiteral)) {
       return null;
     }
     RelDataTypeField field = rowType.getFieldList().get(iField);
     RelDataType type = field.getType();
     if (type.isStruct()) {
       // null literals for weird stuff like UDT's need
       // special handling during type flattening, so
       // don't use LogicalValues for those
       return null;
     }
 
     RexNode literalExpr = exprConverter.convertLiteral(bb, (SqlLiteral) sqlNode);
 
     if (!(literalExpr instanceof RexLiteral)) {
       assert literalExpr.isA(SqlKind.CAST);
       RexNode child = ((RexCall) literalExpr).getOperands().get(0);
       assert RexLiteral.isNullLiteral(child);
 
       // NOTE jvs 22-Nov-2006: we preserve type info
       // in LogicalValues digest, so it's OK to lose it here
       return (RexLiteral) child;
     }
 
     RexLiteral literal = (RexLiteral) literalExpr;
 
     Comparable value = literal.getValue();
 
     if (SqlTypeUtil.isExactNumeric(type) && SqlTypeUtil.hasScale(type)) {
       BigDecimal roundedValue =
               NumberUtil.rescaleBigDecimal((BigDecimal) value, type.getScale());
       return rexBuilder.makeExactLiteral(roundedValue, type);
     }
 
     if ((value instanceof NlsString) && (type.getSqlTypeName() == SqlTypeName.CHAR)) {
       // pad fixed character type
       NlsString unpadded = (NlsString) value;
       return rexBuilder.makeCharLiteral(
               new NlsString(Spaces.padRight(unpadded.getValue(), type.getPrecision()),
                       unpadded.getCharsetName(),
                       unpadded.getCollation()));
     }
     return literal;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertMatchRecognize	(	Blackboard	bb,
		SqlCall	call
	)

inlineprotected

Definition at line 2147 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(), org.apache.calcite.sql2rel.SqlToRelConverter.desc(), org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries(), and setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                                                     {
     final SqlMatchRecognize matchRecognize = (SqlMatchRecognize) call;
     final SqlValidatorNamespace ns = validator.getNamespace(matchRecognize);
     final SqlValidatorScope scope = validator.getMatchRecognizeScope(matchRecognize);
 
     final Blackboard matchBb = createBlackboard(scope, null, false);
     final RelDataType rowType = ns.getRowType();
     // convert inner query, could be a table name or a derived table
     SqlNode expr = matchRecognize.getTableRef();
     convertFrom(matchBb, expr);
     final RelNode input = matchBb.root;
 
     // PARTITION BY
     final SqlNodeList partitionList = matchRecognize.getPartitionList();
     final ImmutableBitSet.Builder partitionKeys = ImmutableBitSet.builder();
     for (SqlNode partition : partitionList) {
       RexNode e = matchBb.convertExpression(partition);
       partitionKeys.set(((RexInputRef) e).getIndex());
     }
 
     // ORDER BY
     final SqlNodeList orderList = matchRecognize.getOrderList();
     final List<RelFieldCollation> orderKeys = new ArrayList<>();
     for (SqlNode order : orderList) {
       final RelFieldCollation.Direction direction;
       switch (order.getKind()) {
         case DESCENDING:
           direction = RelFieldCollation.Direction.DESCENDING;
           order = ((SqlCall) order).operand(0);
           break;
         case NULLS_FIRST:
         case NULLS_LAST:
           throw new AssertionError();
         default:
           direction = RelFieldCollation.Direction.ASCENDING;
           break;
       }
       final RelFieldCollation.NullDirection nullDirection =
               validator.config().defaultNullCollation().last(desc(direction))
               ? RelFieldCollation.NullDirection.LAST
               : RelFieldCollation.NullDirection.FIRST;
       RexNode e = matchBb.convertExpression(order);
       orderKeys.add(new RelFieldCollation(
               ((RexInputRef) e).getIndex(), direction, nullDirection));
     }
     final RelCollation orders = cluster.traitSet().canonize(RelCollations.of(orderKeys));
 
     // convert pattern
     final Set<String> patternVarsSet = new HashSet<>();
     SqlNode pattern = matchRecognize.getPattern();
     final SqlBasicVisitor<RexNode> patternVarVisitor = new SqlBasicVisitor<RexNode>() {
       @Override
       public RexNode visit(SqlCall call) {
         List<SqlNode> operands = call.getOperandList();
         List<RexNode> newOperands = new ArrayList<>();
         for (SqlNode node : operands) {
           newOperands.add(node.accept(this));
         }
         return rexBuilder.makeCall(
                 validator.getUnknownType(), call.getOperator(), newOperands);
       }
 
       @Override
       public RexNode visit(SqlIdentifier id) {
         assert id.isSimple();
         patternVarsSet.add(id.getSimple());
         return rexBuilder.makeLiteral(id.getSimple());
       }
 
       @Override
       public RexNode visit(SqlLiteral literal) {
         if (literal instanceof SqlNumericLiteral) {
           return rexBuilder.makeExactLiteral(BigDecimal.valueOf(literal.intValue(true)));
         } else {
           return rexBuilder.makeLiteral(literal.booleanValue());
         }
       }
     };
     final RexNode patternNode = pattern.accept(patternVarVisitor);
 
     SqlLiteral interval = matchRecognize.getInterval();
     RexNode intervalNode = null;
     if (interval != null) {
       intervalNode = matchBb.convertLiteral(interval);
     }
 
     // convert subset
     final SqlNodeList subsets = matchRecognize.getSubsetList();
     final Map<String, TreeSet<String>> subsetMap = new HashMap<>();
     for (SqlNode node : subsets) {
       List<SqlNode> operands = ((SqlCall) node).getOperandList();
       SqlIdentifier left = (SqlIdentifier) operands.get(0);
       patternVarsSet.add(left.getSimple());
       SqlNodeList rights = (SqlNodeList) operands.get(1);
       final TreeSet<String> list = new TreeSet<>();
       for (SqlNode right : rights) {
         assert right instanceof SqlIdentifier;
         list.add(((SqlIdentifier) right).getSimple());
       }
       subsetMap.put(left.getSimple(), list);
     }
 
     SqlNode afterMatch = matchRecognize.getAfter();
     if (afterMatch == null) {
       afterMatch =
               SqlMatchRecognize.AfterOption.SKIP_TO_NEXT_ROW.symbol(SqlParserPos.ZERO);
     }
 
     final RexNode after;
     if (afterMatch instanceof SqlCall) {
       List<SqlNode> operands = ((SqlCall) afterMatch).getOperandList();
       SqlOperator operator = ((SqlCall) afterMatch).getOperator();
       assert operands.size() == 1;
       SqlIdentifier id = (SqlIdentifier) operands.get(0);
       assert patternVarsSet.contains(id.getSimple())
           : id.getSimple()
               + " not defined in pattern";
       RexNode rex = rexBuilder.makeLiteral(id.getSimple());
       after = rexBuilder.makeCall(
               validator.getUnknownType(), operator, ImmutableList.of(rex));
     } else {
       after = matchBb.convertExpression(afterMatch);
     }
 
     matchBb.setPatternVarRef(true);
 
     // convert measures
     final ImmutableMap.Builder<String, RexNode> measureNodes = ImmutableMap.builder();
     for (SqlNode measure : matchRecognize.getMeasureList()) {
       List<SqlNode> operands = ((SqlCall) measure).getOperandList();
       String alias = ((SqlIdentifier) operands.get(1)).getSimple();
       RexNode rex = matchBb.convertExpression(operands.get(0));
       measureNodes.put(alias, rex);
     }
 
     // convert definitions
     final ImmutableMap.Builder<String, RexNode> definitionNodes = ImmutableMap.builder();
     for (SqlNode def : matchRecognize.getPatternDefList()) {
       replaceSubQueries(matchBb, def, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
       List<SqlNode> operands = ((SqlCall) def).getOperandList();
       String alias = ((SqlIdentifier) operands.get(1)).getSimple();
       RexNode rex = matchBb.convertExpression(operands.get(0));
       definitionNodes.put(alias, rex);
     }
 
     final SqlLiteral rowsPerMatch = matchRecognize.getRowsPerMatch();
     final boolean allRows = rowsPerMatch != null
             && rowsPerMatch.getValue() == SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS;
 
     matchBb.setPatternVarRef(false);
 
     final RelFactories.MatchFactory factory = RelFactories.DEFAULT_MATCH_FACTORY;
     final RelNode rel = factory.createMatch(input,
             patternNode,
             rowType,
             matchRecognize.getStrictStart().booleanValue(),
             matchRecognize.getStrictEnd().booleanValue(),
             definitionNodes.build(),
             measureNodes.build(),
             after,
             subsetMap,
             allRows,
             partitionKeys.build(),
             orders,
             intervalNode);
     bb.setRoot(rel, false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertMerge ( SqlMerge call )

inlineprivate

Definition at line 3687 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.convertInsert(), org.apache.calcite.sql2rel.SqlToRelConverter.convertSelect(), field(), org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable(), join(), and org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive().

                                               {
     RelOptTable targetTable = getTargetTable(call);
 
     // convert update column list from SqlIdentifier to String
     final List<String> targetColumnNameList = new ArrayList<>();
     final RelDataType targetRowType = targetTable.getRowType();
     SqlUpdate updateCall = call.getUpdateCall();
     if (updateCall != null) {
       for (SqlNode targetColumn : updateCall.getTargetColumnList()) {
         SqlIdentifier id = (SqlIdentifier) targetColumn;
         RelDataTypeField field = SqlValidatorUtil.getTargetField(
                 targetRowType, typeFactory, id, catalogReader, targetTable);
         assert field != null : "column " + id.toString() + " not found";
         targetColumnNameList.add(field.getName());
       }
     }
 
     // replace the projection of the source select with a
     // projection that contains the following:
     // 1) the expressions corresponding to the new insert row (if there is
     // an insert)
     // 2) all columns from the target table (if there is an update)
     // 3) the set expressions in the update call (if there is an update)
 
     // first, convert the merge's source select to construct the columns
     // from the target table and the set expressions in the update call
     RelNode mergeSourceRel = convertSelect(call.getSourceSelect(), false);
 
     // then, convert the insert statement so we can get the insert
     // values expressions
     SqlInsert insertCall = call.getInsertCall();
     int nLevel1Exprs = 0;
     List<RexNode> level1InsertExprs = null;
     List<RexNode> level2InsertExprs = null;
     if (insertCall != null) {
       RelNode insertRel = convertInsert(insertCall);
 
       // if there are 2 level of projections in the insert source, combine
       // them into a single project; level1 refers to the topmost project;
       // the level1 projection contains references to the level2
       // expressions, except in the case where no target expression was
       // provided, in which case, the expression is the default value for
       // the column; or if the expressions directly map to the source
       // table
       level1InsertExprs = ((LogicalProject) insertRel.getInput(0)).getProjects();
       if (insertRel.getInput(0).getInput(0) instanceof LogicalProject) {
         level2InsertExprs =
                 ((LogicalProject) insertRel.getInput(0).getInput(0)).getProjects();
       }
       nLevel1Exprs = level1InsertExprs.size();
     }
 
     LogicalJoin join = (LogicalJoin) mergeSourceRel.getInput(0);
     int nSourceFields = join.getLeft().getRowType().getFieldCount();
     final List<RexNode> projects = new ArrayList<>();
     for (int level1Idx = 0; level1Idx < nLevel1Exprs; level1Idx++) {
       if ((level2InsertExprs != null)
               && (level1InsertExprs.get(level1Idx) instanceof RexInputRef)) {
         int level2Idx = ((RexInputRef) level1InsertExprs.get(level1Idx)).getIndex();
         projects.add(level2InsertExprs.get(level2Idx));
       } else {
         projects.add(level1InsertExprs.get(level1Idx));
       }
     }
     if (updateCall != null) {
       final LogicalProject project = (LogicalProject) mergeSourceRel;
       projects.addAll(Util.skip(project.getProjects(), nSourceFields));
     }
 
     relBuilder.push(join).project(projects);
 
     return LogicalTableModify.create(targetTable,
             catalogReader,
             relBuilder.build(),
             LogicalTableModify.Operation.MERGE,
             targetColumnNameList,
             null,
             false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertMultisets	(	final List< SqlNode >	operands,
		Blackboard	bb
	)

inlineprivate

Definition at line 3862 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.cluster, org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery(), org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryOrInList(), org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(), setup.root, org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.scope, and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertRowConstructor(), and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                                 {
     // NOTE: Wael 2/04/05: this implementation is not the most efficient in
     // terms of planning since it generates XOs that can be reduced.
     final List<Object> joinList = new ArrayList<>();
     List<SqlNode> lastList = new ArrayList<>();
     for (int i = 0; i < operands.size(); i++) {
       SqlNode operand = operands.get(i);
       if (!(operand instanceof SqlCall)) {
         lastList.add(operand);
         continue;
       }
 
       final SqlCall call = (SqlCall) operand;
       final RelNode input;
       switch (call.getKind()) {
         case MULTISET_VALUE_CONSTRUCTOR:
         case ARRAY_VALUE_CONSTRUCTOR:
           final SqlNodeList list =
                   new SqlNodeList(call.getOperandList(), call.getParserPosition());
           CollectNamespace nss = (CollectNamespace) validator.getNamespace(call);
           Blackboard usedBb;
           if (null != nss) {
             usedBb = createBlackboard(nss.getScope(), null, false);
           } else {
             usedBb = createBlackboard(new ListScope(bb.scope) {
               public SqlNode getNode() {
                 return call;
               }
             }, null, false);
           }
           RelDataType multisetType = validator.getValidatedNodeType(call);
           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;
         default:
           lastList.add(operand);
           continue;
       }
 
       if (lastList.size() > 0) {
         joinList.add(lastList);
       }
       lastList = new ArrayList<>();
       Collect collect = new Collect(cluster,
               cluster.traitSetOf(Convention.NONE),
               input,
               validator.deriveAlias(call, i));
       joinList.add(collect);
     }
 
     if (joinList.size() == 0) {
       joinList.add(lastList);
     }
 
     for (int i = 0; i < joinList.size(); i++) {
       Object o = joinList.get(i);
       if (o instanceof List) {
         @SuppressWarnings("unchecked")
         List<SqlNode> projectList = (List<SqlNode>) o;
         final List<RexNode> selectList = new ArrayList<>();
         final List<String> fieldNameList = new ArrayList<>();
         for (int j = 0; j < projectList.size(); j++) {
           SqlNode operand = projectList.get(j);
           selectList.add(bb.convertExpression(operand));
 
           // REVIEW angel 5-June-2005: Use deriveAliasFromOrdinal
           // instead of deriveAlias to match field names from
           // SqlRowOperator. Otherwise, get error Type
           // 'RecordType(INTEGER EMPNO)' has no field 'EXPR$0' when
           // doing select * from unnest( select multiset[empno]
           // from sales.emps);
 
           fieldNameList.add(SqlUtil.deriveAliasFromOrdinal(j));
         }
 
         relBuilder.push(LogicalValues.createOneRow(cluster))
                 .projectNamed(selectList, fieldNameList, true);
 
         joinList.set(i, relBuilder.build());
       }
     }
 
     RelNode ret = (RelNode) joinList.get(0);
     for (int i = 1; i < joinList.size(); i++) {
       RelNode relNode = (RelNode) joinList.get(i);
       ret = RelFactories.DEFAULT_JOIN_FACTORY.createJoin(ret,
               relNode,
               ImmutableList.of(),
               rexBuilder.makeLiteral(true),
               ImmutableSet.of(),
               JoinRelType.INNER,
               false);
     }
     return ret;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql2rel.SqlToRelConverter.convertNonCorrelatedSubQuery	(	SubQuery	subQuery,
		Blackboard	bb,
		RelNode	converted,
		boolean	isExists
	)

inlineprivate

Determines if a sub-query is non-correlated and if so, converts it to a constant.

Parameters

subQuery	the call that references the sub-query
bb	blackboard used to convert the sub-query
converted	RelNode tree corresponding to the sub-query
isExists	true if the sub-query is part of an EXISTS expression

Returns: Whether the sub-query can be converted to a constant

Definition at line 1362 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.isSubQueryNonCorrelated(), and org.apache.calcite.sql2rel.SqlToRelConverter.subQueryConverter.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                                  {
     SqlCall call = (SqlBasicCall) subQuery.node;
     if (subQueryConverter.canConvertSubQuery()
             && isSubQueryNonCorrelated(converted, bb)) {
       // First check if the sub-query has already been converted
       // because it's a nested sub-query. If so, don't re-evaluate
       // it again.
       RexNode constExpr = mapConvertedNonCorrSubqs.get(call);
       if (constExpr == null) {
         constExpr = subQueryConverter.convertSubQuery(
                 call, this, isExists, config.isExplain());
       }
       if (constExpr != null) {
         subQuery.expr = constExpr;
         mapConvertedNonCorrSubqs.put(call, constExpr);
         return true;
       }
     }
     return false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertOrder	(	SqlSelect	select,
		Blackboard	bb,
		RelCollation	collation,
		List< SqlNode >	orderExprList,
		SqlNode	offset,
		SqlNode	fetch
	)

inlineprotected

Converts a query's ORDER BY clause, if any.

Ignores the ORDER BY clause if the query is not top-level and FETCH or OFFSET are not present.

Parameters

select	Query
bb	Blackboard
collation	Collation list
orderExprList	Method populates this list with orderBy expressions not present in selectList
offset	Expression for number of rows to discard before returning first row
fetch	Expression for number of rows to fetch

Definition at line 804 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertExpression(), setup.root, and org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.top.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl().

                          {
     if (!bb.top || select.getOrderList() == null
             || select.getOrderList().getList().isEmpty()) {
       assert !bb.top || collation.getFieldCollations().isEmpty();
       if ((offset == null
                   || (offset instanceof SqlLiteral
                           && ((SqlLiteral) offset)
                                      .bigDecimalValue()
                                      .equals(BigDecimal.ZERO)))
               && fetch == null) {
         return;
       }
     }
 
     // Create a sorter using the previously constructed collations.
     bb.setRoot(LogicalSort.create(bb.root,
                        collation,
                        offset == null ? null : convertExpression(offset),
                        fetch == null ? null : convertExpression(fetch)),
             false);
 
     // If extra expressions were added to the project list for sorting,
     // add another project to remove them. But make the collation empty, because
     // we can't represent the real collation.
     //
     // If it is the top node, use the real collation, but don't trim fields.
     if (orderExprList.size() > 0 && !bb.top) {
       final List<RexNode> exprs = new ArrayList<>();
       final RelDataType rowType = bb.root.getRowType();
       final int fieldCount = rowType.getFieldCount() - orderExprList.size();
       for (int i = 0; i < fieldCount; i++) {
         exprs.add(rexBuilder.makeInputRef(bb.root, i));
       }
       bb.setRoot(LogicalProject.create(bb.root,
                          ImmutableList.of(),
                          exprs,
                          rowType.getFieldNames().subList(0, fieldCount)),
               false);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelFieldCollation org.apache.calcite.sql2rel.SqlToRelConverter.convertOrderItem	(	SqlSelect	select,
		SqlNode	orderItem,
		List< SqlNode >	extraExprs,
		RelFieldCollation.Direction	direction,
		RelFieldCollation.NullDirection	nullDirection
	)

inlineprotected

Definition at line 3139 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.desc().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.gatherOrderExprs().

                                                          {
     assert select != null;
     // Handle DESC keyword, e.g. 'select a, b from t order by a desc'.
     switch (orderItem.getKind()) {
       case DESCENDING:
         return convertOrderItem(select,
                 ((SqlCall) orderItem).operand(0),
                 extraExprs,
                 RelFieldCollation.Direction.DESCENDING,
                 nullDirection);
       case NULLS_FIRST:
         return convertOrderItem(select,
                 ((SqlCall) orderItem).operand(0),
                 extraExprs,
                 direction,
                 RelFieldCollation.NullDirection.FIRST);
       case NULLS_LAST:
         return convertOrderItem(select,
                 ((SqlCall) orderItem).operand(0),
                 extraExprs,
                 direction,
                 RelFieldCollation.NullDirection.LAST);
     }
 
     SqlNode converted = validator.expandOrderExpr(select, orderItem);
 
     switch (nullDirection) {
       case UNSPECIFIED:
         nullDirection = validator.config().defaultNullCollation().last(desc(direction))
                 ? RelFieldCollation.NullDirection.LAST
                 : RelFieldCollation.NullDirection.FIRST;
     }
 
     // Scan the select list and order exprs for an identical expression.
     final SelectScope selectScope = validator.getRawSelectScope(select);
     int ordinal = -1;
     for (SqlNode selectItem : selectScope.getExpandedSelectList()) {
       ++ordinal;
       if (converted.equalsDeep(stripAs(selectItem), Litmus.IGNORE)) {
         return new RelFieldCollation(ordinal, direction, nullDirection);
       }
     }
 
     for (SqlNode extraExpr : extraExprs) {
       ++ordinal;
       if (converted.equalsDeep(extraExpr, Litmus.IGNORE)) {
         return new RelFieldCollation(ordinal, direction, nullDirection);
       }
     }
 
     // TODO: handle collation sequence
     // TODO: flag expressions as non-standard
 
     extraExprs.add(converted);
     return new RelFieldCollation(ordinal + 1, direction, nullDirection);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertOver	(	Blackboard	bb,
		SqlNode	node
	)

inlineprivate

Definition at line 1847 of file SqlToRelConverter.java.

References report.rows.

                                                            {
     SqlCall call = (SqlCall) node;
     SqlCall aggCall = call.operand(0);
     boolean ignoreNulls = false;
     switch (aggCall.getKind()) {
       case IGNORE_NULLS:
         ignoreNulls = true;
         // fall through
       case RESPECT_NULLS:
         aggCall = aggCall.operand(0);
     }
 
     SqlNode windowOrRef = call.operand(1);
     final SqlWindow window = validator.resolveWindow(windowOrRef, bb.scope);
 
     SqlNode sqlLowerBound = window.getLowerBound();
     SqlNode sqlUpperBound = window.getUpperBound();
     boolean rows = window.isRows();
     SqlNodeList orderList = window.getOrderList();
 
     if (!aggCall.getOperator().allowsFraming()) {
       // If the operator does not allow framing, bracketing is implicitly
       // everything up to the current row.
       sqlLowerBound = SqlWindow.createUnboundedPreceding(SqlParserPos.ZERO);
       sqlUpperBound = SqlWindow.createCurrentRow(SqlParserPos.ZERO);
       if (aggCall.getKind() == SqlKind.ROW_NUMBER) {
         // ROW_NUMBER() expects specific kind of framing.
         rows = true;
       }
     } else if (orderList.size() == 0) {
       // Without ORDER BY, there must be no bracketing.
       sqlLowerBound = SqlWindow.createUnboundedPreceding(SqlParserPos.ZERO);
       sqlUpperBound = SqlWindow.createUnboundedFollowing(SqlParserPos.ZERO);
     } else if (sqlLowerBound == null && sqlUpperBound == null) {
       sqlLowerBound = SqlWindow.createUnboundedPreceding(SqlParserPos.ZERO);
       sqlUpperBound = SqlWindow.createCurrentRow(SqlParserPos.ZERO);
     } else if (sqlUpperBound == null) {
       sqlUpperBound = SqlWindow.createCurrentRow(SqlParserPos.ZERO);
     } else if (sqlLowerBound == null) {
       sqlLowerBound = SqlWindow.createCurrentRow(SqlParserPos.ZERO);
     }
     final SqlNodeList partitionList = window.getPartitionList();
     final ImmutableList.Builder<RexNode> partitionKeys = ImmutableList.builder();
     for (SqlNode partition : partitionList) {
       partitionKeys.add(bb.convertExpression(partition));
     }
     final RexNode lowerBound = bb.convertExpression(sqlLowerBound);
     final RexNode upperBound = bb.convertExpression(sqlUpperBound);
     if (orderList.size() == 0 && !rows) {
       // A logical range requires an ORDER BY clause. Use the implicit
       // ordering of this relation. There must be one, otherwise it would
       // have failed validation.
       orderList = bb.scope.getOrderList();
       if (orderList == null) {
         throw new AssertionError("Relation should have sort key for implicit ORDER BY");
       }
     }
 
     final ImmutableList.Builder<RexFieldCollation> orderKeys = ImmutableList.builder();
     for (SqlNode order : orderList) {
       orderKeys.add(bb.convertSortExpression(order,
               RelFieldCollation.Direction.ASCENDING,
               RelFieldCollation.NullDirection.UNSPECIFIED));
     }
 
     try {
       Preconditions.checkArgument(bb.window == null, "already in window agg mode");
       bb.window = window;
       RexNode rexAgg = exprConverter.convertCall(bb, aggCall);
       rexAgg = rexBuilder.ensureType(validator.getValidatedNodeType(call), rexAgg, false);
 
       // Walk over the tree and apply 'over' to all agg functions. This is
       // necessary because the returned expression is not necessarily a call
       // to an agg function. For example, AVG(x) becomes SUM(x) / COUNT(x).
 
       final SqlLiteral q = aggCall.getFunctionQuantifier();
       final boolean isDistinct = q != null && q.getValue() == SqlSelectKeyword.DISTINCT;
 
       final RexShuttle visitor = new HistogramShuttle(partitionKeys.build(),
               orderKeys.build(),
               RexWindowBounds.create(sqlLowerBound, lowerBound),
               RexWindowBounds.create(sqlUpperBound, upperBound),
               rows,
               window.isAllowPartial(),
               isDistinct,
               ignoreNulls);
       return rexAgg.accept(visitor);
     } finally {
       bb.window = null;
     }
   }

RelRoot org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery	(	SqlNode	query,
		final boolean	needsValidation,
		final boolean	top
	)

inline

Converts an unvalidated query's parse tree into a relational expression.

Parameters

query	Query to convert
needsValidation	Whether to validate the query before converting; `false` if the query has already been validated.
top	Whether the query is top-level, say if its result will become a JDBC result set; `false` if the query will be part of a view.

Definition at line 568 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable(), org.apache.calcite.sql2rel.SqlToRelConverter.convertCursor(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertMultisets().

                                                                            {
     if (needsValidation) {
       query = validator.validate(query);
     }
 
     RelNode result = convertQueryRecursive(query, top, null).rel;
     if (top) {
       if (isStream(query)) {
         result = new LogicalDelta(cluster, result.getTraitSet(), result);
       }
     }
     RelCollation collation = RelCollations.EMPTY;
     if (!query.isA(SqlKind.DML)) {
       if (isOrdered(query)) {
         collation = requiredCollation(result);
       }
     }
     checkConvertedType(query, result);
 
     if (SQL2REL_LOGGER.isDebugEnabled()) {
       SQL2REL_LOGGER.debug(RelOptUtil.dumpPlan("Plan after converting SqlNode to RelNode",
               result,
               SqlExplainFormat.TEXT,
               SqlExplainLevel.EXPPLAN_ATTRIBUTES));
     }
 
     final RelDataType validatedRowType = validator.getValidatedNodeType(query);
     List<RelHint> hints = new ArrayList<>();
     if (query.getKind() == SqlKind.SELECT) {
       final SqlSelect select = (SqlSelect) query;
       if (select.hasHints()) {
         hints = SqlUtil.getRelHint(hintStrategies, select.getHints());
       }
     }
     // propagate the hints.
     result = RelOptUtil.propagateRelHints(result, false);
     return RelRoot.of(result, validatedRowType, query.getKind())
             .withCollation(collation)
             .withHints(hints);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryOrInList	(	Blackboard	bb,
		SqlNode	seek,
		RelDataType	targetRowType
	)

inlineprivate

Definition at line 1548 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertRowValues().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertExists(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMultisets(), and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                   {
     // NOTE: Once we start accepting single-row queries as row constructors,
     // there will be an ambiguity here for a case like X IN ((SELECT Y FROM
     // Z)). The SQL standard resolves the ambiguity by saying that a lone
     // select should be interpreted as a table expression, not a row
     // expression. The semantic difference is that a table expression can
     // return multiple rows.
     if (seek instanceof SqlNodeList) {
       return convertRowValues(
               bb, seek, ((SqlNodeList) seek).getList(), false, targetRowType);
     } else {
       return convertQueryRecursive(seek, false, null).project();
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelRoot org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive	(	SqlNode	query,
		boolean	top,
		RelDataType	targetRowType
	)

inlineprotected

Recursively converts a query to a relational expression.

Parameters

query	Query
top	Whether this query is the top-level query of the statement
targetRowType	Target row type, or null

Returns: Relational expression

Definition at line 3240 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), org.apache.calcite.sql2rel.SqlToRelConverter.convertInsert(), org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery(), org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryOrInList(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertSetOp().

                                                                  {
     final SqlKind kind = query.getKind();
     switch (kind) {
       case SELECT:
         return RelRoot.of(convertSelect((SqlSelect) query, top), kind);
       case INSERT:
         return RelRoot.of(convertInsert((SqlInsert) query), kind);
       case DELETE:
         return RelRoot.of(convertDelete((SqlDelete) query), kind);
       case UPDATE:
         return RelRoot.of(convertUpdate((SqlUpdate) query), kind);
       case MERGE:
         return RelRoot.of(convertMerge((SqlMerge) query), kind);
       case UNION:
       case INTERSECT:
       case EXCEPT:
         return RelRoot.of(convertSetOp((SqlCall) query), kind);
       case WITH:
         return convertWith((SqlWith) query, top);
       case VALUES:
         return RelRoot.of(convertValues((SqlCall) query, targetRowType), kind);
       default:
         throw new AssertionError("not a query: " + query);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertRowConstructor	(	Blackboard	bb,
		SqlCall	rowConstructor
	)

inlineprivate

Converts a row constructor into a relational expression.

Parameters

bb	Blackboard
rowConstructor	Row constructor expression

Returns: Relational expression which returns a single row.

Definition at line 3845 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertMultisets(), and org.apache.calcite.sql2rel.SqlToRelConverter.isRowConstructor().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertRowValues().

                                                                                {
     Preconditions.checkArgument(isRowConstructor(rowConstructor));
     final List<SqlNode> operands = rowConstructor.getOperandList();
     return convertMultisets(operands, bb);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertRowValues	(	Blackboard	bb,
		SqlNode	rowList,
		Collection< SqlNode >	rows,
		boolean	allowLiteralsOnly,
		RelDataType	targetRowType
	)

inlineprivate

Definition at line 1564 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.cluster, org.apache.calcite.sql2rel.SqlToRelConverter.config, org.apache.calcite.sql2rel.SqlToRelConverter.convertLiteralInValuesList(), org.apache.calcite.sql2rel.SqlToRelConverter.convertRowConstructor(), org.apache.calcite.sql2rel.SqlToRelConverter.isRowConstructor(), and org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryOrInList().

                                      {
     // NOTE jvs 30-Apr-2006: We combine all rows consisting entirely of
     // literals into a single LogicalValues; this gives the optimizer a smaller
     // input tree. For everything else (computed expressions, row
     // sub-queries), we union each row in as a projection on top of a
     // LogicalOneRow.
 
     final ImmutableList.Builder<ImmutableList<RexLiteral>> tupleList =
             ImmutableList.builder();
     final RelDataType rowType;
     if (targetRowType != null) {
       rowType = targetRowType;
     } else {
       rowType = SqlTypeUtil.promoteToRowType(
               typeFactory, validator.getValidatedNodeType(rowList), null);
     }
 
     final List<RelNode> unionInputs = new ArrayList<>();
     for (SqlNode node : rows) {
       SqlBasicCall call;
       if (isRowConstructor(node)) {
         call = (SqlBasicCall) node;
         ImmutableList.Builder<RexLiteral> tuple = ImmutableList.builder();
         for (Ord<SqlNode> operand : Ord.zip(call.operands)) {
           RexLiteral rexLiteral =
                   convertLiteralInValuesList(operand.e, bb, rowType, operand.i);
           if ((rexLiteral == null) && allowLiteralsOnly) {
             return null;
           }
           if ((rexLiteral == null) || !config.isCreateValuesRel()) {
             // fallback to convertRowConstructor
             tuple = null;
             break;
           }
           tuple.add(rexLiteral);
         }
         if (tuple != null) {
           tupleList.add(tuple.build());
           continue;
         }
       } else {
         RexLiteral rexLiteral = convertLiteralInValuesList(node, bb, rowType, 0);
         if ((rexLiteral != null) && config.isCreateValuesRel()) {
           tupleList.add(ImmutableList.of(rexLiteral));
           continue;
         } else {
           if ((rexLiteral == null) && allowLiteralsOnly) {
             return null;
           }
         }
 
         // convert "1" to "row(1)"
         call = (SqlBasicCall) SqlStdOperatorTable.ROW.createCall(SqlParserPos.ZERO, node);
       }
       unionInputs.add(convertRowConstructor(bb, call));
     }
     LogicalValues values = LogicalValues.create(cluster, rowType, tupleList.build());
     RelNode resultRel;
     if (unionInputs.isEmpty()) {
       resultRel = values;
     } else {
       if (!values.getTuples().isEmpty()) {
         unionInputs.add(values);
       }
       resultRel = LogicalUnion.create(unionInputs, true);
     }
     leaves.put(resultRel, resultRel.getRowType().getFieldCount());
     return resultRel;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertSelect	(	SqlSelect	select,
		boolean	top
	)

inline

Converts a SELECT statement's parse tree into a relational expression.

Definition at line 645 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl(), org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(), and setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertDelete(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMerge(), org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertUpdate().

                                                               {
     final SqlValidatorScope selectScope = validator.getWhereScope(select);
     final Blackboard bb = createBlackboard(selectScope, null, top);
     convertSelectImpl(bb, select);
     return bb.root;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl	(	final Blackboard	bb,
		SqlSelect	select
	)

inlineprotected

Implementation of convertSelect(SqlSelect, boolean); derived class may override.

Definition at line 664 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertAgg(), org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), org.apache.calcite.sql2rel.SqlToRelConverter.convertOrder(), org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectList(), org.apache.calcite.sql2rel.SqlToRelConverter.convertWhere(), org.apache.calcite.sql2rel.SqlToRelConverter.distinctify(), org.apache.calcite.sql2rel.SqlToRelConverter.gatherOrderExprs(), org.apache.calcite.sql2rel.SqlToRelConverter.hintStrategies, setup.root, and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSelect().

                                                                           {
     convertFrom(bb, select.getFrom());
     convertWhere(bb, select.getWhere());
 
     final List<SqlNode> orderExprList = new ArrayList<>();
     final List<RelFieldCollation> collationList = new ArrayList<>();
     gatherOrderExprs(bb, select, select.getOrderList(), orderExprList, collationList);
     final RelCollation collation =
             cluster.traitSet().canonize(RelCollations.of(collationList));
 
     if (validator.isAggregate(select)) {
       convertAgg(bb, select, orderExprList);
     } else {
       convertSelectList(bb, select, orderExprList);
     }
 
     if (select.isDistinct()) {
       distinctify(bb, true);
     }
 
     convertOrder(
             select, bb, collation, orderExprList, select.getOffset(), select.getFetch());
 
     if (select.hasHints()) {
       final List<RelHint> hints = SqlUtil.getRelHint(hintStrategies, select.getHints());
       // Attach the hints to the first Hintable node we found from the root node.
       bb.setRoot(bb.root.accept(new RelShuttleImpl() {
         boolean attached = false;
 
         @Override
         public RelNode visitChild(RelNode parent, int i, RelNode child) {
           if (parent instanceof Hintable && !attached) {
             attached = true;
             return ((Hintable) parent).attachHints(hints);
           } else {
             return super.visitChild(parent, i, child);
           }
         }
       }),
               true);
     } else {
       bb.setRoot(bb.root, true);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectList	(	Blackboard	bb,
		SqlSelect	select,
		List< SqlNode >	orderList
	)

inlineprivate

Definition at line 3963 of file SqlToRelConverter.java.

References setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl().

                                                                     {
     SqlNodeList selectList = select.getSelectList();
     selectList = validator.expandStar(selectList, select, false);
 
     replaceSubQueries(bb, selectList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
     List<String> fieldNames = new ArrayList<>();
     final List<RexNode> exprs = new ArrayList<>();
     final Collection<String> aliases = new TreeSet<>();
 
     // Project any system fields. (Must be done before regular select items,
     // because offsets may be affected.)
     final List<SqlMonotonicity> columnMonotonicityList = new ArrayList<>();
     extraSelectItems(bb, select, exprs, fieldNames, aliases, columnMonotonicityList);
 
     // Project select clause.
     int i = -1;
     for (SqlNode expr : selectList) {
       ++i;
       exprs.add(bb.convertExpression(expr));
       fieldNames.add(deriveAlias(expr, aliases, i));
     }
 
     // Project extra fields for sorting.
     for (SqlNode expr : orderList) {
       ++i;
       SqlNode expr2 = validator.expandOrderExpr(select, expr);
       exprs.add(bb.convertExpression(expr2));
       fieldNames.add(deriveAlias(expr, aliases, i));
     }
 
     fieldNames = SqlValidatorUtil.uniquify(
             fieldNames, catalogReader.nameMatcher().isCaseSensitive());
 
     relBuilder.push(bb.root).projectNamed(exprs, fieldNames, true);
     bb.setRoot(relBuilder.build(), false);
 
     assert bb.columnMonotonicities.isEmpty();
     bb.columnMonotonicities.addAll(columnMonotonicityList);
     for (SqlNode selectItem : selectList) {
       bb.columnMonotonicities.add(selectItem.getMonotonicity(bb.scope));
     }
   }

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertSetOp ( SqlCall call )

inlineprotected

Converts a set operation (UNION, INTERSECT, MINUS) into relational expressions.

Parameters

call	Call to set operator

Returns: Relational expression

Definition at line 3274 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.all(), org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive(), and UNION.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive().

                                                {
     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());
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertTemporalTable	(	Blackboard	bb,
		SqlCall	call
	)

inlineprivate

Definition at line 2403 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), and setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                                                  {
     final SqlSnapshot snapshot = (SqlSnapshot) call;
     final RexNode period = bb.convertExpression(snapshot.getPeriod());
 
     // convert inner query, could be a table name or a derived table
     SqlNode expr = snapshot.getTableRef();
     convertFrom(bb, expr);
 
     final RelNode snapshotRel = relBuilder.push(bb.root).snapshot(period).build();
 
     bb.setRoot(snapshotRel, false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertToSingleValueSubq	(	SqlNode	query,
		RelNode	plan
	)

inline

Converts the RelNode tree for a select statement to a select that produces a single value.

Parameters

query	the query
plan	the original RelNode tree corresponding to the statement

Returns: the converted RelNode tree

Definition at line 1392 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.cluster.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                        {
     // Check whether query is guaranteed to produce a single value.
     if (query instanceof SqlSelect) {
       SqlSelect select = (SqlSelect) query;
       SqlNodeList selectList = select.getSelectList();
       SqlNodeList groupList = select.getGroup();
 
       if ((selectList.size() == 1) && ((groupList == null) || (groupList.size() == 0))) {
         SqlNode selectExpr = selectList.get(0);
         if (selectExpr instanceof SqlCall) {
           SqlCall selectExprCall = (SqlCall) selectExpr;
           if (Util.isSingleValue(selectExprCall)) {
             return plan;
           }
         }
 
         // If there is a limit with 0 or 1,
         // it is ensured to produce a single value
         if (select.getFetch() != null && select.getFetch() instanceof SqlNumericLiteral) {
           SqlNumericLiteral limitNum = (SqlNumericLiteral) select.getFetch();
           if (((BigDecimal) limitNum.getValue()).intValue() < 2) {
             return plan;
           }
         }
       }
     } else if (query instanceof SqlCall) {
       // If the query is (values ...),
       // it is necessary to look into the operands to determine
       // whether SingleValueAgg is necessary
       SqlCall exprCall = (SqlCall) query;
       if (exprCall.getOperator() instanceof SqlValuesOperator
               && Util.isSingleValue(exprCall)) {
         return plan;
       }
     }
 
     // If not, project SingleValueAgg
     return RelOptUtil.createSingleValueAggRel(cluster, plan);
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertUnnest	(	Blackboard	bb,
		SqlCall	call,
		List< String >	fieldNames
	)

inlineprivate

Definition at line 2117 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.cluster, org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries(), setup.root, org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.root, and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                                                                    {
     final List<SqlNode> nodes = call.getOperandList();
     final SqlUnnestOperator operator = (SqlUnnestOperator) call.getOperator();
     for (SqlNode node : nodes) {
       replaceSubQueries(bb, node, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
     }
     final List<RexNode> exprs = new ArrayList<>();
     for (Ord<SqlNode> node : Ord.zip(nodes)) {
       exprs.add(relBuilder.alias(
               bb.convertExpression(node.e), validator.deriveAlias(node.e, node.i)));
     }
     RelNode child = (null != bb.root) ? bb.root : LogicalValues.createOneRow(cluster);
     RelNode uncollect;
     if (validator.config().sqlConformance().allowAliasUnnestItems()) {
       uncollect = relBuilder.push(child)
                           .project(exprs)
                           .uncollect(fieldNames, operator.withOrdinality)
                           .build();
     } else {
       // REVIEW danny 2020-04-26: should we unify the normal field aliases and the
       // item aliases ?
       uncollect = relBuilder.push(child)
                           .project(exprs)
                           .uncollect(Collections.emptyList(), operator.withOrdinality)
                           .rename(fieldNames)
                           .build();
     }
     bb.setRoot(uncollect, true);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertUpdate ( SqlUpdate call )

inlineprivate

Definition at line 3650 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.convertSelect(), org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard(), field(), org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable(), anonymous_namespace{Utm.h}.n, org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries(), and org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive().

                                                 {
     final SqlValidatorScope scope = validator.getWhereScope(call.getSourceSelect());
     Blackboard bb = createBlackboard(scope, null, false);
 
     replaceSubQueries(bb, call, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
     RelOptTable targetTable = getTargetTable(call);
 
     // convert update column list from SqlIdentifier to String
     final List<String> targetColumnNameList = new ArrayList<>();
     final RelDataType targetRowType = targetTable.getRowType();
     for (SqlNode node : call.getTargetColumnList()) {
       SqlIdentifier id = (SqlIdentifier) node;
       RelDataTypeField field = SqlValidatorUtil.getTargetField(
               targetRowType, typeFactory, id, catalogReader, targetTable);
       assert field != null : "column " + id.toString() + " not found";
       targetColumnNameList.add(field.getName());
     }
 
     RelNode sourceRel = convertSelect(call.getSourceSelect(), false);
 
     bb.setRoot(sourceRel, false);
     Builder<RexNode> rexNodeSourceExpressionListBuilder = ImmutableList.builder();
     for (SqlNode n : call.getSourceExpressionList()) {
       RexNode rn = bb.convertExpression(n);
       rexNodeSourceExpressionListBuilder.add(rn);
     }
 
     return LogicalTableModify.create(targetTable,
             catalogReader,
             sourceRel,
             LogicalTableModify.Operation.UPDATE,
             targetColumnNameList,
             rexNodeSourceExpressionListBuilder.build(),
             false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.convertUsing	(	SqlValidatorNamespace	leftNamespace,
		SqlValidatorNamespace	rightNamespace,
		List< String >	nameList
	)

inlineprivate

Returns an expression for matching columns of a USING clause or inferred from NATURAL JOIN. "a JOIN b USING (x, y)" becomes "a.x = b.x AND a.y = b.y". Returns null if the column list is empty.

Parameters

leftNamespace	Namespace of left input to join
rightNamespace	Namespace of right input to join
nameList	List of column names to join on

Returns: Expression to match columns from name list, or true if name list is empty

Definition at line 2721 of file SqlToRelConverter.java.

References field(), anonymous_namespace{Utm.h}.n, setup.name, and org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertJoinCondition().

                                  {
     final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
     final List<RexNode> list = new ArrayList<>();
     for (String name : nameList) {
       List<RexNode> operands = new ArrayList<>();
       int offset = 0;
       for (SqlValidatorNamespace n : ImmutableList.of(leftNamespace, rightNamespace)) {
         final RelDataType rowType = n.getRowType();
         final RelDataTypeField field = nameMatcher.field(rowType, name);
         operands.add(rexBuilder.makeInputRef(field.getType(), offset + field.getIndex()));
         offset += rowType.getFieldList().size();
       }
       list.add(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, operands));
     }
     return RexUtil.composeConjunction(rexBuilder, list);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.convertValues	(	SqlCall	values,
		RelDataType	targetRowType
	)

inline

Converts a SELECT statement's parse tree into a relational expression.

Definition at line 4054 of file SqlToRelConverter.java.

References setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive().

                                                                           {
     final SqlValidatorScope scope = validator.getOverScope(values);
     assert scope != null;
     final Blackboard bb = createBlackboard(scope, null, false);
     convertValuesImpl(bb, values, targetRowType);
     return bb.root;
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertValuesImpl	(	Blackboard	bb,
		SqlCall	values,
		RelDataType	targetRowType
	)

inlineprivate

Converts a values clause (as in "INSERT INTO T(x,y) VALUES (1,2)") into a relational expression.

Parameters

bb	Blackboard
values	Call to SQL VALUES operator
targetRowType	Target row type

Definition at line 4070 of file SqlToRelConverter.java.

References setup.root, and org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.scope.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                                                     {
     // Attempt direct conversion to LogicalValues; if that fails, deal with
     // fancy stuff like sub-queries below.
     RelNode valuesRel =
             convertRowValues(bb, values, values.getOperandList(), true, targetRowType);
     if (valuesRel != null) {
       bb.setRoot(valuesRel, true);
       return;
     }
 
     final List<RelNode> unionRels = new ArrayList<>();
     for (SqlNode rowConstructor1 : values.getOperandList()) {
       SqlCall rowConstructor = (SqlCall) rowConstructor1;
       Blackboard tmpBb = createBlackboard(bb.scope, null, false);
       replaceSubQueries(tmpBb, rowConstructor, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
       final List<Pair<RexNode, String>> exps = new ArrayList<>();
       for (Ord<SqlNode> operand : Ord.zip(rowConstructor.getOperandList())) {
         exps.add(Pair.of(tmpBb.convertExpression(operand.e),
                 validator.deriveAlias(operand.e, operand.i)));
       }
       RelNode in =
               (null == tmpBb.root) ? LogicalValues.createOneRow(cluster) : tmpBb.root;
       unionRels.add(
               relBuilder.push(in).project(Pair.left(exps), Pair.right(exps)).build());
     }
 
     if (unionRels.size() == 0) {
       throw new AssertionError("empty values clause");
     } else if (unionRels.size() == 1) {
       bb.setRoot(unionRels.get(0), true);
     } else {
       bb.setRoot(LogicalUnion.create(unionRels, true), true);
     }
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.convertWhere	(	final Blackboard	bb,
		final SqlNode	where
	)

inlineprivate

Converts a WHERE clause.

Parameters

bb	Blackboard
where	WHERE clause, may be null

Definition at line 979 of file SqlToRelConverter.java.

References f(), org.apache.calcite.sql2rel.SqlToRelConverter.getCorrelationUse(), org.apache.calcite.sql2rel.SqlToRelConverter.pushDownNotForIn(), org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries(), setup.root, org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.scope, and org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl().

                                                                       {
     if (where == null) {
       return;
     }
     SqlNode newWhere = pushDownNotForIn(bb.scope, where);
     replaceSubQueries(bb, newWhere, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
     final RexNode convertedWhere = bb.convertExpression(newWhere);
     final RexNode convertedWhere2 =
             RexUtil.removeNullabilityCast(typeFactory, convertedWhere);
 
     // only allocate filter if the condition is not TRUE
     if (convertedWhere2.isAlwaysTrue()) {
       return;
     }
 
     final RelFactories.FilterFactory filterFactory = RelFactories.DEFAULT_FILTER_FACTORY;
     final RelNode filter =
             filterFactory.createFilter(bb.root, convertedWhere2, ImmutableSet.of());
     final RelNode r;
     final CorrelationUse p = getCorrelationUse(bb, filter);
     if (p != null) {
       assert p.r instanceof Filter;
       Filter f = (Filter) p.r;
       r = LogicalFilter.create(f.getInput(), f.getCondition(), ImmutableSet.of(p.id));
     } else {
       r = filter;
     }
 
     bb.setRoot(r, false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelRoot org.apache.calcite.sql2rel.SqlToRelConverter.convertWith	(	SqlWith	with,
		boolean	top
	)

inline

Converts a WITH sub-query into a relational expression.

Definition at line 4047 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQueryRecursive().

                                                         {
     return convertQuery(with.body, false, top);
   }

Here is the caller graph for this function:

final void org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl	(	Blackboard	bb,
		final AggConverter	aggConverter,
		SqlNodeList	selectList,
		SqlNodeList	groupList,
		SqlNode	having,
		List< SqlNode >	orderExprList
	)

inlineprotected

Definition at line 2781 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createAggregate(), org.apache.calcite.sql2rel.SqlToRelConverter.pushDownNotForIn(), org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries(), org.apache.calcite.sql2rel.SqlToRelConverter.rewriteAggregateWithGroupId(), setup.root, org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.scope, and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertAgg().

                                        {
     // Find aggregate functions in SELECT and HAVING clause
     final AggregateFinder aggregateFinder = new AggregateFinder();
     selectList.accept(aggregateFinder);
     if (having != null) {
       having.accept(aggregateFinder);
     }
 
     // first replace the sub-queries inside the aggregates
     // because they will provide input rows to the aggregates.
     replaceSubQueries(bb, aggregateFinder.list, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
     // also replace sub-queries inside filters in the aggregates
     replaceSubQueries(
             bb, aggregateFinder.filterList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
     // also replace sub-queries inside ordering spec in the aggregates
     replaceSubQueries(bb, aggregateFinder.orderList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
     // If group-by clause is missing, pretend that it has zero elements.
     if (groupList == null) {
       groupList = SqlNodeList.EMPTY;
     }
 
     replaceSubQueries(bb, groupList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
     // register the group exprs
 
     // build a map to remember the projections from the top scope to the
     // output of the current root.
     //
     // Calcite allows expressions, not just column references in
     // group by list. This is not SQL 2003 compliant, but hey.
 
     final AggregatingSelectScope scope = aggConverter.aggregatingSelectScope;
     final AggregatingSelectScope.Resolved r = scope.resolved.get();
     for (SqlNode groupExpr : r.groupExprList) {
       aggConverter.addGroupExpr(groupExpr);
     }
 
     final RexNode havingExpr;
     final List<Pair<RexNode, String>> projects = new ArrayList<>();
 
     try {
       Preconditions.checkArgument(bb.agg == null, "already in agg mode");
       bb.agg = aggConverter;
 
       // convert the select and having expressions, so that the
       // agg converter knows which aggregations are required
 
       selectList.accept(aggConverter);
       // Assert we don't have dangling items left in the stack
       assert !aggConverter.inOver;
       for (SqlNode expr : orderExprList) {
         expr.accept(aggConverter);
         assert !aggConverter.inOver;
       }
       if (having != null) {
         having.accept(aggConverter);
         assert !aggConverter.inOver;
       }
 
       // compute inputs to the aggregator
       List<Pair<RexNode, String>> preExprs = aggConverter.getPreExprs();
 
       if (preExprs.size() == 0) {
         // Special case for COUNT(*), where we can end up with no inputs
         // at all. The rest of the system doesn't like 0-tuples, so we
         // select a dummy constant here.
         final RexNode zero = rexBuilder.makeExactLiteral(BigDecimal.ZERO);
         preExprs = ImmutableList.of(Pair.of(zero, (String) null));
       }
 
       final RelNode inputRel = bb.root;
 
       // Project the expressions required by agg and having.
       bb.setRoot(relBuilder.push(inputRel)
                          .projectNamed(Pair.left(preExprs), Pair.right(preExprs), false)
                          .build(),
               false);
       bb.mapRootRelToFieldProjection.put(bb.root, r.groupExprProjection);
 
       // REVIEW jvs 31-Oct-2007: doesn't the declaration of
       // monotonicity here assume sort-based aggregation at
       // the physical level?
 
       // Tell bb which of group columns are sorted.
       bb.columnMonotonicities.clear();
       for (SqlNode groupItem : groupList) {
         bb.columnMonotonicities.add(bb.scope.getMonotonicity(groupItem));
       }
 
       final RelNode relNode = aggConverter.containsGroupId()
               ? rewriteAggregateWithGroupId(bb, r, aggConverter)
               : createAggregate(bb, r.groupSet, r.groupSets, aggConverter.getAggCalls());
 
       bb.setRoot(relNode, false);
       bb.mapRootRelToFieldProjection.put(bb.root, r.groupExprProjection);
 
       // Replace sub-queries in having here and modify having to use
       // the replaced expressions
       if (having != null) {
         SqlNode newHaving = pushDownNotForIn(bb.scope, having);
         replaceSubQueries(bb, newHaving, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
         havingExpr = bb.convertExpression(newHaving);
       } else {
         havingExpr = relBuilder.literal(true);
       }
 
       // Now convert the other sub-queries in the select list.
       // This needs to be done separately from the sub-query inside
       // any aggregate in the select list, and after the aggregate rel
       // is allocated.
       replaceSubQueries(bb, selectList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
       // Now sub-queries in the entire select list have been converted.
       // Convert the select expressions to get the final list to be
       // projected.
       int k = 0;
 
       // For select expressions, use the field names previously assigned
       // by the validator. If we derive afresh, we might generate names
       // like "EXPR$2" that don't match the names generated by the
       // validator. This is especially the case when there are system
       // fields; system fields appear in the relnode's rowtype but do not
       // (yet) appear in the validator type.
       final SelectScope selectScope = SqlValidatorUtil.getEnclosingSelectScope(bb.scope);
       assert selectScope != null;
       final SqlValidatorNamespace selectNamespace =
               validator.getNamespace(selectScope.getNode());
       final List<String> names = selectNamespace.getRowType().getFieldNames();
       int sysFieldCount = selectList.size() - names.size();
       for (SqlNode expr : selectList) {
         projects.add(Pair.of(bb.convertExpression(expr),
                 k < sysFieldCount ? validator.deriveAlias(expr, k++)
                                   : names.get(k++ - sysFieldCount)));
       }
 
       for (SqlNode expr : orderExprList) {
         projects.add(
                 Pair.of(bb.convertExpression(expr), validator.deriveAlias(expr, k++)));
       }
     } finally {
       bb.agg = null;
     }
 
     // implement HAVING (we have already checked that it is non-trivial)
     relBuilder.push(bb.root);
     if (havingExpr != null) {
       relBuilder.filter(havingExpr);
     }
 
     // implement the SELECT list
     relBuilder.project(Pair.left(projects), Pair.right(projects))
             .rename(Pair.right(projects));
     bb.setRoot(relBuilder.build(), false);
 
     // Tell bb which of group columns are sorted.
     bb.columnMonotonicities.clear();
     for (SqlNode selectItem : selectList) {
       bb.columnMonotonicities.add(bb.scope.getMonotonicity(selectItem));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createAggregate	(	Blackboard	bb,
		ImmutableBitSet	groupSet,
		ImmutableList< ImmutableBitSet >	groupSets,
		List< AggregateCall >	aggCalls
	)

inlineprotected

Creates an Aggregate.

In case the aggregate rel changes the order in which it projects fields, the groupExprProjection parameter is provided, and the implementation of this method may modify it.

The sortedCount parameter is the number of expressions known to be monotonic. These expressions must be on the leading edge of the grouping keys. The default implementation of this method ignores this parameter.

Parameters

bb	Blackboard
groupSet	Bit set of ordinals of grouping columns
groupSets	Grouping sets
aggCalls	Array of calls to aggregate functions

Returns: LogicalAggregate

Definition at line 3070 of file SqlToRelConverter.java.

References setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl(), org.apache.calcite.sql2rel.SqlToRelConverter.distinctify(), and org.apache.calcite.sql2rel.SqlToRelConverter.rewriteAggregateWithGroupId().

                                         {
     return LogicalAggregate.create(
             bb.root, ImmutableList.of(), groupSet, groupSets, aggCalls);
   }

Here is the caller graph for this function:

Blackboard org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard	(	SqlValidatorScope	scope,
		Map< String, RexNode >	nameToNodeMap,
		boolean	top
	)

inlineprotected

Factory method for creating translation workspace.

Definition at line 655 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertExists(), org.apache.calcite.sql2rel.SqlToRelConverter.convertExpression(), org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMatchRecognize(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMultisets(), org.apache.calcite.sql2rel.SqlToRelConverter.convertSelect(), org.apache.calcite.sql2rel.SqlToRelConverter.convertUpdate(), org.apache.calcite.sql2rel.SqlToRelConverter.createInsertBlackboard(), and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                                     {
     return new Blackboard(scope, nameToNodeMap, top);
   }

Here is the caller graph for this function:

Blackboard org.apache.calcite.sql2rel.SqlToRelConverter.createInsertBlackboard	(	RelOptTable	targetTable,
		RexNode	sourceRef,
		List< String >	targetColumnNames
	)

inlineprivate

Creates a blackboard for translating the expressions of generated columns in an INSERT statement.

Definition at line 3520 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createBlackboard().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.collectInsertTargets(), org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList(), and org.apache.calcite.sql2rel.SqlToRelConverter.toRel().

                                                                                       {
     final Map<String, RexNode> nameToNodeMap = new HashMap<>();
     int j = 0;
 
     // Assign expressions for non-generated columns.
     final List<ColumnStrategy> strategies = targetTable.getColumnStrategies();
     final List<String> targetFields = targetTable.getRowType().getFieldNames();
     for (String targetColumnName : targetColumnNames) {
       final int i = targetFields.indexOf(targetColumnName);
       switch (strategies.get(i)) {
         case STORED:
         case VIRTUAL:
           break;
         default:
           nameToNodeMap.put(targetColumnName, rexBuilder.makeFieldAccess(sourceRef, j++));
       }
     }
     return createBlackboard(null, nameToNodeMap, false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createJoin	(	Blackboard	bb,
		RelNode	leftRel,
		RelNode	rightRel,
		RexNode	joinCond,
		JoinRelType	joinType
	)

inlineprotected

Definition at line 2459 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.getCorrelationUse(), org.apache.calcite.sql2rel.SqlToRelConverter.leaves, and org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertFrom().

                                 {
     assert joinCond != null;
 
     final CorrelationUse p = getCorrelationUse(bb, rightRel);
     if (p != null) {
       RelNode innerRel = p.r;
       ImmutableBitSet requiredCols = p.requiredColumns;
 
       if (!joinCond.isAlwaysTrue()) {
         final RelFactories.FilterFactory factory = RelFactories.DEFAULT_FILTER_FACTORY;
         final RexCorrelVariable rexCorrel =
                 (RexCorrelVariable) rexBuilder.makeCorrel(leftRel.getRowType(), p.id);
         final RexAccessShuttle shuttle = new RexAccessShuttle(rexBuilder, rexCorrel);
 
         // Replace outer RexInputRef with RexFieldAccess,
         // and push lateral join predicate into inner child
         final RexNode newCond = joinCond.accept(shuttle);
         innerRel = factory.createFilter(p.r, newCond, ImmutableSet.of());
         requiredCols =
                 ImmutableBitSet.fromBitSet(shuttle.varCols).union(p.requiredColumns);
       }
 
       return LogicalCorrelate.create(leftRel, innerRel, p.id, requiredCols, joinType);
     }
 
     // MAt 8 Jan 2021 original code
     // final RelNode node = relBuilder.push(leftRel).push(rightRel).join(joinType,
     // joinCond).build();
 
     // MAT 8 Jan 2021 this is HEAVY.AI code
     final Join originalJoin = (Join) RelFactories.DEFAULT_JOIN_FACTORY.createJoin(leftRel,
             rightRel,
             ImmutableList.of(),
             joinCond,
             ImmutableSet.of(),
             joinType,
             false);
     RelNode node = originalJoin;
     // MAT 08 Jan 2021 end of HEAVY.AI Code
 
     // If join conditions are pushed down, update the leaves.
     if (node instanceof Project) {
       final Join newJoin = (Join) node.getInputs().get(0);
       if (leaves.containsKey(leftRel)) {
         leaves.put(newJoin.getLeft(), leaves.get(leftRel));
       }
       if (leaves.containsKey(rightRel)) {
         leaves.put(newJoin.getRight(), leaves.get(rightRel));
       }
     }
     return node;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createModify	(	RelOptTable	targetTable,
		RelNode	source
	)

inlineprivate

Creates a relational expression to modify a table or modifiable view.

Definition at line 3309 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader, org.apache.calcite.sql2rel.SqlToRelConverter.cluster, org.apache.calcite.sql2rel.SqlToRelConverter.createSource(), and org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertInsert().

                                                                         {
     final ModifiableTable modifiableTable = targetTable.unwrap(ModifiableTable.class);
     if (modifiableTable != null && modifiableTable == targetTable.unwrap(Table.class)) {
       return modifiableTable.toModificationRel(cluster,
               targetTable,
               catalogReader,
               source,
               LogicalTableModify.Operation.INSERT,
               null,
               null,
               false);
     }
     final ModifiableView modifiableView = targetTable.unwrap(ModifiableView.class);
     if (modifiableView != null) {
       final Table delegateTable = modifiableView.getTable();
       final RelDataType delegateRowType = delegateTable.getRowType(typeFactory);
       final RelOptTable delegateRelOptTable = RelOptTableImpl.create(
               null, delegateRowType, delegateTable, modifiableView.getTablePath());
       final RelNode newSource =
               createSource(targetTable, source, modifiableView, delegateRowType);
       return createModify(delegateRelOptTable, newSource);
     }
     return LogicalTableModify.create(targetTable,
             catalogReader,
             source,
             LogicalTableModify.Operation.INSERT,
             null,
             null,
             false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.createSource	(	RelOptTable	targetTable,
		RelNode	source,
		ModifiableView	modifiableView,
		RelDataType	delegateRowType
	)

inlineprivate

Wraps a relational expression in the projects and filters implied by a ModifiableView.

The input relational expression is suitable for inserting into the view, and the returned relational expression is suitable for inserting into its delegate table.

In principle, the delegate table of a view might be another modifiable view, and if so, the process can be repeated.

Definition at line 3353 of file SqlToRelConverter.java.

References field(), and org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.createModify().

                                        {
     final ImmutableIntList mapping = modifiableView.getColumnMapping();
     assert mapping.size() == targetTable.getRowType().getFieldCount();
 
     // For columns represented in the mapping, the expression is just a field
     // reference.
     final Map<Integer, RexNode> projectMap = new HashMap<>();
     final List<RexNode> filters = new ArrayList<>();
     for (int i = 0; i < mapping.size(); i++) {
       int target = mapping.get(i);
       if (target >= 0) {
         projectMap.put(target, RexInputRef.of(i, source.getRowType()));
       }
     }
 
     // For columns that are not in the mapping, and have a constraint of the
     // form "column = value", the expression is the literal "value".
     //
     // If a column has multiple constraints, the extra ones will become a
     // filter.
     final RexNode constraint = modifiableView.getConstraint(rexBuilder, delegateRowType);
     RelOptUtil.inferViewPredicates(projectMap, filters, constraint);
     final List<Pair<RexNode, String>> projects = new ArrayList<>();
     for (RelDataTypeField field : delegateRowType.getFieldList()) {
       RexNode node = projectMap.get(field.getIndex());
       if (node == null) {
         node = rexBuilder.makeNullLiteral(field.getType());
       }
       projects.add(Pair.of(
               rexBuilder.ensureType(field.getType(), node, false), field.getName()));
     }
 
     return relBuilder.push(source)
             .projectNamed(Pair.left(projects), Pair.right(projects), false)
             .filter(filters)
             .build();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelOptTable.ToRelContext org.apache.calcite.sql2rel.SqlToRelConverter.createToRelContext ( List< RelHint > hints )

inlineprivate

Definition at line 3394 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.cluster, and org.apache.calcite.sql2rel.SqlToRelConverter.viewExpander.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.flattenTypes(), and org.apache.calcite.sql2rel.SqlToRelConverter.toRel().

                                                                            {
     return ViewExpanders.toRelContext(viewExpander, cluster, hints);
   }

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.decorrelate	(	SqlNode	query,
		RelNode	rootRel
	)

inline

If sub-query is correlated and decorrelation is enabled, performs decorrelation.

Parameters

query	Query
rootRel	Root relational expression

Returns: New root relational expression after decorrelation

Definition at line 492 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.checkConvertedType(), org.apache.calcite.sql2rel.SqlToRelConverter.config, org.apache.calcite.sql2rel.SqlToRelConverter.decorrelateQuery(), and run_benchmark_import.result.

                                                              {
     if (!config.isDecorrelationEnabled()) {
       return rootRel;
     }
     final RelNode result = decorrelateQuery(rootRel);
     if (result != rootRel) {
       checkConvertedType(query, result);
     }
     return result;
   }

Here is the call graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.decorrelateQuery ( RelNode rootRel )

inlineprotected

Definition at line 3217 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.relBuilder.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.decorrelate().

                                                       {
     return RelDecorrelator.decorrelateQuery(rootRel, relBuilder);
   }

Here is the caller graph for this function:

String org.apache.calcite.sql2rel.SqlToRelConverter.deriveAlias	(	final SqlNode	node,
		Collection< String >	aliases,
		final int	ordinal
	)

inlineprivate

Definition at line 4028 of file SqlToRelConverter.java.

                                                                              {
     String alias = validator.deriveAlias(node, ordinal);
     if ((alias == null) || aliases.contains(alias)) {
       String aliasBase = (alias == null) ? "EXPR$" : alias;
       for (int j = 0;; j++) {
         alias = aliasBase + j;
         if (!aliases.contains(alias)) {
           break;
         }
       }
     }
     aliases.add(alias);
     return alias;
   }

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.desc ( RelFieldCollation.Direction direction )

inlinestaticprivate

Definition at line 3200 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertMatchRecognize(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertOrderItem().

                                                                      {
     switch (direction) {
       case DESCENDING:
       case STRICTLY_DESCENDING:
         return true;
       default:
         return false;
     }
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.distinctify	(	Blackboard	bb,
		boolean	checkForDupExprs
	)

inlineprivate

Having translated 'SELECT ... FROM ... [GROUP BY ...] [HAVING ...]', adds a relational expression to make the results unique.

If the SELECT clause contains duplicate expressions, adds org.apache.calcite.rel.logical.LogicalProjects so that we are grouping on the minimal set of keys. The performance gain isn't huge, but it is difficult to detect these duplicate expressions later.

Parameters

bb	Blackboard
checkForDupExprs	Check for duplicate expressions

Definition at line 722 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createAggregate(), field(), and setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl().

                                                                     {
     // Look for duplicate expressions in the project.
     // Say we have 'select x, y, x, z'.
     // Then dups will be {[2, 0]}
     // and oldToNew will be {[0, 0], [1, 1], [2, 0], [3, 2]}
     RelNode rel = bb.root;
     if (checkForDupExprs && (rel instanceof LogicalProject)) {
       LogicalProject project = (LogicalProject) rel;
       final List<RexNode> projectExprs = project.getProjects();
       final List<Integer> origins = new ArrayList<>();
       int dupCount = 0;
       for (int i = 0; i < projectExprs.size(); i++) {
         int x = projectExprs.indexOf(projectExprs.get(i));
         if (x >= 0 && x < i) {
           origins.add(x);
           ++dupCount;
         } else {
           origins.add(i);
         }
       }
       if (dupCount == 0) {
         distinctify(bb, false);
         return;
       }
 
       final Map<Integer, Integer> squished = new HashMap<>();
       final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
       final List<Pair<RexNode, String>> newProjects = new ArrayList<>();
       for (int i = 0; i < fields.size(); i++) {
         if (origins.get(i) == i) {
           squished.put(i, newProjects.size());
           newProjects.add(RexInputRef.of2(i, fields));
         }
       }
       rel = LogicalProject.create(
               rel, ImmutableList.of(), Pair.left(newProjects), Pair.right(newProjects));
       bb.root = rel;
       distinctify(bb, false);
       rel = bb.root;
 
       // Create the expressions to reverse the mapping.
       // Project($0, $1, $0, $2).
       final List<Pair<RexNode, String>> undoProjects = new ArrayList<>();
       for (int i = 0; i < fields.size(); i++) {
         final int origin = origins.get(i);
         RelDataTypeField field = fields.get(i);
         undoProjects.add(Pair.of(
                 new RexInputRef(squished.get(origin), field.getType()), field.getName()));
       }
 
       rel = LogicalProject.create(
               rel, ImmutableList.of(), Pair.left(undoProjects), Pair.right(undoProjects));
       bb.setRoot(rel, false);
 
       return;
     }
 
     // Usual case: all of the expressions in the SELECT clause are
     // different.
     final ImmutableBitSet groupSet =
             ImmutableBitSet.range(rel.getRowType().getFieldCount());
     rel = createAggregate(bb, groupSet, ImmutableList.of(groupSet), ImmutableList.of());
 
     bb.setRoot(rel, false);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql2rel.SqlToRelConverter.enableDecorrelation ( )

inlineprotected

Definition at line 3211 of file SqlToRelConverter.java.

                                           {
     // disable sub-query decorrelation when needed.
     // e.g. if outer joins are not supported.
     return config.isDecorrelationEnabled();
   }

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.ensureSqlType	(	RelDataType	type,
		RexNode	node
	)

inlineprivate

Ensures that an expression has a given SqlTypeName, applying a cast if necessary. If the expression already has the right type family, returns the expression unchanged.

Definition at line 1494 of file SqlToRelConverter.java.

References run_benchmark_import.type.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertInToOr().

                                                                 {
     if (type.getSqlTypeName() == node.getType().getSqlTypeName()
             || (type.getSqlTypeName() == SqlTypeName.VARCHAR
                     && node.getType().getSqlTypeName() == SqlTypeName.CHAR)) {
       return node;
     }
     return rexBuilder.ensureType(type, node, true);
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.extraSelectItems	(	Blackboard	bb,
		SqlSelect	select,
		List< RexNode >	exprList,
		List< String >	nameList,
		Collection< String >	aliasList,
		List< SqlMonotonicity >	columnMonotonicityList
	)

inlineprotected

Adds extra select items. The default implementation adds nothing; derived classes may add columns to exprList, nameList, aliasList and columnMonotonicityList.

Parameters

bb	Blackboard
select	Select statement being translated
exprList	List of expressions in select clause
nameList	List of names, one per column
aliasList	Collection of aliases that have been used already
columnMonotonicityList	List of monotonicity, one per column

Definition at line 4021 of file SqlToRelConverter.java.

4026 {}

void org.apache.calcite.sql2rel.SqlToRelConverter.findSubQueries	(	Blackboard	bb,
		SqlNode	node,
		RelOptUtil.Logic	logic,
		boolean	registerOnlyScalarSubQueries
	)

inlineprivate

Builds a list of all IN or EXISTS operators inside SQL parse tree. Does not traverse inside queries.

Parameters

bb	blackboard
node	the SQL parse tree
logic	Whether the answer needs to be in full 3-valued logic (TRUE, FALSE, UNKNOWN) will be required, or whether we can accept an approximation (say representing UNKNOWN as FALSE)
registerOnlyScalarSubQueries	if set to true and the parse tree corresponds to a variation of a select node, only register it if it's a scalar sub-query

Definition at line 1709 of file SqlToRelConverter.java.

References QueryRunner.ALL, and run_benchmark_import.type.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries().

                                                 {
     final SqlKind kind = node.getKind();
     switch (kind) {
       case EXISTS:
       case SELECT:
       case MULTISET_QUERY_CONSTRUCTOR:
       case MULTISET_VALUE_CONSTRUCTOR:
       case ARRAY_QUERY_CONSTRUCTOR:
       case CURSOR:
       case SCALAR_QUERY:
         if (!registerOnlyScalarSubQueries || (kind == SqlKind.SCALAR_QUERY)) {
           bb.registerSubQuery(node, RelOptUtil.Logic.TRUE_FALSE);
         }
         return;
       case IN:
         break;
       case NOT_IN:
       case NOT:
         logic = logic.negate();
         break;
     }
     if (node instanceof SqlCall) {
       switch (kind) {
         // Do no change logic for AND, IN and NOT IN expressions;
         // but do change logic for OR, NOT and others;
         // EXISTS was handled already.
         case AND:
         case IN:
         case NOT_IN:
           break;
         default:
           logic = RelOptUtil.Logic.TRUE_FALSE_UNKNOWN;
           break;
       }
       for (SqlNode operand : ((SqlCall) node).getOperandList()) {
         if (operand != null) {
           // In the case of an IN expression, locate scalar
           // sub-queries so we can convert them to constants
           findSubQueries(bb,
                   operand,
                   logic,
                   kind == SqlKind.IN || kind == SqlKind.NOT_IN || kind == SqlKind.SOME
                           || kind == SqlKind.ALL || registerOnlyScalarSubQueries);
         }
       }
     } else if (node instanceof SqlNodeList) {
       for (SqlNode child : (SqlNodeList) node) {
         findSubQueries(bb,
                 child,
                 logic,
                 kind == SqlKind.IN || kind == SqlKind.NOT_IN || kind == SqlKind.SOME
                         || kind == SqlKind.ALL || registerOnlyScalarSubQueries);
       }
     }
 
     // Now that we've located any scalar sub-queries inside the IN
     // expression, register the IN expression itself. We need to
     // register the scalar sub-queries first so they can be converted
     // before the IN expression is converted.
     switch (kind) {
       case IN:
       case NOT_IN:
       case SOME:
       case ALL:
         switch (logic) {
           case TRUE_FALSE_UNKNOWN:
             RelDataType type = validator.getValidatedNodeTypeIfKnown(node);
             if (type == null) {
               // The node might not be validated if we still don't know type of the node.
               // Therefore return directly.
               return;
             } else {
               break;
             }
             // fall through
           case UNKNOWN_AS_FALSE:
             logic = RelOptUtil.Logic.TRUE;
         }
         bb.registerSubQuery(node, logic);
         break;
     }
   }

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.flattenTypes	(	RelNode	rootRel,
		boolean	restructure
	)

inline

Definition at line 478 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createToRelContext(), org.apache.calcite.sql2rel.SqlToRelConverter.relBuilder, and org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder.

                                                                     {
     RelStructuredTypeFlattener typeFlattener = new RelStructuredTypeFlattener(
             relBuilder, rexBuilder, createToRelContext(ImmutableList.of()), restructure);
     return typeFlattener.rewrite(rootRel);
   }

Here is the call graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.gatherOrderExprs	(	Blackboard	bb,
		SqlSelect	select,
		SqlNodeList	orderList,
		List< SqlNode >	extraOrderExprs,
		List< RelFieldCollation >	collationList
	)

inlineprotected

Creates a list of collations required to implement the ORDER BY clause, if there is one. Populates extraOrderExprs with any sort expressions which are not in the select clause.

Parameters

bb	Scope within which to resolve identifiers
select	Select clause. Never null, because we invent a dummy SELECT if ORDER BY is applied to a set operation (UNION etc.)
orderList	Order by clause, may be null
extraOrderExprs	Sort expressions which are not in the select clause (output)
collationList	List of collations (output)

Definition at line 3106 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.convertOrderItem(), and org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.top.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl().

                                                  {
     // TODO: add validation rules to SqlValidator also
     assert bb.root != null : "precondition: child != null";
     assert select != null;
     if (orderList == null) {
       return;
     }
 
     if (!bb.top) {
       SqlNode offset = select.getOffset();
       if ((offset == null
                   || (offset instanceof SqlLiteral
                           && ((SqlLiteral) offset)
                                      .bigDecimalValue()
                                      .equals(BigDecimal.ZERO)))
               && select.getFetch() == null) {
         return;
       }
     }
 
     for (SqlNode orderItem : orderList) {
       collationList.add(convertOrderItem(select,
               orderItem,
               extraOrderExprs,
               RelFieldCollation.Direction.ASCENDING,
               RelFieldCollation.NullDirection.UNSPECIFIED));
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelOptCluster org.apache.calcite.sql2rel.SqlToRelConverter.getCluster ( )

inline

Returns the RelOptCluster in use.

Definition at line 354 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.cluster.

                                     {
     return cluster;
   }

Set<RelColumnMapping> org.apache.calcite.sql2rel.SqlToRelConverter.getColumnMappings ( SqlOperator op )

inlineprivate

Definition at line 2416 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable().

                                                                   {
     if (op instanceof ExtTableFunction) {
       ExtTableFunction tf = (ExtTableFunction) op;
       return tf.getColumnMappings();
     }
     SqlReturnTypeInference rti = op.getReturnTypeInference();
     if (rti == null) {
       return null;
     }
     if (rti instanceof TableFunctionReturnTypeInference) {
       TableFunctionReturnTypeInference tfrti = (TableFunctionReturnTypeInference) rti;
       return tfrti.getColumnMappings();
     } else {
       return null;
     }
   }

Here is the caller graph for this function:

CorrelationUse org.apache.calcite.sql2rel.SqlToRelConverter.getCorrelationUse	(	Blackboard	bb,
		final RelNode	r0
	)

inlineprivate

Definition at line 2516 of file SqlToRelConverter.java.

References field(), org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.mapRootRelToFieldProjection, org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder, setup.root, and org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertWhere(), and org.apache.calcite.sql2rel.SqlToRelConverter.createJoin().

                                                                             {
     final Set<CorrelationId> correlatedVariables = RelOptUtil.getVariablesUsed(r0);
     if (correlatedVariables.isEmpty()) {
       return null;
     }
     final ImmutableBitSet.Builder requiredColumns = ImmutableBitSet.builder();
     final List<CorrelationId> correlNames = new ArrayList<>();
 
     // All correlations must refer the same namespace since correlation
     // produces exactly one correlation source.
     // The same source might be referenced by different variables since
     // DeferredLookups are not de-duplicated at create time.
     SqlValidatorNamespace prevNs = null;
 
     for (CorrelationId correlName : correlatedVariables) {
       DeferredLookup lookup = mapCorrelToDeferred.get(correlName);
       RexFieldAccess fieldAccess = lookup.getFieldAccess(correlName);
       String originalRelName = lookup.getOriginalRelName();
       String originalFieldName = fieldAccess.getField().getName();
 
       final SqlNameMatcher nameMatcher =
               bb.getValidator().getCatalogReader().nameMatcher();
       final SqlValidatorScope.ResolvedImpl resolved =
               new SqlValidatorScope.ResolvedImpl();
       lookup.bb.scope.resolve(
               ImmutableList.of(originalRelName), nameMatcher, false, resolved);
       assert resolved.count() == 1;
       final SqlValidatorScope.Resolve resolve = resolved.only();
       final SqlValidatorNamespace foundNs = resolve.namespace;
       final RelDataType rowType = resolve.rowType();
       final int childNamespaceIndex = resolve.path.steps().get(0).i;
       final SqlValidatorScope ancestorScope = resolve.scope;
       boolean correlInCurrentScope = bb.scope.isWithin(ancestorScope);
 
       if (!correlInCurrentScope) {
         continue;
       }
 
       if (prevNs == null) {
         prevNs = foundNs;
       } else {
         assert prevNs
                 == foundNs : "All correlation variables should resolve"
                              + " to the same namespace."
                              + " Prev ns="
                              + prevNs
                              + ", new ns="
                              + foundNs;
       }
 
       int namespaceOffset = 0;
       if (childNamespaceIndex > 0) {
         // If not the first child, need to figure out the width
         // of output types from all the preceding namespaces
         assert ancestorScope instanceof ListScope;
         List<SqlValidatorNamespace> children = ((ListScope) ancestorScope).getChildren();
 
         for (int i = 0; i < childNamespaceIndex; i++) {
           SqlValidatorNamespace child = children.get(i);
           namespaceOffset += child.getRowType().getFieldCount();
         }
       }
 
       RexFieldAccess topLevelFieldAccess = fieldAccess;
       while (topLevelFieldAccess.getReferenceExpr() instanceof RexFieldAccess) {
         topLevelFieldAccess = (RexFieldAccess) topLevelFieldAccess.getReferenceExpr();
       }
       final RelDataTypeField field = rowType.getFieldList().get(
               topLevelFieldAccess.getField().getIndex() - namespaceOffset);
       int pos = namespaceOffset + field.getIndex();
 
       assert field.getType() == topLevelFieldAccess.getField().getType();
 
       assert pos != -1;
 
       if (bb.mapRootRelToFieldProjection.containsKey(bb.root)) {
         // bb.root is an aggregate and only projects group by
         // keys.
         Map<Integer, Integer> exprProjection =
                 bb.mapRootRelToFieldProjection.get(bb.root);
 
         // sub-query can reference group by keys projected from
         // the root of the outer relation.
         if (exprProjection.containsKey(pos)) {
           pos = exprProjection.get(pos);
         } else {
           // correl not grouped
           throw new AssertionError("Identifier '" + originalRelName + "."
                   + originalFieldName + "' is not a group expr");
         }
       }
 
       requiredColumns.set(pos);
       correlNames.add(correlName);
     }
 
     if (correlNames.isEmpty()) {
       // None of the correlating variables originated in this scope.
       return null;
     }
 
     RelNode r = r0;
     if (correlNames.size() > 1) {
       // The same table was referenced more than once.
       // So we deduplicate.
       r = DeduplicateCorrelateVariables.go(
               rexBuilder, correlNames.get(0), Util.skip(correlNames), r0);
       // Add new node to leaves.
       leaves.put(r, r.getRowType().getFieldCount());
     }
     return new CorrelationUse(correlNames.get(0), requiredColumns.build(), r);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

int org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamCount ( )

inline

Returns the number of dynamic parameters encountered during translation; this must only be called after convertQuery.

Returns: number of dynamic parameters

Definition at line 371 of file SqlToRelConverter.java.

                                     {
     return dynamicParamSqlNodes.size();
   }

int org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamCountInExplain ( boolean increment )

inline

Returns the current count of the number of dynamic parameters in an EXPLAIN PLAN statement.

Parameters

increment if true, increment the count

Returns: the current count before the optional increment

Definition at line 396 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.explainParamCount.

                                                               {
     int retVal = explainParamCount;
     if (increment) {
       ++explainParamCount;
     }
     return retVal;
   }

RelDataType org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamType ( int index )

inline

Returns the type inferred for a dynamic parameter.

Parameters

index 0-based index of dynamic parameter

Returns: inferred type, never null

Definition at line 381 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertDynamicParam().

                                                     {
     SqlNode sqlNode = dynamicParamSqlNodes.get(index);
     if (sqlNode == null) {
       throw Util.needToImplement("dynamic param type inference");
     }
     return validator.getValidatedNodeType(sqlNode);
   }

Here is the caller graph for this function:

InitializerExpressionFactory org.apache.calcite.sql2rel.SqlToRelConverter.getInitializerFactory ( SqlValidatorTable validatorTable )

inlineprivate

Definition at line 3541 of file SqlToRelConverter.java.

References f(), and org.apache.calcite.sql2rel.SqlToRelConverter.unwrap().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList().

                                             {
     // We might unwrap a null instead of a InitializerExpressionFactory.
     final Table table = unwrap(validatorTable, Table.class);
     if (table != null) {
       InitializerExpressionFactory f = unwrap(table, InitializerExpressionFactory.class);
       if (f != null) {
         return f;
       }
     }
     return NullInitializerExpressionFactory.INSTANCE;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

int org.apache.calcite.sql2rel.SqlToRelConverter.getInSubqueryThreshold ( )

inlineprotected

Gets the list size threshold under which convertInToOr is used. Lists of this size or greater will instead be converted to use a join against an inline table (org.apache.calcite.rel.logical.LogicalValues) rather than a predicate. A threshold of 0 forces usage of an inline table in all cases; a threshold of Integer.MAX_VALUE forces usage of OR in all cases

Returns: threshold, default DEFAULT_IN_SUB_QUERY_THRESHOLD

Definition at line 1513 of file SqlToRelConverter.java.

                                          {
     return config.getInSubQueryThreshold();
   }

Map<SqlNode, RexNode> org.apache.calcite.sql2rel.SqlToRelConverter.getMapConvertedNonCorrSubqs ( )

inline

Returns the mapping of non-correlated sub-queries that have been converted to the constants that they evaluate to.

Definition at line 408 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.mapConvertedNonCorrSubqs.

                                                              {
     return mapConvertedNonCorrSubqs;
   }

RexBuilder org.apache.calcite.sql2rel.SqlToRelConverter.getRexBuilder ( )

inline

Returns the row-expression builder.

Definition at line 361 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder.

                                     {
     return rexBuilder;
   }

List<RelDataTypeField> org.apache.calcite.sql2rel.SqlToRelConverter.getSystemFields ( )

inlineprotected

Returns a list of fields to be prefixed to each relational expression.

Returns: List of system fields

Definition at line 2676 of file SqlToRelConverter.java.

                                                      {
     return Collections.emptyList();
   }

RelOptTable org.apache.calcite.sql2rel.SqlToRelConverter.getTargetTable ( SqlNode call )

inlineprotected

Definition at line 3437 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.collectInsertTargets(), org.apache.calcite.sql2rel.SqlToRelConverter.convertColumnList(), org.apache.calcite.sql2rel.SqlToRelConverter.convertDelete(), org.apache.calcite.sql2rel.SqlToRelConverter.convertInsert(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMerge(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertUpdate().

                                                      {
     final SqlValidatorNamespace targetNs = validator.getNamespace(call);
     if (targetNs.isWrapperFor(SqlValidatorImpl.DmlNamespace.class)) {
       final SqlValidatorImpl.DmlNamespace dmlNamespace =
               targetNs.unwrap(SqlValidatorImpl.DmlNamespace.class);
       return SqlValidatorUtil.getRelOptTable(dmlNamespace, catalogReader, null, null);
     }
     final SqlValidatorNamespace resolvedNamespace = targetNs.resolve();
     return SqlValidatorUtil.getRelOptTable(resolvedNamespace, catalogReader, null, null);
   }

Here is the caller graph for this function:

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.isOrdered ( SqlNode query )

inlinestatic

Definition at line 615 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery().

                                                  {
     switch (query.getKind()) {
       case SELECT:
         return ((SqlSelect) query).getOrderList() != null
                 && ((SqlSelect) query).getOrderList().size() > 0;
       case WITH:
         return isOrdered(((SqlWith) query).body);
       case ORDER_BY:
         return ((SqlOrderBy) query).orderList.size() > 0;
       default:
         return false;
     }
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql2rel.SqlToRelConverter.isRowConstructor ( SqlNode node )

inlineprivate

Definition at line 1685 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertRowConstructor(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertRowValues().

                                                  {
     if (!(node.getKind() == SqlKind.ROW)) {
       return false;
     }
     SqlCall call = (SqlCall) node;
     return call.getOperator().getName().equalsIgnoreCase("row");
   }

Here is the caller graph for this function:

static boolean org.apache.calcite.sql2rel.SqlToRelConverter.isStream ( SqlNode query )

inlinestaticprivate

Definition at line 610 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery().

                                                  {
     return query instanceof SqlSelect
             && ((SqlSelect) query).isKeywordPresent(SqlSelectKeyword.STREAM);
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql2rel.SqlToRelConverter.isSubQueryNonCorrelated	(	RelNode	subq,
		Blackboard	bb
	)

inlineprivate

Determines whether a sub-query is non-correlated. Note that a non-correlated sub-query can contain correlated references, provided those references do not reference select statements that are parents of the sub-query.

Parameters

subq	the sub-query
bb	blackboard used while converting the sub-query, i.e., the blackboard of the parent query of this sub-query

Returns: true if the sub-query is non-correlated

Definition at line 2639 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertNonCorrelatedSubQuery().

                                                                        {
     Set<CorrelationId> correlatedVariables = RelOptUtil.getVariablesUsed(subq);
     for (CorrelationId correlName : correlatedVariables) {
       DeferredLookup lookup = mapCorrelToDeferred.get(correlName);
       String originalRelName = lookup.getOriginalRelName();
 
       final SqlNameMatcher nameMatcher =
               lookup.bb.scope.getValidator().getCatalogReader().nameMatcher();
       final SqlValidatorScope.ResolvedImpl resolved =
               new SqlValidatorScope.ResolvedImpl();
       lookup.bb.scope.resolve(
               ImmutableList.of(originalRelName), nameMatcher, false, resolved);
 
       SqlValidatorScope ancestorScope = resolved.only().scope;
 
       // If the correlated reference is in a scope that's "above" the
       // sub-query, then this is a correlated sub-query.
       SqlValidatorScope parentScope = bb.scope;
       do {
         if (ancestorScope == parentScope) {
           return false;
         }
         if (parentScope instanceof DelegatingScope) {
           parentScope = ((DelegatingScope) parentScope).getParent();
         } else {
           break;
         }
       } while (parentScope != null);
     }
     return true;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql2rel.SqlToRelConverter.isTrimUnusedFields ( )

inline

Returns whether to trim unused fields as part of the conversion process.

Returns: Whether to trim unused fields

Definition at line 3227 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.trimUnusedFields().

                                       {
     return config.isTrimUnusedFields();
   }

Here is the caller graph for this function:

SqlQuantifyOperator org.apache.calcite.sql2rel.SqlToRelConverter.negate ( SqlQuantifyOperator operator )

inlineprivate

Definition at line 4810 of file SqlToRelConverter.java.

References QueryRunner.ALL.

                                                                    {
     assert operator.kind == SqlKind.ALL;
     return SqlStdOperatorTable.some(operator.comparisonKind.negateNullSafe());
   }

RelFieldTrimmer org.apache.calcite.sql2rel.SqlToRelConverter.newFieldTrimmer ( )

inlineprotected

Creates a RelFieldTrimmer.

Returns: Field trimmer

Definition at line 553 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.relBuilder, and org.apache.calcite.sql2rel.SqlToRelConverter.validator.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.trimUnusedFields().

                                               {
     return new RelFieldTrimmer(validator, relBuilder);
   }

Here is the caller graph for this function:

static SqlNode org.apache.calcite.sql2rel.SqlToRelConverter.pushDownNotForIn	(	SqlValidatorScope	scope,
		SqlNode	sqlNode
	)

inlinestaticprivate

Push down all the NOT logical operators into any IN/NOT IN operators.

Parameters

scope	Scope where sqlNode occurs
sqlNode	the root node from which to look for NOT operators

Returns: the transformed SqlNode representation with NOT pushed down.

Definition at line 880 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.containsInOperator(), and org.apache.calcite.sql2rel.SqlToRelConverter.reg().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertWhere(), and org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl().

                                                                                     {
     if (!(sqlNode instanceof SqlCall) || !containsInOperator(sqlNode)) {
       return sqlNode;
     }
     final SqlCall sqlCall = (SqlCall) sqlNode;
     switch (sqlCall.getKind()) {
       case AND:
       case OR:
         final List<SqlNode> operands = new ArrayList<>();
         for (SqlNode operand : sqlCall.getOperandList()) {
           operands.add(pushDownNotForIn(scope, operand));
         }
         final SqlCall newCall =
                 sqlCall.getOperator().createCall(sqlCall.getParserPosition(), operands);
         return reg(scope, newCall);
 
       case NOT:
         assert sqlCall.operand(0) instanceof SqlCall;
         final SqlCall call = sqlCall.operand(0);
         switch (sqlCall.operand(0).getKind()) {
           case CASE:
             final SqlCase caseNode = (SqlCase) call;
             final SqlNodeList thenOperands = new SqlNodeList(SqlParserPos.ZERO);
 
             for (SqlNode thenOperand : caseNode.getThenOperands()) {
               final SqlCall not =
                       SqlStdOperatorTable.NOT.createCall(SqlParserPos.ZERO, thenOperand);
               thenOperands.add(pushDownNotForIn(scope, reg(scope, not)));
             }
             SqlNode elseOperand = caseNode.getElseOperand();
             if (!SqlUtil.isNull(elseOperand)) {
               // "not(unknown)" is "unknown", so no need to simplify
               final SqlCall not =
                       SqlStdOperatorTable.NOT.createCall(SqlParserPos.ZERO, elseOperand);
               elseOperand = pushDownNotForIn(scope, reg(scope, not));
             }
 
             return reg(scope,
                     SqlStdOperatorTable.CASE.createCall(SqlParserPos.ZERO,
                             caseNode.getValueOperand(),
                             caseNode.getWhenOperands(),
                             thenOperands,
                             elseOperand));
 
           case AND:
             final List<SqlNode> orOperands = new ArrayList<>();
             for (SqlNode operand : call.getOperandList()) {
               orOperands.add(pushDownNotForIn(scope,
                       reg(scope,
                               SqlStdOperatorTable.NOT.createCall(
                                       SqlParserPos.ZERO, operand))));
             }
             return reg(scope,
                     SqlStdOperatorTable.OR.createCall(SqlParserPos.ZERO, orOperands));
 
           case OR:
             final List<SqlNode> andOperands = new ArrayList<>();
             for (SqlNode operand : call.getOperandList()) {
               andOperands.add(pushDownNotForIn(scope,
                       reg(scope,
                               SqlStdOperatorTable.NOT.createCall(
                                       SqlParserPos.ZERO, operand))));
             }
             return reg(scope,
                     SqlStdOperatorTable.AND.createCall(SqlParserPos.ZERO, andOperands));
 
           case NOT:
             assert call.operandCount() == 1;
             return pushDownNotForIn(scope, call.operand(0));
 
           case NOT_IN:
             return reg(scope,
                     SqlStdOperatorTable.IN.createCall(
                             SqlParserPos.ZERO, call.getOperandList()));
 
           case IN:
             return reg(scope,
                     SqlStdOperatorTable.NOT_IN.createCall(
                             SqlParserPos.ZERO, call.getOperandList()));
         }
     }
     return sqlNode;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static SqlNode org.apache.calcite.sql2rel.SqlToRelConverter.reg	(	SqlValidatorScope	scope,
		SqlNode	e
	)

inlinestaticprivate

Registers with the validator a SqlNode that has been created during the Sql-to-Rel process.

Definition at line 968 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.pushDownNotForIn().

                                                                  {
     scope.getValidator().deriveType(scope, e);
     return e;
   }

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries	(	final Blackboard	bb,
		final SqlNode	expr,
		RelOptUtil.Logic	logic
	)

inlineprivate

Definition at line 1010 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.findSubQueries(), org.apache.calcite.sql2rel.SqlToRelConverter.Blackboard.subQueryList, and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable(), org.apache.calcite.sql2rel.SqlToRelConverter.convertJoinCondition(), org.apache.calcite.sql2rel.SqlToRelConverter.convertMatchRecognize(), org.apache.calcite.sql2rel.SqlToRelConverter.convertUnnest(), org.apache.calcite.sql2rel.SqlToRelConverter.convertUpdate(), org.apache.calcite.sql2rel.SqlToRelConverter.convertWhere(), and org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl().

                                                                            {
     findSubQueries(bb, expr, logic, false);
     for (SubQuery node : bb.subQueryList) {
       substituteSubQuery(bb, node);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelCollation org.apache.calcite.sql2rel.SqlToRelConverter.requiredCollation ( RelNode r )

inlineprivate

Definition at line 629 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery().

                                                     {
     if (r instanceof Sort) {
       return ((Sort) r).collation;
     }
     if (r instanceof Project) {
       return requiredCollation(((Project) r).getInput());
     }
     if (r instanceof Delta) {
       return requiredCollation(((Delta) r).getInput());
     }
     throw new AssertionError(r);
   }

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.rewriteAggregateWithGroupId	(	Blackboard	bb,
		AggregatingSelectScope.Resolved	r,
		AggConverter	converter
	)

inlineprivate

The

GROUP_ID()

function is used to distinguish duplicate groups. However, as Aggregate normalizes group sets to canonical form (i.e., flatten, sorting, redundancy removal), this information is lost in RelNode. Therefore, it is impossible to implement the function in runtime.

To fill this gap, an aggregation query that contains

GROUP_ID()

function will generally be rewritten into UNION when converting to RelNode.

Also see the discussion in JIRA [CALCITE-1824] GROUP_ID returns wrong result.

Definition at line 2963 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createAggregate(), and Integer.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.createAggImpl().

                                                                                     {
     final List<AggregateCall> aggregateCalls = converter.getAggCalls();
     final ImmutableBitSet groupSet = r.groupSet;
     final Map<ImmutableBitSet, Integer> groupSetCount = r.groupSetCount;
 
     final List<String> fieldNamesIfNoRewrite =
             createAggregate(bb, groupSet, r.groupSets, aggregateCalls)
                     .getRowType()
                     .getFieldNames();
 
     // If n duplicates exist for a particular grouping, the {@code GROUP_ID()}
     // function produces values in the range 0 to n-1. For each value,
     // we need to figure out the corresponding group sets.
     //
     // For example, "... GROUPING SETS (a, a, b, c, c, c, c)"
     // (i) The max value of the GROUP_ID() function returns is 3
     // (ii) GROUPING SETS (a, b, c) produces value 0,
     // GROUPING SETS (a, c) produces value 1,
     // GROUPING SETS (c) produces value 2
     // GROUPING SETS (c) produces value 3
     final Map<Integer, Set<ImmutableBitSet>> groupIdToGroupSets = new HashMap<>();
     int maxGroupId = 0;
     for (Map.Entry<ImmutableBitSet, Integer> entry : groupSetCount.entrySet()) {
       int groupId = entry.getValue() - 1;
       if (groupId > maxGroupId) {
         maxGroupId = groupId;
       }
       for (int i = 0; i <= groupId; i++) {
         groupIdToGroupSets
                 .computeIfAbsent(i, k -> Sets.newTreeSet(ImmutableBitSet.COMPARATOR))
                 .add(entry.getKey());
       }
     }
 
     // AggregateCall list without GROUP_ID function
     final List<AggregateCall> aggregateCallsWithoutGroupId = new ArrayList<>();
     for (AggregateCall aggregateCall : aggregateCalls) {
       if (aggregateCall.getAggregation().kind != SqlKind.GROUP_ID) {
         aggregateCallsWithoutGroupId.add(aggregateCall);
       }
     }
     final List<RelNode> projects = new ArrayList<>();
     // For each group id value , we first construct an Aggregate without
     // GROUP_ID() function call, and then create a Project node on top of it.
     // The Project adds literal value for group id in right position.
     for (int groupId = 0; groupId <= maxGroupId; groupId++) {
       // Create the Aggregate node without GROUP_ID() call
       final ImmutableList<ImmutableBitSet> groupSets =
               ImmutableList.copyOf(groupIdToGroupSets.get(groupId));
       final RelNode aggregate =
               createAggregate(bb, groupSet, groupSets, aggregateCallsWithoutGroupId);
 
       // RexLiteral for each GROUP_ID, note the type should be BIGINT
       final RelDataType groupIdType = typeFactory.createSqlType(SqlTypeName.BIGINT);
       final RexNode groupIdLiteral =
               rexBuilder.makeExactLiteral(BigDecimal.valueOf(groupId), groupIdType);
 
       relBuilder.push(aggregate);
       final List<RexNode> selectList = new ArrayList<>();
       final int groupExprLength = r.groupExprList.size();
       // Project fields in group by expressions
       for (int i = 0; i < groupExprLength; i++) {
         selectList.add(relBuilder.field(i));
       }
       // Project fields in aggregate calls
       int groupIdCount = 0;
       for (int i = 0; i < aggregateCalls.size(); i++) {
         if (aggregateCalls.get(i).getAggregation().kind == SqlKind.GROUP_ID) {
           selectList.add(groupIdLiteral);
           groupIdCount++;
         } else {
           int ordinal = groupExprLength + i - groupIdCount;
           selectList.add(relBuilder.field(ordinal));
         }
       }
       final RelNode project =
               relBuilder.project(selectList, fieldNamesIfNoRewrite).build();
       projects.add(project);
     }
     // Skip to create Union when there is only one child, i.e., no duplicate group
     // set.
     if (projects.size() == 1) {
       return projects.get(0);
     }
     return LogicalUnion.create(projects, true);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void org.apache.calcite.sql2rel.SqlToRelConverter.setDynamicParamCountInExplain ( int explainParamCount )

inline

Sets the number of dynamic parameters in the current EXPLAIN PLAN statement.

Parameters

explainParamCount number of dynamic parameters in the statement

Definition at line 439 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.explainParamCount.

                                                                    {
     assert config.isExplain();
     this.explainParamCount = explainParamCount;
   }

void org.apache.calcite.sql2rel.SqlToRelConverter.setSubQueryConverter ( SubQueryConverter converter )

inline

Sets a new SubQueryConverter. To have any effect, this must be called before any convert method.

Parameters

converter new SubQueryConverter

Definition at line 430 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.subQueryConverter.

                                                                 {
     subQueryConverter = converter;
   }

void org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery	(	Blackboard	bb,
		SubQuery	subQuery
	)

inlineprivate

Definition at line 1018 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.replaceSubQueries().

                                                                     {
     final RexNode expr = subQuery.expr;
     if (expr != null) {
       // Already done.
       return;
     }
 
     final SqlBasicCall call;
     final RelNode rel;
     final SqlNode query;
     final RelOptUtil.Exists converted;
 
     boolean isExpand = config.getExpandPredicate().test(bb.getTopNode(), subQuery.node);
 
     switch (subQuery.node.getKind()) {
       case CURSOR:
         convertCursor(bb, subQuery);
         return;
 
       case MULTISET_QUERY_CONSTRUCTOR:
       case MULTISET_VALUE_CONSTRUCTOR:
       case ARRAY_QUERY_CONSTRUCTOR:
         rel = convertMultisets(ImmutableList.of(subQuery.node), bb);
         subQuery.expr = bb.register(rel, JoinRelType.INNER);
         return;
 
       case IN:
       case NOT_IN:
       case SOME:
       case ALL:
         call = (SqlBasicCall) subQuery.node;
         query = call.operand(1);
         if (!isExpand && !(query instanceof SqlNodeList)) {
           return;
         }
         final SqlNode leftKeyNode = call.operand(0);
 
         final List<RexNode> leftKeys;
         switch (leftKeyNode.getKind()) {
           case ROW:
             leftKeys = new ArrayList<>();
             for (SqlNode sqlExpr : ((SqlBasicCall) leftKeyNode).getOperandList()) {
               leftKeys.add(bb.convertExpression(sqlExpr));
             }
             break;
           default:
             leftKeys = ImmutableList.of(bb.convertExpression(leftKeyNode));
         }
 
         if (query instanceof SqlNodeList) {
           SqlNodeList valueList = (SqlNodeList) query;
           if (!containsNullLiteral(valueList)
                   && valueList.size() < config.getInSubQueryThreshold()) {
             // We're under the threshold, so convert to OR.
             subQuery.expr = convertInToOr(
                     bb, leftKeys, valueList, (SqlInOperator) call.getOperator());
             return;
           }
 
           // Otherwise, let convertExists translate
           // values list into an inline table for the
           // reference to Q below.
         }
 
         // Project out the search columns from the left side
 
         // Q1:
         // "select from emp where emp.deptno in (select col1 from T)"
         //
         // is converted to
         //
         // "select from
         // emp inner join (select distinct col1 from T)) q
         // on emp.deptno = q.col1
         //
         // Q2:
         // "select from emp where emp.deptno not in (Q)"
         //
         // is converted to
         //
         // "select from
         // emp left outer join (select distinct col1, TRUE from T) q
         // on emp.deptno = q.col1
         // where emp.deptno <> null
         // and q.indicator <> TRUE"
         //
         // Note: Sub-query can be used as SqlUpdate#condition like below:
         //
         // UPDATE emp
         // SET empno = 1 WHERE emp.empno IN (
         // SELECT emp.empno FROM emp WHERE emp.empno = 2)
         //
         // In such case, when converting SqlUpdate#condition, bb.root is null
         // and it makes no sense to do the sub-query substitution.
         if (bb.root == null) {
           return;
         }
         final RelDataType targetRowType = SqlTypeUtil.promoteToRowType(
                 typeFactory, validator.getValidatedNodeType(leftKeyNode), null);
         final boolean notIn = call.getOperator().kind == SqlKind.NOT_IN;
         converted = convertExists(
                 query, RelOptUtil.SubQueryType.IN, subQuery.logic, notIn, targetRowType);
         if (converted.indicator) {
           // Generate
           // emp CROSS JOIN (SELECT COUNT(*) AS c,
           // COUNT(deptno) AS ck FROM dept)
           final RelDataType longType = typeFactory.createSqlType(SqlTypeName.BIGINT);
           final RelNode seek = converted.r.getInput(0); // fragile
           final int keyCount = leftKeys.size();
           final List<Integer> args = ImmutableIntList.range(0, keyCount);
           LogicalAggregate aggregate = LogicalAggregate.create(seek,
                   ImmutableList.of(),
                   ImmutableBitSet.of(),
                   null,
                   ImmutableList.of(AggregateCall.create(SqlStdOperatorTable.COUNT,
                                            false,
                                            false,
                                            false,
                                            ImmutableList.of(),
                                            -1,
                                            RelCollations.EMPTY,
                                            longType,
                                            null),
                           AggregateCall.create(SqlStdOperatorTable.COUNT,
                                   false,
                                   false,
                                   false,
                                   args,
                                   -1,
                                   RelCollations.EMPTY,
                                   longType,
                                   null)));
           LogicalJoin join = LogicalJoin.create(bb.root,
                   aggregate,
                   ImmutableList.of(),
                   rexBuilder.makeLiteral(true),
                   ImmutableSet.of(),
                   JoinRelType.INNER);
           bb.setRoot(join, false);
         }
         final RexNode rex = bb.register(converted.r,
                 converted.outerJoin ? JoinRelType.LEFT : JoinRelType.INNER,
                 leftKeys);
 
         RelOptUtil.Logic logic = subQuery.logic;
         switch (logic) {
           case TRUE_FALSE_UNKNOWN:
           case UNKNOWN_AS_TRUE:
             if (!converted.indicator) {
               logic = RelOptUtil.Logic.TRUE_FALSE;
             }
         }
         subQuery.expr = translateIn(logic, bb.root, rex);
         if (notIn) {
           subQuery.expr = rexBuilder.makeCall(SqlStdOperatorTable.NOT, subQuery.expr);
         }
         return;
 
       case EXISTS:
         // "select from emp where exists (select a from T)"
         //
         // is converted to the following if the sub-query is correlated:
         //
         // "select from emp left outer join (select AGG_TRUE() as indicator
         // from T group by corr_var) q where q.indicator is true"
         //
         // If there is no correlation, the expression is replaced with a
         // boolean indicating whether the sub-query returned 0 or >= 1 row.
         call = (SqlBasicCall) subQuery.node;
         query = call.operand(0);
         if (!isExpand) {
           return;
         }
         final SqlValidatorScope seekScope = (query instanceof SqlSelect)
                 ? validator.getSelectScope((SqlSelect) query)
                 : null;
         final Blackboard seekBb = createBlackboard(seekScope, null, false);
         final RelNode seekRel = convertQueryOrInList(seekBb, query, null);
         // An EXIST sub-query whose inner child has at least 1 tuple
         // (e.g. an Aggregate with no grouping columns or non-empty Values
         // node) should be simplified to a Boolean constant expression.
         final RelMetadataQuery mq = seekRel.getCluster().getMetadataQuery();
         final Double minRowCount = mq.getMinRowCount(seekRel);
         if (minRowCount != null && minRowCount >= 1D) {
           subQuery.expr = rexBuilder.makeLiteral(true);
           return;
         }
         converted = RelOptUtil.createExistsPlan(seekRel,
                 RelOptUtil.SubQueryType.EXISTS,
                 subQuery.logic,
                 true,
                 relBuilder);
         assert !converted.indicator;
         if (convertNonCorrelatedSubQuery(subQuery, bb, converted.r, true)) {
           return;
         }
         subQuery.expr = bb.register(converted.r, JoinRelType.LEFT);
         return;
 
       case SCALAR_QUERY:
         // Convert the sub-query. If it's non-correlated, convert it
         // to a constant expression.
         if (!isExpand) {
           return;
         }
         call = (SqlBasicCall) subQuery.node;
         query = call.operand(0);
         converted = convertExists(
                 query, RelOptUtil.SubQueryType.SCALAR, subQuery.logic, true, null);
         assert !converted.indicator;
         if (convertNonCorrelatedSubQuery(subQuery, bb, converted.r, false)) {
           return;
         }
         rel = convertToSingleValueSubq(query, converted.r);
         subQuery.expr = bb.register(rel, JoinRelType.LEFT);
         return;
 
       case SELECT:
         // This is used when converting multiset queries:
         //
         // select * from unnest(select multiset[deptno] from emps);
         //
         converted = convertExists(subQuery.node,
                 RelOptUtil.SubQueryType.SCALAR,
                 subQuery.logic,
                 true,
                 null);
         assert !converted.indicator;
         subQuery.expr = bb.register(converted.r, JoinRelType.LEFT);
 
         // This is used when converting window table functions:
         //
         // select * from table(tumble(table emps, descriptor(deptno), interval '3' DAY))
         //
         bb.cursors.add(converted.r);
         return;
 
       default:
         throw new AssertionError("unexpected kind of sub-query: " + subQuery.node);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.toRel	(	final RelOptTable	table,
		final List< RelHint >	hints
	)

inline

Definition at line 3398 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.createInsertBlackboard(), org.apache.calcite.sql2rel.SqlToRelConverter.createToRelContext(), and f().

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertCollectionTable(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier().

                                                                            {
     final RelNode scan = table.toRel(createToRelContext(hints));
 
     final InitializerExpressionFactory ief =
             Util.first(table.unwrap(InitializerExpressionFactory.class),
                     NullInitializerExpressionFactory.INSTANCE);
 
     boolean hasVirtualFields = table.getRowType().getFieldList().stream().anyMatch(
             f -> ief.generationStrategy(table, f.getIndex()) == ColumnStrategy.VIRTUAL);
 
     if (hasVirtualFields) {
       final RexNode sourceRef = rexBuilder.makeRangeReference(scan);
       final Blackboard bb = createInsertBlackboard(
               table, sourceRef, table.getRowType().getFieldNames());
       final List<RexNode> list = new ArrayList<>();
       for (RelDataTypeField f : table.getRowType().getFieldList()) {
         final ColumnStrategy strategy = ief.generationStrategy(table, f.getIndex());
         switch (strategy) {
           case VIRTUAL:
             list.add(ief.newColumnDefaultValue(table, f.getIndex(), bb));
             break;
           default:
             list.add(rexBuilder.makeInputRef(
                     scan, RelOptTableImpl.realOrdinal(table, f.getIndex())));
         }
       }
       relBuilder.push(scan);
       relBuilder.project(list);
       final RelNode project = relBuilder.build();
       if (ief.postExpressionConversionHook() != null) {
         return ief.postExpressionConversionHook().apply(bb, project);
       } else {
         return project;
       }
     }
 
     return scan;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.SqlToRelConverter.translateIn	(	RelOptUtil.Logic	logic,
		RelNode	root,
		final RexNode	rex
	)

inlineprivate

Definition at line 1260 of file SqlToRelConverter.java.

References run_benchmark_import.args, join(), org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder, and setup.root.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

                                                                                        {
     switch (logic) {
       case TRUE:
         return rexBuilder.makeLiteral(true);
 
       case TRUE_FALSE:
       case UNKNOWN_AS_FALSE:
         assert rex instanceof RexRangeRef;
         final int fieldCount = rex.getType().getFieldCount();
         RexNode rexNode = rexBuilder.makeFieldAccess(rex, fieldCount - 1);
         rexNode = rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, rexNode);
 
         // Then append the IS NOT NULL(leftKeysForIn).
         //
         // RexRangeRef contains the following fields:
         // leftKeysForIn,
         // rightKeysForIn (the original sub-query select list),
         // nullIndicator
         //
         // The first two lists contain the same number of fields.
         final int k = (fieldCount - 1) / 2;
         for (int i = 0; i < k; i++) {
           rexNode = rexBuilder.makeCall(SqlStdOperatorTable.AND,
                   rexNode,
                   rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL,
                           rexBuilder.makeFieldAccess(rex, i)));
         }
         return rexNode;
 
       case TRUE_FALSE_UNKNOWN:
       case UNKNOWN_AS_TRUE:
         // select e.deptno,
         // case
         // when ct.c = 0 then false
         // when dt.i is not null then true
         // when e.deptno is null then null
         // when ct.ck < ct.c then null
         // else false
         // end
         // from e
         // cross join (select count(*) as c, count(deptno) as ck from v) as ct
         // left join (select distinct deptno, true as i from v) as dt
         // on e.deptno = dt.deptno
         final Join join = (Join) root;
         final Project left = (Project) join.getLeft();
         final RelNode leftLeft = ((Join) left.getInput()).getLeft();
         final int leftLeftCount = leftLeft.getRowType().getFieldCount();
         final RelDataType longType = typeFactory.createSqlType(SqlTypeName.BIGINT);
         final RexNode cRef = rexBuilder.makeInputRef(root, leftLeftCount);
         final RexNode ckRef = rexBuilder.makeInputRef(root, leftLeftCount + 1);
         final RexNode iRef =
                 rexBuilder.makeInputRef(root, root.getRowType().getFieldCount() - 1);
 
         final RexLiteral zero = rexBuilder.makeExactLiteral(BigDecimal.ZERO, longType);
         final RexLiteral trueLiteral = rexBuilder.makeLiteral(true);
         final RexLiteral falseLiteral = rexBuilder.makeLiteral(false);
         final RexNode unknownLiteral = rexBuilder.makeNullLiteral(trueLiteral.getType());
 
         final ImmutableList.Builder<RexNode> args = ImmutableList.builder();
         args.add(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, cRef, zero),
                 falseLiteral,
                 rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, iRef),
                 trueLiteral);
         final JoinInfo joinInfo = join.analyzeCondition();
         for (int leftKey : joinInfo.leftKeys) {
           final RexNode kRef = rexBuilder.makeInputRef(root, leftKey);
           args.add(
                   rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, kRef), unknownLiteral);
         }
         args.add(rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, ckRef, cRef),
                 unknownLiteral,
                 falseLiteral);
 
         return rexBuilder.makeCall(SqlStdOperatorTable.CASE, args.build());
 
       default:
         throw new AssertionError(logic);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

RelNode org.apache.calcite.sql2rel.SqlToRelConverter.trimUnusedFields	(	boolean	ordered,
		RelNode	rootRel
	)

inline

Walks over a tree of relational expressions, replacing each RelNode with a 'slimmed down' relational expression that projects only the fields required by its consumer.

This may make things easier for the optimizer, by removing crud that would expand the search space, but is difficult for the optimizer itself to do it, because optimizer rules must preserve the number and type of fields. Hence, this transform that operates on the entire tree, similar to the type-flattening transform.

Currently this functionality is disabled in farrago/luciddb; the default implementation of this method does nothing.

Parameters

ordered	Whether the relational expression must produce results in a particular order (typically because it has an ORDER BY at top level)
rootRel	Relational expression that is at the root of the tree

Returns: Trimmed relational expression

Definition at line 525 of file SqlToRelConverter.java.

References org.apache.calcite.sql2rel.SqlToRelConverter.isTrimUnusedFields(), org.apache.calcite.sql2rel.SqlToRelConverter.newFieldTrimmer(), and org.apache.calcite.sql2rel.SqlToRelConverter.SQL2REL_LOGGER.

                                                                     {
     // Trim fields that are not used by their consumer.
     if (isTrimUnusedFields()) {
       final RelFieldTrimmer trimmer = newFieldTrimmer();
       final List<RelCollation> collations =
               rootRel.getTraitSet().getTraits(RelCollationTraitDef.INSTANCE);
       rootRel = trimmer.trim(rootRel);
       if (!ordered && collations != null && !collations.isEmpty()
               && !collations.equals(ImmutableList.of(RelCollations.EMPTY))) {
         final RelTraitSet traitSet =
                 rootRel.getTraitSet().replace(RelCollationTraitDef.INSTANCE, collations);
         rootRel = rootRel.copy(traitSet, rootRel.getInputs());
       }
       if (SQL2REL_LOGGER.isDebugEnabled()) {
         SQL2REL_LOGGER.debug(RelOptUtil.dumpPlan("Plan after trimming unused fields",
                 rootRel,
                 SqlExplainFormat.TEXT,
                 SqlExplainLevel.EXPPLAN_ATTRIBUTES));
       }
     }
     return rootRel;
   }

Here is the call graph for this function:

static <T> T org.apache.calcite.sql2rel.SqlToRelConverter.unwrap	(	Object	o,
		Class< T >	clazz
	)

inlinestaticprivate

Definition at line 3554 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.getInitializerFactory().

                                                         {
     if (o instanceof Wrapper) {
       return ((Wrapper) o).unwrap(clazz);
     }
     return null;
   }

Here is the caller graph for this function:

Member Data Documentation

final Prepare.CatalogReader org.apache.calcite.sql2rel.SqlToRelConverter.catalogReader

protected

Definition at line 251 of file SqlToRelConverter.java.

final RelOptCluster org.apache.calcite.sql2rel.SqlToRelConverter.cluster

protected

Definition at line 252 of file SqlToRelConverter.java.

final SqlToRelConverter.Config org.apache.calcite.sql2rel.SqlToRelConverter.config

Definition at line 261 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertRowValues(), org.apache.calcite.sql2rel.SqlToRelConverter.decorrelate(), org.apache.calcite.sql2rel.SqlToRelConverter.SqlToRelConverter(), and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

final Deque<String> org.apache.calcite.sql2rel.SqlToRelConverter.datasetStack = new ArrayDeque<>()

private

Stack of names of datasets requested by the TABLE(SAMPLE(<datasetName>, <query>)) construct.

Definition at line 273 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier().

final int org.apache.calcite.sql2rel.SqlToRelConverter.DEFAULT_IN_SUB_QUERY_THRESHOLD = 20

static

Size of the smallest IN list that will be converted to a semijoin to a static table.

Definition at line 242 of file SqlToRelConverter.java.

final int org.apache.calcite.sql2rel.SqlToRelConverter.DEFAULT_IN_SUBQUERY_THRESHOLD = DEFAULT_IN_SUB_QUERY_THRESHOLD

static

Definition at line 245 of file SqlToRelConverter.java.

final List<SqlDynamicParam> org.apache.calcite.sql2rel.SqlToRelConverter.dynamicParamSqlNodes = new ArrayList<>()

private

Definition at line 255 of file SqlToRelConverter.java.

int org.apache.calcite.sql2rel.SqlToRelConverter.explainParamCount

private

Definition at line 260 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.getDynamicParamCountInExplain(), and org.apache.calcite.sql2rel.SqlToRelConverter.setDynamicParamCountInExplain().

final SqlNodeToRexConverter org.apache.calcite.sql2rel.SqlToRelConverter.exprConverter

private

Definition at line 258 of file SqlToRelConverter.java.

final HintStrategyTable org.apache.calcite.sql2rel.SqlToRelConverter.hintStrategies

private

Definition at line 259 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertIdentifier(), org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery(), and org.apache.calcite.sql2rel.SqlToRelConverter.convertSelectImpl().

final Map<RelNode, Integer> org.apache.calcite.sql2rel.SqlToRelConverter.leaves = new HashMap<>()

protected

Definition at line 254 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.createJoin().

final Map<SqlNode, RexNode> org.apache.calcite.sql2rel.SqlToRelConverter.mapConvertedNonCorrSubqs = new HashMap<>()

private

Mapping of non-correlated sub-queries that have been converted to their equivalent constants. Used to avoid re-evaluating the sub-query if it's already been evaluated.

Definition at line 280 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.getMapConvertedNonCorrSubqs().

final Map<CorrelationId, DeferredLookup> org.apache.calcite.sql2rel.SqlToRelConverter.mapCorrelToDeferred = new HashMap<>()

private

Fields used in name resolution for correlated sub-queries.

Definition at line 267 of file SqlToRelConverter.java.

final SqlOperatorTable org.apache.calcite.sql2rel.SqlToRelConverter.opTab

private

Definition at line 256 of file SqlToRelConverter.java.

final RelBuilder org.apache.calcite.sql2rel.SqlToRelConverter.relBuilder

private

Definition at line 262 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertExists(), org.apache.calcite.sql2rel.SqlToRelConverter.decorrelateQuery(), org.apache.calcite.sql2rel.SqlToRelConverter.flattenTypes(), org.apache.calcite.sql2rel.SqlToRelConverter.newFieldTrimmer(), and org.apache.calcite.sql2rel.SqlToRelConverter.substituteSubQuery().

final RexBuilder org.apache.calcite.sql2rel.SqlToRelConverter.rexBuilder

protected

Definition at line 250 of file SqlToRelConverter.java.

final Logger org.apache.calcite.sql2rel.SqlToRelConverter.SQL2REL_LOGGER = CalciteTrace.getSqlToRelTracer()

staticprotected

Definition at line 236 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertQuery(), and org.apache.calcite.sql2rel.SqlToRelConverter.trimUnusedFields().

SubQueryConverter org.apache.calcite.sql2rel.SqlToRelConverter.subQueryConverter

private

Definition at line 253 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.convertNonCorrelatedSubQuery(), and org.apache.calcite.sql2rel.SqlToRelConverter.setSubQueryConverter().

final RelDataTypeFactory org.apache.calcite.sql2rel.SqlToRelConverter.typeFactory

protected

Definition at line 257 of file SqlToRelConverter.java.

final SqlValidator org.apache.calcite.sql2rel.SqlToRelConverter.validator

protected

Definition at line 249 of file SqlToRelConverter.java.

final RelOptTable.ViewExpander org.apache.calcite.sql2rel.SqlToRelConverter.viewExpander

Definition at line 282 of file SqlToRelConverter.java.

Referenced by org.apache.calcite.sql2rel.SqlToRelConverter.createToRelContext(), and org.apache.calcite.sql2rel.SqlToRelConverter.SqlToRelConverter().

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/java/calcite/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation