Package com.apple.foundationdb.record.query.plan.temp

Class Quantifier

  • All Implemented Interfaces:
    Bindable, Correlated<Quantifier>
    Direct Known Subclasses:
    Quantifier.Existential, Quantifier.ForEach, Quantifier.Physical
    @API(EXPERIMENTAL)
public abstract class Quantifier
extends Object
implements Bindable, Correlated<Quantifier>
    Models the concept of quantification.

    A quantifier describes the data flow between the output of one RelationalExpression R and the consumption of that data by another RelationalExpression S. S is said to own the quantifier, while the quantifier is said to range over R. Quantifiers come in very few but very distinct flavors. All flavors are implemented by static inner final classes in order to emulate a sealed trait.

    Quantifiers separate what it means to be producing versus consuming items. The expression a quantifier ranges over produces records, the quantifier flows information (in a manner determined by the flavor) that is consumed by the expression containing or owning the quantifier. That expression can consume the data in a way independent of how the data was produced in the first place.

    A quantifier works closely with the expression that owns it. Depending on the semantics of the owning expression it becomes possible to model correlations. For example, in a logical join expression the quantifier can provide a binding of the item being currently consumed by the join's outer to other (inner) parts of the data flow that are also rooted at the owning (join) expression.

    • Method Detail

      • forEachBuilder

        @Nonnull
public static Quantifier.ForEach.ForEachBuilder forEachBuilder()
        Create a builder for a for-each quantifier containing relational expressions.
        Returns:
        a for-each quantifier builder

      • physicalBuilder

        public static Quantifier.Physical.PhysicalBuilder physicalBuilder()
        Create a builder for a physical quantifier containing record query plans.
        Returns:
        a physical quantifier builder

      • getShorthand

        @Nonnull
public abstract String getShorthand()
        Return a short hand string for the quantifier. As a quantifier's semantics is usually quite subtle and should not distract from expressions. For example, when a data flow is visualized the returned string should be short.
        Returns:
        a short string representing the quantifier.

      • acceptPropertyVisitor

        @Nullable
public <U> U acceptPropertyVisitor​(@Nonnull
                                   PlannerProperty<U> visitor)
        Allow the computation of PlannerPropertys across the quantifiers in the data flow graph.
        Type Parameters:
        U - the type of the property being computed
        Parameters:
        visitor - the planner property that is being computed
        Returns:
        the property

      • semanticEquals

        public boolean semanticEquals​(@Nullable
                              Object other,
                              @Nonnull
                              AliasMap aliasMap)
        Description copied from interface: Correlated
        Determine equality with respect to an equivalence map between CorrelationIdentifiers based on semantic equality: equality of the plan fragments implementing under the given correlation bindings. The contract of this variant of equals() differs from its regular Java counterpart. A correlation is mostly just one part inside of composition of objects that expresses a more complicated (correlated) structure such as a filter. For instance q1.x = 5 uses a correlation to q1. That entity representing the filter is said to be correlated to q1. Similarly, q1.x = 6 is a different filter and is not equal under any correlation mapping. In contrast, consider a predicate where everything except the correlation is the same, such as q2.x = 5. Without a binding, these two filters are not the same. However, the filters may be a part of some other entity that can express correlations: SELECT * FROM T as q1 WHERE q1.x = 5 is equal to SELECT * FROM T as q2 WHERE q2.x = 5. It does not matter that q1 and q2 are named differently. It is important, however, that their semantic meaning is the same. In the example both q1 and q2 refer to a record type T which presumably is the same record type. Therefore, these two query blocks are the same, even though they are labelled differently. In the context of this method, we can establish equality between q1.x = 5 and q2.x = 5 if we know that q1 and q2 refer to the same underlying entity. The equivalence map passed in encodes that equality between CorrelationIdentifiers. Note: This method has the same interaction with Object.hashCode() as the regular equals() method. As we can only ever establish true equality using equivalence maps, hashCode() implementations in implementors of this interface must not be dependent on any correlation identifiers used in the structure of the entity. Doing so might violate the fundamental property of hash codes: e1.equals(e2, ...) => e1.hashCode() == e2.hashCode()
        Specified by:
        semanticEquals in interface Correlated<Quantifier>
        Parameters:
        other - the other object to establish equality with
        aliasMap - a map of CorrelationIdentifiers ids to ids'. A correlation identifier id used in this should be considered equal to another correlation identifier id' used in other if either they are the same by Object.equals(java.lang.Object) of if there is a mapping from id to id'.
        Returns:
        true if both entities are considered equal using the equivalences passed in, false otherwise

      • equalsOnKind

        public boolean equalsOnKind​(Object o)

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • semanticHashCode

        public int semanticHashCode()
        Description copied from interface: Correlated
        Return a semantic hash code for this object. The hash code must obey the convention that for any two objects o1 and o2 and for every AliasMap aliasMap: 
         o1.semanticEquals(o1, aliasMap) follows o1.semanticHash() == o2.semanticHash()
        If the semantic hash code of two implementing objects is equal and Correlated.semanticEquals(java.lang.Object, com.apple.foundationdb.record.query.plan.temp.AliasMap) returns true for these two objects the plan fragments are considered to produce the same result under the given correlations bindings. The left side o1.semanticEquals(o1, aliasMap) depends on an AliasMap while o1.semanticHash() == o2.semanticHash() does not. Hence, the hash that is computed is identical regardless of possible bindings.
        Specified by:
        semanticHashCode in interface Correlated<Quantifier>
        Returns:
        the semantic hash code

      • needsRebase

        protected boolean needsRebase​(@Nonnull
                              AliasMap translationMap)
        Helper to determine if anything that this quantifier ranges over is correlated to something that needs to be rebased.
        Parameters:
        translationMap - a map that expresses translations from correlations identifiers to correlation identifiers.
        Returns:
        true if the graph this quantifier ranges over needs to be rebased given the translation map passed in, false otherwise