Java SqlVisitor类代码示例

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
/**
 * Returns whether a given node contains a {@link SqlInOperator}.
 *
 * @param node a RexNode tree
 */
private static boolean containsInOperator(
	SqlNode node) {
	try {
		SqlVisitor<Void> visitor =
			new SqlBasicVisitor<Void>() {
				public Void visit(SqlCall call) {
					if (call.getOperator() instanceof SqlInOperator) {
						throw new Util.FoundOne(call);
					}
					return super.visit(call);
				}
			};
		node.accept(visitor);
		return false;
	} catch (Util.FoundOne e) {
		Util.swallow(e, null);
		return true;
	}
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
public static void ensureNoAliasInExpr(String expr) {
    SqlNode sqlNode = getExpNode(expr);

    SqlVisitor sqlVisitor = new SqlBasicVisitor() {
        @Override
        public Object visit(SqlIdentifier id) {
            if (id.names.size() > 1) {
                throw new IllegalArgumentException(
                        "Column Identifier in the computed column expression should only contain COLUMN");
            }
            return null;
        }
    };

    sqlNode.accept(sqlVisitor);
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
/**
 * Returns whether a given node contains a {@link SqlInOperator}.
 *
 * @param node a RexNode tree
 */
private static boolean containsInOperator(
    SqlNode node) {
  try {
    SqlVisitor<Void> visitor =
        new SqlBasicVisitor<Void>() {
          public Void visit(SqlCall call) {
            if (call.getOperator() instanceof SqlInOperator) {
              throw new Util.FoundOne(call);
            }
            return super.visit(call);
          }
        };
    node.accept(visitor);
    return false;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return true;
  }
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
/**
 * Accepts a {@link SqlVisitor}, and tells it to visit each child.
 *
 * @param visitor Visitor
 */
public <R> void acceptCall(
    SqlVisitor<R> visitor,
    SqlCall call,
    boolean onlyExpressions,
    SqlBasicVisitor.ArgHandler<R> argHandler) {
  if (onlyExpressions) {
    for (Ord<SqlNode> operand : Ord.zip(call.getOperandList())) {
      // if the second param is an Identifier then it's supposed to
      // be a name from a window clause and isn't part of the
      // group by check
      if (operand == null) {
        continue;
      }
      if (operand.i == 1 && operand.e instanceof SqlIdentifier) {
        continue;
      }
      argHandler.visitChild(visitor, call, operand.i, operand.e);
    }
  } else {
    super.acceptCall(visitor, call, onlyExpressions, argHandler);
  }
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
public <R> void acceptCall(
    SqlVisitor<R> visitor,
    SqlCall call,
    boolean onlyExpressions,
    SqlBasicVisitor.ArgHandler<R> argHandler) {
  if (onlyExpressions) {
    for (Ord<SqlNode> operand : Ord.zip(call.getOperandList())) {
      // if the second param is an Identifier then it's supposed to
      // be a name from a window clause and isn't part of the
      // group by check
      if (operand.e == null) {
        continue;
      }
      if (operand.i == 1 && operand.e instanceof SqlIdentifier) {
        // skip refName
        continue;
      }
      argHandler.visitChild(visitor, call, operand.i, operand.e);
    }
  } else {
    super.acceptCall(visitor, call, onlyExpressions, argHandler);
  }
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
@Override public <R> void acceptCall(
    SqlVisitor<R> visitor,
    SqlCall call,
    boolean onlyExpressions,
    SqlBasicVisitor.ArgHandler<R> argHandler) {
  if (onlyExpressions) {
    List<SqlNode> operands = call.getOperandList();
    for (int i = 0; i < operands.size(); i++) {
      SqlNode operand = operands.get(i);
      if (operand == null) {
        continue;
      }
      argHandler.visitChild(visitor, call, i, operand);
    }
  } else {
    super.acceptCall(visitor, call, onlyExpressions, argHandler);
  }
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
@Override
public SqlNode visitChild(
    SqlVisitor<SqlNode> visitor,
    SqlNode expr,
    int i,
    SqlNode operand) {
  if (operand == null) {
    return null;
  }

  boolean localEnableComplex = enableComplex;
  if(rewriteTypes != null){
    switch(rewriteTypes[i]){
    case DISABLE:
      enableComplex = false;
      break;
    case ENABLE:
      enableComplex = true;
    }
  }
  SqlNode newOperand = operand.accept(CompoundIdentifierConverter.this);
  enableComplex = localEnableComplex;
  if (newOperand != operand) {
    update = true;
  }
  clonedOperands[i] = newOperand;
  return newOperand;
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
public static String insertAliasInExpr(String expr, String alias) {
    String prefix = "select ";
    String suffix = " from t";
    String sql = prefix + expr + suffix;
    SqlNode sqlNode = getOnlySelectNode(sql);

    final Set<SqlIdentifier> s = Sets.newHashSet();
    SqlVisitor sqlVisitor = new SqlBasicVisitor() {
        @Override
        public Object visit(SqlIdentifier id) {
            if (id.names.size() > 1) {
                throw new IllegalArgumentException("SqlIdentifier " + id + " contains DB/Table name");
            }
            s.add(id);
            return null;
        }
    };

    sqlNode.accept(sqlVisitor);
    List<SqlIdentifier> sqlIdentifiers = Lists.newArrayList(s);

    descSortByPosition(sqlIdentifiers);

    for (SqlIdentifier sqlIdentifier : sqlIdentifiers) {
        Pair<Integer, Integer> replacePos = getReplacePos(sqlIdentifier, sql);
        int start = replacePos.getFirst();
        sql = sql.substring(0, start) + alias + "." + sql.substring(start);
    }

    return sql.substring(prefix.length(), sql.length() - suffix.length());
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
public static String replaceAliasInExpr(String expr, Map<String, String> renaming) {
    String prefix = "select ";
    String suffix = " from t";
    String sql = prefix + expr + suffix;
    SqlNode sqlNode = CalciteParser.getOnlySelectNode(sql);

    final Set<SqlIdentifier> s = Sets.newHashSet();
    SqlVisitor sqlVisitor = new SqlBasicVisitor() {
        @Override
        public Object visit(SqlIdentifier id) {
            Preconditions.checkState(id.names.size() == 2);
            s.add(id);
            return null;
        }
    };

    sqlNode.accept(sqlVisitor);
    List<SqlIdentifier> sqlIdentifiers = Lists.newArrayList(s);

    CalciteParser.descSortByPosition(sqlIdentifiers);

    for (SqlIdentifier sqlIdentifier : sqlIdentifiers) {
        Pair<Integer, Integer> replacePos = CalciteParser.getReplacePos(sqlIdentifier, sql);
        int start = replacePos.getFirst();
        int end = replacePos.getSecond();
        String aliasInExpr = sqlIdentifier.names.get(0);
        String col = sqlIdentifier.names.get(1);
        String renamedAlias = renaming.get(aliasInExpr);
        Preconditions.checkNotNull(renamedAlias,
                "rename for alias " + aliasInExpr + " in expr (" + expr + ") is not found");
        sql = sql.substring(0, start) + renamedAlias + "." + col + sql.substring(end);
    }

    return sql.substring(prefix.length(), sql.length() - suffix.length());
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
public <R> void acceptCall(
    SqlVisitor<R> visitor,
    SqlCall call,
    boolean onlyExpressions,
    SqlBasicVisitor.ArgHandler<R> argHandler) {
  if (onlyExpressions) {
    // Do not visit operands[1] -- it is not an expression.
    argHandler.visitChild(visitor, call, 0, call.operand(0));
  } else {
    super.acceptCall(visitor, call, onlyExpressions, argHandler);
  }
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
@Override public <R> void acceptCall(SqlVisitor<R> visitor, SqlCall call,
    boolean onlyExpressions, SqlBasicVisitor.ArgHandler<R> argHandler) {
  if (onlyExpressions) {
    // Do not visit operands[1] -- it is not an expression.
    argHandler.visitChild(visitor, call, 0, call.operand(0));
  } else {
    super.acceptCall(visitor, call, onlyExpressions, argHandler);
  }
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
public <R> void acceptCall(
    SqlVisitor<R> visitor,
    SqlCall call,
    boolean onlyExpressions,
    SqlBasicVisitor.ArgHandler<R> argHandler) {
  if (!onlyExpressions) {
    // None of the arguments to the SELECT operator are expressions.
    super.acceptCall(visitor, call, onlyExpressions, argHandler);
  }
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
/**
 * Accepts a {@link SqlVisitor}, visiting each operand of a call. Returns
 * null.
 *
 * @param visitor Visitor
 * @param call    Call to visit
 */
public <R> R acceptCall(SqlVisitor<R> visitor, SqlCall call) {
  for (SqlNode operand : call.getOperandList()) {
    if (operand == null) {
      continue;
    }
    operand.accept(visitor);
  }
  return null;
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
protected SqlVisitor<SqlNode> createConverter() {
  return new CompoundIdentifierConverter();
}
 

import org.apache.calcite.sql.util.SqlVisitor; //导入依赖的package包/类
public <R> R accept(SqlVisitor<R> visitor) {
  return visitor.visit(this);
}