import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
public RexDynamicParam convertDynamicParam(
	final SqlDynamicParam dynamicParam) {
	// REVIEW jvs 8-Jan-2005:  dynamic params may be encountered out of
	// order.  Should probably cross-check with the count from the parser
	// at the end and make sure they all got filled in.  Why doesn't List
	// have a resize() method?!?  Make this a utility.
	while (dynamicParam.getIndex() >= dynamicParamSqlNodes.size()) {
		dynamicParamSqlNodes.add(null);
	}

	dynamicParamSqlNodes.set(
		dynamicParam.getIndex(),
		dynamicParam);
	return rexBuilder.makeDynamicParam(
		getDynamicParamType(dynamicParam.getIndex()),
		dynamicParam.getIndex());
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
/**
 * Determines whether a RexNode corresponds to a sub-query that's been
 * converted to a constant.
 *
 * @param rex the expression to be examined
 * @return true if the expression is a dynamic parameter, a literal, or
 * a literal that is being cast
 */
private boolean isConvertedSubq(RexNode rex) {
	if ((rex instanceof RexLiteral)
		|| (rex instanceof RexDynamicParam)) {
		return true;
	}
	if (rex instanceof RexCall) {
		RexCall call = (RexCall) rex;
		if (call.getOperator() == SqlStdOperatorTable.CAST) {
			RexNode operand = call.getOperands().get(0);
			if (operand instanceof RexLiteral) {
				return true;
			}
		}
	}
	return false;
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
public RexDynamicParam convertDynamicParam(
    final SqlDynamicParam dynamicParam) {
  // REVIEW jvs 8-Jan-2005:  dynamic params may be encountered out of
  // order.  Should probably cross-check with the count from the parser
  // at the end and make sure they all got filled in.  Why doesn't List
  // have a resize() method?!?  Make this a utility.
  while (dynamicParam.getIndex() >= dynamicParamSqlNodes.size()) {
    dynamicParamSqlNodes.add(null);
  }

  dynamicParamSqlNodes.set(
      dynamicParam.getIndex(),
      dynamicParam);
  return rexBuilder.makeDynamicParam(
      getDynamicParamType(dynamicParam.getIndex()),
      dynamicParam.getIndex());
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
/**
 * Determines whether a RexNode corresponds to a sub-query that's been
 * converted to a constant.
 *
 * @param rex the expression to be examined
 * @return true if the expression is a dynamic parameter, a literal, or
 * a literal that is being cast
 */
private boolean isConvertedSubq(RexNode rex) {
  if ((rex instanceof RexLiteral)
      || (rex instanceof RexDynamicParam)) {
    return true;
  }
  if (rex instanceof RexCall) {
    RexCall call = (RexCall) rex;
    if (call.getOperator() == SqlStdOperatorTable.CAST) {
      RexNode operand = call.getOperands().get(0);
      if (operand instanceof RexLiteral) {
        return true;
      }
    }
  }
  return false;
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
private static Expression getExpression(RexNode offset) {
  if (offset instanceof RexDynamicParam) {
    final RexDynamicParam param = (RexDynamicParam) offset;
    return Expressions.convert_(
        Expressions.call(DataContext.ROOT,
            BuiltInMethod.DATA_CONTEXT_GET.method,
            Expressions.constant("?" + param.getIndex())),
        Integer.class);
  } else {
    return Expressions.constant(RexLiteral.intValue(offset));
  }
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
/** Translates a parameter. */
private Expression translateParameter(RexDynamicParam expr,
    RexImpTable.NullAs nullAs, Type storageType) {
  if (storageType == null) {
    storageType = typeFactory.getJavaClass(expr.getType());
  }
  return nullAs.handle(
      convert(
          Expressions.call(root, BuiltInMethod.DATA_CONTEXT_GET.method,
              Expressions.constant("?" + expr.getIndex())),
          storageType));
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
private void checkExponentialCnf(int n) {
  final RelDataType booleanType =
      typeFactory.createSqlType(SqlTypeName.BOOLEAN);
  final RelDataTypeFactory.Builder builder = typeFactory.builder();
  for (int i = 0; i < n; i++) {
    builder.add("x" + i, booleanType)
        .add("y" + i, booleanType);
  }
  final RelDataType rowType3 = builder.build();
  final RexDynamicParam range3 = rexBuilder.makeDynamicParam(rowType3, 0);
  final List<RexNode> list = Lists.newArrayList();
  for (int i = 0; i < n; i++) {
    list.add(
        and(rexBuilder.makeFieldAccess(range3, i * 2),
            rexBuilder.makeFieldAccess(range3, i * 2 + 1)));
  }
  final RexNode cnf = RexUtil.toCnf(rexBuilder, or(list));
  final int nodeCount = nodeCount(cnf);
  assertThat((n + 1) * (int) Math.pow(2, n) + 1, equalTo(nodeCount));
  if (n == 3) {
    assertThat(cnf.toString(),
        equalTo("AND(OR(?0.x0, ?0.x1, ?0.x2), OR(?0.x0, ?0.x1, ?0.y2),"
            + " OR(?0.x0, ?0.y1, ?0.x2), OR(?0.x0, ?0.y1, ?0.y2),"
            + " OR(?0.y0, ?0.x1, ?0.x2), OR(?0.y0, ?0.x1, ?0.y2),"
            + " OR(?0.y0, ?0.y1, ?0.x2), OR(?0.y0, ?0.y1, ?0.y2))"));
  }
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
public Void visitDynamicParam(RexDynamicParam dynamicParam) {
  return pushVariable();
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public RexNode visitDynamicParam(RexDynamicParam dynamicParam) {
  return dynamicParam;
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public LogicalExpression visitDynamicParam(RexDynamicParam dynamicParam) {
  return doUnknown(dynamicParam);
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public Boolean visitDynamicParam(RexDynamicParam dynamicParam) {
  return doUnknown(dynamicParam);
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public Boolean visitDynamicParam(RexDynamicParam paramRexDynamicParam) {
  return true;
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public Boolean visitDynamicParam(RexDynamicParam dynamicParam) {
  return true;
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public StateHolder visitDynamicParam(RexDynamicParam dynamicParam) {
  return new StateHolder(Type.OTHER, dynamicParam);
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public Boolean visitDynamicParam(RexDynamicParam dynamicParam) {
  return false;
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public Expression visitDynamicParam(RexDynamicParam dynamicParam) {
  return super.visitDynamicParam(dynamicParam);
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public List<List<String>> visitDynamicParam(RexDynamicParam dynamicParam) {
  return visitUnknown(dynamicParam);
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public FunctionRender visitDynamicParam(RexDynamicParam dynamicParam) {
  return visitUnknown(dynamicParam);
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override
public TupleFilter visitDynamicParam(RexDynamicParam dynamicParam) {
    String name = dynamicParam.getName();
    TupleFilter filter = new DynamicTupleFilter(name);
    return filter;
}
 

import org.apache.calcite.rex.RexDynamicParam; //导入依赖的package包/类
@Override public Void visitDynamicParam(RexDynamicParam dynamicParam) {
  return pushVariable();
}