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

Class Quantifiers

java.lang.Object

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

public class Quantifiers
extends Object

Auxiliary class containing factory methods and helpers for Quantifier.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	Quantifiers.AliasResolver	Resolver to resolve aliases to quantifiers.

Method Summary

Modifier and Type	Method	Description
static Iterable<AliasMap>	enumerateConstraintAliases(AliasMap aliasMap, List<? extends Quantifier> quantifiers, Function<Quantifier,Collection<AliasMap>> constraintsFunction, Set<CorrelationIdentifier> eligibleAliases, Set<CorrelationIdentifier> otherEligibleAliases)	Method to enumerate the bound aliases due to constraints.
static <E extends RelationalExpression> List<Quantifier.Existential>	existentialQuantifiers(Iterable<? extends ExpressionRef<E>> rangesOverPlans)	Create a list of existential quantifiers from a list of expression references these quantifiers should range over.
static Iterable<AliasMap>	findMatches(AliasMap boundAliasesMap, Collection<? extends Quantifier> quantifiers, Collection<? extends Quantifier> otherQuantifiers, MatchPredicate<Quantifier> matchPredicate)	Method to find matches between the given set of quantifiers and the given set of other quantifiers using an alias map and a matchPredicate.
static <E extends RelationalExpression> List<Quantifier.ForEach>	forEachQuantifiers(Iterable<ExpressionRef<E>> rangesOverExpressions)	Create a list of for-each quantifiers from a list of references to range over.
static <E extends RelationalExpression,Q extends Quantifier> List<Q>	fromExpressions(Iterable<? extends ExpressionRef<E>> rangesOverExpressions, Function<ExpressionRef<E>,Q> creator)	Create a list of quantifiers given a list of references these quantifiers should range over.
static <E extends RecordQueryPlan> List<Quantifier.Physical>	fromPlans(Iterable<? extends ExpressionRef<E>> rangesOverPlans)	Create a list of physical quantifiers given a list of references these quantifiers should range over.
static <M> GenericMatcher<BoundMatch<EnumeratingIterable<M>>>	genericMatcher(AliasMap boundAliasesMap, Collection<? extends Quantifier> quantifiers, Collection<? extends Quantifier> otherQuantifiers, MatchFunction<Quantifier,M> matchFunction)	Method to create a matcher between the given set of quantifiers and the given set of other quantifiers using an alias map and a matchFunction.
static <M> Iterable<BoundMatch<EnumeratingIterable<M>>>	match(AliasMap boundAliasesMap, Collection<? extends Quantifier> quantifiers, Collection<? extends Quantifier> otherQuantifiers, MatchFunction<Quantifier,M> matchFunction)	Method to match the given set of quantifiers and the given set of other quantifiers using an alias map and a matchFunction.
static <Q extends Quantifier> List<Q>	narrow(Class<Q> narrowedClass, List<? extends Quantifier> quantifiers)
static <Q extends Quantifier> Set<Q>	narrow(Class<Q> narrowedClass, Set<? extends Quantifier> quantifiers)
static AliasMap	toAliasMap(com.google.common.collect.BiMap<Quantifier,Quantifier> map)	Convenience helper to create an alias translation map based on a translation map using quantifiers.
static com.google.common.collect.BiMap<CorrelationIdentifier,Quantifier>	toBiMap(Collection<? extends Quantifier> quantifiers)	Convenience helper to create an alias to quantifier map using a collection of quantifiers.
static AliasMap	translate(Quantifier from, Quantifier to)	Convenience helper to create a single ID translation map from the alias of one quantifier to the alias of another quantifier.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

forEachQuantifiers

@Nonnull
public static <E extends RelationalExpression> List<Quantifier.ForEach> forEachQuantifiers(@Nonnull
                                                                                           Iterable<ExpressionRef<E>> rangesOverExpressions)

Create a list of for-each quantifiers from a list of references to range over.

Type Parameters:

E - type parameter to constrain expressions to RelationalExpression

Parameters:

rangesOverExpressions - iterable ExpressionRefs of RelationalExpressions

Returns:

a list of for-each quantifiers where each quantifier ranges over one of the given references

existentialQuantifiers

@Nonnull
public static <E extends RelationalExpression> List<Quantifier.Existential> existentialQuantifiers(@Nonnull
                                                                                                   Iterable<? extends ExpressionRef<E>> rangesOverPlans)

Create a list of existential quantifiers from a list of expression references these quantifiers should range over.

Type Parameters:

E - type parameter to constrain expressions to RelationalExpression

Parameters:

rangesOverPlans - iterable ExpressionRefs of of RelationalExpressions.

Returns:

a list of physical quantifiers where each quantifier ranges over one of the given references

fromPlans

@Nonnull
public static <E extends RecordQueryPlan> List<Quantifier.Physical> fromPlans(@Nonnull
                                                                              Iterable<? extends ExpressionRef<E>> rangesOverPlans)

Create a list of physical quantifiers given a list of references these quantifiers should range over.

Type Parameters:

E - type parameter to constrain expressions to RecordQueryPlan

Parameters:

rangesOverPlans - iterable ExpressionRefs of RecordQueryPlan

Returns:

a list of physical quantifiers where each quantifier ranges over a reference contained in the given iterable

fromExpressions

@Nonnull
public static <E extends RelationalExpression,Q extends Quantifier> List<Q> fromExpressions(@Nonnull
                                                                                                  Iterable<? extends ExpressionRef<E>> rangesOverExpressions,
                                                                                                  @Nonnull
                                                                                                  Function<ExpressionRef<E>,Q> creator)

Create a list of quantifiers given a list of references these quantifiers should range over.

Type Parameters:

E - type parameter to constrain expressions to RelationalExpression

Q - the type of the quantifier to be created

Parameters:

rangesOverExpressions - iterable of ExpressionRefs the quantifiers will be created to range over

creator - lambda to to be called for each expression reference contained in rangesOverExpressions to create the actual quantifier. This allows for callers to create different kinds of quantifier based on needs.

Returns:

a list of quantifiers where each quantifier ranges over an reference contained in the given iterable

translate

@Nonnull
public static AliasMap translate(@Nonnull
                                 Quantifier from,
                                 @Nonnull
                                 Quantifier to)

Convenience helper to create a single ID translation map from the alias of one quantifier to the alias of another quantifier.

Parameters:

from - quantifier

to - quantifier

Returns:

a new translation map mapping from from.getAlias() to to.getAlias()

toAliasMap

@Nonnull
public static AliasMap toAliasMap(@Nonnull
                                  com.google.common.collect.BiMap<Quantifier,Quantifier> map)

Convenience helper to create an alias translation map based on a translation map using quantifiers. of another quantifier.

Parameters:

map - quantifier to quantifier bi-map

Returns:

a new AliasMap mapping from from.getAlias() to to.getAlias()

toBiMap

@Nonnull
public static com.google.common.collect.BiMap<CorrelationIdentifier,Quantifier> toBiMap(@Nonnull
                                                                                              Collection<? extends Quantifier> quantifiers)

Convenience helper to create an alias to quantifier map using a collection of quantifiers.

Parameters:

quantifiers - collection of quantifiers

Returns:

a new BiMap mapping from q.getAlias() to q for every q in quantifiers

narrow

@Nonnull
public static <Q extends Quantifier> List<Q> narrow(@Nonnull
                                                    Class<Q> narrowedClass,
                                                    @Nonnull
                                                    List<? extends Quantifier> quantifiers)

narrow

@Nonnull
public static <Q extends Quantifier> Set<Q> narrow(@Nonnull
                                                   Class<Q> narrowedClass,
                                                   @Nonnull
                                                   Set<? extends Quantifier> quantifiers)

findMatches

@Nonnull
public static Iterable<AliasMap> findMatches(@Nonnull
                                             AliasMap boundAliasesMap,
                                             @Nonnull
                                             Collection<? extends Quantifier> quantifiers,
                                             @Nonnull
                                             Collection<? extends Quantifier> otherQuantifiers,
                                             @Nonnull
                                             MatchPredicate<Quantifier> matchPredicate)

Method to find matches between the given set of quantifiers and the given set of other quantifiers using an alias map and a matchPredicate. This method makes use of predicatedMatcher(com.apple.foundationdb.record.query.plan.temp.AliasMap, java.util.Collection<? extends com.apple.foundationdb.record.query.plan.temp.Quantifier>, java.util.Collection<? extends com.apple.foundationdb.record.query.plan.temp.Quantifier>, com.apple.foundationdb.record.query.plan.temp.matching.MatchPredicate<com.apple.foundationdb.record.query.plan.temp.Quantifier>) to create a matcher that is then used to perform actual matching. Two quantifiers can only match if they are equal on kind and the matchPredicate handed in is also satisfied.

Parameters:

boundAliasesMap - aliases map of already bound quantifiers

quantifiers - collection of quantifiers

otherQuantifiers - collection of other quantifiers

matchPredicate - that tests if two quantifiers and their graph they range over can be considered equivalent

Returns:

an Iterable of AliasMaps containing a mapping from the quantifiers this expression owns to the quantifiers in otherQuantifiers. Note that the mapping is bijective and can therefore be inverted

match

@Nonnull
public static <M> Iterable<BoundMatch<EnumeratingIterable<M>>> match(@Nonnull
                                                                     AliasMap boundAliasesMap,
                                                                     @Nonnull
                                                                     Collection<? extends Quantifier> quantifiers,
                                                                     @Nonnull
                                                                     Collection<? extends Quantifier> otherQuantifiers,
                                                                     @Nonnull
                                                                     MatchFunction<Quantifier,M> matchFunction)

Method to match the given set of quantifiers and the given set of other quantifiers using an alias map and a matchFunction. In contrast to findMatches(com.apple.foundationdb.record.query.plan.temp.AliasMap, java.util.Collection<? extends com.apple.foundationdb.record.query.plan.temp.Quantifier>, java.util.Collection<? extends com.apple.foundationdb.record.query.plan.temp.Quantifier>, com.apple.foundationdb.record.query.plan.temp.matching.MatchPredicate<com.apple.foundationdb.record.query.plan.temp.Quantifier>) this more generic version of the matching algorithm allows to compute an Iterable of results when a match is found which is then associated with the actual BoundMatch. Two quantifiers can be considered a match if the given MatchFunction returns a non-empty Iterable of some type. This method attempts to match each quantifier from the set of quantifiers this expression owns to a quantifier of the given other set of quantifiers such that the given match function is returns a non-empty iterable for each mapping. Note that there may be multiple distinct matches between the quantifier sets. This method returns an Iterable of such matches where each match is only computed when it is requested by an iterator's Iterator.hasNext(). Thus it can be assumed that this method never pre-computes all possible matches. For expressions that cannot introduce correlations, this method's complexity is simply O(n!) where n is the number of quantifiers (which is equal for both sets). This path is taken by UNIONs and other set operations. For expressions that introduce correlations, the matching process is more complicated. First, we determine one topologically correct ordering. Then we iterate through all topologically correct orderings of the set of quantifiers this expression owns. For each element in the permutation of quantifiers that is returned by the EnumeratingIterator we try to match the quantifiers between the sets topologically from left to right (using matchPredicate). For each match we find we add a mapping between the alias of this and the other quantifier that matched into an AliasMap that extends the alias map handed in.

Type Parameters:

M - type that the match function matchFunction produces

Parameters:

boundAliasesMap - aliases map of already bound quantifiers

quantifiers - collection of quantifiers

otherQuantifiers - collection of other quantifiers

matchFunction - that computes an non-empty Iterable of match results if two quantifiers and their graph they range over can be considered matching and an empty Iterable otherwise

Returns:

an Iterable of BoundMatches containing an AliasMap mapping from the quantifiers this expression owns to the quantifiers in otherQuantifiers together with the cross-product of all individual matches that were computed between during the matching of individual quantifiers.

genericMatcher

@Nonnull
public static <M> GenericMatcher<BoundMatch<EnumeratingIterable<M>>> genericMatcher(@Nonnull
                                                                                    AliasMap boundAliasesMap,
                                                                                    @Nonnull
                                                                                    Collection<? extends Quantifier> quantifiers,
                                                                                    @Nonnull
                                                                                    Collection<? extends Quantifier> otherQuantifiers,
                                                                                    @Nonnull
                                                                                    MatchFunction<Quantifier,M> matchFunction)

Method to create a matcher between the given set of quantifiers and the given set of other quantifiers using an alias map and a matchFunction. In contrast to findMatches(com.apple.foundationdb.record.query.plan.temp.AliasMap, java.util.Collection<? extends com.apple.foundationdb.record.query.plan.temp.Quantifier>, java.util.Collection<? extends com.apple.foundationdb.record.query.plan.temp.Quantifier>, com.apple.foundationdb.record.query.plan.temp.matching.MatchPredicate<com.apple.foundationdb.record.query.plan.temp.Quantifier>) this more generic version of the matching algorithm allows to compute an Iterable of results when a match is found which is then associated with the actual BoundMatch. Two quantifiers can be considered a match if the given MatchFunction returns a non-empty Iterable of some type. This method attempts to match each quantifier from the set of quantifiers this expression owns to a quantifier of the given other set of quantifiers such that the given match function is returns a non-empty iterable for each mapping. Note that there may be multiple distinct matches between the quantifier sets. This method returns an Iterable of such matches where each match is only computed when it is requested by an iterator's Iterator.hasNext(). Thus it can be assumed that this method never pre-computes all possible matches. For expressions that cannot introduce correlations, this method's complexity is simply O(n!) where n is the number of quantifiers (which is equal for both sets). This path is taken by UNIONs and other set operations. For expressions that introduce correlations, the matching process is more complicated. First, we determine one topologically correct ordering. Then we iterate through all topologically correct orderings of the set of quantifiers this expression owns. For each element in the permutation of quantifiers that is returned by the EnumeratingIterator we try to match the quantifiers between the sets topologically from left to right (using matchPredicate). For each match we find we add a mapping between the alias of this and the other quantifier that matched into an AliasMap that extends the alias map handed in.

Type Parameters:

M - type that the match function matchFunction produces

Parameters:

boundAliasesMap - aliases map of already bound quantifiers

quantifiers - collection of quantifiers

otherQuantifiers - collection of other quantifiers

matchFunction - that computes an non-empty Iterable of match results if two quantifiers and their graph they range over can be considered matching and an empty Iterable otherwise

Returns:

a new generic matcher

enumerateConstraintAliases

@Nonnull
public static Iterable<AliasMap> enumerateConstraintAliases(@Nonnull
                                                            AliasMap aliasMap,
                                                            @Nonnull
                                                            List<? extends Quantifier> quantifiers,
                                                            @Nonnull
                                                            Function<Quantifier,Collection<AliasMap>> constraintsFunction,
                                                            @Nonnull
                                                            Set<CorrelationIdentifier> eligibleAliases,
                                                            @Nonnull
                                                            Set<CorrelationIdentifier> otherEligibleAliases)

Method to enumerate the bound aliases due to constraints. This reduces the number of permutations the matching algorithm has to enumerate in a subsequent step. Consider the following example: Let's says we have AliasMaps for three given quantifiers:

 q1: Iterable.of((a11 -> aa, a2 -> ab), (a11 -> ab, a2 -> aa), (a11 -> ac, a2 -> ad))
 q2: Iterable.of((a11 -> aa, a2 -> ab), (a11 -> ab, a2 -> aa))
 q3: Iterable.of((a11 -> aa, a2 -> ab), (a11 -> ab, a2 -> aa), (a11 -> ac, a2 -> ad))
 

All quantifiers have a constraint (a11 -> aa, a2 -> ab). This means that in this example, for that alias map in q1 we find exactly one compatible alias map for q2 and q3. The same is true for (a11 -> ab, a2 -> aa). The map (a11 -> ac, a2 -> ad), however, is not one of the constraints in q2. Therefore, that map can never produce a proper match for all three quantifiers as they cannot all use that mapping (q2 only uses incompatible mappings). Similarly if the filtered cross product of alias maps is empty we know that there cannot be any match between these quantifiers at all. If the list of quantifiers passed in is empty, this method returns a singleton iterable of the given AliasMap. This is equivalent to saying that the (empty) set of quantifiers are not imposing a constraint on matching. If the quantifiers that are passed in use only empty alias maps, we consider the empty alias map compatible with any other alias map.

Parameters:

aliasMap - alias map of bound aliases

quantifiers - list of quantifiers

constraintsFunction - a function returning a Collection of AliasMaps with potentially several alias maps. This function must be defined over th set of quantifiers also passed in.

eligibleAliases - a set of aliases to filter the aliases under consideration during enumeration on the source side

otherEligibleAliases - a set of aliases to filter the aliases under consideration during enumeration on the target side

Returns:

an Iterable of possible AliasMaps where each such map contains a set of compatible bindings over all quantifiers.