import org.apache.calcite.sql.util.SqlShuttle; //导入依赖的package包/类
private void checkSelectPrivilegeThrow(SqlNode query) throws PostgresException {
    final PostgresException[] e = {null};

    query.accept(new SqlShuttle() {
        @Override
        public SqlNode visit(SqlIdentifier identifier) {
            if (identifier.names.size() == 3 && e[0] == null) {
                String[] schemaName = {identifier.names.get(0), identifier.names.get(1)};
                e[0] = checkObjectPrivilegeInternal(ObjectPrivilege.SELECT, schemaName);
            }
            return identifier;
        }
    });

    if (e[0] != null)
        throw e[0];
}
 

import org.apache.calcite.sql.util.SqlShuttle; //导入依赖的package包/类
/**
 * Strips namespace from identifiers of sql
 *
 * @param node
 * @param namespace
 * @param dialect
 * @return
 */
private String stripNamespace(final SqlNode node,
                              final String namespace,
                              final SqlDialect dialect) {
  final SqlNode transformedNode = node.accept(
      new SqlShuttle() {
        @Override
        public SqlNode visit(SqlIdentifier id) {
          if (id.names.size() > 1
              && id.names.get(0).toUpperCase().equals(namespace.toUpperCase())) {
            return id.getComponent(1, id.names.size());
          } else {
            return id;
          }
        }
      });
  String result = transformedNode.toSqlString(dialect).toString();
  return result.replace("\n", " ");
}
 

import org.apache.calcite.sql.util.SqlShuttle; //导入依赖的package包/类
private List<String> getDatasourceNames(SqlNode query) {
    final Set<String> dsSet = new HashSet<>();
    query.accept(new SqlShuttle() {
        @Override
        public SqlNode visit(SqlIdentifier identifier) {
            // check whether this is fully qualified table name
            if (identifier.names.size() == 3) {
                dsSet.add(identifier.names.get(0));
            }
            return identifier;
        }
    });

    return new ArrayList<>(dsSet);
}
 

import org.apache.calcite.sql.util.SqlShuttle; //导入依赖的package包/类
public CursorHive(CachedStatement cachedStatement, String name,
                  FormatCode[] paramFormats, byte[][] paramValues,
                  FormatCode[] resultFormats, String dataSourceName) {
    super(cachedStatement, name, paramFormats, paramValues, resultFormats);

    sessionId = Session.currentSession().getId();
    this.dataSourceName = dataSourceName;

    /*
     * NOTE: Deep-copy validatedQuery because TableNameTranslator.toDSN()
     *       changes identifiers of validatedQuery itself.
     *       When this Portal runs again without copied one,
     *       the by-pass test in processBind() which uses the validatedQuery
     *       will produce an error.
     *       To reduce number of copies, cache queryString.
     */
    CachedStatement cStmt = (CachedStatement) getCachedQuery();
    SqlNode cloned = cStmt.getValidatedQuery().accept(new SqlShuttle() {
        @Override
        public SqlNode visit(SqlIdentifier id) {
            return id.clone(id.getParserPosition());
        }
    });
    TableNameTranslator.toDSN(cloned);
    SqlDialect.DatabaseProduct dp = SqlDialect.DatabaseProduct.HIVE;
    queryString = cloned.toSqlString(dp.getDialect()).getSql();
}
 

import org.apache.calcite.sql.util.SqlShuttle; //导入依赖的package包/类
/**
 * Creates a result based on a single relational expression.
 */
public Result result(SqlNode node, Collection<Clause> clauses, RelNode rel) {
    System.out.println("******************************************************");
    System.out.println("******************************************************");
    System.out.println("******************************************************");
    System.out.println("******************************************************");
    System.out.println(node.toString());
    SqlNode cloned = node.accept(new SqlShuttle() {
        @Override
        public SqlNode visit(SqlIdentifier id) {
            return id.clone(id.getParserPosition());
        }
    });
    //TableNameTranslator.toDSN(cloned);
    if (cloned instanceof SqlIdentifier) {
        List<String> dsn = new ArrayList<>();
        SqlIdentifier tableId = (SqlIdentifier) cloned;
        String schemaName = tableId.names.get(1);
        if (!"__DEFAULT".equals(schemaName))
            dsn.add(schemaName);
        dsn.add(tableId.names.get(2));
        tableId.setNames(dsn, null);
    }
    System.out.println(cloned.toString());

    final String alias2 = SqlValidatorUtil.getAlias(node, -1);
    final String alias3 = alias2 != null ? alias2 : "t";
    final String alias4 =
            SqlValidatorUtil.uniquify(
                    alias3, aliasSet, SqlValidatorUtil.EXPR_SUGGESTER);
    final String alias5 = alias2 == null || !alias2.equals(alias4) ? alias4
            : null;
    return new Result(cloned, clauses, alias5,
            Collections.singletonList(Pair.of(alias4, rel.getRowType())));
}
 

import org.apache.calcite.sql.util.SqlShuttle; //导入依赖的package包/类
public RelDataType getParameterRowType(SqlNode sqlQuery) {
  // NOTE: We assume that bind variables occur in depth-first tree
  // traversal in the same order that they occurred in the SQL text.
  final List<RelDataType> types = new ArrayList<>();
  // NOTE: but parameters on fetch/offset would be counted twice
  // as they are counted in the SqlOrderBy call and the inner SqlSelect call
  final Set<SqlNode> alreadyVisited = new HashSet<>();
  sqlQuery.accept(
      new SqlShuttle() {

        @Override public SqlNode visit(SqlDynamicParam param) {
          if (alreadyVisited.add(param)) {
            RelDataType type = getValidatedNodeType(param);
            types.add(type);
          }
          return param;
        }
      });
  return typeFactory.createStructType(
      types,
      new AbstractList<String>() {
        @Override public String get(int index) {
          return "?" + index;
        }

        @Override public int size() {
          return types.size();
        }
      });
}