com.hazelcast.org.apache.calcite.plan.RelOptCost Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.org.apache.calcite.plan;
/**
* RelOptCost defines an interface for optimizer cost in terms of number of rows
* processed, CPU cost, and I/O cost. Optimizer implementations may use all of
* this information, or selectively ignore portions of it. The specific units
* for all of these quantities are rather vague; most relational expressions
* provide a default cost calculation, but optimizers can override this by
* plugging in their own cost models with well-defined meanings for each unit.
* Optimizers which supply their own cost models may also extend this interface
* with additional cost metrics such as memory usage.
*/
public interface RelOptCost {
//~ Methods ----------------------------------------------------------------
/** Returns the number of rows processed; this should not be
* confused with the row count produced by a relational expression
* ({@link com.hazelcast.org.apache.calcite.rel.RelNode#estimateRowCount}). */
double getRows();
/** Returns usage of CPU resources. */
double getCpu();
/** Returns usage of I/O resources. */
double getIo();
/** Returns whether this cost represents an expression that hasn't actually
* been implemented (e.g. a pure relational algebra expression) or can't
* actually be implemented, e.g. a transfer of data between two disconnected
* sites. */
boolean isInfinite();
// REVIEW jvs 3-Apr-2006: we should standardize this
// to Comparator/equals/hashCode
/**
* Compares this to another cost.
*
* @param cost another cost
* @return true iff this is exactly equal to other cost
*/
@SuppressWarnings("NonOverridingEquals")
boolean equals(RelOptCost cost);
/**
* Compares this to another cost, allowing for slight roundoff errors.
*
* @param cost another cost
* @return true iff this is the same as the other cost within a roundoff
* margin of error
*/
boolean isEqWithEpsilon(RelOptCost cost);
/**
* Compares this to another cost.
*
* @param cost another cost
* @return true iff this is less than or equal to other cost
*/
boolean isLe(RelOptCost cost);
/**
* Compares this to another cost.
*
* @param cost another cost
* @return true iff this is strictly less than other cost
*/
boolean isLt(RelOptCost cost);
/**
* Adds another cost to this.
*
* @param cost another cost
* @return sum of this and other cost
*/
RelOptCost plus(RelOptCost cost);
/**
* Subtracts another cost from this.
*
* @param cost another cost
* @return difference between this and other cost
*/
RelOptCost minus(RelOptCost cost);
/**
* Multiplies this cost by a scalar factor.
*
* @param factor scalar factor
* @return scalar product of this and factor
*/
RelOptCost multiplyBy(double factor);
/**
* Computes the ratio between this cost and another cost.
*
* divideBy is the inverse of {@link #multiplyBy(double)}. For any
* finite, non-zero cost and factor f,
* cost.divideBy(cost.multiplyBy(f)) yields 1 / f.
*
* @param cost Other cost
* @return Ratio between costs
*/
double divideBy(RelOptCost cost);
/**
* Forces implementations to override {@link Object#toString} and provide a
* good cost rendering to use during tracing.
*/
@Override String toString();
}