org.apache.calcite.sql2rel.StandardConvertletTable.AvgVarianceConvertlet Class Reference

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

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

Public Member Functions
RexNode	convertCall (SqlRexContext cx, SqlCall call)

Package Functions
	AvgVarianceConvertlet (SqlKind kind)

Private Member Functions
SqlNode	expandAvg (final SqlNode arg, final RelDataType avgType, final SqlRexContext cx)
SqlNode	expandVariance (final SqlNode argInput, final RelDataType varType, final SqlRexContext cx, boolean biased, boolean sqrt)
SqlNode	getCastedSqlNode (SqlNode argInput, RelDataType varType, SqlParserPos pos, RexNode argRex)

Private Attributes
final SqlKind	kind

Detailed Description

Convertlet that handles

AVG 

and

VARIANCE 

windowed aggregate functions.

Definition at line 1173 of file StandardConvertletTable.java.

Constructor & Destructor Documentation

org.apache.calcite.sql2rel.StandardConvertletTable.AvgVarianceConvertlet.AvgVarianceConvertlet ( SqlKind  kind )

inlinepackage

Definition at line 1176 of file StandardConvertletTable.java.

                                        {
      this.kind = kind;
    }

Member Function Documentation

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

inline

Definition at line 1180 of file StandardConvertletTable.java.

References AVG, and run_benchmark_import.type.

                                                               {
      assert call.operandCount() == 1;
      final SqlNode arg = call.operand(0);
      final SqlNode expr;
      final RelDataType type = cx.getValidator().getValidatedNodeType(call);
      switch (kind) {
        case AVG:
          expr = expandAvg(arg, type, cx);
          break;
        case STDDEV_POP:
          expr = expandVariance(arg, type, cx, true, true);
          break;
        case STDDEV_SAMP:
          expr = expandVariance(arg, type, cx, false, true);
          break;
        case VAR_POP:
          expr = expandVariance(arg, type, cx, true, false);
          break;
        case VAR_SAMP:
          expr = expandVariance(arg, type, cx, false, false);
          break;
        default:
          throw Util.unexpected(kind);
      }
      RexNode rex = cx.convertExpression(expr);
      return cx.getRexBuilder().ensureType(type, rex, true);
    }

SqlNode org.apache.calcite.sql2rel.StandardConvertletTable.AvgVarianceConvertlet.expandAvg ( final SqlNode  arg, final RelDataType  avgType, final SqlRexContext  cx  )

inlineprivate

Definition at line 1208 of file StandardConvertletTable.java.

                                                                                  {
      final SqlParserPos pos = SqlParserPos.ZERO;
      final SqlNode sum = SqlStdOperatorTable.SUM.createCall(pos, arg);
      final RexNode sumRex = cx.convertExpression(sum);
      final SqlNode sumCast;
      sumCast = getCastedSqlNode(sum, avgType, pos, sumRex);
      final SqlNode count = SqlStdOperatorTable.COUNT.createCall(pos, arg);
      return SqlStdOperatorTable.DIVIDE.createCall(pos, sumCast, count);
    }

SqlNode org.apache.calcite.sql2rel.StandardConvertletTable.AvgVarianceConvertlet.expandVariance ( final SqlNode  argInput, final RelDataType  varType, final SqlRexContext  cx, boolean  biased, boolean  sqrt  )

inlineprivate

Definition at line 1219 of file StandardConvertletTable.java.

References run_benchmark_import.result.

                          {
      // stddev_pop(x) ==>
      //   power(
      //     (sum(x * x) - sum(x) * sum(x) / count(x))
      //     / count(x),
      //     .5)
      //
      // stddev_samp(x) ==>
      //   power(
      //     (sum(x * x) - sum(x) * sum(x) / count(x))
      //     / (count(x) - 1),
      //     .5)
      //
      // var_pop(x) ==>
      //     (sum(x * x) - sum(x) * sum(x) / count(x))
      //     / count(x)
      //
      // var_samp(x) ==>
      //     (sum(x * x) - sum(x) * sum(x) / count(x))
      //     / (count(x) - 1)
      final SqlParserPos pos = SqlParserPos.ZERO;

      final SqlNode arg =
              getCastedSqlNode(argInput, varType, pos, cx.convertExpression(argInput));

      final SqlNode argSquared = SqlStdOperatorTable.MULTIPLY.createCall(pos, arg, arg);
      final SqlNode argSquaredCasted = getCastedSqlNode(
              argSquared, varType, pos, cx.convertExpression(argSquared));
      final SqlNode sumArgSquared =
              SqlStdOperatorTable.SUM.createCall(pos, argSquaredCasted);
      final SqlNode sumArgSquaredCasted = getCastedSqlNode(
              sumArgSquared, varType, pos, cx.convertExpression(sumArgSquared));
      final SqlNode sum = SqlStdOperatorTable.SUM.createCall(pos, arg);
      final SqlNode sumCasted =
              getCastedSqlNode(sum, varType, pos, cx.convertExpression(sum));
      final SqlNode sumSquared =
              SqlStdOperatorTable.MULTIPLY.createCall(pos, sumCasted, sumCasted);
      final SqlNode sumSquaredCasted = getCastedSqlNode(
              sumSquared, varType, pos, cx.convertExpression(sumSquared));
      final SqlNode count = SqlStdOperatorTable.COUNT.createCall(pos, arg);
      final SqlNode countCasted =
              getCastedSqlNode(count, varType, pos, cx.convertExpression(count));
      final SqlNode avgSumSquared =
              SqlStdOperatorTable.DIVIDE.createCall(pos, sumSquaredCasted, countCasted);
      final SqlNode avgSumSquaredCasted = getCastedSqlNode(
              avgSumSquared, varType, pos, cx.convertExpression(avgSumSquared));
      final SqlNode diff = SqlStdOperatorTable.MINUS.createCall(
              pos, sumArgSquaredCasted, avgSumSquaredCasted);
      final SqlNode diffCasted =
              getCastedSqlNode(diff, varType, pos, cx.convertExpression(diff));
      final SqlNode denominator;
      if (biased) {
        denominator = countCasted;
      } else {
        final SqlNumericLiteral one = SqlLiteral.createExactNumeric("1", pos);
        final SqlLiteral nullLiteral = SqlLiteral.createNull(SqlParserPos.ZERO);
        denominator = new SqlCase(SqlParserPos.ZERO,
                count,
                SqlNodeList.of(SqlStdOperatorTable.EQUALS.createCall(pos, count, one)),
                SqlNodeList.of(getCastedSqlNode(nullLiteral, varType, pos, null)),
                SqlStdOperatorTable.MINUS.createCall(pos, count, one));
      }
      final SqlNode div =
              SqlStdOperatorTable.DIVIDE.createCall(pos, diffCasted, denominator);
      final SqlNode divCasted =
              getCastedSqlNode(div, varType, pos, cx.convertExpression(div));

      SqlNode result = div;
      if (sqrt) {
        final SqlNumericLiteral half = SqlLiteral.createExactNumeric("0.5", pos);
        result = SqlStdOperatorTable.POWER.createCall(pos, divCasted, half);
      }
      return result;
    }

SqlNode org.apache.calcite.sql2rel.StandardConvertletTable.AvgVarianceConvertlet.getCastedSqlNode ( SqlNode  argInput, RelDataType  varType, SqlParserPos  pos, RexNode  argRex  )

inlineprivate

Definition at line 1298 of file StandardConvertletTable.java.

                                                                                     {
      SqlNode arg;
      if (argRex != null && !argRex.getType().equals(varType)) {
        arg = SqlStdOperatorTable.CAST.createCall(
                pos, argInput, SqlTypeUtil.convertTypeToSpec(varType));
      } else {
        arg = argInput;
      }
      return arg;
    }

Member Data Documentation

final SqlKind org.apache.calcite.sql2rel.StandardConvertletTable.AvgVarianceConvertlet.kind

private

Definition at line 1174 of file StandardConvertletTable.java.

Referenced by TableFunctionsFactory_linker.BaseGenerateFiles._get_filename(), heavydb.serialized_result_set.ttypes.TTargetInfo.read(), and heavydb.serialized_result_set.ttypes.TTargetInfo.write().

---

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