import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
private RexVisitorImpl<Void> rexVisitor(final RelNode rel) {
	return new RexVisitorImpl<Void>(true) {
		@Override
		public Void visitFieldAccess(RexFieldAccess fieldAccess) {
			final RexNode ref = fieldAccess.getReferenceExpr();
			if (ref instanceof RexCorrelVariable) {
				final RexCorrelVariable var = (RexCorrelVariable) ref;
				final Correlation correlation = new Correlation(var.id, fieldAccess.getField().getIndex(), corrIdGenerator++);
				mapFieldAccessToCorVar.put(fieldAccess, correlation);
				mapRefRelToCorVar.put(rel, correlation);
			}
			return super.visitFieldAccess(fieldAccess);
		}

		@Override
		public Void visitSubQuery(RexSubQuery subQuery) {
			subQuery.rel.accept(FlinkRelDecorrelator.CorelMapBuilder.this);
			return super.visitSubQuery(subQuery);
		}
	};
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
private boolean references(RexNode e, CorRef correlation) {
  switch (e.getKind()) {
  case CAST:
    final RexNode operand = ((RexCall) e).getOperands().get(0);
    if (isWidening(e.getType(), operand.getType())) {
      return references(operand, correlation);
    }
    return false;
  case FIELD_ACCESS:
    final RexFieldAccess f = (RexFieldAccess) e;
    if (f.getField().getIndex() == correlation.field
        && f.getReferenceExpr() instanceof RexCorrelVariable) {
      if (((RexCorrelVariable) f.getReferenceExpr()).id == correlation.corr) {
        return true;
      }
    }
    // fall through
  default:
    return false;
  }
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
@Test public void testCorrelationFails() {
  final RelBuilder builder = RelBuilder.create(config().build());
  final Holder<RexCorrelVariable> v = Holder.of(null);
  try {
    builder.scan("EMP")
        .variable(v)
        .filter(builder.equals(builder.field(0), v.get()))
        .scan("DEPT")
        .join(JoinRelType.INNER, builder.literal(true),
            ImmutableSet.of(v.get().id));
    fail("expected error");
  } catch (IllegalArgumentException e) {
    assertThat(e.getMessage(),
        containsString("variable $cor0 must not be used by left input to correlation"));
  }
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
@Test public void testCorrelationWithCondition() {
  final RelBuilder builder = RelBuilder.create(config().build());
  final Holder<RexCorrelVariable> v = Holder.of(null);
  RelNode root = builder.scan("EMP")
      .variable(v)
      .scan("DEPT")
      .filter(
          builder.equals(builder.field(0),
              builder.field(v.get(), "DEPTNO")))
      .join(JoinRelType.LEFT,
          builder.equals(builder.field(2, 0, "SAL"),
              builder.literal(1000)),
          ImmutableSet.of(v.get().id))
      .build();
  // Note that the join filter gets pushed to the right-hand input of
  // LogicalCorrelate
  final String expected = ""
      + "LogicalCorrelate(correlation=[$cor0], joinType=[left], requiredColumns=[{7}])\n"
      + "  LogicalTableScan(table=[[scott, EMP]])\n"
      + "  LogicalFilter(condition=[=($cor0.SAL, 1000)])\n"
      + "    LogicalFilter(condition=[=($0, $cor0.DEPTNO)])\n"
      + "      LogicalTableScan(table=[[scott, DEPT]])\n";
  assertThat(str(root), is(expected));
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
private RexVisitorImpl<Void> rexVisitor(final RelNode rel) {
  return new RexVisitorImpl<Void>(true) {
    @Override public Void visitFieldAccess(RexFieldAccess fieldAccess) {
      final RexNode ref = fieldAccess.getReferenceExpr();
      if (ref instanceof RexCorrelVariable) {
        final RexCorrelVariable var = (RexCorrelVariable) ref;
        if (mapFieldAccessToCorVar.containsKey(fieldAccess)) {
          // for cases where different Rel nodes are referring to
          // same correlation var (e.g. in case of NOT IN)
          // avoid generating another correlation var
          // and record the 'rel' is using the same correlation
          mapRefRelToCorRef.put(rel,
              mapFieldAccessToCorVar.get(fieldAccess));
        } else {
          final CorRef correlation =
              new CorRef(var.id, fieldAccess.getField().getIndex(),
                  corrIdGenerator++);
          mapFieldAccessToCorVar.put(fieldAccess, correlation);
          mapRefRelToCorRef.put(rel, correlation);
        }
      }
      return super.visitFieldAccess(fieldAccess);
    }

    @Override public Void visitSubQuery(RexSubQuery subQuery) {
      subQuery.rel.accept(CorelMapBuilder.this);
      return super.visitSubQuery(subQuery);
    }
  };
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
/**
 * Trims the fields of an input relational expression.
 *
 * @param rel        Relational expression
 * @param input      Input relational expression, whose fields to trim
 * @param fieldsUsed Bitmap of fields needed by the consumer
 * @return New relational expression and its field mapping
 */
protected TrimResult trimChild(
    RelNode rel,
    RelNode input,
    final ImmutableBitSet fieldsUsed,
    Set<RelDataTypeField> extraFields) {
  final ImmutableBitSet.Builder fieldsUsedBuilder = fieldsUsed.rebuild();

  // Fields that define the collation cannot be discarded.
  final RelMetadataQuery mq = rel.getCluster().getMetadataQuery();
  final ImmutableList<RelCollation> collations = mq.collations(input);
  for (RelCollation collation : collations) {
    for (RelFieldCollation fieldCollation : collation.getFieldCollations()) {
      fieldsUsedBuilder.set(fieldCollation.getFieldIndex());
    }
  }

  // Correlating variables are a means for other relational expressions to use
  // fields.
  for (final CorrelationId correlation : rel.getVariablesSet()) {
    rel.accept(
        new CorrelationReferenceFinder() {
          protected RexNode handle(RexFieldAccess fieldAccess) {
            final RexCorrelVariable v =
                (RexCorrelVariable) fieldAccess.getReferenceExpr();
            if (v.id.equals(correlation)) {
              fieldsUsedBuilder.set(fieldAccess.getField().getIndex());
            }
            return fieldAccess;
          }
        });
  }

  return dispatchTrimFields(input, fieldsUsedBuilder.build(), extraFields);
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
protected TrimResult result(RelNode r, final Mapping mapping) {
  final RexBuilder rexBuilder = relBuilder.getRexBuilder();
  for (final CorrelationId correlation : r.getVariablesSet()) {
    r = r.accept(
        new CorrelationReferenceFinder() {
          protected RexNode handle(RexFieldAccess fieldAccess) {
            final RexCorrelVariable v =
                (RexCorrelVariable) fieldAccess.getReferenceExpr();
            if (v.id.equals(correlation)
                && v.getType().getFieldCount() == mapping.getSourceCount()) {
              final int old = fieldAccess.getField().getIndex();
              final int new_ = mapping.getTarget(old);
              final RelDataTypeFactory.Builder typeBuilder =
                  relBuilder.getTypeFactory().builder();
              for (int target : Util.range(mapping.getTargetCount())) {
                typeBuilder.add(
                    v.getType().getFieldList().get(mapping.getSource(target)));
              }
              final RexNode newV =
                  rexBuilder.makeCorrel(typeBuilder.build(), v.id);
              if (old != new_) {
                return rexBuilder.makeFieldAccess(newV, new_);
              }
            }
            return fieldAccess;
          }
        });
  }
  return new TrimResult(r, mapping);
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
@Override public RexNode visitCorrelVariable(RexCorrelVariable variable) {
  if (!alternateIds.contains(variable.id)) {
    return variable;
  }

  return builder.makeCorrel(variable.getType(), canonicalId);
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
/** Creates a correlation variable for the current input, and writes it into
 * a Holder. */
public RelBuilder variable(Holder<RexCorrelVariable> v) {
  v.set((RexCorrelVariable)
      getRexBuilder().makeCorrel(peek().getRowType(),
          cluster.createCorrel()));
  return this;
}
 

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
@Override public RexNode visitFieldAccess(RexFieldAccess fieldAccess) {
  if (fieldAccess.getReferenceExpr() instanceof RexCorrelVariable) {
    final RexCorrelVariable v =
        (RexCorrelVariable) fieldAccess.getReferenceExpr();
    variableFields.put(v.id, fieldAccess.getField().getIndex());
  }
  return super.visitFieldAccess(fieldAccess);
}
 

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

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

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

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

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

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

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

import org.apache.calcite.rex.RexCorrelVariable; //导入依赖的package包/类
@Override
public RexNode visitCorrelVariable(RexCorrelVariable variable) {
  foundCorrelVariable = true;
  return super.visitCorrelVariable(variable);
}
 

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

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