Collaboration diagram for org.apache.calcite.sql.SqlOperator:

Public Member Functions
SqlOperandTypeChecker	getOperandTypeChecker ()

SqlOperandCountRange	getOperandCountRange ()

boolean	requiresCreate (List< SqlNode > operands)

String	getName ()

SqlIdentifier	getNameAsId ()

SqlKind	getKind ()

String	toString ()

int	getLeftPrec ()

int	getRightPrec ()

abstract SqlSyntax	getSyntax ()

SqlCall	createCall (SqlLiteral functionQualifier, SqlParserPos pos, SqlNode...operands)

final SqlCall	createCall (SqlParserPos pos, SqlNode...operands)

final SqlCall	createCall (SqlNodeList nodeList)

final SqlCall	createCall (SqlParserPos pos, List<?extends SqlNode > operandList)

SqlNode	rewriteCall (SqlValidator validator, SqlCall call)

void	unparse (SqlWriter writer, SqlCall call, int leftPrec, int rightPrec)

boolean	equals (Object obj)

boolean	isName (String testName, boolean caseSensitive)

int	hashCode ()

void	validateCall (SqlCall call, SqlValidator validator, SqlValidatorScope scope, SqlValidatorScope operandScope)

final RelDataType	validateOperands (SqlValidator validator, SqlValidatorScope scope, SqlCall call)

RelDataType	inferReturnType (SqlOperatorBinding opBinding)

RelDataType	deriveType (SqlValidator validator, SqlValidatorScope scope, SqlCall call)

final RelDataType	inferReturnType (RelDataTypeFactory typeFactory, List< RelDataType > operandTypes)

boolean	checkOperandTypes (SqlCallBinding callBinding, boolean throwOnFailure)

boolean	validRexOperands (int count, Litmus litmus)

String	getSignatureTemplate (final int operandsCount)

final String	getAllowedSignatures ()

String	getAllowedSignatures (String opNameToUse)

SqlOperandTypeInference	getOperandTypeInference ()

boolean	isAggregator ()

boolean	requiresOver ()

boolean	requiresOrder ()

boolean	allowsFraming ()

boolean	isGroup ()

boolean	isGroupAuxiliary ()

SqlReturnTypeInference	getReturnTypeInference ()

Supplier< Strong.Policy >	getStrongPolicyInference ()

SqlMonotonicity	getMonotonicity (SqlCall call, SqlValidatorScope scope)

SqlMonotonicity	getMonotonicity (SqlOperatorBinding call)

boolean	isDeterministic ()

boolean	isSymmetrical ()

boolean	isDynamicFunction ()

boolean	requiresDecimalExpansion ()

boolean	argumentMustBeScalar (int ordinal)

Public Attributes
final SqlKind	kind

Static Public Attributes
static final String	NL = System.getProperty("line.separator")

static final int	MDX_PRECEDENCE = 200

Protected Member Functions
	SqlOperator (String name, SqlKind kind, int leftPrecedence, int rightPrecedence, SqlReturnTypeInference returnTypeInference, SqlOperandTypeInference operandTypeInference, SqlOperandTypeChecker operandTypeChecker)

	SqlOperator (String name, SqlKind kind, int prec, boolean leftAssoc, SqlReturnTypeInference returnTypeInference, SqlOperandTypeInference operandTypeInference, SqlOperandTypeChecker operandTypeChecker)

void	unparseListClause (SqlWriter writer, SqlNode clause)

void	unparseListClause (SqlWriter writer, SqlNode clause, SqlKind sepKind)

void	preValidateCall (SqlValidator validator, SqlValidatorScope scope, SqlCall call)

List< String >	constructArgNameList (SqlCall call)

List< SqlNode >	constructOperandList (SqlValidator validator, SqlCall call, List< String > argNames)

List< RelDataType >	constructArgTypeList (SqlValidator validator, SqlValidatorScope scope, SqlCall call, List< SqlNode > args, boolean convertRowArgToColumnList)

RelDataType	adjustType (SqlValidator validator, final SqlCall call, RelDataType type)

void	checkOperandCount (SqlValidator validator, SqlOperandTypeChecker argType, SqlCall call)

Static Protected Member Functions
static int	leftPrec (int prec, boolean leftAssoc)

static int	rightPrec (int prec, boolean leftAssoc)

Package Functions
boolean	needsSpace ()

public< R > R	acceptCall (SqlVisitor< R > visitor, SqlCall call)

public< R > void	acceptCall (SqlVisitor< R > visitor, SqlCall call, boolean onlyExpressions, SqlBasicVisitor.ArgHandler< R > argHandler)

Private Attributes
final String	name

final int	leftPrec

final int	rightPrec

final SqlReturnTypeInference	returnTypeInference

final SqlOperandTypeInference	operandTypeInference

final SqlOperandTypeChecker	operandTypeChecker

Detailed Description

A SqlOperator is a type of node in a SQL parse tree (it is NOT a node in a SQL parse tree). It includes functions, operators such as '=', and syntactic constructs such as 'case' statements. Operators may represent query-level expressions (e.g. SqlSelectOperator or row-level expressions (e.g. org.apache.calcite.sql.fun.SqlBetweenOperator.

Operators have formal operands, meaning ordered (and optionally named) placeholders for the values they operate on. For example, the division operator takes two operands; the first is the numerator and the second is the denominator. In the context of subclass SqlFunction, formal operands are referred to as parameters.

When an operator is instantiated via a SqlCall, it is supplied with actual operands. For example, in the expression 3 / 5, the literal expression 3 is the actual operand corresponding to the numerator, and 5 is the actual operand corresponding to the denominator. In the context of SqlFunction, actual operands are referred to as arguments

In many cases, the formal/actual distinction is clear from context, in which case we drop these qualifiers.

Definition at line 74 of file SqlOperator.java.

Constructor & Destructor Documentation

org.apache.calcite.sql.SqlOperator.SqlOperator	(	String	name,
		SqlKind	kind,
		int	leftPrecedence,
		int	rightPrecedence,
		SqlReturnTypeInference	returnTypeInference,
		SqlOperandTypeInference	operandTypeInference,
		SqlOperandTypeChecker	operandTypeChecker
	)

inlineprotected

Creates an operator.

Definition at line 125 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.kind, org.apache.calcite.sql.SqlOperator.name, org.apache.calcite.sql.SqlOperator.operandTypeChecker, org.apache.calcite.sql.SqlOperator.operandTypeInference, and org.apache.calcite.sql.SqlOperator.returnTypeInference.

Referenced by org.apache.calcite.sql.SqlOperator.equals().

                                                 {
     assert kind != null;
     this.name = name;
     this.kind = kind;
     this.leftPrec = leftPrecedence;
     this.rightPrec = rightPrecedence;
     this.returnTypeInference = returnTypeInference;
     this.operandTypeInference = operandTypeInference;
     this.operandTypeChecker = operandTypeChecker;
   }

Here is the caller graph for this function:

org.apache.calcite.sql.SqlOperator.SqlOperator	(	String	name,
		SqlKind	kind,
		int	prec,
		boolean	leftAssoc,
		SqlReturnTypeInference	returnTypeInference,
		SqlOperandTypeInference	operandTypeInference,
		SqlOperandTypeChecker	operandTypeChecker
	)

inlineprotected

Creates an operator specifying left/right associativity.

Definition at line 146 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.kind, org.apache.calcite.sql.SqlOperator.leftPrec, org.apache.calcite.sql.SqlOperator.name, org.apache.calcite.sql.SqlOperator.operandTypeChecker, org.apache.calcite.sql.SqlOperator.operandTypeInference, org.apache.calcite.sql.SqlOperator.returnTypeInference, and org.apache.calcite.sql.SqlOperator.rightPrec.

                                                 {
     this(
         name,
         kind,
         leftPrec(prec, leftAssoc),
         rightPrec(prec, leftAssoc),
         returnTypeInference,
         operandTypeInference,
         operandTypeChecker);
   }

Member Function Documentation

public<R> R org.apache.calcite.sql.SqlOperator.acceptCall	(	SqlVisitor< R >	visitor,
		SqlCall	call
	)

inlinepackage

Accepts a SqlVisitor, visiting each operand of a call. Returns null.

Parameters

visitor	Visitor
call	Call to visit

Definition at line 857 of file SqlOperator.java.

                                                                {
     for (SqlNode operand : call.getOperandList()) {
       if (operand == null) {
         continue;
       }
       operand.accept(visitor);
     }
     return null;
   }

public<R> void org.apache.calcite.sql.SqlOperator.acceptCall	(	SqlVisitor< R >	visitor,
		SqlCall	call,
		boolean	onlyExpressions,
		SqlBasicVisitor.ArgHandler< R >	argHandler
	)

inlinepackage

Accepts a SqlVisitor, directing an org.apache.calcite.sql.util.SqlBasicVisitor.ArgHandler to visit an operand of a call.

The argument handler allows fine control about how the operands are visited, and how the results are combined.

Parameters

visitor	Visitor
call	Call to visit
onlyExpressions	If true, ignores operands which are not expressions. For example, in the call to the `AS` operator
argHandler	Called for each operand

Definition at line 882 of file SqlOperator.java.

                                                 {
     List<SqlNode> operands = call.getOperandList();
     for (int i = 0; i < operands.size(); i++) {
       argHandler.visitChild(visitor, call, i, operands.get(i));
     }
   }

RelDataType org.apache.calcite.sql.SqlOperator.adjustType	(	SqlValidator	validator,
		final SqlCall	call,
		RelDataType	type
	)

inlineprotected

Validates and determines coercibility and resulting collation name of binary operator if needed.

Definition at line 638 of file SqlOperator.java.

References run_benchmark_import.type.

Referenced by org.apache.calcite.sql.SqlOperator.deriveType().

                         {
     return type;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.SqlOperator.allowsFraming ( )

inline

Returns whether this is a window function that allows framing (i.e. a ROWS or RANGE clause in the window specification).

Definition at line 820 of file SqlOperator.java.

                                  {
     return true;
   }

boolean org.apache.calcite.sql.SqlOperator.argumentMustBeScalar ( int ordinal )

inline

Returns whether the ordinalth argument to this operator must be scalar (as opposed to a query).

If true (the default), the validator will attempt to convert the argument into a scalar sub-query, which must have one column and return at most one row.

Operators such as SELECT and EXISTS override this method.

Definition at line 986 of file SqlOperator.java.

                                                    {
     return true;
   }

void org.apache.calcite.sql.SqlOperator.checkOperandCount	(	SqlValidator	validator,
		SqlOperandTypeChecker	argType,
		SqlCall	call
	)

inlineprotected

Definition at line 694 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.getName(), and org.apache.calcite.sql.SqlOperator.getOperandCountRange().

Referenced by org.apache.calcite.sql.SqlOperator.validateOperands().

                     {
     SqlOperandCountRange od = call.getOperator().getOperandCountRange();
     if (od.isValidCount(call.operandCount())) {
       return;
     }
     if (od.getMin() == od.getMax()) {
       throw validator.newValidationError(call,
           RESOURCE.invalidArgCount(call.getOperator().getName(), od.getMin()));
     } else {
       throw validator.newValidationError(call, RESOURCE.wrongNumOfArguments());
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.SqlOperator.checkOperandTypes	(	SqlCallBinding	callBinding,
		boolean	throwOnFailure
	)

inline

Checks that the operand values in a SqlCall to this operator are valid. Subclasses must either override this method or supply an instance of SqlOperandTypeChecker to the constructor.

Parameters

callBinding	description of call
throwOnFailure	whether to throw an exception if check fails (otherwise returns false in that case)

Returns: whether check succeeded

Definition at line 669 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.kind, and org.apache.calcite.sql.SqlOperator.operandTypeChecker.

Referenced by org.apache.calcite.sql.SqlOperator.validateOperands().

                               {
     // Check that all of the operands are of the right type.
     if (null == operandTypeChecker) {
       // If you see this you must either give operandTypeChecker a value
       // or override this method.
       throw Util.needToImplement(this);
     }
 
     if (kind != SqlKind.ARGUMENT_ASSIGNMENT) {
       for (Ord<SqlNode> operand : Ord.zip(callBinding.operands())) {
         if (operand.e != null
             && operand.e.getKind() == SqlKind.DEFAULT
             && !operandTypeChecker.isOptional(operand.i)) {
           throw callBinding.newValidationError(RESOURCE.defaultForOptionalParameter());
         }
       }
     }
 
     return operandTypeChecker.checkOperandTypes(
         callBinding,
         throwOnFailure);
   }

Here is the caller graph for this function:

List<String> org.apache.calcite.sql.SqlOperator.constructArgNameList ( SqlCall call )

inlineprotected

Definition at line 550 of file SqlOperator.java.

                                                             {
     // If any arguments are named, construct a map.
     final ImmutableList.Builder<String> nameBuilder = ImmutableList.builder();
     for (SqlNode operand : call.getOperandList()) {
       if (operand.getKind() == SqlKind.ARGUMENT_ASSIGNMENT) {
         final List<SqlNode> operandList = ((SqlCall) operand).getOperandList();
         nameBuilder.add(((SqlIdentifier) operandList.get(1)).getSimple());
       }
     }
     ImmutableList<String> argNames = nameBuilder.build();
 
     if (argNames.isEmpty()) {
       return null;
     } else {
       return argNames;
     }
   }

List<RelDataType> org.apache.calcite.sql.SqlOperator.constructArgTypeList	(	SqlValidator	validator,
		SqlValidatorScope	scope,
		SqlCall	call,
		List< SqlNode >	args,
		boolean	convertRowArgToColumnList
	)

inlineprotected

Definition at line 594 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.deriveType().

                                          {
     // Scope for operands. Usually the same as 'scope'.
     final SqlValidatorScope operandScope = scope.getOperandScope(call);
 
     final ImmutableList.Builder<RelDataType> argTypeBuilder =
             ImmutableList.builder();
     for (SqlNode operand : args) {
       RelDataType nodeType;
       // for row arguments that should be converted to ColumnList
       // types, set the nodeType to a ColumnList type but defer
       // validating the arguments of the row constructor until we know
       // for sure that the row argument maps to a ColumnList type
       if (operand.getKind() == SqlKind.ROW && convertRowArgToColumnList) {
         RelDataTypeFactory typeFactory = validator.getTypeFactory();
         nodeType = typeFactory.createSqlType(SqlTypeName.COLUMN_LIST);
         ((SqlValidatorImpl) validator).setValidatedNodeType(operand, nodeType);
       } else {
         nodeType = validator.deriveType(operandScope, operand);
       }
       argTypeBuilder.add(nodeType);
     }
 
     return argTypeBuilder.build();
   }

Here is the caller graph for this function:

List<SqlNode> org.apache.calcite.sql.SqlOperator.constructOperandList	(	SqlValidator	validator,
		SqlCall	call,
		List< String >	argNames
	)

inlineprotected

Definition at line 568 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.deriveType().

                              {
     if (argNames == null) {
       return call.getOperandList();
     }
     if (argNames.size() < call.getOperandList().size()) {
       throw validator.newValidationError(call,
           RESOURCE.someButNotAllArgumentsAreNamed());
     }
     final int duplicate = Util.firstDuplicate(argNames);
     if (duplicate >= 0) {
       throw validator.newValidationError(call,
           RESOURCE.duplicateArgumentName(argNames.get(duplicate)));
     }
     final ImmutableList.Builder<SqlNode> argBuilder = ImmutableList.builder();
     for (SqlNode operand : call.getOperandList()) {
       if (operand.getKind() == SqlKind.ARGUMENT_ASSIGNMENT) {
         final List<SqlNode> operandList = ((SqlCall) operand).getOperandList();
         argBuilder.add(operandList.get(0));
       }
     }
     return argBuilder.build();
   }

Here is the caller graph for this function:

SqlCall org.apache.calcite.sql.SqlOperator.createCall	(	SqlLiteral	functionQualifier,
		SqlParserPos	pos,
		SqlNode...	operands
	)

inline

Creates a call to this operand with an array of operands.

The position of the resulting call is the union of the pos and the positions of all of the operands.

Parameters

functionQualifier	function qualifier (e.g. "DISTINCT"), may be
pos	parser position of the identifier of the call
operands	array of operands

Definition at line 254 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.createCall().

                            {
     pos = pos.plusAll(Arrays.asList(operands));
     return new SqlBasicCall(this, operands, pos, false, functionQualifier);
   }

Here is the caller graph for this function:

final SqlCall org.apache.calcite.sql.SqlOperator.createCall	(	SqlParserPos	pos,
		SqlNode...	operands
	)

inline

Creates a call to this operand with an array of operands.

The position of the resulting call is the union of the pos and the positions of all of the operands.

Parameters

pos	Parser position
operands	List of arguments

Returns: call to this operator

Definition at line 272 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.createCall().

                            {
     return createCall(null, pos, operands);
   }

Here is the call graph for this function:

final SqlCall org.apache.calcite.sql.SqlOperator.createCall ( SqlNodeList nodeList )

inline

Creates a call to this operand with a list of operands contained in a SqlNodeList.

The position of the resulting call inferred from the SqlNodeList.

Parameters

nodeList List of arguments

Returns: call to this operator

Definition at line 287 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.createCall().

                             {
     return createCall(
         null,
         nodeList.getParserPosition(),
         nodeList.toArray());
   }

Here is the call graph for this function:

final SqlCall org.apache.calcite.sql.SqlOperator.createCall	(	SqlParserPos	pos,
		List<?extends SqlNode >	operandList
	)

inline

Creates a call to this operand with a list of operands.

The position of the resulting call is the union of the pos and the positions of all of the operands.

Definition at line 301 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.createCall().

                                            {
     return createCall(
         null,
         pos,
         operandList.toArray(new SqlNode[0]));
   }

Here is the call graph for this function:

RelDataType org.apache.calcite.sql.SqlOperator.deriveType	(	SqlValidator	validator,
		SqlValidatorScope	scope,
		SqlCall	call
	)

inline

Derives the type of a call to this operator.

This method is an intrinsic part of the validation process so, unlike inferReturnType, specific operators would not typically override this method.

Parameters

validator	Validator
scope	Scope of validation
call	Call to this operator

Returns: Type of call

Definition at line 519 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.adjustType(), run_benchmark_import.args, org.apache.calcite.sql.SqlOperator.constructArgTypeList(), org.apache.calcite.sql.SqlOperator.constructOperandList(), org.apache.calcite.sql.SqlOperator.getKind(), org.apache.calcite.sql.SqlOperator.getNameAsId(), org.apache.calcite.sql.SqlOperator.getSyntax(), run_benchmark_import.type, and org.apache.calcite.sql.SqlOperator.validateOperands().

                     {
     for (SqlNode operand : call.getOperandList()) {
       RelDataType nodeType = validator.deriveType(scope, operand);
       assert nodeType != null;
     }
 
     final List<SqlNode> args = constructOperandList(validator, call, null);
 
     final List<RelDataType> argTypes = constructArgTypeList(validator, scope,
         call, args, false);
 
     // Always disable type coercion for builtin operator operands,
     // they are handled by the TypeCoercion specifically.
     final SqlOperator sqlOperator =
         SqlUtil.lookupRoutine(validator.getOperatorTable(), getNameAsId(),
             argTypes, null, null, getSyntax(), getKind(),
             validator.getCatalogReader().nameMatcher(), false);
 
     ((SqlBasicCall) call).setOperator(sqlOperator);
     RelDataType type = call.getOperator().validateOperands(validator, scope, call);
 
     // Validate and determine coercibility and resulting collation
     // name of binary operator if needed.
     type = adjustType(validator, call, type);
     SqlValidatorUtil.checkCharsetAndCollateConsistentIfCharType(type);
     return type;
   }

Here is the call graph for this function:

boolean org.apache.calcite.sql.SqlOperator.equals ( Object obj )

inline

Definition at line 380 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.kind, setup.name, and org.apache.calcite.sql.SqlOperator.SqlOperator().

                                     {
     if (!(obj instanceof SqlOperator)) {
       return false;
     }
     if (!obj.getClass().equals(this.getClass())) {
       return false;
     }
     SqlOperator other = (SqlOperator) obj;
     return name.equals(other.name) && kind == other.kind;
   }

Here is the call graph for this function:

final String org.apache.calcite.sql.SqlOperator.getAllowedSignatures ( )

inline

Returns a string describing the expected operand types of a call, e.g. "SUBSTR(VARCHAR, INTEGER, INTEGER)".

Definition at line 741 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.name.

                                              {
     return getAllowedSignatures(name);
   }

String org.apache.calcite.sql.SqlOperator.getAllowedSignatures ( String opNameToUse )

inline

Returns a string describing the expected operand types of a call, e.g. "SUBSTRING(VARCHAR, INTEGER, INTEGER)" where the name (SUBSTRING in this example) can be replaced by a specified name.

Definition at line 750 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.operandTypeChecker.

                                                          {
     assert operandTypeChecker != null
         : "If you see this, assign operandTypeChecker a value "
         + "or override this function";
     return operandTypeChecker.getAllowedSignatures(this, opNameToUse)
         .trim();
   }

SqlKind org.apache.calcite.sql.SqlOperator.getKind ( )

inline

Definition at line 223 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.kind.

Referenced by org.apache.calcite.sql.SqlOperator.deriveType().

                            {
     return kind;
   }

Here is the caller graph for this function:

int org.apache.calcite.sql.SqlOperator.getLeftPrec ( )

inline

Definition at line 231 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.leftPrec.

                            {
     return leftPrec;
   }

SqlMonotonicity org.apache.calcite.sql.SqlOperator.getMonotonicity	(	SqlCall	call,
		SqlValidatorScope	scope
	)

inline

Returns whether this operator is monotonic.

Default implementation returns SqlMonotonicity#NOT_MONOTONIC.

Parameters

call	Call to this operator
scope	Scope in which the call occurs

Deprecated:: Use getMonotonicity(SqlOperatorBinding)

Definition at line 921 of file SqlOperator.java.

                                {
     return getMonotonicity(
         new SqlCallBinding(scope.getValidator(), scope, call));
   }

SqlMonotonicity org.apache.calcite.sql.SqlOperator.getMonotonicity ( SqlOperatorBinding call )

inline

Returns whether a call to this operator is monotonic.

Default implementation returns SqlMonotonicity#NOT_MONOTONIC.

Parameters

call	Call to this operator with particular arguments and information about the monotonicity of the arguments

Definition at line 936 of file SqlOperator.java.

                                                                   {
     return SqlMonotonicity.NOT_MONOTONIC;
   }

String org.apache.calcite.sql.SqlOperator.getName ( )

inline

Definition at line 212 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.name.

Referenced by org.apache.calcite.sql.SqlOperator.checkOperandCount(), org.apache.calcite.sql.SqlOperator.getNameAsId(), and org.apache.calcite.sql.validate.SqlValidatorImpl.validateNoAggs().

                           {
     return name;
   }

Here is the caller graph for this function:

SqlIdentifier org.apache.calcite.sql.SqlOperator.getNameAsId ( )

inline

Returns the fully-qualified name of this operator.

Definition at line 219 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.getName().

Referenced by org.apache.calcite.sql.SqlOperator.deriveType().

                                      {
     return new SqlIdentifier(getName(), SqlParserPos.ZERO);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

SqlOperandCountRange org.apache.calcite.sql.SqlOperator.getOperandCountRange ( )

inline

Returns a constraint on the number of operands expected by this operator. Subclasses may override this method; when they don't, the range is derived from the SqlOperandTypeChecker associated with this operator.

Returns: acceptable range

Definition at line 194 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.operandTypeChecker.

Referenced by org.apache.calcite.sql.SqlOperator.checkOperandCount().

                                                      {
     if (operandTypeChecker != null) {
       return operandTypeChecker.getOperandCountRange();
     }
 
     // If you see this error you need to override this method
     // or give operandTypeChecker a value.
     throw Util.needToImplement(this);
   }

Here is the caller graph for this function:

SqlOperandTypeChecker org.apache.calcite.sql.SqlOperator.getOperandTypeChecker ( )

inline

Definition at line 182 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.operandTypeChecker.

Referenced by org.apache.calcite.sql2rel.StandardConvertletTable.convertCall().

                                                        {
     return operandTypeChecker;
   }

Here is the caller graph for this function:

SqlOperandTypeInference org.apache.calcite.sql.SqlOperator.getOperandTypeInference ( )

inline

Definition at line 758 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.operandTypeInference.

                                                            {
     return operandTypeInference;
   }

SqlReturnTypeInference org.apache.calcite.sql.SqlOperator.getReturnTypeInference ( )

inline

Returns the return type inference strategy for this operator, or null if return type inference is implemented by a subclass override.

Definition at line 895 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.returnTypeInference.

                                                          {
     return returnTypeInference;
   }

int org.apache.calcite.sql.SqlOperator.getRightPrec ( )

inline

Definition at line 235 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.rightPrec.

                             {
     return rightPrec;
   }

String org.apache.calcite.sql.SqlOperator.getSignatureTemplate ( final int operandsCount )

inline

Returns a template describing how the operator signature is to be built. E.g for the binary + operator the template looks like "{1} {0} {2}" {0} is the operator, subsequent numbers are operands.

Parameters

operandsCount is used with functions that can take a variable number of operands

Returns: signature template, or null to indicate that a default template will suffice

Definition at line 733 of file SqlOperator.java.

                                                               {
     return null;
   }

Supplier<Strong.Policy> org.apache.calcite.sql.SqlOperator.getStrongPolicyInference ( )

inline

Returns the Strong.Policy strategy for this operator, or null if there is no particular strategy, in which case this policy will be deducted from the operator's SqlKind.

See Also: Strong

Definition at line 906 of file SqlOperator.java.

                                                             {
     return null;
   }

abstract SqlSyntax org.apache.calcite.sql.SqlOperator.getSyntax ( )

pure virtual

Returns the syntactic type of this operator, never null.

Referenced by org.apache.calcite.sql.SqlOperator.deriveType(), and org.apache.calcite.sql.SqlOperator.unparse().

Here is the caller graph for this function:

int org.apache.calcite.sql.SqlOperator.hashCode ( )

inline

Definition at line 395 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.kind, and org.apache.calcite.sql.SqlOperator.name.

                                   {
     return Objects.hash(kind, name);
   }

RelDataType org.apache.calcite.sql.SqlOperator.inferReturnType ( SqlOperatorBinding opBinding )

inline

Infers the return type of an invocation of this operator; only called after the number and types of operands have already been validated. Subclasses must either override this method or supply an instance of SqlReturnTypeInference to the constructor.

Parameters

opBinding description of invocation (not necessarily a SqlCall)

Returns: inferred return type

Definition at line 490 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.returnTypeInference.

Referenced by org.apache.calcite.sql.SqlOperator.inferReturnType(), and org.apache.calcite.sql.SqlOperator.validateOperands().

                                     {
     if (returnTypeInference != null) {
       RelDataType returnType = returnTypeInference.inferReturnType(opBinding);
       if (returnType == null) {
         throw new IllegalArgumentException("Cannot infer return type for "
             + opBinding.getOperator() + "; operand types: "
             + opBinding.collectOperandTypes());
       }
       return returnType;
     }
 
     // Derived type should have overridden this method, since it didn't
     // supply a type inference rule.
     throw Util.needToImplement(this);
   }

Here is the caller graph for this function:

final RelDataType org.apache.calcite.sql.SqlOperator.inferReturnType	(	RelDataTypeFactory	typeFactory,
		List< RelDataType >	operandTypes
	)

inline

Infers the type of a call to this operator with a given set of operand types. Shorthand for inferReturnType(SqlOperatorBinding).

Definition at line 649 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.inferReturnType().

                                       {
     return inferReturnType(
         new ExplicitOperatorBinding(
             typeFactory,
             this,
             operandTypes));
   }

Here is the call graph for this function:

boolean org.apache.calcite.sql.SqlOperator.isAggregator ( )

inline

Returns whether this operator is an aggregate function. By default, subclass type is used (an instance of SqlAggFunction is assumed to be an aggregator; anything else is not).

Per SQL:2011, there are aggregate functions and window functions. Every aggregate function (e.g. SUM) is also a window function. There are window functions that are not aggregate functions, e.g. RANK, NTILE, LEAD, FIRST_VALUE.

Collectively, aggregate and window functions are called analytic functions. Despite its name, this method returns true for every analytic function.

See Also: requiresOrder()

Returns: whether this operator is an analytic function (aggregate function or window function)

Definition at line 782 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateExpr().

                                 {
     return false;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.SqlOperator.isDeterministic ( )

inline

Returns whether a call to this operator is guaranteed to always return the same result given the same operands; true is assumed by default.

Definition at line 944 of file SqlOperator.java.

                                    {
     return true;
   }

boolean org.apache.calcite.sql.SqlOperator.isDynamicFunction ( )

inline

Returns whether it is unsafe to cache query plans referencing this operator; false is assumed by default.

Definition at line 963 of file SqlOperator.java.

                                      {
     return false;
   }

boolean org.apache.calcite.sql.SqlOperator.isGroup ( )

inline

Returns whether this is a group function.

Group functions can only appear in the GROUP BY clause.

Examples are

HOP

,

TUMBLE

,

SESSION

.

Group functions have auxiliary functions, e.g.

HOP_START

, but these are not group functions.

Definition at line 834 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.validate.SqlValidatorImpl.validateNoAggs().

                            {
     return false;
   }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.SqlOperator.isGroupAuxiliary ( )

inline

Returns whether this is an group auxiliary function.

Examples are

HOP_START

and

HOP_END

(both auxiliary to

HOP

).

See Also: isGroup()

Definition at line 846 of file SqlOperator.java.

                                     {
     return false;
   }

boolean org.apache.calcite.sql.SqlOperator.isName	(	String	testName,
		boolean	caseSensitive
	)

inline

Definition at line 391 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.name.

                                                                 {
     return caseSensitive ? name.equals(testName) : name.equalsIgnoreCase(testName);
   }

boolean org.apache.calcite.sql.SqlOperator.isSymmetrical ( )

inline

Returns whether a call to this operator is not sensitive to the operands input order. An operator is symmetrical if the call returns the same result when the operands are shuffled.

By default, returns true for SqlKind#SYMMETRICAL.

Definition at line 955 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.kind.

                                  {
     return SqlKind.SYMMETRICAL.contains(kind);
   }

static int org.apache.calcite.sql.SqlOperator.leftPrec	(	int	prec,
		boolean	leftAssoc
	)

inlinestaticprotected

Definition at line 166 of file SqlOperator.java.

                                                              {
     assert (prec % 2) == 0;
     if (!leftAssoc) {
       ++prec;
     }
     return prec;
   }

boolean org.apache.calcite.sql.SqlOperator.needsSpace ( )

inlinepackage

Returns whether this operator should be surrounded by space when unparsed.

Returns: whether this operator should be surrounded by space

Definition at line 630 of file SqlOperator.java.

                        {
     return true;
   }

void org.apache.calcite.sql.SqlOperator.preValidateCall	(	SqlValidator	validator,
		SqlValidatorScope	scope,
		SqlCall	call
	)

inlineprotected

Receives notification that validation of a call to this operator is beginning. Subclasses can supply custom behavior; default implementation does nothing.

Parameters

validator	invoking validator
scope	validation scope
call	the call being validated

Definition at line 474 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.validateOperands().

477 {

478 }

Here is the caller graph for this function:

boolean org.apache.calcite.sql.SqlOperator.requiresCreate ( List< SqlNode > operands )

inline

Definition at line 208 of file SqlOperator.java.

                                                         {                 // HEAVY.AI new
     return false;                                                         // HEAVY.AI new
   }                                                                       // HEAVY.AI new

boolean org.apache.calcite.sql.SqlOperator.requiresDecimalExpansion ( )

inline

Method to check if call requires expansion when it has decimal operands. The default implementation is to return true.

Definition at line 971 of file SqlOperator.java.

                                             {
     return true;
   }

boolean org.apache.calcite.sql.SqlOperator.requiresOrder ( )

inline

Returns whether this is a window function that requires ordering.

Per SQL:2011, 2, 6.10: "If <ntile function>, <lead or lag function>, RANK or DENSE_RANK is specified, then the window ordering clause shall be present."

See Also: isAggregator()

Definition at line 812 of file SqlOperator.java.

                                  {
     return false;
   }

boolean org.apache.calcite.sql.SqlOperator.requiresOver ( )

inline

Returns whether this is a window function that requires an OVER clause.

For example, returns true for

RANK

,

DENSE_RANK

and other ranking functions; returns false for

SUM

,

COUNT

,

MIN

,

MAX

,

AVG

(they can be used as non-window aggregate functions).

If

requiresOver

returns true, then isAggregator() must also return true.

See Also: allowsFraming(); requiresOrder()

Definition at line 799 of file SqlOperator.java.

                                 {
     return false;
   }

SqlNode org.apache.calcite.sql.SqlOperator.rewriteCall	(	SqlValidator	validator,
		SqlCall	call
	)

inline

Rewrites a call to this operator. Some operators are implemented as trivial rewrites (e.g. NULLIF becomes CASE). However, we don't do this at createCall time because we want to preserve the original SQL syntax as much as possible; instead, we do this before the call is validated (so the trivial operator doesn't need its own implementation of type derivation methods). The default implementation is to just return the original call without any rewrite.

Parameters

validator	Validator
call	Call to be rewritten

Returns: rewritten call

Definition at line 323 of file SqlOperator.java.

                                                                    {
     return call;
   }

static int org.apache.calcite.sql.SqlOperator.rightPrec	(	int	prec,
		boolean	leftAssoc
	)

inlinestaticprotected

Definition at line 174 of file SqlOperator.java.

                                                               {
     assert (prec % 2) == 0;
     if (leftAssoc) {
       ++prec;
     }
     return prec;
   }

String org.apache.calcite.sql.SqlOperator.toString ( )

inline

Definition at line 227 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.name.

                            {
     return name;
   }

void org.apache.calcite.sql.SqlOperator.unparse	(	SqlWriter	writer,
		SqlCall	call,
		int	leftPrec,
		int	rightPrec
	)

inline

Writes a SQL representation of a call to this operator to a writer, including parentheses if the operators on either side are of greater precedence.

The default implementation of this method delegates to SqlSyntax#unparse.

Definition at line 335 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.getSyntax(), org.apache.calcite.sql.SqlOperator.leftPrec, and org.apache.calcite.sql.SqlOperator.rightPrec.

                      {
     getSyntax().unparse(writer, this, call, leftPrec, rightPrec);
   }

Here is the call graph for this function:

void org.apache.calcite.sql.SqlOperator.unparseListClause	(	SqlWriter	writer,
		SqlNode	clause
	)

inlineprotected

Definition at line 344 of file SqlOperator.java.

                                                                      {
     final SqlNodeList nodeList =
         clause instanceof SqlNodeList
             ? (SqlNodeList) clause
             : SqlNodeList.of(clause);
     writer.list(SqlWriter.FrameTypeEnum.SIMPLE, SqlWriter.COMMA, nodeList);
   }

void org.apache.calcite.sql.SqlOperator.unparseListClause	(	SqlWriter	writer,
		SqlNode	clause,
		SqlKind	sepKind
	)

inlineprotected

Definition at line 353 of file SqlOperator.java.

                        {
     final SqlNodeList nodeList =
         clause instanceof SqlNodeList
             ? (SqlNodeList) clause
             : SqlNodeList.of(clause);
     final SqlBinaryOperator sepOp;
     if (sepKind == null) {
       sepOp = SqlWriter.COMMA;
     } else {
       switch (sepKind) {
       case AND:
         sepOp = SqlStdOperatorTable.AND;
         break;
       case OR:
         sepOp = SqlStdOperatorTable.OR;
         break;
       default:
         throw new AssertionError();
       }
     }
     writer.list(SqlWriter.FrameTypeEnum.SIMPLE, sepOp, nodeList);
   }

void org.apache.calcite.sql.SqlOperator.validateCall	(	SqlCall	call,
		SqlValidator	validator,
		SqlValidatorScope	scope,
		SqlValidatorScope	operandScope
	)

inline

Validates a call to this operator.

This method should not perform type-derivation or perform validation related related to types. That is done later, by deriveType(SqlValidator, SqlValidatorScope, SqlCall). This method should focus on structural validation.

A typical implementation of this method first validates the operands, then performs some operator-specific logic. The default implementation just validates the operands.

This method is the default implementation of SqlCall#validate; but note that some sub-classes of SqlCall never call this method.

Parameters

call	the call to this operator
validator	the active validator
scope	validator scope
operandScope	validator scope in which to validate operands to this call; usually equal to scope, but not always because some operators introduce new scopes

See Also: SqlNode::validateExpr(SqlValidator, SqlValidatorScope); deriveType(SqlValidator, SqlValidatorScope, SqlCall)

Definition at line 423 of file SqlOperator.java.

                                       {
     assert call.getOperator() == this;
     for (SqlNode operand : call.getOperandList()) {
       operand.validateExpr(validator, operandScope);
     }
   }

final RelDataType org.apache.calcite.sql.SqlOperator.validateOperands	(	SqlValidator	validator,
		SqlValidatorScope	scope,
		SqlCall	call
	)

inline

Validates the operands of a call, inferring the return type in the process.

Parameters

validator	active validator
scope	validation scope
call	call to be validated

Returns: inferred type

Definition at line 443 of file SqlOperator.java.

References org.apache.calcite.sql.SqlOperator.checkOperandCount(), org.apache.calcite.sql.SqlOperator.checkOperandTypes(), org.apache.calcite.sql.SqlOperator.inferReturnType(), org.apache.calcite.sql.SqlOperator.operandTypeChecker, and org.apache.calcite.sql.SqlOperator.preValidateCall().

Referenced by org.apache.calcite.sql.SqlOperator.deriveType().

                     {
     // Let subclasses know what's up.
     preValidateCall(validator, scope, call);
 
     // Check the number of operands
     checkOperandCount(validator, operandTypeChecker, call);
 
     SqlCallBinding opBinding = new SqlCallBinding(validator, scope, call);
 
     checkOperandTypes(
         opBinding,
         true);
 
     // Now infer the result type.
     RelDataType ret = inferReturnType(opBinding);
     ((SqlValidatorImpl) validator).setValidatedNodeType(call, ret);
     return ret;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean org.apache.calcite.sql.SqlOperator.validRexOperands	(	int	count,
		Litmus	litmus
	)

inline

Returns whether the given operands are valid. If not valid and

fail

, throws an assertion error.

Similar to checkOperandCount, but some operators may have different valid operands in SqlNode and

RexNode

formats (some examples are CAST and AND), and this method throws internal errors, not user errors.

Definition at line 719 of file SqlOperator.java.

                                                             {
     return true;
   }

Member Data Documentation

final SqlKind org.apache.calcite.sql.SqlOperator.kind

See SqlKind. It's possible to have a name that doesn't match the kind

Definition at line 95 of file SqlOperator.java.

Referenced by TableFunctionsFactory_linker.BaseGenerateFiles._get_filename(), org.apache.calcite.sql.SqlOperator.checkOperandTypes(), org.apache.calcite.sql.SqlOperator.equals(), org.apache.calcite.sql.SqlOperator.getKind(), org.apache.calcite.sql.SqlOperator.hashCode(), org.apache.calcite.sql.SqlOperator.isSymmetrical(), heavydb.serialized_result_set.ttypes.TTargetInfo.read(), org.apache.calcite.sql.SqlOperator.SqlOperator(), and heavydb.serialized_result_set.ttypes.TTargetInfo.write().

final int org.apache.calcite.sql.SqlOperator.leftPrec

private

The precedence with which this operator binds to the expression to the left. This is less than the right precedence if the operator is left-associative.

Definition at line 102 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.getLeftPrec(), org.apache.calcite.sql.SqlOperator.SqlOperator(), and org.apache.calcite.sql.SqlOperator.unparse().

final int org.apache.calcite.sql.SqlOperator.MDX_PRECEDENCE = 200

static

Maximum precedence.

Definition at line 82 of file SqlOperator.java.

final String org.apache.calcite.sql.SqlOperator.name

private

The name of the operator/function. Ex. "OVERLAY" or "TRIM"

Definition at line 89 of file SqlOperator.java.

Referenced by TableFunctionsFactory_declbracket.Bracket.__repr__(), TableFunctionsFactory_declbracket.Bracket.__str__(), TableFunctionsFactory_declbracket.Bracket.apply_column(), TableFunctionsFactory_declbracket.Bracket.apply_namespace(), TableFunctionsFactory_declbracket.Bracket.format_sizer(), org.apache.calcite.sql.SqlOperator.getAllowedSignatures(), org.apache.calcite.sql.SqlOperator.getName(), org.apache.calcite.sql.SqlOperator.hashCode(), org.apache.calcite.sql.SqlOperator.isName(), TableFunctionsFactory_declbracket.Bracket.normalize(), heavydb.extension_functions.ttypes.TUserDefinedFunction.read(), heavydb.extension_functions.ttypes.TUserDefinedTableFunction.read(), heavydb.thrift.ttypes.TDashboardGrantees.read(), heavydb.thrift.ttypes.TGeoFileLayerInfo.read(), heavydb.thrift.ttypes.TCustomExpression.read(), org.apache.calcite.sql.SqlOperator.SqlOperator(), TableFunctionsFactory_declbracket.Bracket.tostring(), org.apache.calcite.sql.SqlOperator.toString(), heavydb.extension_functions.ttypes.TUserDefinedFunction.write(), heavydb.extension_functions.ttypes.TUserDefinedTableFunction.write(), heavydb.thrift.ttypes.TDashboardGrantees.write(), heavydb.thrift.ttypes.TGeoFileLayerInfo.write(), and heavydb.thrift.ttypes.TCustomExpression.write().

final String org.apache.calcite.sql.SqlOperator.NL = System.getProperty("line.separator")

static

Definition at line 77 of file SqlOperator.java.

final SqlOperandTypeChecker org.apache.calcite.sql.SqlOperator.operandTypeChecker

private

Used to validate operand types.

Definition at line 118 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.checkOperandTypes(), org.apache.calcite.sql.SqlOperator.getAllowedSignatures(), org.apache.calcite.sql.SqlOperator.getOperandCountRange(), org.apache.calcite.sql.SqlOperator.getOperandTypeChecker(), org.apache.calcite.sql.SqlOperator.SqlOperator(), and org.apache.calcite.sql.SqlOperator.validateOperands().

final SqlOperandTypeInference org.apache.calcite.sql.SqlOperator.operandTypeInference

private

Used to infer types of unknown operands.

Definition at line 115 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.getOperandTypeInference(), and org.apache.calcite.sql.SqlOperator.SqlOperator().

final SqlReturnTypeInference org.apache.calcite.sql.SqlOperator.returnTypeInference

private

Used to infer the return type of a call to this operator.

Definition at line 112 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.getReturnTypeInference(), org.apache.calcite.sql.SqlOperator.inferReturnType(), and org.apache.calcite.sql.SqlOperator.SqlOperator().

final int org.apache.calcite.sql.SqlOperator.rightPrec

private

The precedence with which this operator binds to the expression to the right. This is more than the left precedence if the operator is left-associative.

Definition at line 109 of file SqlOperator.java.

Referenced by org.apache.calcite.sql.SqlOperator.getRightPrec(), org.apache.calcite.sql.SqlOperator.SqlOperator(), and org.apache.calcite.sql.SqlOperator.unparse().

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/sql/SqlOperator.java

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Package Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation