Interface SearchPredicateFactory

  • All Known Subinterfaces:
    ElasticsearchSearchPredicateFactory, ExtendedSearchPredicateFactory<S>, LuceneSearchPredicateFactory
    All Known Implementing Classes:
    AbstractSearchPredicateFactory

    public interface SearchPredicateFactory
    A factory for search predicates.

    This is the main entry point to the predicate DSL.

    Field paths

    By default, field paths passed to this DSL are interpreted as absolute, i.e. relative to the index root.

    However, a new, "relative" factory can be created with withRoot(String): the new factory interprets paths as relative to the object field passed as argument to the method.

    This can be useful when calling reusable methods that can apply the same predicate on different object fields that have same structure (same sub-fields).

    Such a factory can also transform relative paths into absolute paths using toAbsolutePath(String); this can be useful for native predicates in particular.

    • Method Detail

      • bool

        PredicateFinalStep bool​(Consumer<? super BooleanPredicateClausesStep<?>> clauseContributor)
        Match documents if they match a combination of boolean clauses, which will be defined by the given consumer.

        Best used with lambda expressions.

        Parameters:
        clauseContributor - A consumer that will add clauses to the step passed in parameter. Should generally be a lambda expression.
        Returns:
        The final step of the boolean predicate definition.
        See Also:
        BooleanPredicateClausesStep
      • match

        MatchPredicateFieldStep<?> match()
        Match documents where targeted fields have a value that "matches" a given single value.

        Note that "value matching" may be exact or approximate depending on the type of the targeted fields: numeric fields in particular imply exact matches, while analyzed, full-text fields imply approximate matches depending on how they are analyzed.

        Returns:
        The initial step of a DSL where the "match" predicate can be defined.
        See Also:
        MatchPredicateFieldStep
      • range

        RangePredicateFieldStep<?> range()
        Match documents where targeted fields have a value within lower and upper bounds.
        Returns:
        The initial step of a DSL where the "range" predicate can be defined.
        See Also:
        RangePredicateFieldStep
      • phrase

        PhrasePredicateFieldStep<?> phrase()
        Match documents where targeted fields have a value that contains a given phrase.
        Returns:
        The initial step of a DSL where the "phrase" predicate can be defined.
        See Also:
        PhrasePredicateFieldStep
      • wildcard

        WildcardPredicateFieldStep<?> wildcard()
        Match documents where targeted fields contain a term that matches a given pattern, such as inter*on or pa?t.

        Note that such patterns are not analyzed, thus any character that is not a wildcard must match exactly the content of the index (including uppercase letters, diacritics, ...).

        Returns:
        The initial step of a DSL where the "wildcard" predicate can be defined.
        See Also:
        WildcardPredicateFieldStep
      • regexp

        RegexpPredicateFieldStep<?> regexp()
        Match documents where targeted fields contain a term that matches a given regular expression.
        Returns:
        The initial step of a DSL where the "regexp" predicate can be defined.
        See Also:
        RegexpPredicateFieldStep
      • terms

        TermsPredicateFieldStep<?> terms()
        Match documents where targeted fields contain a term that matches some terms of a given series of terms.
        Returns:
        The initial step of a DSL where the "terms" predicate can be defined.
        See Also:
        TermsPredicateFieldStep
      • exists

        ExistsPredicateFieldStep<?> exists()
        Match documents where a given field exists.

        Fields are considered to exist in a document when they have at least one non-null value in this document.

        Returns:
        The initial step of a DSL where the "exists" predicate can be defined.
        See Also:
        ExistsPredicateFieldStep
      • named

        @Incubating
        NamedPredicateOptionsStep named​(String path)
        Match documents if they match a combination of defined named predicate clauses.
        Parameters:
        path - The path to the named predicate, formatted as <object field path>.<predicate name>, or just <predicate name> if the predicate was declared at the root.
        Returns:
        The initial step of a DSL where named predicate predicates can be defined.
        See Also:
        NamedPredicateOptionsStep
      • extension

        <T> T extension​(SearchPredicateFactoryExtension<T> extension)
        Extend the current factory with the given extension, resulting in an extended factory offering different types of predicates.
        Type Parameters:
        T - The type of factory provided by the extension.
        Parameters:
        extension - The extension to the predicate DSL.
        Returns:
        The extended factory.
        Throws:
        SearchException - If the extension cannot be applied (wrong underlying backend, ...).
      • withRoot

        @Incubating
        SearchPredicateFactory withRoot​(String objectFieldPath)
        Create a new predicate factory whose root for all paths passed to the DSL will be the given object field.

        This is used to call reusable methods that apply the same predicate on different object fields that have same structure (same sub-fields).

        Parameters:
        objectFieldPath - The path from the current root to an object field that will become the new root.
        Returns:
        A new predicate factory using the given object field as root.
      • toAbsolutePath

        @Incubating
        String toAbsolutePath​(String relativeFieldPath)
        Parameters:
        relativeFieldPath - The path to a field, relative to the root of this factory.
        Returns:
        The absolute path of the field, for use in native predicates for example. Note the path is returned even if the field doesn't exist.