Java JoinRelType类代码示例

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
public boolean apply(Join join, JoinRelType joinType, RexNode exp) {
  if (joinType != JoinRelType.INNER) {
    return true;  // In OUTER join, we could not pull-up the filter.
                  // All we can do is keep the filter with JOIN, and
                  // then decide whether the filter could be pushed down
                  // into LEFT/RIGHT.
  }

  List<RexNode> tmpLeftKeys = Lists.newArrayList();
  List<RexNode> tmpRightKeys = Lists.newArrayList();
  List<RelDataTypeField> sysFields = Lists.newArrayList();

  RexNode remaining = RelOptUtil.splitJoinCondition(sysFields, join.getLeft(), join.getRight(), exp, tmpLeftKeys, tmpRightKeys, null, null);

  if (remaining.isAlwaysTrue()) {
    return true;
  }

  return false;
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Override
public void setupHashJoinProbe(FragmentContext context, VectorContainer buildBatch, RecordBatch probeBatch,
                               int probeRecordCount, HashJoinBatch outgoing, HashTable hashTable,
                               HashJoinHelper hjHelper, JoinRelType joinRelType) {

  this.probeBatch = probeBatch;
  this.probeSchema = probeBatch.getSchema();
  this.buildBatch = buildBatch;
  this.joinType = joinRelType;
  this.recordsToProcess = probeRecordCount;
  this.hashTable = hashTable;
  this.hjHelper = hjHelper;
  this.outgoingJoinBatch = outgoing;

  doSetup(context, buildBatch, probeBatch, outgoing);
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
public JoinOutcome getOutcome() {
  if (!ok) {
    return JoinOutcome.FAILURE;
  }
  if (bothMatches(IterOutcome.NONE) ||
          (joinType == JoinRelType.INNER && eitherMatches(IterOutcome.NONE)) ||
          (joinType == JoinRelType.LEFT && lastLeft == IterOutcome.NONE) ||
          (joinType == JoinRelType.RIGHT && lastRight == IterOutcome.NONE)) {
    return JoinOutcome.NO_MORE_DATA;
  }
  if (bothMatches(IterOutcome.OK) ||
          (eitherMatches(IterOutcome.NONE) && eitherMatches(IterOutcome.OK))) {
    return JoinOutcome.BATCH_RETURNED;
  }
  if (eitherMatches(IterOutcome.OK_NEW_SCHEMA)) {
    return JoinOutcome.SCHEMA_CHANGED;
  }
  if (eitherMatches(IterOutcome.NOT_YET)) {
    return JoinOutcome.WAITING;
  }
  return JoinOutcome.FAILURE;
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
public boolean apply(Join join, JoinRelType joinType, RexNode exp) {
  if (joinType != JoinRelType.INNER) {
    return true;  // In OUTER join, we could not pull-up the filter.
                  // All we can do is keep the filter with JOIN, and
                  // then decide whether the filter could be pushed down
                  // into LEFT/RIGHT.
  }

  List<RexNode> tmpLeftKeys = Lists.newArrayList();
  List<RexNode> tmpRightKeys = Lists.newArrayList();
  List<RelDataTypeField> sysFields = Lists.newArrayList();
  List<Integer> filterNulls = Lists.newArrayList();

  RexNode remaining = RelOptUtil.splitJoinCondition(sysFields, join.getLeft(), join.getRight(),
      exp, tmpLeftKeys, tmpRightKeys, filterNulls, null);

  return remaining.isAlwaysTrue();
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Override
protected boolean checkPreconditions(JoinRel join, RelNode left, RelNode right,
    PlannerSettings settings) {
  JoinRelType type = join.getJoinType();

  if (! (type == JoinRelType.INNER || type == JoinRelType.LEFT)) {
    return false;
  }

  JoinCategory category = JoinUtils.getJoinCategory(left, right, join.getCondition(),
      Lists.<Integer>newArrayList(), Lists.<Integer>newArrayList(), Lists.<Boolean>newArrayList());
  if (category == JoinCategory.EQUALITY
      && (settings.isHashJoinEnabled() || settings.isMergeJoinEnabled())) {
    return false;
  }

  if (settings.isNlJoinForScalarOnly()) {
    if (JoinUtils.isScalarSubquery(left) || JoinUtils.isScalarSubquery(right)) {
      return true;
    } else {
      return false;
    }
  }

  return true;
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Override
public void noMoreToConsumeRight() throws Exception {
  state.is(State.CAN_CONSUME_R);

  if (table.size() == 0 && !(joinType == JoinRelType.LEFT || joinType == JoinRelType.FULL)) {
    // nothing needs to be read on the left side as right side is empty
    state = State.DONE;
    return;
  }

  this.probe = new VectorizedProbe(
      context.getAllocator(),
      hyperContainer,
      left,
      probeOutputs,
      buildOutputs,
      config.getJoinType(),
      buildInfoList,
      startIndices,
      table,
      probePivot,
      context.getTargetBatchSize(),
      comparator);
  state = State.CAN_CONSUME_L;
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Test
public void emptyRightWithLeftJoin() throws Exception {
  JoinInfo joinInfo = getJoinInfo(Arrays.asList(new JoinCondition("EQUALS", f("r_regionKey"), f("key"))),
    JoinRelType.LEFT);

  final Table expected = t(
    th("key", "value", "r_regionKey"),
    false,
    tr(NULL_BIGINT, NULL_BIGINT, 0L),
    tr(NULL_BIGINT, NULL_BIGINT, 1L),
    tr(NULL_BIGINT, NULL_BIGINT, 2L),
    tr(NULL_BIGINT, NULL_BIGINT, 3L),
    tr(NULL_BIGINT, NULL_BIGINT, 4L)
  );


  validateDual(joinInfo.operator, joinInfo.clazz,
    TpchGenerator.singleGenerator(TpchTable.REGION, 0.1, getTestAllocator(), "r_regionKey"),
    new EmptyGenerator(getTestAllocator()), DEFAULT_BATCH, expected);
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Test
public void nationRegionPartialKeyRight() throws Exception {
  JoinInfo info = getJoinInfo( Arrays.asList(new JoinCondition("EQUALS", f("n_nationKey"), f("r_regionKey"))), JoinRelType.RIGHT);

  final Table expected = t(
      th("r_regionKey", "r_name", "n_nationKey", "n_name"),
      tr(0L, "AFRICA", 0L, "ALGERIA"),
      tr(1L, "AMERICA", 1L, "ARGENTINA"),
      tr(2L, "ASIA", 2L, "BRAZIL"),
      tr(3L, "EUROPE", 3L, "CANADA"),
      tr(4L, "MIDDLE EAST", 4L, "EGYPT")
      );

  validateDual(
      info.operator, info.clazz,
      TpchGenerator.singleGenerator(TpchTable.NATION, 0.1, getTestAllocator(), "n_nationKey", "n_name"),
      TpchGenerator.singleGenerator(TpchTable.REGION, 0.1, getTestAllocator(), "r_regionKey", "r_name"),
      DEFAULT_BATCH, expected);
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
/** Creates a DrillJoinRel.
 * We do not throw InvalidRelException in Logical planning phase. It's up to the post-logical planning check or physical planning
 * to detect the unsupported join type, and throw exception.
 * */
public DrillJoinRel(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition,
    JoinRelType joinType)  {
  super(cluster, traits, left, right, condition, joinType);
  assert traits.contains(DrillRel.DRILL_LOGICAL);
  RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys);
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Override
public Join copy(RelTraitSet traitSet, RexNode conditionExpr, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone) {
  try {
    return new NestedLoopJoinPrel(this.getCluster(), traitSet, left, right, conditionExpr, joinType);
  }catch (InvalidRelException e) {
    throw new AssertionError(e);
  }
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Override
protected boolean checkPreconditions(DrillJoinRel join, RelNode left, RelNode right,
    PlannerSettings settings) {
  JoinRelType type = join.getJoinType();

  if (! (type == JoinRelType.INNER || type == JoinRelType.LEFT)) {
    return false;
  }

  List<Integer> leftKeys = Lists.newArrayList();
  List<Integer> rightKeys = Lists.newArrayList() ;
  JoinCategory category = JoinUtils.getJoinCategory(left, right, join.getCondition(), leftKeys, rightKeys);
  if (category == JoinCategory.EQUALITY
      && (settings.isHashJoinEnabled() || settings.isMergeJoinEnabled())) {
    return false;
  }

  if (settings.isNlJoinForScalarOnly()) {
    if (JoinUtils.isScalarSubquery(left) || JoinUtils.isScalarSubquery(right)) {
      return true;
    } else {
      return false;
    }
  }

  return true;
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
protected boolean checkBroadcastConditions(RelOptPlanner planner, DrillJoinRel join, RelNode left, RelNode right) {

    double estimatedRightRowCount = RelMetadataQuery.getRowCount(right);
    if (estimatedRightRowCount < PrelUtil.getSettings(join.getCluster()).getBroadcastThreshold()
        && ! left.getTraitSet().getTrait(DrillDistributionTraitDef.INSTANCE).equals(DrillDistributionTrait.SINGLETON)
        && (join.getJoinType() == JoinRelType.INNER || join.getJoinType() == JoinRelType.LEFT)
        ) {
      return true;
    }
    return false;
  }
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Test
public void testFullJoin() throws Exception {
  Join join = JdbcAssert
      .withModel(MODEL, "HR")
      .sql("select * from emp full join dept on emp.deptId = dept.deptId")
      .returnsUnordered("DEPTID=31; LASTNAME=Rafferty; DEPTID0=31; NAME=Sales",
          "DEPTID=33; LASTNAME=Jones; DEPTID0=33; NAME=Engineering",
          "DEPTID=33; LASTNAME=Steinberg; DEPTID0=33; NAME=Engineering",
          "DEPTID=34; LASTNAME=Robinson; DEPTID0=34; NAME=Clerical",
          "DEPTID=34; LASTNAME=Smith; DEPTID0=34; NAME=Clerical",
          "DEPTID=null; LASTNAME=John; DEPTID0=null; NAME=null",
          "DEPTID=null; LASTNAME=null; DEPTID0=35; NAME=Marketing").planContains(Join.class);
  Assert.assertEquals(JoinRelType.FULL, join.getJoinType());
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Override
public Join copy(RelTraitSet traitSet, RexNode conditionExpr, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone) {
  try {
    return new HashJoinPrel(this.getCluster(), traitSet, left, right, conditionExpr, joinType, this.swapped);
  }catch (InvalidRelException e) {
    throw new AssertionError(e);
  }
}
 

import org.apache.calcite.rel.core.JoinRelType; //导入依赖的package包/类
@Override
public Join copy(RelTraitSet traitSet, RexNode conditionExpr, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone) {
  try {
    return new MergeJoinPrel(this.getCluster(), traitSet, left, right, conditionExpr, joinType);
  }catch (InvalidRelException e) {
    throw new AssertionError(e);
  }
}