How to use

org.qcri.rheem.core.optimizer.cardinality.DefaultCardinalityEstimator

constructor

@Override
public Optional<CardinalityEstimator> createCardinalityEstimator(
    final int outputIndex,
    final Configuration configuration) {
  Validate.inclusiveBetween(0, 0, outputIndex);
  return Optional.of(new DefaultCardinalityEstimator(1d, 1, this.isSupportingBroadcastInputs(),
      inputCards -> inputCards[0]));
}

@Override
public Optional<CardinalityEstimator> createCardinalityEstimator(
    final int outputIndex,
    final Configuration configuration) {
  Validate.inclusiveBetween(0, 0, outputIndex);
  return Optional.of(new DefaultCardinalityEstimator(1d, 1, this.isSupportingBroadcastInputs(),
      inputCards -> inputCards[0]));
}

@Override
public Optional<CardinalityEstimator> createCardinalityEstimator(
    final int outputIndex,
    final Configuration configuration) {
  Validate.inclusiveBetween(0, 0, outputIndex);
  return Optional.of(new DefaultCardinalityEstimator(1d, 1, this.isSupportingBroadcastInputs(),
      inputCards -> inputCards[0]));
}

@Override
public Optional<CardinalityEstimator> createCardinalityEstimator(
    final int outputIndex,
    final Configuration configuration) {
  Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
  return Optional.of(new DefaultCardinalityEstimator(1d, 2, this.isSupportingBroadcastInputs(),
      inputCards -> inputCards[0] + inputCards[1]));
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    // The current idea: We assume, we have a foreign-key like join
    // TODO: Find a better estimator.
    return Optional.of(new DefaultCardinalityEstimator(
        .5d, 2, this.isSupportingBroadcastInputs(),
        inputCards -> 3 * Math.max(inputCards[0], inputCards[1])
    ));
  }
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    // The current idea: We assume that one side is duplicate-free and included in the other.
    // TODO: Find a better estimator.
    return Optional.of(new DefaultCardinalityEstimator(
        .5d, 2, this.isSupportingBroadcastInputs(),
        inputCards -> Math.min(inputCards[0], inputCards[1])
    ));
  }
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    return Optional.of(new DefaultCardinalityEstimator(
        1d, 1, this.isSupportingBroadcastInputs(),
        inputCards -> inputCards[0]
    ));
  }
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    // TODO: Come up with a dynamic estimator.
    // Assume with a confidence of 0.7 that 70% of the data quanta are pairwise distinct.
    return Optional.of(new DefaultCardinalityEstimator(0.7d, 1, this.isSupportingBroadcastInputs(),
        inputCards -> (long) (inputCards[0] * 0.7d)));
  }
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    // TODO: Come up with a decent way to estimate the "distinctness" of reduction keys.
    return Optional.of(new DefaultCardinalityEstimator(
        0.5d,
        1,
        this.isSupportingBroadcastInputs(),
        inputCards -> (long) (inputCards[0] * 0.1)));
  }
}

@Override
public Optional<CardinalityEstimator> createCardinalityEstimator(
    final int outputIndex,
    final Configuration configuration) {
  Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
  // TODO: Come up with a decent way to estimate the "distinctness" of reduction keys.
  return Optional.of(new DefaultCardinalityEstimator(0.5d, 1, this.isSupportingBroadcastInputs(),
      inputCards -> (long) (inputCards[0] * 0.1)));
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    return Optional.of(new DefaultCardinalityEstimator(
        1d, 2, this.isSupportingBroadcastInputs(),
        inputCards -> inputCards[0] * inputCards[1]
    ));
  }
}

@Override
public Optional<CardinalityEstimator> createCardinalityEstimator(
    final int outputIndex,
    final Configuration configuration) {
  Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
  return Optional.of(new DefaultCardinalityEstimator(1d, 1, this.isSupportingBroadcastInputs(), inputCards -> inputCards[0]));
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    return Optional.of(new DefaultCardinalityEstimator(1d, 1, this.isSupportingBroadcastInputs(),
        inputCards -> inputCards[0]));
  }
}

  @Override
  public Optional<CardinalityEstimator> createCardinalityEstimator(
      final int outputIndex,
      final Configuration configuration) {
    Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
    // The current idea: We assume, we have a foreign-key like join
    // TODO: Find a better estimator.
    return Optional.of(new DefaultCardinalityEstimator(
        .5d, 2, this.isSupportingBroadcastInputs(),
        inputCards -> (long) (0.1 * (inputCards[0] + inputCards[1]))
    ));
  }
}

@Override
public Optional<CardinalityEstimator> createCardinalityEstimator(
    final int outputIndex,
    final Configuration configuration) {
  Validate.inclusiveBetween(0, this.getNumOutputs() - 1, outputIndex);
  return Optional.of(new DefaultCardinalityEstimator(1d, this.getNumInputs(), this.isSupportingBroadcastInputs(),
      inputCards -> this.collection.size()));
}

vertexDistincter.at(epoch);
vertexDistincter.setName(String.format("%s (distinct vertices)", operatorBaseName));
vertexDistincter.setCardinalityEstimator(0, new DefaultCardinalityEstimator(
    0.5d, 1, false, longs -> Math.round(longs[0] * NUM_VERTICES_PER_EDGE / 2)
));
adjacencyCreator.at(epoch);
adjacencyCreator.setName(String.format("%s (create adjacencies)", operatorBaseName));
adjacencyCreator.setCardinalityEstimator(0, new DefaultCardinalityEstimator(
    0.5d, 1, false, longs -> Math.round(longs[0] * NUM_VERTICES_PER_EDGE)
));
rankJoin.at(epoch);
rankJoin.setName(String.format("%s (join adjacencies and ranks)", operatorBaseName));
rankJoin.setCardinalityEstimator(0, new DefaultCardinalityEstimator(
    .99d, 2, false, longs -> longs[0]
));
sumPartialRanks.at(epoch);
sumPartialRanks.setName(String.format("%s (sum partial ranks)", operatorBaseName));
sumPartialRanks.setCardinalityEstimator(0, new DefaultCardinalityEstimator(
    0.5d, 1, false, longs -> Math.round(longs[0] * NUM_VERTICES_PER_EDGE)
));