How to use

guessSelectivity

method

in

org.apache.calcite.rel.metadata.RelMdUtil

double residualSelectivity = RelMdUtil.guessSelectivity(constraintBasedResult.right);
double rowCount;
if (constraintBasedResult.left.isPKSideSimple) {

selectivity = RelMdUtil.guessSelectivity(condition);
guess = true;

/**
 * Returns default estimates for selectivities, in the absence of stats.
 *
 * @param predicate predicate for which selectivity will be computed; null
 *                  means true, so gives selectity of 1.0
 * @return estimated selectivity
 */
public static double guessSelectivity(RexNode predicate) {
 return guessSelectivity(predicate, false);
}

 public Double getSelectivity(RelNode rel, RelMetadataQuery mq,
   RexNode predicate) {
  return RelMdUtil.guessSelectivity(predicate);
 }
}

/**
 * Returns default estimates for selectivities, in the absence of stats.
 *
 * @param predicate predicate for which selectivity will be computed; null
 *                  means true, so gives selectity of 1.0
 * @return estimated selectivity
 */
public static double guessSelectivity(RexNode predicate) {
 return guessSelectivity(predicate, false);
}

 public Double getSelectivity(RelNode rel, RelMetadataQuery mq,
   RexNode predicate) {
  return RelMdUtil.guessSelectivity(predicate);
 }
}

 private Double getDistinctRowCountFromEstimateRowCount(RelNode rel, RelMetadataQuery mq, ImmutableBitSet groupKey, RexNode predicate) {
  final int groupKeySize = groupKey.cardinality();
  return rel.estimateRowCount(mq) * (1.0 - Math.pow(0.9, groupKeySize)) * RelMdUtil.guessSelectivity(predicate);
 }
}

private Double getSelectivity(RelSubset rel, RexNode predicate) {
 if (rel.getBest() != null) {
  return getSelectivity(rel.getBest(), predicate);
 } else {
  List<RelNode> list = rel.getRelList();
  if (list != null && list.size() > 0) {
   return getSelectivity(list.get(0), predicate);
  }
 }
 return RelMdUtil.guessSelectivity(predicate);
}

public Double getDistinctRowCount(Values rel, RelMetadataQuery mq,
  ImmutableBitSet groupKey, RexNode predicate) {
 if (predicate == null || predicate.isAlwaysTrue()) {
  if (groupKey.isEmpty()) {
   return 1D;
  }
 }
 double selectivity = RelMdUtil.guessSelectivity(predicate);
 // assume half the rows are duplicates
 double nRows = rel.estimateRowCount(mq) / 2;
 return RelMdUtil.numDistinctVals(nRows, nRows * selectivity);
}

public Double getDistinctRowCount(Values rel, RelMetadataQuery mq,
  ImmutableBitSet groupKey, RexNode predicate) {
 if (predicate == null || predicate.isAlwaysTrue()) {
  if (groupKey.isEmpty()) {
   return 1D;
  }
 }
 double selectivity = RelMdUtil.guessSelectivity(predicate);
 // assume half the rows are duplicates
 double nRows = rel.estimateRowCount(mq) / 2;
 return RelMdUtil.numDistinctVals(nRows, nRows * selectivity);
}

   filter, filterRows, totalRows, sel);
} else {
 sel = RelMdUtil.guessSelectivity(filter);
 if (stats.isStatsAvailable()) {
  logger.debug("index_plan_info: Filter row count is UNKNOWN for filter: {}, using guess {}", filter, sel);
 logger.debug("index_plan_info: Selectivity of index columns remainder filters: {}", remainderSel);
} else {
 remainderSel = RelMdUtil.guessSelectivity(indexColumnsRemainderFilter);
 if (stats.isStatsAvailable()) {
  logger.debug("index_plan_info: Filter row count is UNKNOWN for remainder filter : {}, using guess {}",

public Double getSelectivity(Aggregate rel, RelMetadataQuery mq,
  RexNode predicate) {
 final List<RexNode> notPushable = new ArrayList<>();
 final List<RexNode> pushable = new ArrayList<>();
 RelOptUtil.splitFilters(
   rel.getGroupSet(),
   predicate,
   pushable,
   notPushable);
 final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
 RexNode childPred =
   RexUtil.composeConjunction(rexBuilder, pushable, true);
 Double selectivity = mq.getSelectivity(rel.getInput(), childPred);
 if (selectivity == null) {
  return null;
 } else {
  RexNode pred =
    RexUtil.composeConjunction(rexBuilder, notPushable, true);
  return selectivity * RelMdUtil.guessSelectivity(pred);
 }
}

public Double getSelectivity(Aggregate rel, RelMetadataQuery mq,
  RexNode predicate) {
 final List<RexNode> notPushable = new ArrayList<>();
 final List<RexNode> pushable = new ArrayList<>();
 RelOptUtil.splitFilters(
   rel.getGroupSet(),
   predicate,
   pushable,
   notPushable);
 final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
 RexNode childPred =
   RexUtil.composeConjunction(rexBuilder, pushable, true);
 Double selectivity = mq.getSelectivity(rel.getInput(), childPred);
 if (selectivity == null) {
  return null;
 } else {
  RexNode pred =
    RexUtil.composeConjunction(rexBuilder, notPushable, true);
  return selectivity * RelMdUtil.guessSelectivity(pred);
 }
}

selectivity = RelMdUtil.guessSelectivity(condition);
guess = true;

RexNode preds =
  RexUtil.composeConjunction(rexBuilder, notPushable, true);
return distinctRowCount * RelMdUtil.guessSelectivity(preds);

public Double getSelectivity(Project rel, RelMetadataQuery mq,
  RexNode predicate) {
 final List<RexNode> notPushable = new ArrayList<>();
 final List<RexNode> pushable = new ArrayList<>();
 RelOptUtil.splitFilters(
   ImmutableBitSet.range(rel.getRowType().getFieldCount()),
   predicate,
   pushable,
   notPushable);
 final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
 RexNode childPred =
   RexUtil.composeConjunction(rexBuilder, pushable, true);
 RexNode modifiedPred;
 if (childPred == null) {
  modifiedPred = null;
 } else {
  modifiedPred = RelOptUtil.pushPastProject(childPred, rel);
 }
 Double selectivity = mq.getSelectivity(rel.getInput(), modifiedPred);
 if (selectivity == null) {
  return null;
 } else {
  RexNode pred =
    RexUtil.composeConjunction(rexBuilder, notPushable, true);
  return selectivity * RelMdUtil.guessSelectivity(pred);
 }
}

public Double getSelectivity(Project rel, RelMetadataQuery mq,
  RexNode predicate) {
 final List<RexNode> notPushable = new ArrayList<>();
 final List<RexNode> pushable = new ArrayList<>();
 RelOptUtil.splitFilters(
   ImmutableBitSet.range(rel.getRowType().getFieldCount()),
   predicate,
   pushable,
   notPushable);
 final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
 RexNode childPred =
   RexUtil.composeConjunction(rexBuilder, pushable, true);
 RexNode modifiedPred;
 if (childPred == null) {
  modifiedPred = null;
 } else {
  modifiedPred = RelOptUtil.pushPastProject(childPred, rel);
 }
 Double selectivity = mq.getSelectivity(rel.getInput(), modifiedPred);
 if (selectivity == null) {
  return null;
 } else {
  RexNode pred =
    RexUtil.composeConjunction(rexBuilder, notPushable, true);
  return selectivity * RelMdUtil.guessSelectivity(pred);
 }
}

RexNode preds =
  RexUtil.composeConjunction(rexBuilder, notPushable, true);
return distinctRowCount * RelMdUtil.guessSelectivity(preds);

RexNode preds =
  RexUtil.composeConjunction(rexBuilder, notPushable, true);
distinctRowCount *= RelMdUtil.guessSelectivity(preds);

RexNode preds =
  RexUtil.composeConjunction(rexBuilder, notPushable, true);
distinctRowCount *= RelMdUtil.guessSelectivity(preds);