Java SqlSelect.getGroup方法代码示例

import org.apache.calcite.sql.SqlSelect; //导入方法依赖的package包/类
private GroupBy parseGroupBy(SqlSelect sqlSelect) {
    GroupBy groupBy = null;
    SqlNodeList sqlGroupBy = sqlSelect.getGroup();
    if (sqlGroupBy != null) {
        ExpressionGenerator exprGenerator = new ExpressionGenerator(streams, catalogUdfs);
        ExpressionList exprList = (ExpressionList) sqlGroupBy.accept(exprGenerator);
        groupBy = new GroupBy(exprList.getExpressions());
        referredUdfs.addAll(exprGenerator.getReferredUdfs());
    }
    LOG.debug("GroupBy {}", groupBy);
    return groupBy;
}
 

import org.apache.calcite.sql.SqlSelect; //导入方法依赖的package包/类
/** Returns the parse tree node (GROUP BY, HAVING, or an aggregate function
 * call) that causes {@code select} to be an aggregate query, or null if it
 * is not an aggregate query.
 *
 * <p>The node is useful context for error messages,
 * but you cannot assume that the node is the only aggregate function. */
protected SqlNode getAggregate(SqlSelect select) {
  SqlNode node = select.getGroup();
  if (node != null) {
    return node;
  }
  node = select.getHaving();
  if (node != null) {
    return node;
  }
  return getAgg(select);
}
 

import org.apache.calcite.sql.SqlSelect; //导入方法依赖的package包/类
private void checkRollUpInGroupBy(SqlSelect select) {
  SqlNodeList group = select.getGroup();
  if (group != null) {
    for (SqlNode node : group) {
      checkRollUp(null, select, node, getGroupScope(select), "GROUP BY");
    }
  }
}
 

import org.apache.calcite.sql.SqlSelect; //导入方法依赖的package包/类
private VirtualDatasetState extractSelect(String sql, SqlNode node, final RelDataType relDataType) {
  SqlSelect select = (SqlSelect)node;

  // From table
  FromNode from = extractFrom(select);

  // Selected columns
  List<Column> columns = extractColumns(relDataType, select, from);

  SqlNode where = select.getWhere();
  if (where != null) {
    return fallback("where is not supported yet", where, sql);
  }
  SqlNodeList groupBy = select.getGroup();
  if (groupBy != null) {
    return fallback("group by is not supported yet", groupBy, sql);
  }
  SqlNode having = select.getHaving();
  if (having != null) {
    return fallback("having is not supported yet", having, sql);
  }
  SqlNodeList windowDecls = select.getWindowList();
  if (windowDecls != null && !windowDecls.getList().isEmpty()) {
    return fallback("window is not supported yet", windowDecls, sql);
  }
  List<Order> orders = extractOrders(select.getOrderList(), from);

  SqlNode offset = select.getOffset();
  if (offset != null) {
    return fallback("offset is not supported yet", offset, sql);
  }
  SqlNode fetch = select.getFetch();
  if (fetch != null) {
    return fallback("fetch is not supported yet", fetch, sql);
  }
  FromTable fromTable = new FromTable(from.getTableToString());
  if (from.alias != null) {
    fromTable.setAlias(from.getAliasToString());
  }
  return new VirtualDatasetState(fromTable.wrap())
      .setColumnsList(columns)
      .setOrdersList(orders);
}
 

import org.apache.calcite.sql.SqlSelect; //导入方法依赖的package包/类
/**
 * Converts the RelNode tree for a select statement to a select that
 * produces a single value.
 *
 * @param query the query
 * @param plan   the original RelNode tree corresponding to the statement
 * @return the converted RelNode tree
 */
public RelNode convertToSingleValueSubq(
	SqlNode query,
	RelNode plan) {
	// Check whether query is guaranteed to produce a single value.
	if (query instanceof SqlSelect) {
		SqlSelect select = (SqlSelect) query;
		SqlNodeList selectList = select.getSelectList();
		SqlNodeList groupList = select.getGroup();

		if ((selectList.size() == 1)
			&& ((groupList == null) || (groupList.size() == 0))) {
			SqlNode selectExpr = selectList.get(0);
			if (selectExpr instanceof SqlCall) {
				SqlCall selectExprCall = (SqlCall) selectExpr;
				if (Util.isSingleValue(selectExprCall)) {
					return plan;
				}
			}

			// If there is a limit with 0 or 1,
			// it is ensured to produce a single value
			if (select.getFetch() != null
				&& select.getFetch() instanceof SqlNumericLiteral) {
				SqlNumericLiteral limitNum = (SqlNumericLiteral) select.getFetch();
				if (((BigDecimal) limitNum.getValue()).intValue() < 2) {
					return plan;
				}
			}
		}
	} else if (query instanceof SqlCall) {
		// If the query is (values ...),
		// it is necessary to look into the operands to determine
		// whether SingleValueAgg is necessary
		SqlCall exprCall = (SqlCall) query;
		if (exprCall.getOperator()
			instanceof SqlValuesOperator
			&& Util.isSingleValue(exprCall)) {
			return plan;
		}
	}

	// If not, project SingleValueAgg
	return RelOptUtil.createSingleValueAggRel(
		cluster,
		plan);
}
 

import org.apache.calcite.sql.SqlSelect; //导入方法依赖的package包/类
/**
 * Converts the RelNode tree for a select statement to a select that
 * produces a single value.
 *
 * @param query the query
 * @param plan   the original RelNode tree corresponding to the statement
 * @return the converted RelNode tree
 */
public RelNode convertToSingleValueSubq(
    SqlNode query,
    RelNode plan) {
  // Check whether query is guaranteed to produce a single value.
  if (query instanceof SqlSelect) {
    SqlSelect select = (SqlSelect) query;
    SqlNodeList selectList = select.getSelectList();
    SqlNodeList groupList = select.getGroup();

    if ((selectList.size() == 1)
        && ((groupList == null) || (groupList.size() == 0))) {
      SqlNode selectExpr = selectList.get(0);
      if (selectExpr instanceof SqlCall) {
        SqlCall selectExprCall = (SqlCall) selectExpr;
        if (Util.isSingleValue(selectExprCall)) {
          return plan;
        }
      }

      // If there is a limit with 0 or 1,
      // it is ensured to produce a single value
      if (select.getFetch() != null
          && select.getFetch() instanceof SqlNumericLiteral) {
        SqlNumericLiteral limitNum = (SqlNumericLiteral) select.getFetch();
        if (((BigDecimal) limitNum.getValue()).intValue() < 2) {
          return plan;
        }
      }
    }
  } else if (query instanceof SqlCall) {
    // If the query is (values ...),
    // it is necessary to look into the operands to determine
    // whether SingleValueAgg is necessary
    SqlCall exprCall = (SqlCall) query;
    if (exprCall.getOperator()
        instanceof SqlValuesOperator
            && Util.isSingleValue(exprCall)) {
      return plan;
    }
  }

  // If not, project SingleValueAgg
  return RelOptUtil.createSingleValueAggRel(
      cluster,
      plan);
}