Package com.valqueries.automapper

Interface ValqueriesQuery<T>

All Superinterfaces:
CrudRepository.InlineQuery<T,ValqueriesQuery<T>>
All Known Implementing Classes:
BaseValqueriesQuery, TestDoubleQuery, ValqueriesQueryImpl
public interface ValqueriesQuery<T> extends CrudRepository.InlineQuery<T,ValqueriesQuery<T>>

  • Method Details

    • in

      <X> ValqueriesQuery<T> in(Function<T,X> field, Collection<X> value)
      Match if the value of a field equals any of the specified values.

      Example: 

      
 query.in(Person::getName, List.of("Bob", "Frank"))

      This will match people with the name "Bob" or "Frank".

      Null values are never in, but if a mix of null and non-null values are passed, the null values will be ignored due to the OR nature of the in operation.

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the getter of the field to match
      value - the values to match, in an OR fashion
      Returns:
      the query, for chaining

    • in

      <X> ValqueriesQuery<T> in(BiConsumer<T,X> field, Collection<X> value)
      Match if the value of a field equals any of the specified values.

      Example: 

      
 query.in(Person::setName, List.of("Bob", "Frank"))

      This will match people with the name "Bob" or "Frank".

      Null values are never in, but if a mix of null and non-null values are passed, the null values will be ignored due to the OR nature of the in operation.

      If you wish to match both null and non-null values you can use .or(or -> or.isNull(field).in(field, value).

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the setter of the field to match
      value - the values to match, in an OR fashion
      Returns:
      the query, for chaining

    • in

      <X> ValqueriesQuery<T> in(Function<T,X> field, X... value)
      Match if the value of a field equals any of the specified values.

      Example: 

      
 query.in(Person::getName, "Bob", "Frank")

      This will match people with the name "Bob" or "Frank".

      Null values are never in, but if a mix of null and non-null values are passed, the null values will be ignored due to the OR nature of the in operation.

      If you wish to match both null and non-null values you can use .or(or -> or.isNull(field).in(field, value).

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the getter of the field to match
      value - the values to match, in an OR fashion
      Returns:
      the query, for chaining

    • in

      <X> ValqueriesQuery<T> in(BiConsumer<T,X> field, X... value)
      Match if the value of a field equals any of the specified values.

      Example: 

      
 query.in(Person::setName, "Bob", "Frank")

      This will match people with the name "Bob" or "Frank".

      Null values are never in, but if a mix of null and non-null values are passed, the null values will be ignored due to the OR nature of the in operation.

      If you wish to match both null and non-null values you can use .or(or -> or.isNull(field).in(field, value).

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the setter of the field to match
      value - the values to match, in an OR fashion
      Returns:
      the query, for chaining

    • in

      ValqueriesQuery<T> in(Property.PropertyValueList<?> values)

    • notIn

      <X> ValqueriesQuery<T> notIn(Function<T,X> field, Collection<X> value)
      Match if the value of a field does not equal any of the specified values.

      Example: 

      
 query.notIn(Person::getName, List.of("Bob", "Frank"))

      This will match people with a name other than "Bob" or "Frank", but not people with a null name.

      If the passed values include a null value, no match will be made.

      The empty list is a valid argument, and will match all values. This is equivalent to not having the condition at all.

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the getter of the field to match
      value - the values to match, in an AND fashion
      Returns:
      the query, for chaining

    • notIn

      <X> ValqueriesQuery<T> notIn(BiConsumer<T,X> field, Collection<X> value)
      Match if the value of a field does not equal any of the specified values.

      Example: 

      
 query.notIn(Person::setName, List.of("Bob", "Frank"))

      This will match people with a name other than "Bob" or "Frank", but not people with a null name.

      If the passed values include a null value, no match will be made.

      The empty list is a valid argument, and will match all values. This is equivalent to not having the condition at all.

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the setter of the field to match
      value - the values to match, in an AND fashion
      Returns:
      the query, for chaining

    • notIn

      <X> ValqueriesQuery<T> notIn(Function<T,X> field, X... value)
      Match if the value of a field does not equal any of the specified values.

      Example: 

      
 query.notIn(Person::getName, "Bob", "Frank")

      This will match people with a name other than "Bob" or "Frank", but not people with a null name.

      If the passed values include a null value, no match will be made.

      The empty list is a valid argument, and will match all values. This is equivalent to not having the condition at all.

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the getter of the field to match
      value - the values to match, in an AND fashion
      Returns:
      the query, for chaining

    • notIn

      <X> ValqueriesQuery<T> notIn(BiConsumer<T,X> field, X... value)
      Match if the value of a field does not equal any of the specified values.

      Example: 

      
 query.notIn(Person::setName, "Bob", "Frank")

      This will match people with a name other than "Bob" or "Frank", but not people with a null name.

      If the passed values include a null value, no match will be made.

      The empty list is a valid argument, and will match all values. This is equivalent to not having the condition at all.

      Type Parameters:
      X - the type of the field and value
      Parameters:
      field - a method reference to the setter of the field to match
      value - the values to match, in an AND fashion
      Returns:
      the query, for chaining

    • notIn

      ValqueriesQuery<T> notIn(Property.PropertyValueList<?> values)

    • like

      ValqueriesQuery<T> like(Function<T,String> field, String value)
      Match if the value of a field is like the specified value.

      Like uses a simplified version of SQL LIKE, where the value can contain the SQL wildcards % and _.

      The % wildcard matches any number of characters, including zero. The _ wildcard matches exactly one character.

      Example: 

      
 query.like(Person::getName, "Bob%")

      This will match people with a name starting with "Bob".

      Secondary example: 

      
 query.like(Person::getName, "%Bob%")

      This will match people with a name containing "Bob" anywhere in the name.

      Tertiary example: 

      
     query.like(Person::getName, "B_b")

      This will match people with a name containing "B", followed by any letter, then followed by "b", exactly.

      like will never match null values in the database, additionally if a null value is passed, no match will be made even against non-null values.

      Parameters:
      field - a method reference to the getter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • like

      ValqueriesQuery<T> like(BiConsumer<T,String> field, String value)
      Match if the value of a field is like the specified value.

      Like uses a simplified version of SQL LIKE, where the value can contain the SQL wildcards % and _.

      The % wildcard matches any number of characters, including zero. The _ wildcard matches exactly one character.

      Example: 

      
 query.like(Person::setName, "Bob%")

      This will match people with a name starting with "Bob".

      Secondary example: 

      
 query.like(Person::setName, "%Bob%")

      This will match people with a name containing "Bob" anywhere in the name.

      Tertiary example: 

      
     query.like(Person::setName, "B_b")

      This will match people with a name containing "B", followed by any letter, then followed by "b", exactly.

      like will never match null values in the database, additionally if a null value is passed, no match will be made even against non-null values.

      Parameters:
      field - a method reference to the setter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • like

      ValqueriesQuery<T> like(Property.PropertyValue<String> propertyValue)

    • notLike

      ValqueriesQuery<T> notLike(Function<T,String> field, String value)
      Match if the value of a field is not like the specified value.

      Like uses a simplified version of SQL LIKE, where the value can contain the SQL wildcards % and _.

      The % wildcard matches any number of characters, including zero. The _ wildcard matches exactly one character.

      Example: 

      
 query.notLike(Person::getName, "Bob%")

      This will match people with a name not starting with "Bob".

      Secondary example: 

      
 query.notLike(Person::getName, "%Bob%")

      This will match people with a name not containing "Bob" anywhere in the name.

      Tertiary example: 

      
     query.notLike(Person::getName, "B_b")

      This will match people with a name that is not "B", followed by any letter, then followed by "b", exactly. For example it will match "Frank" or "Bubba", but not "Bob".

      notLike will never match null values in the database, additionally if a null value is passed, no match will be made even against non-null values.

      Parameters:
      field - a method reference to the getter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • notLike

      ValqueriesQuery<T> notLike(BiConsumer<T,String> field, String value)
      Match if the value of a field is not like the specified value.

      Like uses a simplified version of SQL LIKE, where the value can contain the SQL wildcards % and _.

      The % wildcard matches any number of characters, including zero. The _ wildcard matches exactly one character.

      Example: 

      
 query.notLike(Person::setName, "Bob%")

      This will match people with a name not starting with "Bob".

      Secondary example: 

      
 query.notLike(Person::setName, "%Bob%")

      This will match people with a name not containing "Bob" anywhere in the name.

      Tertiary example: 

      
     query.notLike(Person::setName, "B_b")

      This will match people with a name that is not "B", followed by any letter, then followed by "b", exactly. For example, it will match "Frank" or "Bubba", but not "Bob".

      notLike will never match null values in the database, additionally if a null value is passed, no match will be made even against non-null values.

      Parameters:
      field - a method reference to the setter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • notLike

      ValqueriesQuery<T> notLike(Property.PropertyValue<String> propertyValue)

    • isNotNull

      ValqueriesQuery<T> isNotNull(Function<T,?> field)
      Match if the value of a field is not null.

      Example: 

      
     query.isNotNull(Person::getEmail)

      This will match people whose email is not null.

      Note: if the model class has fields of primitive type, they won't be null, even if the database contains NULL values. In this case isNotNull will still match correctly based on the values in the database.

      Parameters:
      field - a method reference to the getter of the field to match
      Returns:
      the query, for chaining

    • isNotNull

      ValqueriesQuery<T> isNotNull(BiConsumer<T,?> field)
      Match if the value of a field is not null.

      Example: 

      
     query.isNotNull(Person::setEmail)

      This will match people whose email is not null.

      Note: if the model class has fields of primitive type, they won't be null, even if the database contains NULL values. In this case isNotNull will still match correctly based on the values in the database.

      Parameters:
      field - a method reference to the setter of the field to match
      Returns:
      the query, for chaining

    • isNotNull

      ValqueriesQuery<T> isNotNull(Property<?> property)

    • freetext

      ValqueriesQuery<T> freetext(Function<T,String> field, String value)

    • freetext

      ValqueriesQuery<T> freetext(BiConsumer<T,String> field, String value)

    • freetext

      ValqueriesQuery<T> freetext(Property.PropertyValue<String> propertyValue)

    • subQuery

      <X> ValqueriesQuery<T> subQuery(Function<T,X> field, Consumer<ValqueriesQuery<X>> subQuery)
      Perform further queries on a related model.

      A related model is one that is referenced by a field in the current model and which is mapped via a Relation annotation.

      Example: 

      
     query.subQuery(Person::getAddress,
     subQuery -> subQuery.eq(Address::getCity, "Stockholm"))

      This will match people whose address has the city "Stockholm".

      The subQuery is not executed until the main query is executed.

      The subQuery is executed in the same transaction as the main query.

      Type Parameters:
      X - the type of the sub-object
      Parameters:
      field - a method reference to the getter of the field to match
      subQuery - a consumer that will be called with the subQuery
      Returns:
      the query, for chaining

    • subQuery

      <X> ValqueriesQuery<T> subQuery(BiConsumer<T,X> field, Consumer<ValqueriesQuery<X>> subQuery)
      Perform further queries on a related model.

      A related model is one that is referenced by a field in the current model and which is mapped via a Relation annotation.

      Example: 

      
     query.subQuery(Person::setAddress,
     subQuery -> subQuery.eq(Address::setCity, "Stockholm"))

      This will match people whose address has the city "Stockholm".

      The subQuery is not executed until the main query is executed.

      The subQuery is executed in the same transaction as the main query.

      Type Parameters:
      X - the type of the sub-object
      Parameters:
      field - a method reference to the setter of the field to match
      subQuery - a consumer that will be called with the subQuery
      Returns:
      the query, for chaining

    • subQueryList

      <X> ValqueriesQuery<T> subQueryList(Function<T,? extends Collection<X>> field, Consumer<ValqueriesQuery<X>> subQuery)
      Perform further queries on a related model which has a one-to-many relation.

      A related model is one that is referenced by a field in the current model and which is mapped via a Relation annotation.

      Example:

      Assume that Person object has a list of Address objects, and that the Address object has a field called "city". 

      
     query.subQueryList(Person::getAddresses,
     subQuery -> subQuery.eq(Address::getCity, "Stockholm"))

      This will match people who have any addresses where the city is "Stockholm".

      The subQuery is not executed until the main query is executed.

      The subQuery is executed in the same transaction as the main query.

      Type Parameters:
      X - the type of the sub-object
      Parameters:
      subQuery - a consumer that will be called with the subQuery
      Returns:
      the query, for chaining

    • subQueryList

      <X> ValqueriesQuery<T> subQueryList(BiConsumer<T,? extends Collection<X>> field, Consumer<ValqueriesQuery<X>> subQuery)
      Perform further queries on a related model which has a one-to-many relation.

      A related model is one that is referenced by a field in the current model and which is mapped via a Relation annotation.

      Example:

      Assume that Person object has a list of Address objects, and that the Address object has a field called "city". 

      
     query.subQueryList(Person::setAddresses,
     subQuery -> subQuery.eq(Address::setCity, "Stockholm"))

      This will match people who have any address(es) where the city is "Stockholm".

      The subQuery is not executed until the main query is executed.

      The subQuery is executed in the same transaction as the main query.

      Type Parameters:
      X - the type of the sub-object
      Parameters:
      subQuery - a consumer that will be called with the subQuery
      Returns:
      the query, for chaining

    • subQueryList

      <X> ValqueriesQuery<T> subQueryList(RelationDescriber relationDescriber, Consumer<ValqueriesQuery<X>> subQuery)

    • groupBy

      ValqueriesGroupQuery<T> groupBy(Function<T,?>... fields)
      Create a group by query.
      Parameters:
      fields - Getters of the fields to group by. The values of ValqueriesGroupResultRow.groupByValues() will be in the same order.
      Returns:
      the group by query that allows adding aggregations.

    • groupBy

      ValqueriesGroupQuery<T> groupBy(BiConsumer<T,?>... fields)
      Create a group by query.
      Parameters:
      fields - Setters of the fields to group by. The values of ValqueriesGroupResultRow.groupByValues() will be in the same order.
      Returns:
      the group by query that allows adding aggregations.

    • aggregateAll

      ValqueriesGroupQuery<T> aggregateAll()
      Allows to perform aggregations without grouping by any columns. The result will be a single row with empty ValqueriesGroupResultRow.groupByValues().
      Returns:
      the query that allows adding aggregations.

    • update

      CrudRepository.CrudUpdateResult update(Consumer<ValqueriesUpdate<T>> updater)