org.apache.calcite.plan.hep.HepRelVertex Java Examples

private static boolean isEmpty(RelNode node) {
  if (node instanceof Values) {
    return ((Values) node).getTuples().isEmpty();
  }
  if (node instanceof HepRelVertex) {
    return isEmpty(((HepRelVertex) node).getCurrentRel());
  }
  // Note: relation input might be a RelSubset, so we just iterate over the relations
  // in order to check if the subset is equivalent to an empty relation.
  if (!(node instanceof RelSubset)) {
    return false;
  }
  RelSubset subset = (RelSubset) node;
  for (RelNode rel : subset.getRels()) {
    if (isEmpty(rel)) {
      return true;
    }
  }
  return false;
}
 

@Override
public boolean matches(RelOptRuleCall call) {
	FlinkLogicalCorrelate correlate = call.rel(0);
	RelNode right = ((HepRelVertex) correlate.getRight()).getCurrentRel();
	FlinkLogicalTableFunctionScan tableFunctionScan;
	if (right instanceof FlinkLogicalTableFunctionScan) {
		tableFunctionScan = (FlinkLogicalTableFunctionScan) right;
	} else if (right instanceof FlinkLogicalCalc) {
		tableFunctionScan = StreamExecCorrelateRule.getTableScan((FlinkLogicalCalc) right);
	} else {
		return false;
	}
	RexNode rexNode = tableFunctionScan.getCall();
	if (rexNode instanceof RexCall) {
		return PythonUtil.isPythonCall(rexNode, null) && PythonUtil.containsNonPythonCall(rexNode)
			|| PythonUtil.isNonPythonCall(rexNode) && PythonUtil.containsPythonCall(rexNode, null)
			|| (PythonUtil.isPythonCall(rexNode, null) && RexUtil.containsFieldAccess(rexNode));
	}
	return false;
}
 

private boolean containsSnapshot(RelNode relNode) {
	RelNode original = null;
	if (relNode instanceof RelSubset) {
		original = ((RelSubset) relNode).getOriginal();
	} else if (relNode instanceof HepRelVertex) {
		original = ((HepRelVertex) relNode).getCurrentRel();
	} else {
		original = relNode;
	}
	if (original instanceof LogicalSnapshot) {
		return true;
	} else if (original instanceof SingleRel) {
		return containsSnapshot(((SingleRel) original).getInput());
	} else {
		return false;
	}
}
 

@Override
public boolean matches(RelOptRuleCall call) {
	FlinkLogicalCorrelate correlate = call.rel(0);
	RelNode right = ((HepRelVertex) correlate.getRight()).getCurrentRel();
	FlinkLogicalTableFunctionScan tableFuncScan;
	if (right instanceof FlinkLogicalTableFunctionScan) {
		tableFuncScan = (FlinkLogicalTableFunctionScan) right;
	} else if (right instanceof FlinkLogicalCalc) {
		Option<FlinkLogicalTableFunctionScan> scan = CorrelateUtil
			.getTableFunctionScan((FlinkLogicalCalc) right);
		if (scan.isEmpty()) {
			return false;
		}
		tableFuncScan = scan.get();
	} else {
		return false;
	}
	RexNode rexNode = tableFuncScan.getCall();
	if (rexNode instanceof RexCall) {
		return PythonUtil.isPythonCall(rexNode, null) && PythonUtil.containsNonPythonCall(rexNode)
			|| PythonUtil.isNonPythonCall(rexNode) && PythonUtil.containsPythonCall(rexNode, null)
			|| (PythonUtil.isPythonCall(rexNode, null) && RexUtil.containsFieldAccess(rexNode));
	}
	return false;
}
 

private boolean containsSnapshot(RelNode relNode) {
	RelNode original = null;
	if (relNode instanceof RelSubset) {
		original = ((RelSubset) relNode).getOriginal();
	} else if (relNode instanceof HepRelVertex) {
		original = ((HepRelVertex) relNode).getCurrentRel();
	} else {
		original = relNode;
	}
	if (original instanceof LogicalSnapshot) {
		return true;
	} else if (original instanceof SingleRel) {
		return containsSnapshot(((SingleRel) original).getInput());
	} else {
		return false;
	}
}
 

private static boolean canSwapJoinInputsInternal(RelNode rel) {
  if (rel instanceof DrillAggregateRel &&
      ((DrillAggregateRel) rel).getAggCallList().size() > 0) {
    return false;
  } else if (rel instanceof HepRelVertex) {
    return canSwapJoinInputsInternal(((HepRelVertex) rel).getCurrentRel());
  } else if (rel instanceof RelSubset) {
    if (((RelSubset) rel).getBest() != null) {
      return canSwapJoinInputsInternal(((RelSubset) rel).getBest());
    } else {
      return canSwapJoinInputsInternal(((RelSubset) rel).getOriginal());
    }
  } else {
    for (RelNode child : rel.getInputs()) {
      if (!canSwapJoinInputsInternal(child)) {
        return false;
      }
    }
  }
  return true;
}
 

public static RelNode getValidJoinInput(RelNode rel) {
  if (rel instanceof DrillScanRel) {
    return rel;
  } else if (rel instanceof DrillProjectRel
      || rel instanceof DrillFilterRel
      || rel instanceof DrillLimitRel) {
    for (RelNode child : rel.getInputs()) {
      RelNode tgt = getValidJoinInput(child);
      if (tgt != null) {
        return tgt;
      }
    }
  } else if (rel instanceof HepRelVertex) {
    return getValidJoinInput(((HepRelVertex) rel).getCurrentRel());
  } else if (rel instanceof RelSubset) {
    if (((RelSubset) rel).getBest() != null) {
      return getValidJoinInput(((RelSubset) rel).getBest());
    } else {
      return getValidJoinInput(((RelSubset) rel).getOriginal());
    }
  }
  return null;
}
 

private static RelNode stripHep(RelNode rel) {
	if (rel instanceof HepRelVertex) {
		HepRelVertex hepRelVertex = (HepRelVertex) rel;
		rel = hepRelVertex.getCurrentRel();
	}
	return rel;
}
 

private static RelNode stripHep(RelNode rel) {
  if (rel instanceof HepRelVertex) {
    HepRelVertex hepRelVertex = (HepRelVertex) rel;
    rel = hepRelVertex.getCurrentRel();
  }
  return rel;
}
 

@Override protected RelNode visitChild(RelNode parent, int i, RelNode child) {
  if (child instanceof HepRelVertex) {
    child = ((HepRelVertex) child).getCurrentRel();
  } else if (child instanceof RelSubset) {
    RelSubset subset = (RelSubset) child;
    child = Util.first(subset.getBest(), subset.getOriginal());
  }
  return super.visitChild(parent, i, child).accept(rexVisitor);
}
 

private static RelNode stripHep(RelNode rel) {
	if (rel instanceof HepRelVertex) {
		HepRelVertex hepRelVertex = (HepRelVertex) rel;
		rel = hepRelVertex.getCurrentRel();
	}
	return rel;
}
 

@Override
public RelNode visit(RelNode other) {
  if (other instanceof HepRelVertex) {
    return super.visit(((HepRelVertex) other).getCurrentRel());
  } else {
    return super.visit(other);
  }
}
 

private static RelNode stripHep(RelNode rel) {
  if (rel instanceof HepRelVertex) {
    HepRelVertex hepRelVertex = (HepRelVertex) rel;
    rel = hepRelVertex.getCurrentRel();
  }
  return rel;
}
 

private static RelNode stripHep(RelNode rel) {
  if (rel instanceof HepRelVertex) {
    HepRelVertex hepRelVertex = (HepRelVertex) rel;
    rel = hepRelVertex.getCurrentRel();
  }
  return rel;
}
 

/**
 * Returns whether statistics-based estimates or guesses are used by the optimizer
 * for the {@link RelNode} rel.
 * @param rel : input
 * @return TRUE if the estimate is a guess, FALSE otherwise
 * */
public static boolean guessRows(RelNode rel) {
    final PlannerSettings settings = rel.getCluster().getPlanner().getContext().unwrap(PlannerSettings.class);
    if (!settings.useStatistics()) {
        return true;
    }
    /* We encounter RelSubset/HepRelVertex which are CALCITE constructs, hence we
     * cannot add guessRows() to the DrillRelNode interface.
     */
    if (rel instanceof RelSubset) {
        if (((RelSubset) rel).getBest() != null) {
            return guessRows(((RelSubset) rel).getBest());
        } else if (((RelSubset) rel).getOriginal() != null) {
            return guessRows(((RelSubset) rel).getOriginal());
        }
    } else if (rel instanceof HepRelVertex) {
        if (((HepRelVertex) rel).getCurrentRel() != null) {
            return guessRows(((HepRelVertex) rel).getCurrentRel());
        }
    } else if (rel instanceof TableScan) {
        DrillTable table = Utilities.getDrillTable(rel.getTable());
        try {
            TableMetadata tableMetadata;
            return table == null || (tableMetadata = table.getGroupScan().getTableMetadata()) == null
                    || !((Boolean) TableStatisticsKind.HAS_STATISTICS.getValue(tableMetadata));
        } catch (IOException e) {
            RelOptPlanner.LOGGER.debug("Unable to obtain table metadata due to exception:", e);
            return true;
        }
    } else {
        for (RelNode child : rel.getInputs()) {
            if (guessRows(child)) { // at least one child is a guess
                return true;
            }
        }
    }
    return false;
}
 

private static RelNode stripHep(RelNode rel) {
    if (rel instanceof HepRelVertex) {
        HepRelVertex hepRelVertex = (HepRelVertex) rel;
        rel = hepRelVertex.getCurrentRel();
    }
    return rel;
}
 

@Override
protected RelNode visitChild(RelNode parent, int i, RelNode child) {
    if (child instanceof HepRelVertex) {
        child = ((HepRelVertex) child).getCurrentRel();
    } else if (child instanceof RelSubset) {
        RelSubset subset = (RelSubset) child;
        child = Util.first(subset.getBest(), subset.getOriginal());
    }
    return super.visitChild(parent, i, child).accept(rexVisitor);
}
 

private boolean findRowKeyJoin(RelNode rel) {
  if (rel instanceof RowKeyJoinPrel) {
    return true;
  }
  if (rel instanceof RelSubset) {
    if (((RelSubset) rel).getBest() != null) {
      if (findRowKeyJoin(((RelSubset) rel).getBest())) {
        return true;
      }
    } else if (((RelSubset) rel).getOriginal() != null) {
      if (findRowKeyJoin(((RelSubset) rel).getOriginal())) {
        return true;
      }
    }
  } else if (rel instanceof HepRelVertex) {
    if (((HepRelVertex) rel).getCurrentRel() != null) {
      if (findRowKeyJoin(((HepRelVertex) rel).getCurrentRel())) {
        return true;
      }
    }
  } else {
    for (RelNode child : rel.getInputs()) {
      if (findRowKeyJoin(child)) {
        return true;
      }
    }
  }
  return false;
}
 

public ImmutableList<RelCollation> collations(HepRelVertex rel,
    RelMetadataQuery mq) {
  return mq.collations(rel.getCurrentRel());
}
 

public Multimap<Class<? extends RelNode>, RelNode> getNodeTypes(HepRelVertex rel,
    RelMetadataQuery mq) {
  return mq.getNodeTypes(rel.getCurrentRel());
}
 

public Set<RexNode> getExpressionLineage(HepRelVertex rel, RelMetadataQuery mq,
    RexNode outputExpression) {
  return mq.getExpressionLineage(rel.getCurrentRel(), outputExpression);
}
 

public RelDistribution distribution(HepRelVertex rel, RelMetadataQuery mq) {
  return mq.distribution(rel.getCurrentRel());
}
 

public RelOptPredicateList getPredicates(HepRelVertex rel,
    RelMetadataQuery mq) {
  return mq.getPulledUpPredicates(rel.getCurrentRel());
}
 

public RelOptPredicateList getAllPredicates(HepRelVertex rel, RelMetadataQuery mq) {
  return mq.getAllPredicates(rel.getCurrentRel());
}
 

public Boolean areColumnsUnique(HepRelVertex rel, RelMetadataQuery mq,
    ImmutableBitSet columns, boolean ignoreNulls) {
  columns = decorateWithConstantColumnsFromPredicates(columns, rel, mq);
  return mq.areColumnsUnique(rel.getCurrentRel(), columns, ignoreNulls);
}
 

public ImmutableList<RelCollation> collations(HepRelVertex rel,
    RelMetadataQuery mq) {
  return mq.collations(rel.getCurrentRel());
}
 

public RelDistribution distribution(HepRelVertex rel, RelMetadataQuery mq) {
  return mq.distribution(rel.getCurrentRel());
}
 

public Set<RexNode> getExpressionLineage(HepRelVertex rel, RelMetadataQuery mq,
    RexNode outputExpression) {
  return mq.getExpressionLineage(rel.getCurrentRel(), outputExpression);
}
 

public Multimap<Class<? extends RelNode>, RelNode> getNodeTypes(HepRelVertex rel,
    RelMetadataQuery mq) {
  return mq.getNodeTypes(rel.getCurrentRel());
}
 

public Set<RelTableRef> getTableReferences(HepRelVertex rel, RelMetadataQuery mq) {
  return mq.getTableReferences(rel.getCurrentRel());
}