org.apache.calcite.sql2rel.StandardConvertletTable Class Reference

Inheritance diagram for org.apache.calcite.sql2rel.StandardConvertletTable:

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

Classes
class	AvgVarianceConvertlet
class	FloorCeilConvertlet
class	GreatestConvertlet
class	RegrCovarianceConvertlet
class	TimestampAddConvertlet
class	TimestampDiffConvertlet
class	TrimConvertlet

Public Member Functions
RexNode	convertCase (SqlRexContext cx, SqlCase call)
RexNode	convertMultiset (SqlRexContext cx, SqlMultisetValueConstructor op, SqlCall call)
RexNode	convertArray (SqlRexContext cx, SqlArrayValueConstructor op, SqlCall call)
RexNode	convertMap (SqlRexContext cx, SqlMapValueConstructor op, SqlCall call)
RexNode	convertMultisetQuery (SqlRexContext cx, SqlMultisetQueryConstructor op, SqlCall call)
RexNode	convertJdbc (SqlRexContext cx, SqlJdbcFunctionCall op, SqlCall call)
RexNode	convertExtract (SqlRexContext cx, SqlExtractFunction op, SqlCall call)
RexNode	convertDatetimeMinus (SqlRexContext cx, SqlDatetimeSubtractionOperator op, SqlCall call)
RexNode	convertFunction (SqlRexContext cx, SqlFunction fun, SqlCall call)
RexNode	convertWindowFunction (SqlRexContext cx, SqlWindowTableFunction fun, SqlCall call)
RexNode	convertJsonValueFunction (SqlRexContext cx, SqlJsonValueFunction fun, SqlCall call)
RexNode	convertSequenceValue (SqlRexContext cx, SqlSequenceValueOperator fun, SqlCall call)
RexNode	convertAggregateFunction (SqlRexContext cx, SqlAggFunction fun, SqlCall call)
RexNode	convertCall (SqlRexContext cx, SqlCall call)
RexNode	convertBetween (SqlRexContext cx, SqlBetweenOperator op, SqlCall call)
RexNode	convertLiteralChain (SqlRexContext cx, SqlLiteralChainOperator op, SqlCall call)
RexNode	convertRow (SqlRexContext cx, SqlRowOperator op, SqlCall call)
RexNode	convertOverlaps (SqlRexContext cx, SqlOverlapsOperator op, SqlCall call)
RexNode	castToValidatedType (SqlRexContext cx, SqlCall call, RexNode value)

Static Public Member Functions
static RexNode	castToValidatedType (SqlNode node, RexNode e, SqlValidator validator, RexBuilder rexBuilder)

Static Public Attributes
static final StandardConvertletTable	INSTANCE = new StandardConvertletTable()

Protected Member Functions
RexNode	convertCast (SqlRexContext cx, final SqlCall call)
RexNode	convertTryCast (SqlRexContext cx, final SqlCall call)
RexNode	convertFloorCeil (SqlRexContext cx, SqlCall call)

Private Member Functions
	StandardConvertletTable ()
RexNode	or (RexBuilder rexBuilder, RexNode a0, RexNode a1)
RexNode	eq (RexBuilder rexBuilder, RexNode a0, RexNode a1)
RexNode	ge (RexBuilder rexBuilder, RexNode a0, RexNode a1)
RexNode	le (RexBuilder rexBuilder, RexNode a0, RexNode a1)
RexNode	and (RexBuilder rexBuilder, RexNode a0, RexNode a1)
RexNode	plus (RexBuilder rexBuilder, RexNode a0, RexNode a1)
RexNode	minus (RexBuilder rexBuilder, RexNode a0, RexNode a1)
RexNode	case_ (RexBuilder rexBuilder, RexNode...args)
SqlCall	plus (SqlParserPos pos, SqlNode a0, SqlNode a1)
RexNode	mod (RexBuilder rexBuilder, RelDataType resType, RexNode res, BigDecimal val)
RexNode	convertCall (SqlRexContext cx, SqlOperator op, List< SqlNode > operands)
List< Integer >	elseArgs (int count)
RexNode	convertPlus (SqlRexContext cx, SqlCall call)
RexNode	convertIsDistinctFrom (SqlRexContext cx, SqlCall call, boolean neg)
Pair< RexNode, RexNode >	convertOverlapsOperand (SqlRexContext cx, SqlParserPos pos, SqlNode operand)

Static Private Member Functions
static RexNode	convertInterval (SqlRexContext cx, SqlCall call)
static RexNode	divideInt (RexBuilder rexBuilder, RexNode a0, RexNode a1)
static RexNode	multiply (RexBuilder rexBuilder, RexNode a0, RexNode a1)
static RexNode	divide (RexBuilder rexBuilder, RexNode res, BigDecimal val)
static RexNode	makeConstructorCall (SqlRexContext cx, SqlFunction constructor, List< RexNode > exprs)
static List< RexNode >	convertExpressionList (SqlRexContext cx, List< SqlNode > nodes, SqlOperandTypeChecker.Consistency consistency)
static RelDataType	consistentType (SqlRexContext cx, SqlOperandTypeChecker.Consistency consistency, List< RelDataType > types)

Detailed Description

Standard implementation of SqlRexConvertletTable.

Definition at line 95 of file StandardConvertletTable.java.

Constructor & Destructor Documentation

org.apache.calcite.sql2rel.StandardConvertletTable.StandardConvertletTable ( )

inlineprivate

Definition at line 101 of file StandardConvertletTable.java.

References org.apache.calcite.sql2rel.StandardConvertletTable.convertCall(), org.apache.calcite.sql2rel.StandardConvertletTable.convertDatetimeMinus(), org.apache.calcite.sql2rel.StandardConvertletTable.convertIsDistinctFrom(), and com.mapd.calcite.parser.HeavyDBSqlOperatorTable.TRY_CAST.

                                    {
    super();

    // Register aliases (operators which have a different name but
    // identical behavior to other operators).
    addAlias(SqlStdOperatorTable.CHARACTER_LENGTH, SqlStdOperatorTable.CHAR_LENGTH);
    addAlias(SqlStdOperatorTable.IS_UNKNOWN, SqlStdOperatorTable.IS_NULL);
    addAlias(SqlStdOperatorTable.IS_NOT_UNKNOWN, SqlStdOperatorTable.IS_NOT_NULL);
    addAlias(SqlStdOperatorTable.PERCENT_REMAINDER, SqlStdOperatorTable.MOD);

    // Register convertlets for specific objects.
    registerOp(SqlStdOperatorTable.CAST, this::convertCast);
    registerOp(SqlLibraryOperators.INFIX_CAST, this::convertCast);

    // HEAVY.AI new
    registerOp(HeavyDBSqlOperatorTable.TRY_CAST, this::convertTryCast);
    // end HEAVY.AI new

    registerOp(SqlStdOperatorTable.IS_DISTINCT_FROM,
            (cx, call) -> convertIsDistinctFrom(cx, call, false));
    registerOp(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
            (cx, call) -> convertIsDistinctFrom(cx, call, true));

    registerOp(SqlStdOperatorTable.PLUS, this::convertPlus);

    registerOp(SqlStdOperatorTable.MINUS, (cx, call) -> {
      final RexCall e = (RexCall) StandardConvertletTable.this.convertCall(
              cx, call.getOperator(), call.getOperandList());
      switch (e.getOperands().get(0).getType().getSqlTypeName()) {
        case DATE:
        case TIME:
        case TIMESTAMP:
          return convertDatetimeMinus(cx, SqlStdOperatorTable.MINUS_DATE, call);
        default:
          return e;
      }
    });

    registerOp(
            SqlLibraryOperators.LTRIM, new TrimConvertlet(SqlTrimFunction.Flag.LEADING));
    registerOp(
            SqlLibraryOperators.RTRIM, new TrimConvertlet(SqlTrimFunction.Flag.TRAILING));

    registerOp(SqlLibraryOperators.GREATEST, new GreatestConvertlet());
    registerOp(SqlLibraryOperators.LEAST, new GreatestConvertlet());

    registerOp(SqlLibraryOperators.NVL, (cx, call) -> {
      final RexBuilder rexBuilder = cx.getRexBuilder();
      final RexNode operand0 = cx.convertExpression(call.getOperandList().get(0));
      final RexNode operand1 = cx.convertExpression(call.getOperandList().get(1));
      final RelDataType type = cx.getValidator().getValidatedNodeType(call);
      return rexBuilder.makeCall(type,
              SqlStdOperatorTable.CASE,
              ImmutableList.of(
                      rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, operand0),
                      rexBuilder.makeCast(type, operand0),
                      rexBuilder.makeCast(type, operand1)));
    });

    registerOp(SqlLibraryOperators.DECODE, (cx, call) -> {
      final RexBuilder rexBuilder = cx.getRexBuilder();
      final List<RexNode> operands = convertExpressionList(
              cx, call.getOperandList(), SqlOperandTypeChecker.Consistency.NONE);
      final RelDataType type = cx.getValidator().getValidatedNodeType(call);
      final List<RexNode> exprs = new ArrayList<>();
      for (int i = 1; i < operands.size() - 1; i += 2) {
        exprs.add(RelOptUtil.isDistinctFrom(
                rexBuilder, operands.get(0), operands.get(i), true));
        exprs.add(operands.get(i + 1));
      }
      if (operands.size() % 2 == 0) {
        exprs.add(Util.last(operands));
      } else {
        exprs.add(rexBuilder.makeNullLiteral(type));
      }
      return rexBuilder.makeCall(type, SqlStdOperatorTable.CASE, exprs);
    });

    // Expand "x NOT LIKE y" into "NOT (x LIKE y)"
    registerOp(SqlStdOperatorTable.NOT_LIKE,
            (cx, call)
                    -> cx.convertExpression(
                            SqlStdOperatorTable.NOT.createCall(SqlParserPos.ZERO,
                                    SqlStdOperatorTable.LIKE.createCall(
                                            SqlParserPos.ZERO, call.getOperandList()))));

    // Expand "x NOT SIMILAR y" into "NOT (x SIMILAR y)"
    registerOp(SqlStdOperatorTable.NOT_SIMILAR_TO,
            (cx, call)
                    -> cx.convertExpression(
                            SqlStdOperatorTable.NOT.createCall(SqlParserPos.ZERO,
                                    SqlStdOperatorTable.SIMILAR_TO.createCall(
                                            SqlParserPos.ZERO, call.getOperandList()))));

    // Unary "+" has no effect, so expand "+ x" into "x".
    registerOp(SqlStdOperatorTable.UNARY_PLUS,
            (cx, call) -> cx.convertExpression(call.operand(0)));

    // "DOT"
    registerOp(SqlStdOperatorTable.DOT,
            (cx, call)
                    -> cx.getRexBuilder().makeFieldAccess(
                            cx.convertExpression(call.operand(0)),
                            call.operand(1).toString(),
                            false));
    // "AS" has no effect, so expand "x AS id" into "x".
    registerOp(
            SqlStdOperatorTable.AS, (cx, call) -> cx.convertExpression(call.operand(0)));
    // "SQRT(x)" is equivalent to "POWER(x, .5)"
    registerOp(SqlStdOperatorTable.SQRT,
            (cx, call)
                    -> cx.convertExpression(SqlStdOperatorTable.POWER.createCall(
                            SqlParserPos.ZERO,
                            call.operand(0),
                            SqlLiteral.createExactNumeric("0.5", SqlParserPos.ZERO))));

    // REVIEW jvs 24-Apr-2006: This only seems to be working from within a
    // windowed agg.  I have added an optimizer rule
    // org.apache.calcite.rel.rules.AggregateReduceFunctionsRule which handles
    // other cases post-translation.  The reason I did that was to defer the
    // implementation decision; e.g. we may want to push it down to a foreign
    // server directly rather than decomposed; decomposition is easier than
    // recognition.

    // Convert "avg(<expr>)" to "cast(sum(<expr>) / count(<expr>) as
    // <type>)". We don't need to handle the empty set specially, because
    // the SUM is already supposed to come out as NULL in cases where the
    // COUNT is zero, so the null check should take place first and prevent
    // division by zero. We need the cast because SUM and COUNT may use
    // different types, say BIGINT.
    //
    // Similarly STDDEV_POP and STDDEV_SAMP, VAR_POP and VAR_SAMP.
    registerOp(SqlStdOperatorTable.AVG, new AvgVarianceConvertlet(SqlKind.AVG));
    registerOp(SqlStdOperatorTable.STDDEV_POP,
            new AvgVarianceConvertlet(SqlKind.STDDEV_POP));
    registerOp(SqlStdOperatorTable.STDDEV_SAMP,
            new AvgVarianceConvertlet(SqlKind.STDDEV_SAMP));
    registerOp(
            SqlStdOperatorTable.STDDEV, new AvgVarianceConvertlet(SqlKind.STDDEV_SAMP));
    registerOp(SqlStdOperatorTable.VAR_POP, new AvgVarianceConvertlet(SqlKind.VAR_POP));
    registerOp(SqlStdOperatorTable.VAR_SAMP, new AvgVarianceConvertlet(SqlKind.VAR_SAMP));
    registerOp(SqlStdOperatorTable.VARIANCE, new AvgVarianceConvertlet(SqlKind.VAR_SAMP));
    registerOp(SqlStdOperatorTable.COVAR_POP,
            new RegrCovarianceConvertlet(SqlKind.COVAR_POP));
    registerOp(SqlStdOperatorTable.COVAR_SAMP,
            new RegrCovarianceConvertlet(SqlKind.COVAR_SAMP));
    registerOp(
            SqlStdOperatorTable.REGR_SXX, new RegrCovarianceConvertlet(SqlKind.REGR_SXX));
    registerOp(
            SqlStdOperatorTable.REGR_SYY, new RegrCovarianceConvertlet(SqlKind.REGR_SYY));

    final SqlRexConvertlet floorCeilConvertlet = new FloorCeilConvertlet();
    registerOp(SqlStdOperatorTable.FLOOR, floorCeilConvertlet);
    registerOp(SqlStdOperatorTable.CEIL, floorCeilConvertlet);

    registerOp(SqlStdOperatorTable.TIMESTAMP_ADD, new TimestampAddConvertlet());
    registerOp(SqlStdOperatorTable.TIMESTAMP_DIFF, new TimestampDiffConvertlet());

    registerOp(SqlStdOperatorTable.INTERVAL, StandardConvertletTable::convertInterval);

    // Convert "element(<expr>)" to "$element_slice(<expr>)", if the
    // expression is a multiset of scalars.
    if (false) {
      registerOp(SqlStdOperatorTable.ELEMENT, (cx, call) -> {
        assert call.operandCount() == 1;
        final SqlNode operand = call.operand(0);
        final RelDataType type = cx.getValidator().getValidatedNodeType(operand);
        if (!type.getComponentType().isStruct()) {
          return cx.convertExpression(SqlStdOperatorTable.ELEMENT_SLICE.createCall(
                  SqlParserPos.ZERO, operand));
        }

        // fallback on default behavior
        return StandardConvertletTable.this.convertCall(cx, call);
      });
    }

    // Convert "$element_slice(<expr>)" to "element(<expr>).field#0"
    if (false) {
      registerOp(SqlStdOperatorTable.ELEMENT_SLICE, (cx, call) -> {
        assert call.operandCount() == 1;
        final SqlNode operand = call.operand(0);
        final RexNode expr = cx.convertExpression(
                SqlStdOperatorTable.ELEMENT.createCall(SqlParserPos.ZERO, operand));
        return cx.getRexBuilder().makeFieldAccess(expr, 0);
      });
    }
  }

Here is the call graph for this function:

Member Function Documentation

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.and ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlineprivate

Definition at line 323 of file StandardConvertletTable.java.

                                                                     {
    return rexBuilder.makeCall(SqlStdOperatorTable.AND, a0, a1);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.case_ ( RexBuilder  rexBuilder, RexNode...  args  )

inlineprivate

Definition at line 343 of file StandardConvertletTable.java.

References run_benchmark_import.args.

                                                                {
    return rexBuilder.makeCall(SqlStdOperatorTable.CASE, args);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.castToValidatedType ( SqlRexContext  cx, SqlCall  call, RexNode  value  )

inline

Casts a RexNode value to the validated type of a SqlCall. If the value was already of the validated type, then the value is returned without an additional cast.

Definition at line 1021 of file StandardConvertletTable.java.

                                                                                    {
    return castToValidatedType(call, value, cx.getValidator(), cx.getRexBuilder());
  }

static RexNode org.apache.calcite.sql2rel.StandardConvertletTable.castToValidatedType ( SqlNode  node, RexNode  e, SqlValidator  validator, RexBuilder  rexBuilder  )

inlinestatic

Casts a RexNode value to the validated type of a SqlCall. If the value was already of the validated type, then the value is returned without an additional cast.

Definition at line 1030 of file StandardConvertletTable.java.

References run_benchmark_import.type.

                                                                                  {
    final RelDataType type = validator.getValidatedNodeType(node);
    if (e.getType() == type) {
      return e;
    }
    return rexBuilder.makeCast(type, e);
  }

static RelDataType org.apache.calcite.sql2rel.StandardConvertletTable.consistentType ( SqlRexContext  cx, SqlOperandTypeChecker.Consistency  consistency, List< RelDataType >  types  )

inlinestaticprivate

Definition at line 787 of file StandardConvertletTable.java.

References run_benchmark_import.type.

                                   {
    switch (consistency) {
      case COMPARE:
        if (SqlTypeUtil.areSameFamily(types)) {
          // All arguments are of same family. No need for explicit casts.
          return null;
        }
        final List<RelDataType> nonCharacterTypes = new ArrayList<>();
        for (RelDataType type : types) {
          if (type.getFamily() != SqlTypeFamily.CHARACTER) {
            nonCharacterTypes.add(type);
          }
        }
        if (!nonCharacterTypes.isEmpty()) {
          final int typeCount = types.size();
          types = nonCharacterTypes;
          if (nonCharacterTypes.size() < typeCount) {
            final RelDataTypeFamily family = nonCharacterTypes.get(0).getFamily();
            if (family instanceof SqlTypeFamily) {
              // The character arguments might be larger than the numeric
              // argument. Give ourselves some headroom.
              switch ((SqlTypeFamily) family) {
                case INTEGER:
                case NUMERIC:
                  nonCharacterTypes.add(
                          cx.getTypeFactory().createSqlType(SqlTypeName.BIGINT));
              }
            }
          }
        }
        // fall through
      case LEAST_RESTRICTIVE:
        return cx.getTypeFactory().leastRestrictive(types);
      default:
        return null;
    }
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertAggregateFunction ( SqlRexContext  cx, SqlAggFunction  fun, SqlCall  call  )

inline

Definition at line 667 of file StandardConvertletTable.java.

                                                              {
    final List<SqlNode> operands = call.getOperandList();
    final List<RexNode> exprs;
    if (call.isCountStar()) {
      exprs = ImmutableList.of();
    } else {
      exprs = convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE);
    }
    RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
    final int groupCount = cx.getGroupCount();
    if (returnType == null) {
      RexCallBinding binding =
              new RexCallBinding(cx.getTypeFactory(), fun, exprs, ImmutableList.of()) {
                @Override
                public int getGroupCount() {
                  return groupCount;
                }
              };
      returnType = fun.inferReturnType(binding);
    }
    return cx.getRexBuilder().makeCall(returnType, fun, exprs);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertArray ( SqlRexContext  cx, SqlArrayValueConstructor  op, SqlCall  call  )

inline

Definition at line 414 of file StandardConvertletTable.java.

                                                                       {
    return convertCall(cx, call);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertBetween ( SqlRexContext  cx, SqlBetweenOperator  op, SqlCall  call  )

inline

Converts a BETWEEN expression.

Called automatically via reflection.

Definition at line 874 of file StandardConvertletTable.java.

References run_benchmark_import.res.

                                                                                       {
    final List<RexNode> list = convertExpressionList(
            cx, call.getOperandList(), op.getOperandTypeChecker().getConsistency());
    final RexNode x = list.get(SqlBetweenOperator.VALUE_OPERAND);
    final RexNode y = list.get(SqlBetweenOperator.LOWER_OPERAND);
    final RexNode z = list.get(SqlBetweenOperator.UPPER_OPERAND);

    final RexBuilder rexBuilder = cx.getRexBuilder();
    RexNode ge1 = ge(rexBuilder, x, y);
    RexNode le1 = le(rexBuilder, x, z);
    RexNode and1 = and(rexBuilder, ge1, le1);

    RexNode res;
    final SqlBetweenOperator.Flag symmetric = op.flag;
    switch (symmetric) {
      case ASYMMETRIC:
        res = and1;
        break;
      case SYMMETRIC:
        RexNode ge2 = ge(rexBuilder, x, z);
        RexNode le2 = le(rexBuilder, x, y);
        RexNode and2 = and(rexBuilder, ge2, le2);
        res = or(rexBuilder, and1, and2);
        break;
      default:
        throw Util.unexpected(symmetric);
    }
    final SqlBetweenOperator betweenOp = (SqlBetweenOperator) call.getOperator();
    if (betweenOp.isNegated()) {
      res = rexBuilder.makeCall(SqlStdOperatorTable.NOT, res);
    }
    return res;
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertCall ( SqlRexContext  cx, SqlCall  call  )

inline

Converts a call to an operator into a RexCall to the same operator.

Called automatically via reflection.

Parameters

cx	Context
call	Call

Returns

Rex call

Definition at line 733 of file StandardConvertletTable.java.

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

                                                             {
    return convertCall(cx, call.getOperator(), call.getOperandList());
  }

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertCall ( SqlRexContext  cx, SqlOperator  op, List< SqlNode >  operands  )

inlineprivate

Converts a SqlCall to a RexCall with a perhaps different operator.

Definition at line 741 of file StandardConvertletTable.java.

References org.apache.calcite.sql.SqlOperator.getOperandTypeChecker(), and run_benchmark_import.type.

                                                                                        {
    final RexBuilder rexBuilder = cx.getRexBuilder();
    final SqlOperandTypeChecker.Consistency consistency =
            op.getOperandTypeChecker() == null
            ? SqlOperandTypeChecker.Consistency.NONE
            : op.getOperandTypeChecker().getConsistency();
    final List<RexNode> exprs = convertExpressionList(cx, operands, consistency);
    RelDataType type = rexBuilder.deriveReturnType(op, exprs);
    return rexBuilder.makeCall(type, op, RexUtil.flatten(exprs, op));
  }

Here is the call graph for this function:

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertCase ( SqlRexContext  cx, SqlCase  call  )

inline

Converts a CASE expression.

Definition at line 356 of file StandardConvertletTable.java.

References run_benchmark_import.type.

                                                             {
    SqlNodeList whenList = call.getWhenOperands();
    SqlNodeList thenList = call.getThenOperands();
    assert whenList.size() == thenList.size();

    RexBuilder rexBuilder = cx.getRexBuilder();
    final List<RexNode> exprList = new ArrayList<>();
    final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
    final RexLiteral unknownLiteral =
            rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
    final RexLiteral nullLiteral =
            rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.NULL));
    for (int i = 0; i < whenList.size(); i++) {
      if (SqlUtil.isNullLiteral(whenList.get(i), false)) {
        exprList.add(unknownLiteral);
      } else {
        exprList.add(cx.convertExpression(whenList.get(i)));
      }
      if (SqlUtil.isNullLiteral(thenList.get(i), false)) {
        exprList.add(nullLiteral);
      } else {
        exprList.add(cx.convertExpression(thenList.get(i)));
      }
    }
    if (SqlUtil.isNullLiteral(call.getElseOperand(), false)) {
      exprList.add(nullLiteral);
    } else {
      exprList.add(cx.convertExpression(call.getElseOperand()));
    }

    RelDataType type = rexBuilder.deriveReturnType(call.getOperator(), exprList);
    for (int i : elseArgs(exprList.size())) {
      exprList.set(i, rexBuilder.ensureType(type, exprList.get(i), false));
    }
    return rexBuilder.makeCall(type, SqlStdOperatorTable.CASE, exprList);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertCast ( SqlRexContext  cx, final SqlCall  call  )

inlineprotected

Definition at line 450 of file StandardConvertletTable.java.

References run_benchmark_import.type.

                                                                      {
    RelDataTypeFactory typeFactory = cx.getTypeFactory();
    assert call.getKind() == SqlKind.CAST;
    final SqlNode left = call.operand(0);
    final SqlNode right = call.operand(1);
    if (right instanceof SqlIntervalQualifier) {
      final SqlIntervalQualifier intervalQualifier = (SqlIntervalQualifier) right;
      if (left instanceof SqlIntervalLiteral) {
        RexLiteral sourceInterval = (RexLiteral) cx.convertExpression(left);
        BigDecimal sourceValue = (BigDecimal) sourceInterval.getValue();
        RexLiteral castedInterval =
                cx.getRexBuilder().makeIntervalLiteral(sourceValue, intervalQualifier);
        return castToValidatedType(cx, call, castedInterval);
      } else if (left instanceof SqlNumericLiteral) {
        RexLiteral sourceInterval = (RexLiteral) cx.convertExpression(left);
        BigDecimal sourceValue = (BigDecimal) sourceInterval.getValue();
        final BigDecimal multiplier = intervalQualifier.getUnit().multiplier;
        sourceValue = sourceValue.multiply(multiplier);
        RexLiteral castedInterval =
                cx.getRexBuilder().makeIntervalLiteral(sourceValue, intervalQualifier);
        return castToValidatedType(cx, call, castedInterval);
      }
      return castToValidatedType(cx, call, cx.convertExpression(left));
    }
    SqlDataTypeSpec dataType = (SqlDataTypeSpec) right;
    RelDataType type = dataType.deriveType(cx.getValidator());
    if (type == null) {
      type = cx.getValidator().getValidatedNodeType(dataType.getTypeName());
    }
    RexNode arg = cx.convertExpression(left);
    if (arg.getType().isNullable()) {
      type = typeFactory.createTypeWithNullability(type, true);
    }
    if (SqlUtil.isNullLiteral(left, false)) {
      final SqlValidatorImpl validator = (SqlValidatorImpl) cx.getValidator();
      validator.setValidatedNodeType(left, type);
      return cx.convertExpression(left);
    }
    if (null != dataType.getCollectionsTypeName()) {
      final RelDataType argComponentType = arg.getType().getComponentType();
      final RelDataType componentType = type.getComponentType();
      if (argComponentType.isStruct() && !componentType.isStruct()) {
        RelDataType tt = typeFactory.builder()
                                 .add(argComponentType.getFieldList().get(0).getName(),
                                         componentType)
                                 .build();
        tt = typeFactory.createTypeWithNullability(tt, componentType.isNullable());
        boolean isn = type.isNullable();
        type = typeFactory.createMultisetType(tt, -1);
        type = typeFactory.createTypeWithNullability(type, isn);
      }
    }
    return cx.getRexBuilder().makeCast(type, arg);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertDatetimeMinus ( SqlRexContext  cx, SqlDatetimeSubtractionOperator  op, SqlCall  call  )

inline

Definition at line 599 of file StandardConvertletTable.java.

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

                                                                             {
    // Rewrite datetime minus
    final RexBuilder rexBuilder = cx.getRexBuilder();
    final List<SqlNode> operands = call.getOperandList();
    final List<RexNode> exprs =
            convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE);

    final RelDataType resType = cx.getValidator().getValidatedNodeType(call);
    return rexBuilder.makeCall(resType, op, exprs.subList(0, 2));
  }

Here is the caller graph for this function:

static List<RexNode> org.apache.calcite.sql2rel.StandardConvertletTable.convertExpressionList ( SqlRexContext  cx, List< SqlNode >  nodes, SqlOperandTypeChecker.Consistency  consistency  )

inlinestaticprivate

Definition at line 767 of file StandardConvertletTable.java.

References run_benchmark_import.type.

                                                         {
    final List<RexNode> exprs = new ArrayList<>();
    for (SqlNode node : nodes) {
      exprs.add(cx.convertExpression(node));
    }
    if (exprs.size() > 1) {
      final RelDataType type = consistentType(cx, consistency, RexUtil.types(exprs));
      if (type != null) {
        final List<RexNode> oldExprs = Lists.newArrayList(exprs);
        exprs.clear();
        for (RexNode expr : oldExprs) {
          exprs.add(cx.getRexBuilder().ensureType(type, expr, true));
        }
      }
    }
    return exprs;
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertExtract ( SqlRexContext  cx, SqlExtractFunction  op, SqlCall  call  )

inline

Converts a call to the

EXTRACT 

function.

Called automatically via reflection.

Definition at line 568 of file StandardConvertletTable.java.

                                                                                       {
    return convertFunction(cx, (SqlFunction) call.getOperator(), call);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertFloorCeil ( SqlRexContext  cx, SqlCall  call  )

inlineprotected

Definition at line 531 of file StandardConvertletTable.java.

                                                                     {
    final boolean floor = call.getKind() == SqlKind.FLOOR;
    // Rewrite floor, ceil of interval
    if (call.operandCount() == 1 && call.operand(0) instanceof SqlIntervalLiteral) {
      final SqlIntervalLiteral literal = call.operand(0);
      SqlIntervalLiteral.IntervalValue interval =
              literal.getValueAs(SqlIntervalLiteral.IntervalValue.class);
      BigDecimal val = interval.getIntervalQualifier().getStartUnit().multiplier;
      RexNode rexInterval = cx.convertExpression(literal);

      final RexBuilder rexBuilder = cx.getRexBuilder();
      RexNode zero = rexBuilder.makeExactLiteral(BigDecimal.valueOf(0));
      RexNode cond = ge(rexBuilder, rexInterval, zero);

      RexNode pad = rexBuilder.makeExactLiteral(val.subtract(BigDecimal.ONE));
      RexNode cast = rexBuilder.makeReinterpretCast(
              rexInterval.getType(), pad, rexBuilder.makeLiteral(false));
      RexNode sum = floor ? minus(rexBuilder, rexInterval, cast)
                          : plus(rexBuilder, rexInterval, cast);

      RexNode kase = floor ? case_(rexBuilder, rexInterval, cond, sum)
                           : case_(rexBuilder, sum, cond, rexInterval);

      RexNode factor = rexBuilder.makeExactLiteral(val);
      RexNode div = divideInt(rexBuilder, kase, factor);
      return multiply(rexBuilder, div, factor);
    }

    // normal floor, ceil function
    return convertFunction(cx, (SqlFunction) call.getOperator(), call);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertFunction ( SqlRexContext  cx, SqlFunction  fun, SqlCall  call  )

inline

Definition at line 611 of file StandardConvertletTable.java.

                                                                                  {
    final List<SqlNode> operands = call.getOperandList();
    final List<RexNode> exprs =
            convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE);
    if (fun.getFunctionType() == SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR) {
      return makeConstructorCall(cx, fun, exprs);
    }
    RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
    if (returnType == null) {
      returnType = cx.getRexBuilder().deriveReturnType(fun, exprs);
    }
    return cx.getRexBuilder().makeCall(returnType, fun, exprs);
  }

static RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertInterval ( SqlRexContext  cx, SqlCall  call  )

inlinestaticprivate

Converts an interval expression to a numeric multiplied by an interval literal.

Definition at line 294 of file StandardConvertletTable.java.

References anonymous_namespace{Utm.h}.n.

                                                                         {
    // "INTERVAL n HOUR" becomes "n * INTERVAL '1' HOUR"
    final SqlNode n = call.operand(0);
    final SqlIntervalQualifier intervalQualifier = call.operand(1);
    final SqlIntervalLiteral literal = SqlLiteral.createInterval(
            1, "1", intervalQualifier, call.getParserPosition());
    final SqlCall multiply =
            SqlStdOperatorTable.MULTIPLY.createCall(call.getParserPosition(), n, literal);
    return cx.convertExpression(multiply);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertIsDistinctFrom ( SqlRexContext  cx, SqlCall  call, boolean  neg  )

inlineprivate

Definition at line 863 of file StandardConvertletTable.java.

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

                                                                                     {
    RexNode op0 = cx.convertExpression(call.operand(0));
    RexNode op1 = cx.convertExpression(call.operand(1));
    return RelOptUtil.isDistinctFrom(cx.getRexBuilder(), op0, op1, neg);
  }

Here is the caller graph for this function:

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertJdbc ( SqlRexContext  cx, SqlJdbcFunctionCall  op, SqlCall  call  )

inline

Definition at line 443 of file StandardConvertletTable.java.

                                                                                     {
    // Yuck!! The function definition contains arguments!
    // TODO: adopt a more conventional definition/instance structure
    final SqlCall convertedCall = op.getLookupCall();
    return cx.convertExpression(convertedCall);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertJsonValueFunction ( SqlRexContext  cx, SqlJsonValueFunction  fun, SqlCall  call  )

inline

Definition at line 638 of file StandardConvertletTable.java.

                                                                    {
    // For Expression with explicit return type:
    // i.e. json_value('{"foo":"bar"}', 'lax $.foo', returning varchar(2000))
    // use the specified type as the return type.
    List<SqlNode> operands = call.getOperandList();
    boolean hasExplicitReturningType = SqlJsonValueFunction.hasExplicitTypeSpec(
            operands.toArray(SqlNode.EMPTY_ARRAY));
    if (hasExplicitReturningType) {
      operands = SqlJsonValueFunction.removeTypeSpecOperands(call);
    }
    final List<RexNode> exprs =
            convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE);
    RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
    return cx.getRexBuilder().makeCall(returnType, fun, exprs);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertLiteralChain ( SqlRexContext  cx, SqlLiteralChainOperator  op, SqlCall  call  )

inline

Converts a LiteralChain expression: that is, concatenates the operands immediately, to produce a single literal string.

Called automatically via reflection.

Definition at line 914 of file StandardConvertletTable.java.

                                                                      {
    Util.discard(cx);

    SqlLiteral sum = SqlLiteralChainOperator.concatenateOperands(call);
    return cx.convertLiteral(sum);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertMap ( SqlRexContext  cx, SqlMapValueConstructor  op, SqlCall  call  )

inline

Definition at line 419 of file StandardConvertletTable.java.

                                                                                       {
    return convertCall(cx, call);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertMultiset ( SqlRexContext  cx, SqlMultisetValueConstructor  op, SqlCall  call  )

inline

Definition at line 393 of file StandardConvertletTable.java.

                                                                          {
    final RelDataType originalType = cx.getValidator().getValidatedNodeType(call);
    RexRangeRef rr = cx.getSubQueryExpr(call);
    assert rr != null;
    RelDataType msType = rr.getType().getFieldList().get(0).getType();
    RexNode expr = cx.getRexBuilder().makeInputRef(msType, rr.getOffset());
    assert msType.getComponentType().isStruct();
    if (!originalType.getComponentType().isStruct()) {
      // If the type is not a struct, the multiset operator will have
      // wrapped the type as a record. Add a call to the $SLICE operator
      // to compensate. For example,
      // if '<ms>' has type 'RECORD (INTEGER x) MULTISET',
      // then '$SLICE(<ms>) has type 'INTEGER MULTISET'.
      // This will be removed as the expression is translated.
      expr = cx.getRexBuilder().makeCall(
              originalType, SqlStdOperatorTable.SLICE, ImmutableList.of(expr));
    }
    return expr;
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertMultisetQuery ( SqlRexContext  cx, SqlMultisetQueryConstructor  op, SqlCall  call  )

inline

Definition at line 423 of file StandardConvertletTable.java.

                                                                          {
    final RelDataType originalType = cx.getValidator().getValidatedNodeType(call);
    RexRangeRef rr = cx.getSubQueryExpr(call);
    assert rr != null;
    RelDataType msType = rr.getType().getFieldList().get(0).getType();
    RexNode expr = cx.getRexBuilder().makeInputRef(msType, rr.getOffset());
    assert msType.getComponentType().isStruct();
    if (!originalType.getComponentType().isStruct()) {
      // If the type is not a struct, the multiset operator will have
      // wrapped the type as a record. Add a call to the $SLICE operator
      // to compensate. For example,
      // if '<ms>' has type 'RECORD (INTEGER x) MULTISET',
      // then '$SLICE(<ms>) has type 'INTEGER MULTISET'.
      // This will be removed as the expression is translated.
      expr = cx.getRexBuilder().makeCall(SqlStdOperatorTable.SLICE, expr);
    }
    return expr;
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertOverlaps ( SqlRexContext  cx, SqlOverlapsOperator  op, SqlCall  call  )

inline

Converts a call to OVERLAPS.

Called automatically via reflection.

Definition at line 947 of file StandardConvertletTable.java.

                                                                                         {
    // for intervals [t0, t1] overlaps [t2, t3], we can find if the
    // intervals overlaps by: ~(t1 < t2 or t3 < t0)
    assert call.getOperandList().size() == 2;

    final Pair<RexNode, RexNode> left =
            convertOverlapsOperand(cx, call.getParserPosition(), call.operand(0));
    final RexNode r0 = left.left;
    final RexNode r1 = left.right;
    final Pair<RexNode, RexNode> right =
            convertOverlapsOperand(cx, call.getParserPosition(), call.operand(1));
    final RexNode r2 = right.left;
    final RexNode r3 = right.right;

    // Sort end points into start and end, such that (s0 <= e0) and (s1 <= e1).
    final RexBuilder rexBuilder = cx.getRexBuilder();
    RexNode leftSwap = le(rexBuilder, r0, r1);
    final RexNode s0 = case_(rexBuilder, leftSwap, r0, r1);
    final RexNode e0 = case_(rexBuilder, leftSwap, r1, r0);
    RexNode rightSwap = le(rexBuilder, r2, r3);
    final RexNode s1 = case_(rexBuilder, rightSwap, r2, r3);
    final RexNode e1 = case_(rexBuilder, rightSwap, r3, r2);
    // (e0 >= s1) AND (e1 >= s0)
    switch (op.kind) {
      case OVERLAPS:
        return and(rexBuilder, ge(rexBuilder, e0, s1), ge(rexBuilder, e1, s0));
      case CONTAINS:
        return and(rexBuilder, le(rexBuilder, s0, s1), ge(rexBuilder, e0, e1));
      case PERIOD_EQUALS:
        return and(rexBuilder, eq(rexBuilder, s0, s1), eq(rexBuilder, e0, e1));
      case PRECEDES:
        return le(rexBuilder, e0, s1);
      case IMMEDIATELY_PRECEDES:
        return eq(rexBuilder, e0, s1);
      case SUCCEEDS:
        return ge(rexBuilder, s0, e1);
      case IMMEDIATELY_SUCCEEDS:
        return eq(rexBuilder, s0, e1);
      default:
        throw new AssertionError(op);
    }
  }

Pair<RexNode, RexNode> org.apache.calcite.sql2rel.StandardConvertletTable.convertOverlapsOperand ( SqlRexContext  cx, SqlParserPos  pos, SqlNode  operand  )

inlineprivate

Definition at line 990 of file StandardConvertletTable.java.

                                                               {
    final SqlNode a0;
    final SqlNode a1;
    switch (operand.getKind()) {
      case ROW:
        a0 = ((SqlCall) operand).operand(0);
        final SqlNode a10 = ((SqlCall) operand).operand(1);
        final RelDataType t1 = cx.getValidator().getValidatedNodeType(a10);
        if (SqlTypeUtil.isInterval(t1)) {
          // make t1 = t0 + t1 when t1 is an interval.
          a1 = plus(pos, a0, a10);
        } else {
          a1 = a10;
        }
        break;
      default:
        a0 = operand;
        a1 = operand;
    }

    final RexNode r0 = cx.convertExpression(a0);
    final RexNode r1 = cx.convertExpression(a1);
    return Pair.of(r0, r1);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertPlus ( SqlRexContext  cx, SqlCall  call  )

inlineprivate

Definition at line 827 of file StandardConvertletTable.java.

                                                              {
    final RexNode rex = convertCall(cx, call);
    switch (rex.getType().getSqlTypeName()) {
      case DATE:
      case TIME:
      case TIMESTAMP:
        // Use special "+" operator for datetime + interval.
        // Re-order operands, if necessary, so that interval is second.
        final RexBuilder rexBuilder = cx.getRexBuilder();
        List<RexNode> operands = ((RexCall) rex).getOperands();
        if (operands.size() == 2) {
          final SqlTypeName sqlTypeName = operands.get(0).getType().getSqlTypeName();
          switch (sqlTypeName) {
            case INTERVAL_YEAR:
            case INTERVAL_YEAR_MONTH:
            case INTERVAL_MONTH:
            case INTERVAL_DAY:
            case INTERVAL_DAY_HOUR:
            case INTERVAL_DAY_MINUTE:
            case INTERVAL_DAY_SECOND:
            case INTERVAL_HOUR:
            case INTERVAL_HOUR_MINUTE:
            case INTERVAL_HOUR_SECOND:
            case INTERVAL_MINUTE:
            case INTERVAL_MINUTE_SECOND:
            case INTERVAL_SECOND:
              operands = ImmutableList.of(operands.get(1), operands.get(0));
          }
        }
        return rexBuilder.makeCall(
                rex.getType(), SqlStdOperatorTable.DATETIME_PLUS, operands);
      default:
        return rex;
    }
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertRow ( SqlRexContext  cx, SqlRowOperator  op, SqlCall  call  )

inline

Converts a ROW.

Called automatically via reflection.

Definition at line 927 of file StandardConvertletTable.java.

References run_benchmark_import.type.

                                                                               {
    if (cx.getValidator().getValidatedNodeType(call).getSqlTypeName()
            != SqlTypeName.COLUMN_LIST) {
      return convertCall(cx, call);
    }
    final RexBuilder rexBuilder = cx.getRexBuilder();
    final List<RexNode> columns = new ArrayList<>();
    for (SqlNode operand : call.getOperandList()) {
      columns.add(rexBuilder.makeLiteral(((SqlIdentifier) operand).getSimple()));
    }
    final RelDataType type =
            rexBuilder.deriveReturnType(SqlStdOperatorTable.COLUMN_LIST, columns);
    return rexBuilder.makeCall(type, SqlStdOperatorTable.COLUMN_LIST, columns);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertSequenceValue ( SqlRexContext  cx, SqlSequenceValueOperator  fun, SqlCall  call  )

inline

Definition at line 655 of file StandardConvertletTable.java.

                                                                        {
    final List<SqlNode> operands = call.getOperandList();
    assert operands.size() == 1;
    assert operands.get(0) instanceof SqlIdentifier;
    final SqlIdentifier id = (SqlIdentifier) operands.get(0);
    final String key = Util.listToString(id.names);
    RelDataType returnType = cx.getValidator().getValidatedNodeType(call);
    return cx.getRexBuilder().makeCall(
            returnType, fun, ImmutableList.of(cx.getRexBuilder().makeLiteral(key)));
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertTryCast ( SqlRexContext  cx, final SqlCall  call  )

inlineprotected

Definition at line 506 of file StandardConvertletTable.java.

References com.mapd.calcite.parser.HeavyDBSqlOperatorTable.TRY_CAST, and run_benchmark_import.type.

                                                                         {
    RelDataTypeFactory typeFactory = cx.getTypeFactory();
    // assert call.getKind() == SqlKind.CAST;
    final SqlNode left = call.operand(0);
    final SqlNode right = call.operand(1);

    SqlDataTypeSpec dataType = (SqlDataTypeSpec) right;
    RelDataType type = dataType.deriveType(cx.getValidator());
    if (type == null) {
      type = cx.getValidator().getValidatedNodeType(dataType.getTypeName());
    }
    RexNode arg = cx.convertExpression(left);
    if (arg.getType().isNullable()) {
      type = typeFactory.createTypeWithNullability(type, true);
    }
    if (SqlUtil.isNullLiteral(left, false)) {
      final SqlValidatorImpl validator = (SqlValidatorImpl) cx.getValidator();
      validator.setValidatedNodeType(left, type);
      return cx.convertExpression(left);
    }
    return cx.getRexBuilder().makeCall(
            type, HeavyDBSqlOperatorTable.TRY_CAST, ImmutableList.of(arg));
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.convertWindowFunction ( SqlRexContext  cx, SqlWindowTableFunction  fun, SqlCall  call  )

inline

Definition at line 625 of file StandardConvertletTable.java.

                                                                      {
    // The first operand of window function is actually a query, skip that.
    final List<SqlNode> operands = Util.skip(call.getOperandList(), 1);
    final List<RexNode> exprs =
            convertExpressionList(cx, operands, SqlOperandTypeChecker.Consistency.NONE);
    RelDataType returnType = cx.getValidator().getValidatedNodeTypeIfKnown(call);
    if (returnType == null) {
      returnType = cx.getRexBuilder().deriveReturnType(fun, exprs);
    }
    return cx.getRexBuilder().makeCall(returnType, fun, exprs);
  }

static RexNode org.apache.calcite.sql2rel.StandardConvertletTable.divide ( RexBuilder  rexBuilder, RexNode  res, BigDecimal  val  )

inlinestaticprivate

Definition at line 581 of file StandardConvertletTable.java.

References run_benchmark_import.res.

                                                                                    {
    if (val.equals(BigDecimal.ONE)) {
      return res;
    }
    // If val is between 0 and 1, rather than divide by val, multiply by its
    // reciprocal. For example, rather than divide by 0.001 multiply by 1000.
    if (val.compareTo(BigDecimal.ONE) < 0 && val.signum() == 1) {
      try {
        final BigDecimal reciprocal =
                BigDecimal.ONE.divide(val, RoundingMode.UNNECESSARY);
        return multiply(rexBuilder, res, rexBuilder.makeExactLiteral(reciprocal));
      } catch (ArithmeticException e) {
        // ignore - reciprocal is not an integer
      }
    }
    return divideInt(rexBuilder, res, rexBuilder.makeExactLiteral(val));
  }

static RexNode org.apache.calcite.sql2rel.StandardConvertletTable.divideInt ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlinestaticprivate

Definition at line 327 of file StandardConvertletTable.java.

                                                                                  {
    return rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE_INTEGER, a0, a1);
  }

List<Integer> org.apache.calcite.sql2rel.StandardConvertletTable.elseArgs ( int  count )

inlineprivate

Definition at line 752 of file StandardConvertletTable.java.

                                            {
    // If list is odd, e.g. [0, 1, 2, 3, 4] we get [1, 3, 4]
    // If list is even, e.g. [0, 1, 2, 3, 4, 5] we get [2, 4, 5]
    final List<Integer> list = new ArrayList<>();
    for (int i = count % 2;;) {
      list.add(i);
      i += 2;
      if (i >= count) {
        list.add(i - 1);
        break;
      }
    }
    return list;
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.eq ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlineprivate

Definition at line 311 of file StandardConvertletTable.java.

                                                                    {
    return rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, a0, a1);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.ge ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlineprivate

Definition at line 315 of file StandardConvertletTable.java.

                                                                    {
    return rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN_OR_EQUAL, a0, a1);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.le ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlineprivate

Definition at line 319 of file StandardConvertletTable.java.

                                                                    {
    return rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN_OR_EQUAL, a0, a1);
  }

static RexNode org.apache.calcite.sql2rel.StandardConvertletTable.makeConstructorCall ( SqlRexContext  cx, SqlFunction  constructor, List< RexNode >  exprs  )

inlinestaticprivate

Definition at line 691 of file StandardConvertletTable.java.

References anonymous_namespace{Utm.h}.n, and run_benchmark_import.type.

                                                                          {
    final RexBuilder rexBuilder = cx.getRexBuilder();
    RelDataType type = rexBuilder.deriveReturnType(constructor, exprs);

    int n = type.getFieldCount();
    ImmutableList.Builder<RexNode> initializationExprs = ImmutableList.builder();
    final InitializerContext initializerContext = new InitializerContext() {
      public RexBuilder getRexBuilder() {
        return rexBuilder;
      }

      public SqlNode validateExpression(RelDataType rowType, SqlNode expr) {
        throw new UnsupportedOperationException();
      }

      public RexNode convertExpression(SqlNode e) {
        throw new UnsupportedOperationException();
      }
    };
    for (int i = 0; i < n; ++i) {
      initializationExprs.add(
              cx.getInitializerExpressionFactory().newAttributeInitializer(
                      type, constructor, i, exprs, initializerContext));
    }

    List<RexNode> defaultCasts = RexUtil.generateCastExpressions(
            rexBuilder, type, initializationExprs.build());

    return rexBuilder.makeNewInvocation(type, defaultCasts);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.minus ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlineprivate

Definition at line 335 of file StandardConvertletTable.java.

                                                                       {
    return rexBuilder.makeCall(SqlStdOperatorTable.MINUS, a0, a1);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.mod ( RexBuilder  rexBuilder, RelDataType  resType, RexNode  res, BigDecimal  val  )

inlineprivate

Definition at line 572 of file StandardConvertletTable.java.

References run_benchmark_import.res.

                                                                                   {
    if (val.equals(BigDecimal.ONE)) {
      return res;
    }
    return rexBuilder.makeCall(
            SqlStdOperatorTable.MOD, res, rexBuilder.makeExactLiteral(val, resType));
  }

static RexNode org.apache.calcite.sql2rel.StandardConvertletTable.multiply ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlinestaticprivate

Definition at line 339 of file StandardConvertletTable.java.

                                                                                 {
    return rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, a0, a1);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.or ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlineprivate

Definition at line 307 of file StandardConvertletTable.java.

                                                                    {
    return rexBuilder.makeCall(SqlStdOperatorTable.OR, a0, a1);
  }

RexNode org.apache.calcite.sql2rel.StandardConvertletTable.plus ( RexBuilder  rexBuilder, RexNode  a0, RexNode  a1  )

inlineprivate

Definition at line 331 of file StandardConvertletTable.java.

                                                                      {
    return rexBuilder.makeCall(SqlStdOperatorTable.PLUS, a0, a1);
  }

SqlCall org.apache.calcite.sql2rel.StandardConvertletTable.plus ( SqlParserPos  pos, SqlNode  a0, SqlNode  a1  )

inlineprivate

Definition at line 349 of file StandardConvertletTable.java.

                                                                 {
    return SqlStdOperatorTable.PLUS.createCall(pos, a0, a1);
  }

Member Data Documentation

final StandardConvertletTable org.apache.calcite.sql2rel.StandardConvertletTable.INSTANCE = new StandardConvertletTable()

static

Singleton instance.

Definition at line 97 of file StandardConvertletTable.java.

---

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/StandardConvertletTable.java