org.apache.calcite.sql.SqlCall - java examples

Here are the examples of the java api org.apache.calcite.sql.SqlCall taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

155 Examples 7

19 View Complete Implementation : SqlDotOperator.java
Copyright Apache License 2.0
Author : lealone
@Override
public <R> void acceptCall(SqlVisitor<R> visitor, SqlCall call, boolean onlyExpressions, SqlBasicVisitor.ArgHandler<R> argHandler) {
    if (onlyExpressions) {
        // Do not visit operands[1] -- it is not an expression.
        argHandler.visitChild(visitor, call, 0, call.operand(0));
    } else {
        super.acceptCall(visitor, call, onlyExpressions, argHandler);
    }
}

19 View Complete Implementation : SqlDefaultOperator.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    writer.keyword(getName());
}

19 View Complete Implementation : SqlJsonApiCommonSyntaxOperator.java
Copyright Apache License 2.0
Author : lealone
@Override
protected void checkOperandCount(SqlValidator validator, SqlOperandTypeChecker argType, SqlCall call) {
    if (call.operandCount() != 2) {
        throw new UnsupportedOperationException("json preplaceding syntax is not yet supported");
    }
}

19 View Complete Implementation : DrillViewTable.java
Copyright Apache License 2.0
Author : lealone
@Override
public boolean rolledUpColumnValidInsideAgg(String column, SqlCall call, SqlNode parent, CalciteConnectionConfig config) {
    return true;
}

19 View Complete Implementation : SqlJsonTypeFunction.java
Copyright Apache License 2.0
Author : lealone
@Override
protected void checkOperandCount(SqlValidator validator, SqlOperandTypeChecker argType, SqlCall call) {
    replacedert call.operandCount() == 1;
}

19 View Complete Implementation : MssqlSqlDialect.java
Copyright Apache License 2.0
Author : lealone
/**
 * Unparses datetime floor for Microsoft SQL Server.
 * There is no TRUNC function, so simulate this using calls to CONVERT.
 *
 * @param writer Writer
 * @param call Call
 */
private void unparseFloor(SqlWriter writer, SqlCall call) {
    SqlLiteral node = call.operand(1);
    TimeUnitRange unit = (TimeUnitRange) node.getValue();
    switch(unit) {
        case YEAR:
            unparseFloorWithUnit(writer, call, 4, "-01-01");
            break;
        case MONTH:
            unparseFloorWithUnit(writer, call, 7, "-01");
            break;
        case WEEK:
            writer.print("CONVERT(DATETIME, CONVERT(VARCHAR(10), " + "DATEADD(day, - (6 + DATEPART(weekday, ");
            call.operand(0).unparse(writer, 0, 0);
            writer.print(")) % 7, ");
            call.operand(0).unparse(writer, 0, 0);
            writer.print("), 126))");
            break;
        case DAY:
            unparseFloorWithUnit(writer, call, 10, "");
            break;
        case HOUR:
            unparseFloorWithUnit(writer, call, 13, ":00:00");
            break;
        case MINUTE:
            unparseFloorWithUnit(writer, call, 16, ":00");
            break;
        case SECOND:
            unparseFloorWithUnit(writer, call, 19, ":00");
            break;
        default:
            throw new IllegalArgumentException("MSSQL does not support FLOOR for time unit: " + unit);
    }
}

19 View Complete Implementation : SqlScopedShuttle.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public final SqlNode visit(SqlCall call) {
    SqlValidatorScope oldScope = scopes.peek();
    SqlValidatorScope newScope = oldScope.getOperandScope(call);
    scopes.push(newScope);
    SqlNode result = visitScoped(call);
    scopes.pop();
    return result;
}

19 View Complete Implementation : AggregatingSelectScope.java
Copyright Apache License 2.0
Author : lealone
public SqlValidatorScope getOperandScope(SqlCall call) {
    if (call.getOperator().isAggregator()) {
        // If we're the 'SUM' node in 'select a + sum(b + c) from t
        // group by a', then we should validate our arguments in
        // the non-aggregating scope, where 'b' and 'c' are valid
        // column references.
        return parent;
    } else {
        // Check whether expression is constant within the group.
        // 
        // If not, throws. Example, 'empno' in
        // SELECT empno FROM emp GROUP BY deptno
        // 
        // If it perfectly matches an expression in the GROUP BY
        // clause, we validate its arguments in the non-aggregating
        // scope. Example, 'empno + 1' in
        // 
        // SELECT empno + 1 FROM emp GROUP BY empno + 1
        final boolean matches = checkAggregateExpr(call, false);
        if (matches) {
            return parent;
        }
    }
    return super.getOperandScope(call);
}

19 View Complete Implementation : SqlArgumentAssignmentOperator.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    // Arguments are held in reverse order to be consistent with base clreplaced (AS).
    call.operand(1).unparse(writer, leftPrec, getLeftPrec());
    writer.keyword(getName());
    call.operand(0).unparse(writer, getRightPrec(), rightPrec);
}

19 View Complete Implementation : SqlJsonQueryFunction.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall(getName());
    call.operand(0).unparse(writer, 0, 0);
    final SqlJsonQueryWrapperBehavior wrapperBehavior = getEnumValue(call.operand(1));
    switch(wrapperBehavior) {
        case WITHOUT_ARRAY:
            writer.keyword("WITHOUT ARRAY");
            break;
        case WITH_CONDITIONAL_ARRAY:
            writer.keyword("WITH CONDITIONAL ARRAY");
            break;
        case WITH_UNCONDITIONAL_ARRAY:
            writer.keyword("WITH UNCONDITIONAL ARRAY");
            break;
        default:
            throw new IllegalStateException("unreachable code");
    }
    writer.keyword("WRAPPER");
    unparseEmptyOrErrorBehavior(writer, getEnumValue(call.operand(2)));
    writer.keyword("ON EMPTY");
    unparseEmptyOrErrorBehavior(writer, getEnumValue(call.operand(3)));
    writer.keyword("ON ERROR");
    writer.endFunCall(frame);
}

19 View Complete Implementation : DrillTable.java
Copyright Apache License 2.0
Author : lealone
@Override
public boolean rolledUpColumnValidInsideAgg(String column, SqlCall call, SqlNode parent, CalciteConnectionConfig config) {
    return true;
}

19 View Complete Implementation : SqlShuttle.java
Copyright Apache License 2.0
Author : lealone
public SqlNode visit(final SqlCall call) {
    // Handler creates a new copy of 'call' only if one or more operands
    // change.
    ArgHandler<SqlNode> argHandler = new CallCopyingArgHandler(call, false);
    call.getOperator().acceptCall(this, call, false, argHandler);
    return argHandler.result();
}

19 View Complete Implementation : SqlTranslate3Function.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall("TRANSLATE");
    for (SqlNode sqlNode : call.getOperandList()) {
        writer.sep(",");
        sqlNode.unparse(writer, leftPrec, rightPrec);
    }
    writer.endFunCall(frame);
}

19 View Complete Implementation : ParameterScope.java
Copyright Apache License 2.0
Author : lealone
public SqlValidatorScope getOperandScope(SqlCall call) {
    return this;
}

19 View Complete Implementation : DrillConvertletTable.java
Copyright Apache License 2.0
Author : lealone
/*
   * Lookup the hash table to see if we have a custom convertlet for a given
   * operator, if we don't use StandardConvertletTable.
   */
@Override
public SqlRexConvertlet get(SqlCall call) {
    SqlRexConvertlet convertlet;
    if (call.getOperator() instanceof DrillCalciteSqlWrapper) {
        final SqlOperator wrapper = call.getOperator();
        final SqlOperator wrapped = DrillCalciteWrapperUtility.extractSqlOperatorFromWrapper(call.getOperator());
        if ((convertlet = map.get(wrapped)) != null) {
            return convertlet;
        }
        ((SqlBasicCall) call).setOperator(wrapped);
        SqlRexConvertlet sqlRexConvertlet = StandardConvertletTable.INSTANCE.get(call);
        ((SqlBasicCall) call).setOperator(wrapper);
        return sqlRexConvertlet;
    }
    if ((convertlet = map.get(call.getOperator())) != null) {
        return convertlet;
    }
    return StandardConvertletTable.INSTANCE.get(call);
}

19 View Complete Implementation : SqlJsonPrettyFunction.java
Copyright Apache License 2.0
Author : lealone
@Override
protected void checkOperandCount(SqlValidator validator, SqlOperandTypeChecker argType, SqlCall call) {
    replacedert call.operandCount() == 1;
}

19 View Complete Implementation : SqlJsonTypeFunction.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    super.unparse(writer, call, 0, 0);
}

19 View Complete Implementation : SqlDatetimeSubtractionOperator.java
Copyright Apache License 2.0
Author : lealone
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    writer.getDialect().unparseSqlDatetimeArithmetic(writer, call, SqlKind.MINUS, leftPrec, rightPrec);
}

19 View Complete Implementation : ReflectiveConvertletTable.java
Copyright Apache License 2.0
Author : lealone
public SqlRexConvertlet get(SqlCall call) {
    SqlRexConvertlet convertlet;
    final SqlOperator op = call.getOperator();
    // Is there a convertlet for this operator
    // (e.g. SqlStdOperatorTable.plusOperator)?
    convertlet = (SqlRexConvertlet) map.get(op);
    if (convertlet != null) {
        return convertlet;
    }
    // Is there a convertlet for this clreplaced of operator
    // (e.g. SqlBinaryOperator)?
    Clreplaced<?> clazz = op.getClreplaced();
    while (clazz != null) {
        convertlet = (SqlRexConvertlet) map.get(clazz);
        if (convertlet != null) {
            return convertlet;
        }
        clazz = clazz.getSuperclreplaced();
    }
    // Is there a convertlet for this clreplaced of expression
    // (e.g. SqlCall)?
    clazz = call.getClreplaced();
    while (clazz != null) {
        convertlet = (SqlRexConvertlet) map.get(clazz);
        if (convertlet != null) {
            return convertlet;
        }
        clazz = clazz.getSuperclreplaced();
    }
    return null;
}

19 View Complete Implementation : SqlNewOperator.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
// override SqlOperator
public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
    // New specification is purely syntactic, so we rewrite it as a
    // direct call to the constructor method.
    return call.operand(0);
}

19 View Complete Implementation : SqlScopedShuttle.java
Copyright Apache License 2.0
Author : lealone
/**
 * Visits an operator call. If the call has entered a new scope, the base
 * clreplaced will have already modified the scope.
 */
protected SqlNode visitScoped(SqlCall call) {
    return super.visit(call);
}

19 View Complete Implementation : DrillTranslatableTable.java
Copyright Apache License 2.0
Author : lealone
@Override
public boolean rolledUpColumnValidInsideAgg(String column, SqlCall call, SqlNode parent, CalciteConnectionConfig config) {
    return true;
}

19 View Complete Implementation : SqlOverlayFunction.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall(getName());
    call.operand(0).unparse(writer, leftPrec, rightPrec);
    writer.sep("PLACING");
    call.operand(1).unparse(writer, leftPrec, rightPrec);
    writer.sep("FROM");
    call.operand(2).unparse(writer, leftPrec, rightPrec);
    if (4 == call.operandCount()) {
        writer.sep("FOR");
        call.operand(3).unparse(writer, leftPrec, rightPrec);
    }
    writer.endFunCall(frame);
}

19 View Complete Implementation : AbstractTable.java
Copyright Apache License 2.0
Author : lealone
@Override
public boolean rolledUpColumnValidInsideAgg(String column, SqlCall call, SqlNode parent, CalciteConnectionConfig config) {
    return true;
}

19 View Complete Implementation : SqlJsonApiCommonSyntaxOperator.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.SIMPLE);
    call.operand(0).unparse(writer, 0, 0);
    writer.sep(",", true);
    call.operand(1).unparse(writer, 0, 0);
    if (call.operandCount() > 2) {
        writer.keyword("PreplacedING");
        for (int i = 2; i < call.getOperandList().size(); i += 2) {
            call.operand(i).unparse(writer, 0, 0);
            writer.keyword("AS");
            call.operand(i + 1).unparse(writer, 0, 0);
        }
    }
    writer.endFunCall(frame);
}

19 View Complete Implementation : SqlBasicVisitor.java
Copyright Apache License 2.0
Author : lealone
public R visit(SqlCall call) {
    return call.getOperator().acceptCall(this, call);
}

19 View Complete Implementation : DelegatingScope.java
Copyright Apache License 2.0
Author : lealone
public SqlValidatorScope getOperandScope(SqlCall call) {
    if (call instanceof SqlSelect) {
        return validator.getSelectScope((SqlSelect) call);
    }
    return this;
}

19 View Complete Implementation : SqlJsonExistsFunction.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall(getName());
    call.operand(0).unparse(writer, 0, 0);
    if (call.operandCount() == 2) {
        call.operand(1).unparse(writer, 0, 0);
        writer.keyword("ON ERROR");
    }
    writer.endFunCall(frame);
}

19 View Complete Implementation : EmptyScope.java
Copyright Apache License 2.0
Author : lealone
public SqlValidatorScope getOperandScope(SqlCall call) {
    return this;
}

19 View Complete Implementation : ProcedureNamespace.java
Copyright Apache License 2.0
Author : lealone
/**
 * Namespace whose contents are defined by the result of a call to a
 * user-defined procedure.
 */
public clreplaced ProcedureNamespace extends AbstractNamespace {

    // ~ Instance fields --------------------------------------------------------
    private final SqlValidatorScope scope;

    private final SqlCall call;

    // ~ Constructors -----------------------------------------------------------
    ProcedureNamespace(SqlValidatorImpl validator, SqlValidatorScope scope, SqlCall call, SqlNode enclosingNode) {
        super(validator, enclosingNode);
        this.scope = scope;
        this.call = call;
    }

    // ~ Methods ----------------------------------------------------------------
    public RelDataType validateImpl(RelDataType targetRowType) {
        validator.inferUnknownTypes(validator.unknownType, scope, call);
        final RelDataType type = validator.deriveTypeImpl(scope, call);
        final SqlOperator operator = call.getOperator();
        final SqlCallBinding callBinding = new SqlCallBinding(validator, scope, call);
        if (operator instanceof SqlUserDefinedTableFunction) {
            replacedert type.getSqlTypeName() == SqlTypeName.CURSOR : "User-defined table function should have CURSOR type, not " + type;
            final SqlUserDefinedTableFunction udf = (SqlUserDefinedTableFunction) operator;
            return udf.getRowType(validator.typeFactory, callBinding.operands());
        } else if (operator instanceof SqlUserDefinedTableMacro) {
            replacedert type.getSqlTypeName() == SqlTypeName.CURSOR : "User-defined table macro should have CURSOR type, not " + type;
            final SqlUserDefinedTableMacro udf = (SqlUserDefinedTableMacro) operator;
            return udf.getTable(validator.typeFactory, callBinding.operands()).getRowType(validator.typeFactory);
        }
        return type;
    }

    public SqlNode getNode() {
        return call;
    }
}

19 View Complete Implementation : SqlConvertFunction.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall(getName());
    call.operand(0).unparse(writer, leftPrec, rightPrec);
    writer.sep("USING");
    call.operand(1).unparse(writer, leftPrec, rightPrec);
    writer.endFunCall(frame);
}

19 View Complete Implementation : SqlValidatorUtil.java
Copyright Apache License 2.0
Author : lealone
/**
 * replacedyzes a GROUPING SETS item in a GROUP BY clause.
 */
private static void convertGroupSet(SqlValidatorScope scope, Groupreplacedyzer groupreplacedyzer, ImmutableList.Builder<ImmutableBitSet> builder, SqlNode groupExpr) {
    switch(groupExpr.getKind()) {
        case GROUPING_SETS:
            final SqlCall call = (SqlCall) groupExpr;
            for (SqlNode node : call.getOperandList()) {
                convertGroupSet(scope, groupreplacedyzer, builder, node);
            }
            return;
        case ROW:
            final List<ImmutableBitSet> bitSets = replacedyzeGroupTuple(scope, groupreplacedyzer, ((SqlCall) groupExpr).getOperandList());
            builder.add(ImmutableBitSet.union(bitSets));
            return;
        case ROLLUP:
        case CUBE:
            {
                // GROUPING SETS ( (a), ROLLUP(c,b), CUBE(d,e) )
                // is EQUIVALENT to
                // GROUPING SETS ( (a), (c,b), (b) ,(), (d,e), (d), (e) ).
                // Expand all ROLLUP/CUBE nodes
                List<ImmutableBitSet> operandBitSet = replacedyzeGroupTuple(scope, groupreplacedyzer, ((SqlCall) groupExpr).getOperandList());
                switch(groupExpr.getKind()) {
                    case ROLLUP:
                        builder.addAll(rollup(operandBitSet));
                        return;
                    default:
                        builder.addAll(cube(operandBitSet));
                        return;
                }
            }
        default:
            builder.add(replacedyzeGroupExpr(scope, groupreplacedyzer, groupExpr));
            return;
    }
}

19 View Complete Implementation : SqlRollupOperator.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    unparseCube(writer, call);
}

19 View Complete Implementation : SqlNodeToRexConverterImpl.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public RexNode convertCall(SqlRexContext cx, SqlCall call) {
    final SqlRexConvertlet convertlet = convertletTable.get(call);
    if (convertlet != null) {
        return convertlet.convertCall(cx, call);
    }
    // No convertlet was suitable. (Unlikely, because the standard
    // convertlet table has a fall-back for all possible calls.)
    throw Util.needToImplement(call);
}

19 View Complete Implementation : SqlJsonDepthFunction.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    super.unparse(writer, call, 0, 0);
}

19 View Complete Implementation : CollectScope.java
Copyright Apache License 2.0
Author : lealone
/**
 * The name-resolution context for expression inside a multiset call. The
 * objects visible are multiset expressions, and those inherited from the parent
 * scope.
 *
 * @see CollectNamespace
 */
clreplaced CollectScope extends ListScope {

    // ~ Instance fields --------------------------------------------------------
    private final SqlValidatorScope usingScope;

    private final SqlCall child;

    // ~ Constructors -----------------------------------------------------------
    CollectScope(SqlValidatorScope parent, SqlValidatorScope usingScope, SqlCall child) {
        super(parent);
        this.usingScope = usingScope;
        this.child = child;
    }

    // ~ Methods ----------------------------------------------------------------
    public SqlNode getNode() {
        return child;
    }
}

19 View Complete Implementation : SqlExtractFunction.java
Copyright Apache License 2.0
Author : lealone
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall(getName());
    call.operand(0).unparse(writer, 0, 0);
    writer.sep("FROM");
    call.operand(1).unparse(writer, 0, 0);
    writer.endFunCall(frame);
}

19 View Complete Implementation : BigQuerySqlDialect.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparseCall(final SqlWriter writer, final SqlCall call, final int leftPrec, final int rightPrec) {
    switch(call.getKind()) {
        case POSITION:
            final SqlWriter.Frame frame = writer.startFunCall("STRPOS");
            writer.sep(",");
            call.operand(1).unparse(writer, leftPrec, rightPrec);
            writer.sep(",");
            call.operand(0).unparse(writer, leftPrec, rightPrec);
            if (3 == call.operandCount()) {
                throw new RuntimeException("3rd operand Not Supported for Function STRPOS in Big Query");
            }
            writer.endFunCall(frame);
            break;
        case UNION:
            if (!((SqlSetOperator) call.getOperator()).isAll()) {
                SqlSyntax.BINARY.unparse(writer, UNION_DISTINCT, call, leftPrec, rightPrec);
            }
            break;
        case EXCEPT:
            if (!((SqlSetOperator) call.getOperator()).isAll()) {
                SqlSyntax.BINARY.unparse(writer, EXCEPT_DISTINCT, call, leftPrec, rightPrec);
            }
            break;
        case INTERSECT:
            if (!((SqlSetOperator) call.getOperator()).isAll()) {
                SqlSyntax.BINARY.unparse(writer, INTERSECT_DISTINCT, call, leftPrec, rightPrec);
            }
            break;
        default:
            super.unparseCall(writer, call, leftPrec, rightPrec);
    }
}

19 View Complete Implementation : SqlRowOperator.java
Copyright Apache License 2.0
Author : lealone
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    SqlUtil.unparseFunctionSyntax(this, writer, call);
}

19 View Complete Implementation : SqlJsonPrettyFunction.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    super.unparse(writer, call, 0, 0);
}

19 View Complete Implementation : SqlJsonValueExpressionOperator.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    call.operand(0).unparse(writer, 0, 0);
    if (!structured) {
        writer.keyword("FORMAT JSON");
    }
}

19 View Complete Implementation : SqlPositionFunction.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall(getName());
    call.operand(0).unparse(writer, leftPrec, rightPrec);
    writer.sep("IN");
    call.operand(1).unparse(writer, leftPrec, rightPrec);
    if (3 == call.operandCount()) {
        writer.sep("FROM");
        call.operand(2).unparse(writer, leftPrec, rightPrec);
    }
    writer.endFunCall(frame);
}

19 View Complete Implementation : SqlThrowOperator.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
    final SqlWriter.Frame frame = writer.startFunCall(getName());
    call.operand(0).unparse(writer, 0, 0);
    writer.endFunCall(frame);
}

19 View Complete Implementation : SqlCursorConstructor.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public RelDataType deriveType(SqlValidator validator, SqlValidatorScope scope, SqlCall call) {
    SqlSelect subSelect = call.operand(0);
    validator.declareCursor(subSelect, scope);
    subSelect.validateExpr(validator, scope);
    return super.deriveType(validator, scope, call);
}

19 View Complete Implementation : CompoundIdentifierConverter.java
Copyright Apache License 2.0
Author : lealone
@Override
public SqlNode visit(final SqlCall call) {
    // Handler creates a new copy of 'call' only if one or more operands
    // change.
    ArgHandler<SqlNode> argHandler = new ComplexExpressionAware(call);
    boolean localEnableComplex = enableComplex;
    // for the case of UNNEST call set enableComplex to true
    // to convert DrillCompoundIdentifier to the item call.
    if (call.getKind() == SqlKind.UNNEST) {
        enableComplex = true;
    }
    call.getOperator().acceptCall(this, call, false, argHandler);
    enableComplex = localEnableComplex;
    return argHandler.result();
}

19 View Complete Implementation : HiveSqlDialect.java
Copyright Apache License 2.0
Author : lealone
@Override
public void unparseCall(final SqlWriter writer, final SqlCall call, final int leftPrec, final int rightPrec) {
    switch(call.getKind()) {
        case POSITION:
            final SqlWriter.Frame frame = writer.startFunCall("INSTR");
            writer.sep(",");
            call.operand(1).unparse(writer, leftPrec, rightPrec);
            writer.sep(",");
            call.operand(0).unparse(writer, leftPrec, rightPrec);
            if (3 == call.operandCount()) {
                throw new RuntimeException("3rd operand Not Supported for Function INSTR in Hive");
            }
            writer.endFunCall(frame);
            break;
        case MOD:
            SqlOperator op = SqlStdOperatorTable.PERCENT_REMAINDER;
            SqlSyntax.BINARY.unparse(writer, op, call, leftPrec, rightPrec);
            break;
        default:
            super.unparseCall(writer, call, leftPrec, rightPrec);
    }
}

19 View Complete Implementation : DrillSqlOperatorWithoutInference.java
Copyright Apache License 2.0
Author : lealone
@Override
public RelDataType deriveType(SqlValidator validator, SqlValidatorScope scope, SqlCall call) {
    if (NONE.equals(returnType)) {
        return validator.getTypeFactory().createSqlType(SqlTypeName.ANY);
    }
    /*
     * We return a nullable output type both in validation phase and in
     * Sql to Rel phase. We don't know the type of the output until runtime
     * hence have to choose the least restrictive type to avoid any wrong
     * results.
     */
    return getNullableReturnDataType(validator.getTypeFactory());
}

19 View Complete Implementation : IdentifierNamespace.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
protected static Pair<SqlIdentifier, SqlNodeList> split(SqlNode node) {
    switch(node.getKind()) {
        case EXTEND:
            final SqlCall call = (SqlCall) node;
            return Pair.of((SqlIdentifier) call.getOperandList().get(0), (SqlNodeList) call.getOperandList().get(1));
        default:
            return Pair.of((SqlIdentifier) node, null);
    }
}

19 View Complete Implementation : AggFinder.java
Copyright Apache License 2.0
Author : lealone
protected Void found(SqlCall call) {
    throw new Util.FoundOne(call);
}

18 View Complete Implementation : SqlRollupOperator.java
Copyright Apache License 2.0
Author : lealone
private static void unparseCube(SqlWriter writer, SqlCall call) {
    writer.keyword(call.getOperator().getName());
    final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.FUN_CALL, "(", ")");
    for (SqlNode operand : call.getOperandList()) {
        writer.sep(",");
        if (operand.getKind() == SqlKind.ROW) {
            final SqlWriter.Frame frame2 = writer.startList(SqlWriter.FrameTypeEnum.SIMPLE, "(", ")");
            for (SqlNode operand2 : ((SqlCall) operand).getOperandList()) {
                writer.sep(",");
                operand2.unparse(writer, 0, 0);
            }
            writer.endList(frame2);
        } else if (operand instanceof SqlNodeList && ((SqlNodeList) operand).size() == 0) {
            writer.keyword("()");
        } else {
            operand.unparse(writer, 0, 0);
        }
    }
    writer.endList(frame);
}