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

Class FindingMatcher<T>

java.lang.Object

com.apple.foundationdb.record.query.plan.temp.matching.BaseMatcher<T>

com.apple.foundationdb.record.query.plan.temp.matching.FindingMatcher<T>

Type Parameters:

T - the element type

All Implemented Interfaces:

PredicatedMatcher

public class FindingMatcher<T>
extends BaseMatcher<T>
implements PredicatedMatcher

This class implements a PredicatedMatcher which matches two sets of elements of type T to compute an Iterable of AliasMaps. Individual elements are matched by means of a MatchPredicate which accepts or rejects that pair. In order to match this set against the other set, we need to find matching pairs of elements for each element identified by BaseMatcher.getAliases().

Method Summary

Modifier and Type	Method	Description
Iterator<AliasMap>	enumerate(EnumeratingIterator<CorrelationIdentifier> iterator, List<CorrelationIdentifier> otherOrdered)	Method to enumerate the permutations on this side against the permutation of the other side in order to form matches (bijective mappings between the permutations).
Iterable<AliasMap>	findMatches()	Match using the method enumerate(com.apple.foundationdb.record.query.plan.temp.EnumeratingIterator<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>, java.util.List<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>) as EnumerationFunction.
static <T> PredicatedMatcher	onAliasDependencies(AliasMap boundAliasesMap, Collection<? extends T> elements, Function<T,CorrelationIdentifier> elementToAliasFn, Function<T,Set<CorrelationIdentifier>> dependsOnFn, Collection<? extends T> otherElements, Function<T,CorrelationIdentifier> otherElementToAliasFn, Function<T,Set<CorrelationIdentifier>> otherDependsOnFn, MatchPredicate<T> matchPredicate)	Static factory method to create a generic matcher using element type T.
static FindingMatcher<CorrelationIdentifier>	onAliases(AliasMap boundAliasesMap, Set<CorrelationIdentifier> aliases, Function<CorrelationIdentifier,Set<CorrelationIdentifier>> dependsOnFn, Set<CorrelationIdentifier> otherAliases, Function<CorrelationIdentifier,Set<CorrelationIdentifier>> otherDependsOnFn, MatchPredicate<CorrelationIdentifier> matchPredicate)	Static factory method to create a generic matcher using element type T.
protected Iterable<List<CorrelationIdentifier>>	otherCombinations(List<CorrelationIdentifier> otherPermutation, int limitInclusive)

Methods inherited from class com.apple.foundationdb.record.query.plan.temp.matching.BaseMatcher

computeAliases, computeAliasToElementMap, computeDependsOnMap, computeDependsOnMapWithAliases, getAliases, getAliasToElementMap, getBoundAliasesMap, getDependsOnMap, getElementToAliasFn, getOtherAliases, getOtherAliasToElementMap, getOtherDependsOnMap, getOtherElementToAliasFn, isIsomorphic, mapDependenciesToOther, match

Methods inherited from class java.lang.Object

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

Method Detail

findMatches

@Nonnull
public Iterable<AliasMap> findMatches()

Match using the method enumerate(com.apple.foundationdb.record.query.plan.temp.EnumeratingIterator<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>, java.util.List<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>) as EnumerationFunction.

Specified by:

findMatches in interface PredicatedMatcher

Returns:

an iterable of AliasMaps.

otherCombinations

@Nonnull
protected Iterable<List<CorrelationIdentifier>> otherCombinations(List<CorrelationIdentifier> otherPermutation,
                                                                  int limitInclusive)

Specified by:

otherCombinations in class BaseMatcher<T>

enumerate

@Nonnull
public Iterator<AliasMap> enumerate(@Nonnull
                                    EnumeratingIterator<CorrelationIdentifier> iterator,
                                    @Nonnull
                                    List<CorrelationIdentifier> otherOrdered)

Method to enumerate the permutations on this side against the permutation of the other side in order to form matches (bijective mappings between the permutations). The match predicate is called for each pair of elements (for a match attempt). If the match predicate returns true the pair is recorded as a matching pair. We attempt to find a matching pair (one element from this side; one from the other side) for each element identified by BaseMatcher.getAliases(). For each individual new such pair that is found, we continue in the matching attempt. Once a set of bindings is established for all aliases in BaseMatcher.getAliases() this method then includes that AliasMap in the computable of AliasMaps that form the result and proceeds to consume further permutations from the iterator that is passed in in order to establish other matches between this and other.

Parameters:

iterator - an enumerating iterable for the permutations on this side

otherOrdered - one permutation (that is not violating dependencies, constraints, etc.) of the other side

Returns:

an Iterator of match results (of type AliasMap)

onAliases

@Nonnull
public static FindingMatcher<CorrelationIdentifier> onAliases(@Nonnull
                                                              AliasMap boundAliasesMap,
                                                              @Nonnull
                                                              Set<CorrelationIdentifier> aliases,
                                                              @Nonnull
                                                              Function<CorrelationIdentifier,Set<CorrelationIdentifier>> dependsOnFn,
                                                              @Nonnull
                                                              Set<CorrelationIdentifier> otherAliases,
                                                              @Nonnull
                                                              Function<CorrelationIdentifier,Set<CorrelationIdentifier>> otherDependsOnFn,
                                                              @Nonnull
                                                              MatchPredicate<CorrelationIdentifier> matchPredicate)

Static factory method to create a generic matcher using element type T. This method is optimized to the case when the dependsOn sets are already given by sets of CorrelationIdentifiers.

Parameters:

boundAliasesMap - a map with previously-bound aliases. Any match that is computed and passed back to the client is an amendment of this map, i.e., every resulting match's AliasMap always contains at least the bindings in this map

aliases - a set of CorrelationIdentifier representing this set

dependsOnFn - a function from elements to sets of correlation identifiers describing the depends-on relationships between the elements on this side

otherAliases - a set of other elements representing the other side

otherDependsOnFn - a function from elements to sets of correlation identifiers describing the depends-on relationships between the other elements

matchPredicate - a match predicate that rejects or accepts the matching for an individual pair of elements

Returns:

a newly created predicated matcher of type BoundMatch<R>

onAliasDependencies

@Nonnull
public static <T> PredicatedMatcher onAliasDependencies(@Nonnull
                                                        AliasMap boundAliasesMap,
                                                        @Nonnull
                                                        Collection<? extends T> elements,
                                                        @Nonnull
                                                        Function<T,CorrelationIdentifier> elementToAliasFn,
                                                        @Nonnull
                                                        Function<T,Set<CorrelationIdentifier>> dependsOnFn,
                                                        @Nonnull
                                                        Collection<? extends T> otherElements,
                                                        @Nonnull
                                                        Function<T,CorrelationIdentifier> otherElementToAliasFn,
                                                        @Nonnull
                                                        Function<T,Set<CorrelationIdentifier>> otherDependsOnFn,
                                                        @Nonnull
                                                        MatchPredicate<T> matchPredicate)

Static factory method to create a generic matcher using element type T. This method is optimized to the case when the dependsOn sets are already given by sets of CorrelationIdentifiers.

Type Parameters:

T - the element type

Parameters:

boundAliasesMap - a map with previously-bound aliases. Any match that is computed and passed back to the client is an amendment of this map, i.e., every resulting match's AliasMap always contains at least the bindings in this map

elements - a collection of elements of type T representing the domain on this side

elementToAliasFn - a function to map elements of type T on this side to correlation identifiers

dependsOnFn - a function from elements to sets of correlation identifiers describing the depends-on relationships between the elements on this side

otherElements - a collection of other elements representing the domain on the other side

otherElementToAliasFn - a function to map elements of type T on the other side to correlation identifiers

otherDependsOnFn - a function from elements to sets of correlation identifiers describing the depends-on relationships between the other elements

matchPredicate - a match predicate that rejects or accepts the matching for an individual pair of elements

Returns:

a newly created predicated matcher of type BoundMatch<R>