Java SqlSpecialOperator类代码示例

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
/**
 * Converts a list of {expression, operator, expression, ...} into a tree,
 * taking operator precedence and associativity into account.
 *
 * @param list        List of operands and operators. This list is modified as
 *                    expressions are reduced.
 * @param start       Position of first operand in the list. Anything to the
 *                    left of this (besides the immediately preceding operand)
 *                    is ignored. Generally use value 1.
 * @param minPrec     Minimum precedence to consider. If the method encounters
 *                    an operator of lower precedence, it doesn't reduce any
 *                    further.
 * @param stopperKind If not {@link SqlKind#OTHER}, stop reading the list if
 *                    we encounter a token of this kind.
 * @return the root node of the tree which the list condenses into
 */
public static SqlNode toTreeEx(SqlSpecialOperator.TokenSequence list,
    int start, final int minPrec, final SqlKind stopperKind) {
  final Predicate<PrecedenceClimbingParser.Token> predicate =
      new PredicateImpl<PrecedenceClimbingParser.Token>() {
        public boolean test(PrecedenceClimbingParser.Token t) {
          if (t instanceof PrecedenceClimbingParser.Op) {
            final SqlOperator op = ((ToTreeListItem) t.o).op;
            return stopperKind != SqlKind.OTHER
                && op.kind == stopperKind
                || minPrec > 0
                && op.getLeftPrec() < minPrec;
          } else {
            return false;
          }
        }
      };
  PrecedenceClimbingParser parser = list.parser(start, predicate);
  final int beforeSize = parser.all().size();
  parser.partialParse();
  final int afterSize = parser.all().size();
  final SqlNode node = convert(parser.all().get(0));
  list.replaceSublist(start, start + beforeSize - afterSize + 1, node);
  return node;
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
@Test public void testIsDeterministic() {
  SqlOperator ndc = new SqlSpecialOperator(
          "NDC",
          SqlKind.OTHER_FUNCTION,
          0,
          false,
          ReturnTypes.BOOLEAN,
          null, null) {
    @Override public boolean isDeterministic() {
      return false;
    }
  };
  RexNode n = rexBuilder.makeCall(ndc);
  assertFalse(RexUtil.isDeterministic(n));
  assertEquals(0,
          RexUtil.retainDeterministic(RelOptUtil.conjunctions(n)).size());
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
@Override
public Expression visit(SqlCall call) {
    SqlOperator sqlOperator = call.getOperator();
    if (sqlOperator instanceof SqlBinaryOperator) {
        return visitBinaryOperator((SqlBinaryOperator) sqlOperator, call.getOperandList().get(0),
                call.getOperandList().get(1));
    } else if (sqlOperator instanceof SqlSpecialOperator) {
        return visitSqlSpecialOperator((SqlSpecialOperator) sqlOperator, call.getOperandList());
    } else if (sqlOperator instanceof SqlFunction) {
        SqlFunction sqlFunction = (SqlFunction) sqlOperator;
        if (sqlFunction instanceof SqlAggFunction) {
            return visitAggregateFunction(sqlFunction.getName(), call.getOperandList());
        } else if (sqlFunction instanceof SqlUnresolvedFunction) {
            String udfName = sqlFunction.getName().toUpperCase();
            if (catalogUdfs.containsKey(udfName)) {
                Udf udfInfo = catalogUdfs.get(udfName);
                if (udfInfo.isAggregate()) {
                    return visitUserDefinedAggregateFunction(udfInfo, call.getOperandList());
                } else {
                    return visitUserDefinedFunction(udfInfo, call.getOperandList());
                }
            } else {
                throw new UnsupportedOperationException("Unknown built-in or User defined function '" + udfName + "'");
            }
        } else {
            return visitFunction(sqlFunction.getName(), call.getOperandList());
        }
    } else {
        throw new UnsupportedOperationException("Operator " + sqlOperator.getName() + " is not supported");
    }
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
public SqlShowViews(
    SqlParserPos pos,
    SqlNode likePattern) {
  super(pos, likePattern);
  this.likePattern = likePattern;
  operator = new SqlSpecialOperator("SHOW_VIEW", SqlKind.OTHER_DDL);
  operatorString = "SHOW VIEW";
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
public SqlAlterQuarkDataSource(SqlParserPos pos,
                     SqlNodeList targetColumnList,
                     SqlNodeList sourceExpressionList,
                     SqlIdentifier identifier) {
  super(pos, targetColumnList, sourceExpressionList, identifier);
  operator = new SqlSpecialOperator("ALTER_DATASOURCE", SqlKind.OTHER_DDL);
  operatorString = "ALTER DATASOURCE";
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
public SqlAlterQuarkView(SqlParserPos pos,
                     SqlNodeList targetColumnList,
                     SqlNodeList sourceExpressionList,
                     SqlIdentifier identifier) {
  super(pos, targetColumnList, sourceExpressionList, identifier);
  operator = new SqlSpecialOperator("ALTER_VIEW", SqlKind.OTHER_DDL);
  operatorString = "ALTER VIEW";
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
public SqlCreateQuarkDataSource(SqlParserPos pos,
                     SqlNodeList targetColumnList,
                     SqlNodeList sourceExpressionList,
                     SqlIdentifier identifier) {
  super(pos, targetColumnList, sourceExpressionList, identifier);
  operator = new SqlSpecialOperator("CREATE_DATASOURCE", SqlKind.OTHER_DDL);
  operatorString = "CREATE DATASOURCE";
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
@Override protected Function0<CalcitePrepare> createPrepareFactory() {
  return new Function0<CalcitePrepare>() {
    @Override public CalcitePrepare apply() {
      return new CalcitePrepareImpl() {
        @Override protected SqlParser.ConfigBuilder createParserConfig() {
          return super.createParserConfig().setParserFactory(
              new SqlParserImplFactory() {
                @Override public SqlAbstractParserImpl
                getParser(Reader stream) {
                  return new SqlParserImpl(stream) {
                    @Override public SqlNode parseSqlStmtEof() {
                      return new SqlCall(SqlParserPos.ZERO) {
                        @Override public SqlOperator getOperator() {
                          return new SqlSpecialOperator("COMMIT",
                              SqlKind.COMMIT);
                        }

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

        @Override public void executeDdl(Context context, SqlNode node) {
          ++counter;
        }
      };
    }
  };
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
public SqlDropQuarkView(
    SqlParserPos pos,
    SqlIdentifier identifier) {
  super(pos, identifier);
  operator = new SqlSpecialOperator("DROP_VIEW", SqlKind.OTHER_DDL);
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
public SqlDropQuarkDataSource(
    SqlParserPos pos,
    SqlIdentifier identifier) {
  super(pos, identifier);
  operator = new SqlSpecialOperator("DROP_DATASOURCE", SqlKind.OTHER_DDL);
}
 

import org.apache.calcite.sql.SqlSpecialOperator; //导入依赖的package包/类
public SqlShowQuark(SqlParserPos pos, SqlNode likePattern) {
  super(pos);
  operator = new SqlSpecialOperator("SHOW_DATASOURCE", SqlKind.OTHER_DDL);
  this.likePattern = likePattern;
}