Java Code Examples for org.apache.calcite.sql.SqlNodeList

@Override
public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
	writer.keyword("ALTER TABLE");
	tableIdentifier.unparse(writer, leftPrec, rightPrec);
	writer.newlineAndIndent();
	writer.keyword("ADD");
	if (ifNotExists()) {
		writer.keyword("IF NOT EXISTS");
	}
	int opLeftPrec = getOperator().getLeftPrec();
	int opRightPrec = getOperator().getRightPrec();
	for (int i = 0; i < getPartSpecs().size(); i++) {
		writer.newlineAndIndent();
		SqlNodeList partSpec = getPartSpecs().get(i);
		writer.keyword("PARTITION");
		partSpec.unparse(writer, opLeftPrec, opRightPrec);
		SqlCharStringLiteral location = partLocations.get(i);
		if (location != null) {
			writer.keyword("LOCATION");
			location.unparse(writer, opLeftPrec, opRightPrec);
		}
	}
}
 

@Override public void setOperand(int i, SqlNode operand) {

    switch (i) {
      case 0:
        targetColumnList = (SqlNodeList) operand;
        break;
      case 1:
        sourceExpressionList = (SqlNodeList) operand;
        break;
      case 2:
        identifier = (SqlIdentifier) operand;
        break;
      default:
        throw new AssertionError(i);
    }
  }
 

/** @see #dispatch */
public Result visit(Calc e) {
  Result x = visitChild(0, e.getInput());
  parseCorrelTable(e, x);
  final RexProgram program = e.getProgram();
  Builder builder =
      program.getCondition() != null
          ? x.builder(e, Clause.WHERE)
          : x.builder(e);
  if (!isStar(program)) {
    final List<SqlNode> selectList = new ArrayList<>();
    for (RexLocalRef ref : program.getProjectList()) {
      SqlNode sqlExpr = builder.context.toSql(program, ref);
      addSelect(selectList, sqlExpr, e.getRowType());
    }
    builder.setSelect(new SqlNodeList(selectList, POS));
  }

  if (program.getCondition() != null) {
    builder.setWhere(
        builder.context.toSql(program, program.getCondition()));
  }
  return builder.result();
}
 

public SqlNode visit(SqlNodeList nodeList) {
  boolean update = false;
  List<SqlNode> exprs = nodeList.getList();
  int exprCount = exprs.size();
  List<SqlNode> newList = new ArrayList<>(exprCount);
  for (SqlNode operand : exprs) {
    SqlNode clonedOperand;
    if (operand == null) {
      clonedOperand = null;
    } else {
      clonedOperand = operand.accept(this);
      if (clonedOperand != operand) {
        update = true;
      }
    }
    newList.add(clonedOperand);
  }
  if (update) {
    return new SqlNodeList(newList, nodeList.getParserPosition());
  } else {
    return nodeList;
  }
}
 

@Override
public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
	super.unparse(writer, leftPrec, rightPrec);
	writer.newlineAndIndent();
	writer.keyword("DROP");
	if (ifExists) {
		writer.keyword("IF EXISTS");
	}
	int opLeftPrec = getOperator().getLeftPrec();
	int opRightPrec = getOperator().getRightPrec();
	for (SqlNodeList partSpec : partSpecs) {
		writer.newlineAndIndent();
		writer.keyword("PARTITION");
		partSpec.unparse(writer, opLeftPrec, opRightPrec);
	}
}
 

private 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);
}
 

public Result visit(TableFunctionScan e) {
  final List<SqlNode> inputSqlNodes = new ArrayList<>();
  final int inputSize = e.getInputs().size();
  for (int i = 0; i < inputSize; i++) {
    Result child = visitChild(i, e.getInput(i));
    inputSqlNodes.add(child.asStatement());
  }
  final Context context = tableFunctionScanContext(inputSqlNodes);
  SqlNode callNode = context.toSql(null, e.getCall());
  // Convert to table function call, "TABLE($function_name(xxx))"
  SqlNode tableCall = new SqlBasicCall(
      SqlStdOperatorTable.COLLECTION_TABLE,
      new SqlNode[]{callNode},
      SqlParserPos.ZERO);
  SqlNode select = new SqlSelect(
      SqlParserPos.ZERO, null, null, tableCall,
      null, null, null, null, null, null, null, SqlNodeList.EMPTY);
  return result(select, ImmutableList.of(Clause.SELECT), e, null);
}
 

/**
 * Creates a call to the switched form of the case operator, viz:
 *
 * <blockquote><code>CASE value<br>
 * WHEN whenList[0] THEN thenList[0]<br>
 * WHEN whenList[1] THEN thenList[1]<br>
 * ...<br>
 * ELSE elseClause<br>
 * END</code></blockquote>
 */
public static SqlCase createSwitched(SqlParserPos pos, SqlNode value,
    SqlNodeList whenList, SqlNodeList thenList, SqlNode elseClause) {
  if (null != value) {
    List<SqlNode> list = whenList.getList();
    for (int i = 0; i < list.size(); i++) {
      SqlNode e = list.get(i);
      final SqlCall call;
      if (e instanceof SqlNodeList) {
        call = SqlStdOperatorTable.IN.createCall(pos, value, e);
      } else {
        call = SqlStdOperatorTable.EQUALS.createCall(pos, value, e);
      }
      list.set(i, call);
    }
  }

  if (null == elseClause) {
    elseClause = SqlLiteral.createNull(pos);
  }

  return new SqlCase(pos, null, whenList, thenList, elseClause);
}
 

/**
 * Returns the <code>ordinal</code>th item in the select list.
 */
private SqlNode nthSelectItem(int ordinal, final SqlParserPos pos) {
	// TODO: Don't expand the list every time. Maybe keep an expanded
	// version of each expression -- select lists and identifiers -- in
	// the validator.

	SqlNodeList expandedSelectList =
		expandStar(
			select.getSelectList(),
			select,
			false);
	SqlNode expr = expandedSelectList.get(ordinal);
	expr = stripAs(expr);
	if (expr instanceof SqlIdentifier) {
		expr = getScope().fullyQualify((SqlIdentifier) expr).identifier;
	}

	// Create a copy of the expression with the position of the order
	// item.
	return expr.clone(pos);
}
 

public SqlCreateHiveView(SqlParserPos pos, SqlIdentifier viewName, SqlNodeList fieldList, SqlNode query,
		boolean ifNotExists, SqlCharStringLiteral comment, SqlNodeList properties) {
	super(
			pos,
			viewName,
			fieldList,
			query,
			false,
			false,
			ifNotExists,
			HiveDDLUtils.unescapeStringLiteral(comment),
			properties
	);
	HiveDDLUtils.unescapeProperties(properties);
	originPropList = new SqlNodeList(properties.getList(), properties.getParserPosition());
	// mark it as a hive view
	properties.add(HiveDDLUtils.toTableOption(CatalogConfig.IS_GENERIC, "false", pos));
}
 

public SqlMonotonicity getMonotonicity(SqlNode expr) {
  SqlMonotonicity monotonicity = expr.getMonotonicity(this);
  if (monotonicity != SqlMonotonicity.NOT_MONOTONIC) {
    return monotonicity;
  }

  // TODO: compare fully qualified names
  final SqlNodeList orderList = getOrderList();
  if (orderList.size() > 0) {
    SqlNode order0 = orderList.get(0);
    monotonicity = SqlMonotonicity.INCREASING;
    if ((order0 instanceof SqlCall)
        && (((SqlCall) order0).getOperator()
        == SqlStdOperatorTable.DESC)) {
      monotonicity = monotonicity.reverse();
      order0 = ((SqlCall) order0).operand(0);
    }
    if (expr.equalsDeep(order0, Litmus.IGNORE)) {
      return monotonicity;
    }
  }

  return SqlMonotonicity.NOT_MONOTONIC;
}
 

/**
 * Creates the SELECT statement that putatively feeds rows into an UPDATE
 * statement to be updated.
 *
 * @param call Call to the UPDATE operator
 * @return select statement
 */
protected SqlSelect createSourceSelectForUpdate(SqlUpdate call) {
	final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
	selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
	int ordinal = 0;
	for (SqlNode exp : call.getSourceExpressionList()) {
		// Force unique aliases to avoid a duplicate for Y with
		// SET X=Y
		String alias = SqlUtil.deriveAliasFromOrdinal(ordinal);
		selectList.add(SqlValidatorUtil.addAlias(exp, alias));
		++ordinal;
	}
	SqlNode sourceTable = call.getTargetTable();
	if (call.getAlias() != null) {
		sourceTable =
			SqlValidatorUtil.addAlias(
				sourceTable,
				call.getAlias().getSimple());
	}
	return new SqlSelect(SqlParserPos.ZERO, null, selectList, sourceTable,
		call.getCondition(), null, null, null, null, null, null);
}
 

@Test
public void testCreateFunction() throws IOException, ParseException {
  String sql = Joiner.on(";\n").join(
      "CREATE FUNCTION udf AS 'foo.udf'",
      "CREATE FUNCTION udf1 AS 'foo.udf' USING JAR 'mock://foo'",
      "CREATE FUNCTION udf2 AS 'foo.udf' USING JAR 'mock://foo', JAR 'mock://bar'"
  );
  SqlNodeList nodes = Planner.parse(sql);
  Validator validator = new Validator();
  validator.extract(nodes);
  assertEquals(ImmutableList.of(
      URI.create("mock://foo"),
      URI.create("mock://foo"),
      URI.create("mock://bar")
  ), ImmutableList.copyOf(validator.additionalResources()));
}
 

private void validateGroupItem(SqlValidatorScope groupScope,
	AggregatingSelectScope aggregatingScope,
	SqlNode groupItem) {
	switch (groupItem.getKind()) {
		case GROUPING_SETS:
		case ROLLUP:
		case CUBE:
			validateGroupingSets(groupScope, aggregatingScope, (SqlCall) groupItem);
			break;
		default:
			if (groupItem instanceof SqlNodeList) {
				break;
			}
			final RelDataType type = deriveType(groupScope, groupItem);
			setValidatedNodeType(groupItem, type);
	}
}
 

/**
 * Returns the <code>ordinal</code>th item in the select list.
 */
private SqlNode nthSelectItem(int ordinal, final SqlParserPos pos) {
	// TODO: Don't expand the list every time. Maybe keep an expanded
	// version of each expression -- select lists and identifiers -- in
	// the validator.

	SqlNodeList expandedSelectList =
		expandStar(
			select.getSelectList(),
			select,
			false);
	SqlNode expr = expandedSelectList.get(ordinal);
	expr = stripAs(expr);
	if (expr instanceof SqlIdentifier) {
		expr = getScope().fullyQualify((SqlIdentifier) expr).identifier;
	}

	// Create a copy of the expression with the position of the order
	// item.
	return expr.clone(pos);
}
 

/**
 * @see #dispatch
 */
public Result visit(Sort e) {
  Result x = visitChild(0, e.getInput());
  Builder builder = x.builder(e, Clause.ORDER_BY);
  List<SqlNode> orderByList = Expressions.list();
  for (RelFieldCollation field : e.getCollation().getFieldCollations()) {
    builder.addOrderItem(orderByList, field);
  }
  if (!orderByList.isEmpty()) {
    builder.setOrderBy(new SqlNodeList(orderByList, POS));
    x = builder.result();
  }
  if (e.fetch != null) {
    builder = x.builder(e, Clause.FETCH);
    builder.setFetch(builder.context.toSql(null, e.fetch));
    x = builder.result();
  }
  if (e.offset != null) {
    builder = x.builder(e, Clause.OFFSET);
    builder.setOffset(builder.context.toSql(null, e.offset));
    x = builder.result();
  }
  return x;
}
 

@VisibleForTesting
static SqlNodeList parse(String sql) throws ParseException {
  // Keep the SQL syntax consistent with Flink
  try (StringReader in = new StringReader(sql)) {
    SqlParserImpl impl = new SqlParserImpl(in);

    // back tick as the quote
    impl.switchTo("BTID");
    impl.setTabSize(1);
    impl.setQuotedCasing(Lex.JAVA.quotedCasing);
    impl.setUnquotedCasing(Lex.JAVA.unquotedCasing);
    impl.setIdentifierMaxLength(DEFAULT_IDENTIFIER_MAX_LENGTH);
    return impl.SqlStmtsEof();
  }
}
 

/** Wraps a call in a {@link SqlKind#WITHIN_GROUP} call, if
 * {@code orderList} is non-empty. */
private SqlNode withOrder(SqlCall call, SqlNodeList orderList) {
    if (orderList == null || orderList.size() == 0) {
        return call;
    }
    return SqlStdOperatorTable.WITHIN_GROUP.createCall(POS, call, orderList);
}
 

private static void parseSource(SqlSelect sqlSelect, List<String> sources, List<String> udfs)
    throws SqlParseException {
    SqlNodeList selectList = sqlSelect.getSelectList();
    SqlNode from = sqlSelect.getFrom();
    SqlNode where = sqlSelect.getWhere();
    SqlNode having = sqlSelect.getHaving();
    parseSelectList(selectList, sources, udfs);
    parseFrom(from, sources, udfs);
    parseFunction(where, udfs);
    parseFunction(having, udfs);
}
 

public Result visitValues(Values e) {
  final List<String> fields = e.getRowType().getFieldNames();
  final List<Clause> clauses = Collections.singletonList(Clause.SELECT);
  final Context context =
      new AliasContext(Collections.<Pair<String, RelDataType>>emptyList(), false);
  final List<SqlSelect> selects = new ArrayList<>();
  for (List<RexLiteral> tuple : e.getTuples()) {
    final List<SqlNode> selectList = new ArrayList<>();
    for (Pair<RexLiteral, String> literal : Pair.zip(tuple, fields)) {
      selectList.add(
          SqlStdOperatorTable.AS.createCall(
              POS,
              context.toSql(null, literal.left),
              new SqlIdentifier(literal.right, POS)));
    }
    selects.add(
        new SqlSelect(POS, SqlNodeList.EMPTY,
            new SqlNodeList(selectList, POS), null, null, null,
            null, null, null, null, null));
  }
  SqlNode query = null;
  for (SqlSelect select : selects) {
    if (query == null) {
      query = select;
    } else {
      query = SqlStdOperatorTable.UNION_ALL.createCall(POS, query,
          select);
    }
  }
  return result(query, clauses, e);
}
 

private static SqlNodeList creatFullNewSelectList(String alias, SqlNodeList selectList) {
    SqlNodeList newSelectList = new SqlNodeList( selectList.getParserPosition());
    List<String> names = new ArrayList<>(2);
    names.add(alias);
    names.add("");
    newSelectList.add(new SqlIdentifier(names,new SqlParserPos(0,0)));
    return newSelectList;
}
 

/** Creates a SqlCreateFunction. */
public SqlCreateFunction(SqlParserPos pos, boolean replace,
    boolean ifNotExists, SqlIdentifier name,
    SqlNode className, SqlNodeList usingList) {
  super(OPERATOR, pos, replace, ifNotExists);
  this.name = Objects.requireNonNull(name);
  this.className = className;
  this.usingList = Objects.requireNonNull(usingList);
  Preconditions.checkArgument(usingList.size() % 2 == 0);
}
 

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";
}
 

public static void unparseSqlNodeList(SqlWriter writer, int leftPrec, int rightPrec, SqlNodeList fieldList) {
  writer.keyword("(");
  fieldList.get(0).unparse(writer, leftPrec, rightPrec);
  for (int i = 1; i<fieldList.size(); i++) {
    writer.keyword(",");
    fieldList.get(i).unparse(writer, leftPrec, rightPrec);
  }
  writer.keyword(")");
}
 

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);
  }
}
 

GroupByScope(
    SqlValidatorScope parent,
    SqlNodeList groupByList,
    SqlSelect select) {
  super(parent);
  this.groupByList = groupByList;
  this.select = select;
}
 

OrderByScope(
    SqlValidatorScope parent,
    SqlNodeList orderList,
    SqlSelect select) {
  super(parent);
  this.orderList = orderList;
  this.select = select;
}
 

public SqlAlterTable(
		SqlParserPos pos,
		SqlIdentifier tableName,
		@Nullable SqlNodeList partitionSpec) {
	super(pos);
	this.tableIdentifier = requireNonNull(tableName, "tableName should not be null");
	this.partitionSpec = partitionSpec;
}
 

private static List<Expression> convertSelectList(SqlNodeList selectList) {
  List<Expression> selectExpr = new ArrayList<>();

  final Iterator<SqlNode> iterator = selectList.iterator();
  while (iterator.hasNext()) {
    final SqlNode next = iterator.next();
    selectExpr.add(toExpression(next));
  }

  return selectExpr;
}
 

public static SqlNode getOnlySelectNode(String sql) {
    SqlNodeList selectList = null;
    try {
        selectList = ((SqlSelect) CalciteParser.parse(sql)).getSelectList();
    } catch (SqlParseException e) {
        throw new RuntimeException(
                "Failed to parse expression \'" + sql + "\', please make sure the expression is valid", e);
    }

    Preconditions.checkArgument(selectList.size() == 1,
            "Expression is invalid because size of select list exceeds one");

    return selectList.get(0);
}