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

Here are the examples of the java api org.apache.calcite.sql.SqlOperator 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 : RexMultisetUtil.java
Copyright Apache License 2.0
Author : lealone
/**
 * Returns a reference to the first found multiset call or null if none was
 * found
 */
public static RexCall findFirstMultiset(final RexNode node, boolean deep) {
    if (node instanceof RexFieldAccess) {
        return findFirstMultiset(((RexFieldAccess) node).getReferenceExpr(), deep);
    }
    if (!(node instanceof RexCall)) {
        return null;
    }
    final RexCall call = (RexCall) node;
    RexCall firstOne = null;
    for (SqlOperator op : MULTISET_OPERATORS) {
        firstOne = RexUtil.findOperatorCall(op, call);
        if (null != firstOne) {
            if (firstOne.getOperator().equals(SqlStdOperatorTable.CAST) && !isMultisetCast(firstOne)) {
                firstOne = null;
                continue;
            }
            break;
        }
    }
    if (!deep && (firstOne != call)) {
        return null;
    }
    return firstOne;
}

19 View Complete Implementation : SetopOperandTypeChecker.java
Copyright Apache License 2.0
Author : lealone
public String getAllowedSignatures(SqlOperator op, String opName) {
    return "{0} " + opName + " {1}";
}

19 View Complete Implementation : FamilyOperandTypeChecker.java
Copyright Apache License 2.0
Author : lealone
public String getAllowedSignatures(SqlOperator op, String opName) {
    return SqlUtil.getAliasedSignature(op, opName, families);
}

19 View Complete Implementation : UnaryPrefixOperatorConversion.java
Copyright Apache License 2.0
Author : apache
/**
 * Unary prefix Operator conversion clreplaced used to convert expression like Unary NOT and Minus
 */
public clreplaced UnaryPrefixOperatorConversion implements DruidSqlOperatorConverter {

    private final SqlOperator operator;

    private final String druidOperator;

    public UnaryPrefixOperatorConversion(final SqlOperator operator, final String druidOperator) {
        this.operator = operator;
        this.druidOperator = druidOperator;
    }

    @Override
    public SqlOperator calciteOperator() {
        return operator;
    }

    @Override
    public String toDruidExpression(RexNode rexNode, RelDataType rowType, DruidQuery druidQuery) {
        final RexCall call = (RexCall) rexNode;
        final List<String> druidExpressions = DruidExpressions.toDruidExpressions(druidQuery, rowType, call.getOperands());
        if (druidExpressions == null) {
            return null;
        }
        return DruidQuery.format("(%s %s)", druidOperator, Iterables.getOnlyElement(druidExpressions));
    }
}

19 View Complete Implementation : LiteralOperandTypeChecker.java
Copyright Apache License 2.0
Author : apache
public String getAllowedSignatures(SqlOperator op, String opName) {
    return "<LITERAL>";
}

19 View Complete Implementation : SplunkPushDownRule.java
Copyright Apache License 2.0
Author : apache
// TODO: use StringBuilder instead of String
// TODO: refactor this to use more tree like parsing, need to also
// make sure we use parens properly - currently precedence
// rules are simply left to right
private boolean getFilter(SqlOperator op, List<RexNode> operands, StringBuilder s, List<String> fieldNames) {
    if (!valid(op.getKind())) {
        return false;
    }
    boolean like = false;
    switch(op.getKind()) {
        case NOT:
            // NOT op pre-pended
            s = s.append(" NOT ");
            break;
        case CAST:
            return asd(false, operands, s, fieldNames, 0);
        case LIKE:
            like = true;
            break;
    }
    for (int i = 0; i < operands.size(); i++) {
        if (!asd(like, operands, s, fieldNames, i)) {
            return false;
        }
        if (op instanceof SqlBinaryOperator && i == 0) {
            s.append(" ").append(op).append(" ");
        }
    }
    return true;
}

19 View Complete Implementation : RexSqlStandardConvertletTable.java
Copyright Apache License 2.0
Author : lealone
/**
 * Creates and registers a convertlet for an operator in which
 * the SQL and Rex representations are structurally equivalent.
 *
 * @param op operator instance
 */
protected void registerEquivOp(SqlOperator op) {
    registerOp(op, new EquivConvertlet(op));
}

19 View Complete Implementation : UnarySuffixOperatorConversion.java
Copyright Apache License 2.0
Author : apache
/**
 * Unary suffix operator conversion, used to convert function like: expression Unary_Operator
 */
public clreplaced UnarySuffixOperatorConversion implements DruidSqlOperatorConverter {

    private final SqlOperator operator;

    private final String druidOperator;

    public UnarySuffixOperatorConversion(SqlOperator operator, String druidOperator) {
        this.operator = operator;
        this.druidOperator = druidOperator;
    }

    @Override
    public SqlOperator calciteOperator() {
        return operator;
    }

    @Override
    public String toDruidExpression(RexNode rexNode, RelDataType rowType, DruidQuery druidQuery) {
        final RexCall call = (RexCall) rexNode;
        final List<String> druidExpressions = DruidExpressions.toDruidExpressions(druidQuery, rowType, call.getOperands());
        if (druidExpressions == null) {
            return null;
        }
        return DruidQuery.format("(%s %s)", Iterables.getOnlyElement(druidExpressions), druidOperator);
    }
}

19 View Complete Implementation : DrillCalciteSqlOperatorWrapper.java
Copyright Apache License 2.0
Author : lealone
/**
 * This clreplaced serves as a wrapper clreplaced for SqlOperator. The motivation is to plug-in the return type inference and operand
 * type check algorithms of Drill into Calcite's sql validation procedure.
 *
 * Except for the methods which are relevant to the return type inference and operand type check algorithms, the wrapper
 * simply forwards the method calls to the wrapped SqlOperator.
 */
public clreplaced DrillCalciteSqlOperatorWrapper extends SqlOperator implements DrillCalciteSqlWrapper {

    public final SqlOperator operator;

    public DrillCalciteSqlOperatorWrapper(SqlOperator operator, final String rename, final List<DrillFuncHolder> functions) {
        super(operator.getName(), operator.getKind(), operator.getLeftPrec(), operator.getRightPrec(), TypeInferenceUtils.getDrillSqlReturnTypeInference(rename, functions), operator.getOperandTypeInference(), Checker.ANY_CHECKER);
        this.operator = operator;
    }

    @Override
    public SqlOperator getOperator() {
        return operator;
    }

    @Override
    public SqlSyntax getSyntax() {
        return operator.getSyntax();
    }

    @Override
    public SqlCall createCall(SqlLiteral functionQualifier, SqlParserPos pos, SqlNode... operands) {
        return operator.createCall(functionQualifier, pos, operands);
    }

    @Override
    public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
        return operator.rewriteCall(validator, call);
    }

    @Override
    public boolean checkOperandTypes(SqlCallBinding callBinding, boolean throwOnFailure) {
        return true;
    }

    @Override
    public boolean validRexOperands(int count, Litmus litmus) {
        return true;
    }

    @Override
    public String getSignatureTemplate(final int operandsCount) {
        return operator.getSignatureTemplate(operandsCount);
    }

    @Override
    public String getAllowedSignatures(String opNameToUse) {
        return operator.getAllowedSignatures(opNameToUse);
    }

    @Override
    public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
        return operator.getMonotonicity(call);
    }

    @Override
    public boolean isDeterministic() {
        return operator.isDeterministic();
    }

    @Override
    public boolean requiresDecimalExpansion() {
        return operator.requiresDecimalExpansion();
    }

    @Override
    public boolean argumentMustBeScalar(int ordinal) {
        return operator.argumentMustBeScalar(ordinal);
    }

    @Override
    public String toString() {
        return operator.toString();
    }

    @Override
    public void unparse(SqlWriter writer, SqlCall call, int leftPrec, int rightPrec) {
        operator.unparse(writer, call, leftPrec, rightPrec);
    }
}

19 View Complete Implementation : DirectOperatorConversion.java
Copyright Apache License 2.0
Author : apache
/**
 * Direct operator conversion for expression like Function(exp_1,...exp_n)
 */
public clreplaced DirectOperatorConversion implements DruidSqlOperatorConverter {

    private final SqlOperator operator;

    private final String druidFunctionName;

    public DirectOperatorConversion(final SqlOperator operator, final String druidFunctionName) {
        this.operator = operator;
        this.druidFunctionName = druidFunctionName;
    }

    @Override
    public SqlOperator calciteOperator() {
        return operator;
    }

    @Override
    public String toDruidExpression(RexNode rexNode, RelDataType rowType, DruidQuery druidQuery) {
        final RexCall call = (RexCall) rexNode;
        final List<String> druidExpressions = DruidExpressions.toDruidExpressions(druidQuery, rowType, call.getOperands());
        if (druidExpressions == null) {
            return null;
        }
        return DruidExpressions.functionCall(druidFunctionName, druidExpressions);
    }
}

19 View Complete Implementation : SqlDropFunction.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code DROP FUNCTION} statement.
 */
public clreplaced SqlDropFunction extends SqlDropObject {

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("DROP FUNCTION", SqlKind.DROP_FUNCTION);

    /**
     * Creates a SqlDropFunction.
     */
    public SqlDropFunction(SqlParserPos pos, boolean ifExists, SqlIdentifier name) {
        super(OPERATOR, pos, ifExists, name);
    }
}

19 View Complete Implementation : SameOperandTypeChecker.java
Copyright Apache License 2.0
Author : apache
public String getAllowedSignatures(SqlOperator op, String opName) {
    final String typeName = getTypeName();
    return SqlUtil.getAliasedSignature(op, opName, nOperands == -1 ? ImmutableList.of(typeName, typeName, "...") : Collections.nCopies(nOperands, typeName));
}

19 View Complete Implementation : LiteralOperandTypeChecker.java
Copyright Apache License 2.0
Author : lealone
public String getAllowedSignatures(SqlOperator op, String opName) {
    return "<LITERAL>";
}

19 View Complete Implementation : SqlDropType.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code DROP TYPE} statement.
 */
public clreplaced SqlDropType extends SqlDropObject {

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("DROP TYPE", SqlKind.DROP_TYPE);

    SqlDropType(SqlParserPos pos, boolean ifExists, SqlIdentifier name) {
        super(OPERATOR, pos, ifExists, name);
    }
}

19 View Complete Implementation : DrillReduceAggregatesRule.java
Copyright Apache License 2.0
Author : lealone
private static boolean isConversionToSumZeroNeeded(SqlOperator sqlOperator, RelDataType type) {
    sqlOperator = DrillCalciteWrapperUtility.extractSqlOperatorFromWrapper(sqlOperator);
    if (sqlOperator instanceof SqlSumAggFunction && !type.isNullable()) {
        // If SUM(x) is not nullable, the validator must have determined that
        // nulls are impossible (because the group is never empty and x is never
        // null). Therefore we translate to SUM0(x).
        return true;
    }
    return false;
}

19 View Complete Implementation : ListSqlOperatorTable.java
Copyright Apache License 2.0
Author : lealone
// ~ Methods ----------------------------------------------------------------
public void add(SqlOperator op) {
    operatorList.add(op);
}

19 View Complete Implementation : SqlDropTable.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code DROP TABLE} statement.
 */
public clreplaced SqlDropTable extends SqlDropObject {

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("DROP TABLE", SqlKind.DROP_TABLE);

    /**
     * Creates a SqlDropTable.
     */
    SqlDropTable(SqlParserPos pos, boolean ifExists, SqlIdentifier name) {
        super(OPERATOR, pos, ifExists, name);
    }
}

19 View Complete Implementation : MultisetOperandTypeChecker.java
Copyright Apache License 2.0
Author : lealone
public String getAllowedSignatures(SqlOperator op, String opName) {
    return "<MULTISET> " + opName + " <MULTISET>";
}

19 View Complete Implementation : AbstractSqlTester.java
Copyright Apache License 2.0
Author : apache
// SqlTester methods
public void setFor(SqlOperator operator, VmName... unimplementedVmNames) {
// do nothing
}

19 View Complete Implementation : SameOperandTypeChecker.java
Copyright Apache License 2.0
Author : lealone
public String getAllowedSignatures(SqlOperator op, String opName) {
    final String typeName = getTypeName();
    return SqlUtil.getAliasedSignature(op, opName, nOperands == -1 ? ImmutableList.of(typeName, typeName, "...") : Collections.nCopies(nOperands, typeName));
}

19 View Complete Implementation : SetopOperandTypeChecker.java
Copyright Apache License 2.0
Author : apache
public String getAllowedSignatures(SqlOperator op, String opName) {
    return "{0} " + opName + " {1}";
}

19 View Complete Implementation : RexSqlStandardConvertletTable.java
Copyright Apache License 2.0
Author : apache
/**
 * Creates and registers a convertlet for an operator in which
 * the SQL and Rex representations are structurally equivalent.
 *
 * @param op operator instance
 */
protected void registerEquivOp(SqlOperator op) {
    registerOp(op, new EquivConvertlet(op));
}

19 View Complete Implementation : MultisetOperandTypeChecker.java
Copyright Apache License 2.0
Author : apache
public String getAllowedSignatures(SqlOperator op, String opName) {
    return "<MULTISET> " + opName + " <MULTISET>";
}

19 View Complete Implementation : LookupOperatorOverloadsTest.java
Copyright Apache License 2.0
Author : apache
private void checkFunctionType(int size, String name, List<SqlOperator> operatorList) {
    replacedertThat(size, is(operatorList.size()));
    for (SqlOperator op : operatorList) {
        replacedertThat(op, instanceOf(SqlUserDefinedTableFunction.clreplaced));
        replacedertThat(name, is(op.getName()));
    }
}

19 View Complete Implementation : DocumentationTest.java
Copyright Apache License 2.0
Author : apache
private void addOperators(Map<String, PatternOp> map, String prefix, List<SqlOperator> operatorList) {
    for (SqlOperator op : operatorList) {
        final String name = op.getName().equals("TRANSLATE3") ? "TRANSLATE" : op.getName();
        if (op instanceof SqlSpecialOperator || !name.matches("^[a-zA-Z][a-zA-Z0-9_]*$")) {
            continue;
        }
        final String regex;
        if (op instanceof SqlOverlapsOperator) {
            regex = "[ ]*<td>period1 " + name + " period2</td>";
        } else if (op instanceof SqlFunction && (op.getOperandTypeChecker() == null || op.getOperandTypeChecker().getOperandCountRange().getMin() != 0)) {
            regex = prefix + "\\| .*" + name + "\\(.*";
        } else {
            regex = prefix + "\\| .*" + name + ".*";
        }
        map.put(regex, new PatternOp(Pattern.compile(regex), name));
    }
}

19 View Complete Implementation : ListSqlOperatorTable.java
Copyright Apache License 2.0
Author : apache
protected static SqlFunctionCategory category(SqlOperator operator) {
    if (operator instanceof SqlFunction) {
        return ((SqlFunction) operator).getFunctionType();
    } else {
        return SqlFunctionCategory.SYSTEM;
    }
}

19 View Complete Implementation : FamilyOperandTypeChecker.java
Copyright Apache License 2.0
Author : apache
public String getAllowedSignatures(SqlOperator op, String opName) {
    return SqlUtil.getAliasedSignature(op, opName, families);
}

19 View Complete Implementation : SqlDropView.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code DROP VIEW} statement.
 */
public clreplaced SqlDropView extends SqlDropObject {

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("DROP VIEW", SqlKind.DROP_VIEW);

    /**
     * Creates a SqlDropView.
     */
    SqlDropView(SqlParserPos pos, boolean ifExists, SqlIdentifier name) {
        super(OPERATOR, pos, ifExists, name);
    }
}

19 View Complete Implementation : BinaryOperatorConversion.java
Copyright Apache License 2.0
Author : apache
/**
 * Binary operator conversion utility clreplaced used to convert expression like exp1 Operator exp2
 */
public clreplaced BinaryOperatorConversion implements DruidSqlOperatorConverter {

    private final SqlOperator operator;

    private final String druidOperator;

    public BinaryOperatorConversion(final SqlOperator operator, final String druidOperator) {
        this.operator = operator;
        this.druidOperator = druidOperator;
    }

    @Override
    public SqlOperator calciteOperator() {
        return operator;
    }

    @Override
    public String toDruidExpression(RexNode rexNode, RelDataType rowType, DruidQuery druidQuery) {
        final RexCall call = (RexCall) rexNode;
        final List<String> druidExpressions = DruidExpressions.toDruidExpressions(druidQuery, rowType, call.getOperands());
        if (druidExpressions == null) {
            return null;
        }
        if (druidExpressions.size() != 2) {
            throw new IllegalStateException(DruidQuery.format("Got binary operator[%s] with %s args?", operator.getName(), druidExpressions.size()));
        }
        return DruidQuery.format("(%s %s %s)", druidExpressions.get(0), druidOperator, druidExpressions.get(1));
    }
}

19 View Complete Implementation : DrillCalciteWrapperUtility.java
Copyright Apache License 2.0
Author : lealone
/**
 * This static method will extract the SqlOperator inside the given SqlOperator if the given SqlOperator is wrapped
 * in DrillCalciteSqlWrapper and will just return the given SqlOperator if it is not wrapped.
 */
public static SqlOperator extractSqlOperatorFromWrapper(final SqlOperator sqlOperator) {
    if (sqlOperator instanceof DrillCalciteSqlWrapper) {
        return ((DrillCalciteSqlWrapper) sqlOperator).getOperator();
    } else {
        return sqlOperator;
    }
}

19 View Complete Implementation : NaryOperatorConverter.java
Copyright Apache License 2.0
Author : apache
/**
 * Converts Calcite n-ary operators to druid expression eg (arg1 Op arg2 Op arg3)
 */
public clreplaced NaryOperatorConverter implements DruidSqlOperatorConverter {

    private final SqlOperator operator;

    private final String druidOperatorName;

    public NaryOperatorConverter(SqlOperator operator, String druidOperatorName) {
        this.operator = Objects.requireNonNull(operator);
        this.druidOperatorName = Objects.requireNonNull(druidOperatorName);
    }

    @Override
    public SqlOperator calciteOperator() {
        return operator;
    }

    @Nullable
    @Override
    public String toDruidExpression(RexNode rexNode, RelDataType rowType, DruidQuery druidQuery) {
        final RexCall call = (RexCall) rexNode;
        final List<String> druidExpressions = DruidExpressions.toDruidExpressions(druidQuery, rowType, call.getOperands());
        if (druidExpressions == null) {
            return null;
        }
        return DruidExpressions.nAryOperatorCall(druidOperatorName, druidExpressions);
    }
}

19 View Complete Implementation : FindLimit0Visitor.java
Copyright Apache License 2.0
Author : lealone
private static boolean isUnsupportedScalarFunction(final SqlOperator operator) {
    return operator instanceof DrillSqlOperator && unsupportedFunctions.contains(operator.getName().toUpperCase());
}

19 View Complete Implementation : ListSqlOperatorTable.java
Copyright Apache License 2.0
Author : lealone
protected static SqlFunctionCategory category(SqlOperator operator) {
    if (operator instanceof SqlFunction) {
        return ((SqlFunction) operator).getFunctionType();
    } else {
        return SqlFunctionCategory.SYSTEM;
    }
}

19 View Complete Implementation : SqlDropMaterializedView.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code DROP MATERIALIZED VIEW} statement.
 */
public clreplaced SqlDropMaterializedView extends SqlDropObject {

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("DROP MATERIALIZED VIEW", SqlKind.DROP_MATERIALIZED_VIEW);

    /**
     * Creates a SqlDropMaterializedView.
     */
    SqlDropMaterializedView(SqlParserPos pos, boolean ifExists, SqlIdentifier name) {
        super(OPERATOR, pos, ifExists, name);
    }

    @Override
    public void execute(CalcitePrepare.Context context) {
        final Pair<CalciteSchema, String> pair = SqlDdlNodes.schema(context, true, name);
        final Table table = pair.left.plus().getTable(pair.right);
        if (table != null) {
            // Materialized view exists.
            super.execute(context);
            if (table instanceof Wrapper) {
                final MaterializationKey materializationKey = ((Wrapper) table).unwrap(MaterializationKey.clreplaced);
                if (materializationKey != null) {
                    MaterializationService.instance().removeMaterialization(materializationKey);
                }
            }
        }
    }
}

19 View Complete Implementation : RexMultisetUtil.java
Copyright Apache License 2.0
Author : apache
/**
 * Returns a reference to the first found multiset call or null if none was
 * found
 */
public static RexCall findFirstMultiset(final RexNode node, boolean deep) {
    if (node instanceof RexFieldAccess) {
        return findFirstMultiset(((RexFieldAccess) node).getReferenceExpr(), deep);
    }
    if (!(node instanceof RexCall)) {
        return null;
    }
    final RexCall call = (RexCall) node;
    RexCall firstOne = null;
    for (SqlOperator op : MULTISET_OPERATORS) {
        firstOne = RexUtil.findOperatorCall(op, call);
        if (null != firstOne) {
            if (firstOne.getOperator().equals(SqlStdOperatorTable.CAST) && !isMultisetCast(firstOne)) {
                firstOne = null;
                continue;
            }
            break;
        }
    }
    if (!deep && (firstOne != call)) {
        return null;
    }
    return firstOne;
}

19 View Complete Implementation : ListSqlOperatorTable.java
Copyright Apache License 2.0
Author : apache
// ~ Methods ----------------------------------------------------------------
public void add(SqlOperator op) {
    operatorList.add(op);
}

18 View Complete Implementation : SqlCreateSchema.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code CREATE SCHEMA} statement.
 */
public clreplaced SqlCreateSchema extends SqlCreate implements SqlExecutableStatement {

    private final SqlIdentifier name;

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("CREATE SCHEMA", SqlKind.CREATE_SCHEMA);

    /**
     * Creates a SqlCreateSchema.
     */
    SqlCreateSchema(SqlParserPos pos, boolean replace, boolean ifNotExists, SqlIdentifier name) {
        super(OPERATOR, pos, replace, ifNotExists);
        this.name = Objects.requireNonNull(name);
    }

    @Override
    public List<SqlNode> getOperandList() {
        return ImmutableNullableList.of(name);
    }

    @Override
    public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        if (getReplace()) {
            writer.keyword("CREATE OR REPLACE");
        } else {
            writer.keyword("CREATE");
        }
        writer.keyword("SCHEMA");
        if (ifNotExists) {
            writer.keyword("IF NOT EXISTS");
        }
        name.unparse(writer, leftPrec, rightPrec);
    }

    public void execute(CalcitePrepare.Context context) {
        final Pair<CalciteSchema, String> pair = SqlDdlNodes.schema(context, true, name);
        final SchemaPlus subSchema0 = pair.left.plus().getSubSchema(pair.right);
        if (subSchema0 != null) {
            if (!getReplace() && !ifNotExists) {
                throw SqlUtil.newContextException(name.getParserPosition(), RESOURCE.schemaExists(pair.right));
            }
        }
        final Schema subSchema = new AbstractSchema();
        pair.left.add(pair.right, subSchema);
    }
}

18 View Complete Implementation : SqlDropSchema.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code DROP TABLE} statement.
 */
public clreplaced SqlDropSchema extends SqlDrop implements SqlExecutableStatement {

    private final boolean foreign;

    private final SqlIdentifier name;

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("DROP SCHEMA", SqlKind.DROP_TABLE);

    /**
     * Creates a SqlDropSchema.
     */
    SqlDropSchema(SqlParserPos pos, boolean foreign, boolean ifExists, SqlIdentifier name) {
        super(OPERATOR, pos, ifExists);
        this.foreign = foreign;
        this.name = name;
    }

    public List<SqlNode> getOperandList() {
        return ImmutableList.of(SqlLiteral.createBoolean(foreign, SqlParserPos.ZERO), name);
    }

    @Override
    public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        writer.keyword("DROP");
        if (foreign) {
            writer.keyword("FOREIGN");
        }
        writer.keyword("SCHEMA");
        if (ifExists) {
            writer.keyword("IF EXISTS");
        }
        name.unparse(writer, leftPrec, rightPrec);
    }

    public void execute(CalcitePrepare.Context context) {
        final List<String> path = context.getDefaultSchemaPath();
        CalciteSchema schema = context.getRootSchema();
        for (String p : path) {
            schema = schema.getSubSchema(p, true);
        }
        final boolean existed = schema.removeSubSchema(name.getSimple());
        if (!existed && !ifExists) {
            throw SqlUtil.newContextException(name.getParserPosition(), RESOURCE.schemaNotFound(name.getSimple()));
        }
    }
}

18 View Complete Implementation : SqlCreateType.java
Copyright Apache License 2.0
Author : apache
/**
 * Parse tree for {@code CREATE TYPE} statement.
 */
public clreplaced SqlCreateType extends SqlCreate implements SqlExecutableStatement {

    private final SqlIdentifier name;

    private final SqlNodeList attributeDefs;

    private final SqlDataTypeSpec dataType;

    private static final SqlOperator OPERATOR = new SqlSpecialOperator("CREATE TYPE", SqlKind.CREATE_TYPE);

    /**
     * Creates a SqlCreateType.
     */
    SqlCreateType(SqlParserPos pos, boolean replace, SqlIdentifier name, SqlNodeList attributeDefs, SqlDataTypeSpec dataType) {
        super(OPERATOR, pos, replace, false);
        this.name = Objects.requireNonNull(name);
        // may be null
        this.attributeDefs = attributeDefs;
        // may be null
        this.dataType = dataType;
    }

    @Override
    public void execute(CalcitePrepare.Context context) {
        final Pair<CalciteSchema, String> pair = SqlDdlNodes.schema(context, true, name);
        final SqlValidator validator = SqlDdlNodes.validator(context, false);
        pair.left.add(pair.right, typeFactory -> {
            if (dataType != null) {
                return dataType.deriveType(validator);
            } else {
                final RelDataTypeFactory.Builder builder = typeFactory.builder();
                for (SqlNode def : attributeDefs) {
                    final SqlAttributeDefinition attributeDef = (SqlAttributeDefinition) def;
                    final SqlDataTypeSpec typeSpec = attributeDef.dataType;
                    final RelDataType type = typeSpec.deriveType(validator);
                    builder.add(attributeDef.name.getSimple(), type);
                }
                return builder.build();
            }
        });
    }

    @Override
    public List<SqlNode> getOperandList() {
        return ImmutableNullableList.of(name, attributeDefs);
    }

    @Override
    public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        if (getReplace()) {
            writer.keyword("CREATE OR REPLACE");
        } else {
            writer.keyword("CREATE");
        }
        writer.keyword("TYPE");
        name.unparse(writer, leftPrec, rightPrec);
        writer.keyword("AS");
        if (attributeDefs != null) {
            SqlWriter.Frame frame = writer.startList("(", ")");
            for (SqlNode a : attributeDefs) {
                writer.sep(",");
                a.unparse(writer, 0, 0);
            }
            writer.endList(frame);
        } else if (dataType != null) {
            dataType.unparse(writer, leftPrec, rightPrec);
        }
    }
}

18 View Complete Implementation : RexSqlReflectiveConvertletTable.java
Copyright Apache License 2.0
Author : apache
// ~ Methods ----------------------------------------------------------------
public RexSqlConvertlet get(RexCall call) {
    RexSqlConvertlet convertlet;
    final SqlOperator op = call.getOperator();
    // Is there a convertlet for this operator
    // (e.g. SqlStdOperatorTable.plusOperator)?
    convertlet = (RexSqlConvertlet) map.get(op);
    if (convertlet != null) {
        return convertlet;
    }
    // Is there a convertlet for this clreplaced of operator
    // (e.g. SqlBinaryOperator)?
    Clreplaced<? extends Object> clazz = op.getClreplaced();
    while (clazz != null) {
        convertlet = (RexSqlConvertlet) 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 = (RexSqlConvertlet) map.get(clazz);
        if (convertlet != null) {
            return convertlet;
        }
        clazz = clazz.getSuperclreplaced();
    }
    return null;
}

18 View Complete Implementation : RexFuzzer.java
Copyright Apache License 2.0
Author : apache
/**
 * Generates random {@link RexNode} instances for tests.
 */
public clreplaced RexFuzzer extends RexProgramBuilderBase {

    private static final int MAX_VARS = 2;

    private static final SqlOperator[] BOOL_TO_BOOL = { SqlStdOperatorTable.NOT, SqlStdOperatorTable.IS_TRUE, SqlStdOperatorTable.IS_FALSE, SqlStdOperatorTable.IS_NOT_TRUE, SqlStdOperatorTable.IS_NOT_FALSE };

    private static final SqlOperator[] ANY_TO_BOOL = { SqlStdOperatorTable.IS_NULL, SqlStdOperatorTable.IS_NOT_NULL, SqlStdOperatorTable.IS_UNKNOWN, SqlStdOperatorTable.IS_NOT_UNKNOWN };

    private static final SqlOperator[] COMPARABLE_TO_BOOL = { SqlStdOperatorTable.EQUALS, SqlStdOperatorTable.NOT_EQUALS, SqlStdOperatorTable.GREATER_THAN, SqlStdOperatorTable.GREATER_THAN_OR_EQUAL, SqlStdOperatorTable.LESS_THAN, SqlStdOperatorTable.LESS_THAN_OR_EQUAL, SqlStdOperatorTable.IS_DISTINCT_FROM, SqlStdOperatorTable.IS_NOT_DISTINCT_FROM };

    private static final SqlOperator[] BOOL_TO_BOOL_MULTI_ARG = { SqlStdOperatorTable.OR, SqlStdOperatorTable.AND, SqlStdOperatorTable.COALESCE };

    private static final SqlOperator[] ANY_SAME_TYPE_MULTI_ARG = { SqlStdOperatorTable.COALESCE };

    private static final SqlOperator[] NUMERIC_TO_NUMERIC = { SqlStdOperatorTable.PLUS, SqlStdOperatorTable.MINUS, SqlStdOperatorTable.MULTIPLY // Divide by zero is not allowed, so we do not generate divide
    // SqlStdOperatorTable.DIVIDE,
    // SqlStdOperatorTable.DIVIDE_INTEGER,
    };

    private static final SqlOperator[] UNARY_NUMERIC = { SqlStdOperatorTable.UNARY_MINUS, SqlStdOperatorTable.UNARY_PLUS };

    private static final int[] INT_VALUES = { -1, 0, 1, 100500 };

    private final RelDataType intType;

    private final RelDataType nullableIntType;

    /**
     * Generates randomized {@link RexNode}.
     *
     * @param rexBuilder  builder to be used to create nodes
     * @param typeFactory type factory
     */
    public RexFuzzer(RexBuilder rexBuilder, JavaTypeFactory typeFactory) {
        setUp();
        this.rexBuilder = rexBuilder;
        this.typeFactory = typeFactory;
        intType = typeFactory.createSqlType(SqlTypeName.INTEGER);
        nullableIntType = typeFactory.createTypeWithNullability(intType, true);
    }

    public RexNode getExpression(Random r, int depth) {
        return getComparableExpression(r, depth);
    }

    private RexNode fuzzOperator(Random r, SqlOperator[] operators, RexNode... args) {
        return rexBuilder.makeCall(operators[r.nextInt(operators.length)], args);
    }

    private RexNode fuzzOperator(Random r, SqlOperator[] operators, int length, Function<Random, RexNode> factory) {
        List<RexNode> args = new ArrayList<>(length);
        for (int i = 0; i < length; i++) {
            args.add(factory.apply(r));
        }
        return rexBuilder.makeCall(operators[r.nextInt(operators.length)], args);
    }

    public RexNode getComparableExpression(Random r, int depth) {
        int v = r.nextInt(2);
        switch(v) {
            case 0:
                return getBoolExpression(r, depth);
            case 1:
                return getIntExpression(r, depth);
        }
        throw new replacedertionError("should not reach here");
    }

    public RexNode getSimpleBool(Random r) {
        int v = r.nextInt(2);
        switch(v) {
            case 0:
                boolean nullable = r.nextBoolean();
                int field = r.nextInt(MAX_VARS);
                return nullable ? vBool(field) : vBoolNotNull(field);
            case 1:
                return r.nextBoolean() ? trueLiteral : falseLiteral;
            case 2:
                return nullBool;
        }
        throw new replacedertionError("should not reach here");
    }

    public RexNode getBoolExpression(Random r, int depth) {
        int v = depth <= 0 ? 0 : r.nextInt(7);
        switch(v) {
            case 0:
                return getSimpleBool(r);
            case 1:
                return fuzzOperator(r, ANY_TO_BOOL, getExpression(r, depth - 1));
            case 2:
                return fuzzOperator(r, BOOL_TO_BOOL, getBoolExpression(r, depth - 1));
            case 3:
                return fuzzOperator(r, COMPARABLE_TO_BOOL, getBoolExpression(r, depth - 1), getBoolExpression(r, depth - 1));
            case 4:
                return fuzzOperator(r, COMPARABLE_TO_BOOL, getIntExpression(r, depth - 1), getIntExpression(r, depth - 1));
            case 5:
                return fuzzOperator(r, BOOL_TO_BOOL_MULTI_ARG, r.nextInt(3) + 2, x -> getBoolExpression(x, depth - 1));
            case 6:
                return fuzzCase(r, depth - 1, x -> getBoolExpression(x, depth - 1));
        }
        throw new replacedertionError("should not reach here");
    }

    public RexNode getSimpleInt(Random r) {
        int v = r.nextInt(3);
        switch(v) {
            case 0:
                boolean nullable = r.nextBoolean();
                int field = r.nextInt(MAX_VARS);
                return nullable ? vInt(field) : vIntNotNull(field);
            case 1:
                {
                    int i = r.nextInt(INT_VALUES.length + 1);
                    int val = i < INT_VALUES.length ? INT_VALUES[i] : r.nextInt();
                    return rexBuilder.makeLiteral(val, r.nextBoolean() ? intType : nullableIntType, false);
                }
            case 2:
                return nullInt;
        }
        throw new replacedertionError("should not reach here");
    }

    public RexNode getIntExpression(Random r, int depth) {
        int v = depth <= 0 ? 0 : r.nextInt(5);
        switch(v) {
            case 0:
                return getSimpleInt(r);
            case 1:
                return fuzzOperator(r, UNARY_NUMERIC, getIntExpression(r, depth - 1));
            case 2:
                return fuzzOperator(r, NUMERIC_TO_NUMERIC, getIntExpression(r, depth - 1), getIntExpression(r, depth - 1));
            case 3:
                return fuzzOperator(r, ANY_SAME_TYPE_MULTI_ARG, r.nextInt(3) + 2, x -> getIntExpression(x, depth - 1));
            case 4:
                return fuzzCase(r, depth - 1, x -> getIntExpression(x, depth - 1));
        }
        throw new replacedertionError("should not reach here");
    }

    public RexNode fuzzCase(Random r, int depth, Function<Random, RexNode> resultFactory) {
        boolean caseArgWhen = r.nextBoolean();
        int caseBranches = 1 + (depth <= 0 ? 0 : r.nextInt(3));
        List<RexNode> args = new ArrayList<>(caseBranches + 1);
        Function<Random, RexNode> exprFactory;
        if (!caseArgWhen) {
            exprFactory = x -> getBoolExpression(x, depth - 1);
        } else {
            int type = r.nextInt(2);
            RexNode arg;
            Function<Random, RexNode> baseExprFactory;
            switch(type) {
                case 0:
                    baseExprFactory = x -> getBoolExpression(x, depth - 1);
                    break;
                case 1:
                    baseExprFactory = x -> getIntExpression(x, depth - 1);
                    break;
                default:
                    throw new replacedertionError("should not reach here: " + type);
            }
            arg = baseExprFactory.apply(r);
            // emulate  case when arg=2 then .. when arg=4 then ...
            exprFactory = x -> eq(arg, baseExprFactory.apply(x));
        }
        for (int i = 0; i < caseBranches; i++) {
            // when
            args.add(exprFactory.apply(r));
            // then
            args.add(resultFactory.apply(r));
        }
        // else
        args.add(resultFactory.apply(r));
        return case_(args);
    }
}

18 View Complete Implementation : ReflectiveConvertletTable.java
Copyright Apache License 2.0
Author : lealone
/**
 * Registers a convertlet for a given operator instance
 *
 * @param op         Operator instance, say
 * {@link org.apache.calcite.sql.fun.SqlStdOperatorTable#MINUS}
 * @param convertlet Convertlet
 */
protected void registerOp(SqlOperator op, SqlRexConvertlet convertlet) {
    map.put(op, convertlet);
}

18 View Complete Implementation : MockSqlOperatorTable.java
Copyright Apache License 2.0
Author : apache
/**
 * Adds an operator to this table.
 */
public void addOperator(SqlOperator op) {
    listOpTab.add(op);
}

18 View Complete Implementation : SqlUploadJarNode.java
Copyright Apache License 2.0
Author : apache
/**
 * Simple test example of a custom alter system call.
 */
public clreplaced SqlUploadJarNode extends SqlAlter {

    public static final SqlOperator OPERATOR = new SqlSpecialOperator("UPLOAD JAR", SqlKind.OTHER_DDL);

    private final List<SqlNode> jarPaths;

    /**
     * Creates a SqlUploadJarNode.
     */
    public SqlUploadJarNode(SqlParserPos pos, String scope, List<SqlNode> jarPaths) {
        super(pos, scope);
        this.jarPaths = jarPaths;
    }

    @Override
    public SqlOperator getOperator() {
        return OPERATOR;
    }

    @Override
    public List<SqlNode> getOperandList() {
        return jarPaths;
    }

    @Override
    protected void unparseAlterOperation(SqlWriter writer, int leftPrec, int rightPrec) {
        writer.keyword("UPLOAD");
        writer.keyword("JAR");
        SqlWriter.Frame frame = writer.startList("", "");
        for (SqlNode jarPath : jarPaths) {
            jarPath.unparse(writer, leftPrec, rightPrec);
        }
        writer.endList(frame);
    }
}

18 View Complete Implementation : RexExecutorTest.java
Copyright Apache License 2.0
Author : apache
/**
 * Ensures that for a given context operator,
 * the correct value is retrieved from the {@link DataContext}.
 *
 * @param operator The Operator to check
 * @param variable The DataContext variable this operator should be bound to
 * @param value The expected value to retrieve.
 */
private void testContextLiteral(final SqlOperator operator, final DataContext.Variable variable, final Object value) {
    Frameworks.withPrepare((cluster, relOptSchema, rootSchema, statement) -> {
        final RexBuilder rexBuilder = cluster.getRexBuilder();
        final RexExecutorImpl executor = new RexExecutorImpl(new SingleValueDataContext(variable.camelName, value));
        try {
            checkConstant(value, builder -> {
                final List<RexNode> output = new ArrayList<>();
                executor.reduce(rexBuilder, ImmutableList.of(rexBuilder.makeCall(operator)), output);
                return output.get(0);
            });
        } catch (Exception e) {
            throw TestUtil.rethrow(e);
        }
        return null;
    });
}

18 View Complete Implementation : ReflectiveSqlOperatorTable.java
Copyright Apache License 2.0
Author : apache
/**
 * Registers a function or operator in the table.
 */
public void register(SqlOperator op) {
    // Register both for case-sensitive and case-insensitive look up.
    caseSensitiveOperators.put(new CaseSensitiveKey(op.getName(), op.getSyntax()), op);
    caseInsensitiveOperators.put(new CaseInsensitiveKey(op.getName(), op.getSyntax()), op);
}

18 View Complete Implementation : ReflectiveConvertletTable.java
Copyright Apache License 2.0
Author : apache
/**
 * Registers that one operator is an alias for another.
 *
 * @param alias  Operator which is alias
 * @param target Operator to translate calls to
 */
protected void addAlias(final SqlOperator alias, final SqlOperator target) {
    map.put(alias, (SqlRexConvertlet) (cx, call) -> {
        Preconditions.checkArgument(call.getOperator() == alias, "call to wrong operator");
        final SqlCall newCall = target.createCall(SqlParserPos.ZERO, call.getOperandList());
        return cx.convertExpression(newCall);
    });
}

18 View Complete Implementation : ReflectiveConvertletTable.java
Copyright Apache License 2.0
Author : apache
/**
 * Registers a convertlet for a given operator instance
 *
 * @param op         Operator instance, say
 * {@link org.apache.calcite.sql.fun.SqlStdOperatorTable#MINUS}
 * @param convertlet Convertlet
 */
protected void registerOp(SqlOperator op, SqlRexConvertlet convertlet) {
    map.put(op, convertlet);
}

18 View Complete Implementation : RexSqlReflectiveConvertletTable.java
Copyright Apache License 2.0
Author : apache
/**
 * Registers a convertlet for a given operator instance
 *
 * @param op         Operator instance, say
 * {@link org.apache.calcite.sql.fun.SqlStdOperatorTable#MINUS}
 * @param convertlet Convertlet
 */
protected void registerOp(SqlOperator op, RexSqlConvertlet convertlet) {
    map.put(op, convertlet);
}

18 View Complete Implementation : RexProgramFuzzyTest.java
Copyright Apache License 2.0
Author : apache
private void nestedCalls(RexNode arg) {
    SqlOperator[] operators = { SqlStdOperatorTable.NOT, SqlStdOperatorTable.IS_FALSE, SqlStdOperatorTable.IS_NOT_FALSE, SqlStdOperatorTable.IS_TRUE, SqlStdOperatorTable.IS_NOT_TRUE, SqlStdOperatorTable.IS_NULL, SqlStdOperatorTable.IS_NOT_NULL, SqlStdOperatorTable.IS_UNKNOWN, SqlStdOperatorTable.IS_NOT_UNKNOWN };
    for (SqlOperator op1 : operators) {
        RexNode n1 = rexBuilder.makeCall(op1, arg);
        checkUnknownAs(n1);
        for (SqlOperator op2 : operators) {
            RexNode n2 = rexBuilder.makeCall(op2, n1);
            checkUnknownAs(n2);
            for (SqlOperator op3 : operators) {
                RexNode n3 = rexBuilder.makeCall(op3, n2);
                checkUnknownAs(n3);
                for (SqlOperator op4 : operators) {
                    RexNode n4 = rexBuilder.makeCall(op4, n3);
                    checkUnknownAs(n4);
                }
            }
        }
    }
}