Package com.valqueries.automapper

Class BaseValqueriesQuery<T>

java.lang.Object
io.ran.CrudRepoBaseQuery<T,ValqueriesQuery<T>>
com.valqueries.automapper.BaseValqueriesQuery<T>
All Implemented Interfaces:
ValqueriesGroupQuery<T>, ValqueriesQuery<T>, CrudRepository.InlineQuery<T,ValqueriesQuery<T>>
Direct Known Subclasses:
ValqueriesQueryImpl
public abstract class BaseValqueriesQuery<T> extends CrudRepoBaseQuery<T,ValqueriesQuery<T>> implements ValqueriesQuery<T>, ValqueriesGroupQuery<T>

  • Field Details

    • groupByProperties

      protected List<Property<?>> groupByProperties

  • Constructor Details

  • Method Details

    • in

      public abstract ValqueriesQuery<T> in(Property.PropertyValueList<?> propertyValues)
      Specified by:
      in in interface ValqueriesQuery<T>

    • notIn

      public abstract ValqueriesQuery<T> notIn(Property.PropertyValueList<?> propertyValues)
      Specified by:
      notIn in interface ValqueriesQuery<T>

    • like

      public abstract ValqueriesQuery<T> like(Property.PropertyValue<String> propertyValue)
      Specified by:
      like in interface ValqueriesQuery<T>

    • notLike

      public abstract ValqueriesQuery<T> notLike(Property.PropertyValue<String> propertyValue)
      Specified by:
      notLike in interface ValqueriesQuery<T>

    • freetext

      public abstract ValqueriesQuery<T> freetext(Property.PropertyValue<String> propertyValue)
      Specified by:
      freetext in interface ValqueriesQuery<T>

    • isNotNull

      public abstract ValqueriesQuery<T> isNotNull(Property<?> property)
      Specified by:
      isNotNull in interface ValqueriesQuery<T>

    • count

      protected abstract void count(Property<?> resultProperty)

    • sum

      protected abstract void sum(Property<? extends Number> resultProperty)

    • max

      protected abstract <X extends Comparable<? super X>> void max(Property<X> resultProperty)

    • min

      protected abstract <X extends Comparable<? super X>> void min(Property<X> resultProperty)

    • concat

      protected abstract void concat(Property<?> resultProperty, String separator)

    • in

      public <X> ValqueriesQuery<T> in(Function<T,X> field, Collection<X> value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      in in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> in(BiConsumer<T,X> field, Collection<X> value)
      Description copied from interface: ValqueriesQuery
      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).

      Specified by:
      in in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> in(Function<T,X> field, X... value)
      Description copied from interface: ValqueriesQuery
      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).

      Specified by:
      in in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> in(BiConsumer<T,X> field, X... value)
      Description copied from interface: ValqueriesQuery
      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).

      Specified by:
      in in interface ValqueriesQuery<T>
      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

    • notIn

      public <X> ValqueriesQuery<T> notIn(Function<T,X> field, Collection<X> value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      notIn in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> notIn(BiConsumer<T,X> field, Collection<X> value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      notIn in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> notIn(Function<T,X> field, X... value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      notIn in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> notIn(BiConsumer<T,X> field, X... value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      notIn in interface ValqueriesQuery<T>
      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

    • like

      public ValqueriesQuery<T> like(Function<T,String> field, String value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      like in interface ValqueriesQuery<T>
      Parameters:
      field - a method reference to the getter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • like

      public ValqueriesQuery<T> like(BiConsumer<T,String> field, String value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      like in interface ValqueriesQuery<T>
      Parameters:
      field - a method reference to the setter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • notLike

      public ValqueriesQuery<T> notLike(Function<T,String> field, String value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      notLike in interface ValqueriesQuery<T>
      Parameters:
      field - a method reference to the getter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • notLike

      public ValqueriesQuery<T> notLike(BiConsumer<T,String> field, String value)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      notLike in interface ValqueriesQuery<T>
      Parameters:
      field - a method reference to the setter of the field to match
      value - the value to match
      Returns:
      the query, for chaining

    • freetext

      public ValqueriesQuery<T> freetext(Function<T,String> field, String value)
      Specified by:
      freetext in interface ValqueriesQuery<T>

    • isNotNull

      public ValqueriesQuery<T> isNotNull(BiConsumer<T,?> field)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      isNotNull in interface ValqueriesQuery<T>
      Parameters:
      field - a method reference to the setter of the field to match
      Returns:
      the query, for chaining

    • isNotNull

      public ValqueriesQuery<T> isNotNull(Function<T,?> field)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      isNotNull in interface ValqueriesQuery<T>
      Parameters:
      field - a method reference to the getter of the field to match
      Returns:
      the query, for chaining

    • freetext

      public ValqueriesQuery<T> freetext(BiConsumer<T,String> field, String value)
      Specified by:
      freetext in interface ValqueriesQuery<T>

    • subQuery

      public <X> ValqueriesQuery<T> subQuery(Function<T,X> field, Consumer<ValqueriesQuery<X>> subQuery)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      subQuery in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> subQuery(BiConsumer<T,X> field, Consumer<ValqueriesQuery<X>> subQuery)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      subQuery in interface ValqueriesQuery<T>
      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

      public <X> ValqueriesQuery<T> subQueryList(Function<T,? extends Collection<X>> field, Consumer<ValqueriesQuery<X>> subQuery)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      subQueryList in interface ValqueriesQuery<T>
      Type Parameters:
      X - the type of the sub-object
      subQuery - a consumer that will be called with the subQuery
      Returns:
      the query, for chaining

    • subQueryList

      public <X> ValqueriesQuery<T> subQueryList(BiConsumer<T,? extends Collection<X>> field, Consumer<ValqueriesQuery<X>> subQuery)
      Description copied from interface: ValqueriesQuery
      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.

      Specified by:
      subQueryList in interface ValqueriesQuery<T>
      Type Parameters:
      X - the type of the sub-object
      subQuery - a consumer that will be called with the subQuery
      Returns:
      the query, for chaining

    • subQueryList

      public <X> ValqueriesQuery<T> subQueryList(RelationDescriber relationDescriber, Consumer<ValqueriesQuery<X>> subQuery)
      Specified by:
      subQueryList in interface ValqueriesQuery<T>

    • groupBy

      public ValqueriesGroupQuery<T> groupBy(Function<T,?>... fields)
      Description copied from interface: ValqueriesQuery
      Create a group by query.
      Specified by:
      groupBy in interface ValqueriesQuery<T>
      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

      public ValqueriesGroupQuery<T> groupBy(BiConsumer<T,?>... fields)
      Description copied from interface: ValqueriesQuery
      Create a group by query.
      Specified by:
      groupBy in interface ValqueriesQuery<T>
      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

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

    • count

      public ValqueriesGroupQuery<T> count(Function<T,?> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that counts non-NULL values of a field. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      count in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Getter of the field to count
      Returns:
      this query, for chaining

    • count

      public ValqueriesGroupQuery<T> count(BiConsumer<T,?> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that counts non-NULL values of a field.
      Specified by:
      count in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Setter of the field to count
      Returns:
      this query, for chaining

    • sum

      public ValqueriesGroupQuery<T> sum(Function<T,? extends Number> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that sums the values of a field. For Float and Double fields the result will be Double, for BigInteger and BigDecimal the result will be the same, for all other fields the result will be Long. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      sum in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Getter of the field to sum
      Returns:
      this query, for chaining

    • sum

      public ValqueriesGroupQuery<T> sum(BiConsumer<T,? extends Number> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that sums the values of a field. For Float and Double fields the result will be Double, for BigInteger and BigDecimal the result will be the same, for all other fields the result will be Long. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      sum in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Setter of the field to sum
      Returns:
      this query, for chaining

    • max

      public <X extends Comparable<? super X>> ValqueriesGroupQuery<T> max(Function<T,X> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that calculates the maximum value of a field. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      max in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Getter of the field to calculate the maximum of. (If the type is not comparable in Java, but it is comparable in the database, cast the argument to a raw type)
      Returns:
      this query, for chaining

    • max

      public <X extends Comparable<? super X>> ValqueriesGroupQuery<T> max(BiConsumer<T,X> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that calculates the maximum value of a field. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      max in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Setter of the field to calculate the maximum of. (If the type is not comparable in Java, but it is comparable in the database, cast the argument to a raw type)
      Returns:
      this query, for chaining

    • min

      public <X extends Comparable<? super X>> ValqueriesGroupQuery<T> min(Function<T,X> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that calculates the minimum value of a field. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      min in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Getter of the field to calculate the minimum of. (If the type is not comparable in Java, but it is comparable in the database, cast the argument to a raw type)
      Returns:
      this query, for chaining

    • min

      public <X extends Comparable<? super X>> ValqueriesGroupQuery<T> min(BiConsumer<T,X> field)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that calculates the minimum value of a field. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      min in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Setter of the field to calculate the minimum of. (If the type is not comparable in Java, but it is comparable in the database, cast the argument to a raw type)
      Returns:
      this query, for chaining

    • concat

      public ValqueriesGroupQuery<T> concat(Function<T,?> field, String separator)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that concatenates the values of a field as a string. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      concat in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Getter of the field to concatenate
      separator - The separator to use between values
      Returns:
      this query, for chaining

    • concat

      public ValqueriesGroupQuery<T> concat(BiConsumer<T,?> field, String separator)
      Description copied from interface: ValqueriesGroupQuery
      Add an aggregation that concatenates the values of a field as a string. The values in ValqueriesGroupResultRow.aggregationValues() will be in the order aggregations were added to the query.
      Specified by:
      concat in interface ValqueriesGroupQuery<T>
      Parameters:
      field - Setter of the field to concatenate
      separator - The separator to use between values
      Returns:
      this query, for chaining

    • distinct

      public <X> Stream<X> distinct(Function<T,X> field)
      Description copied from interface: CrudRepository.InlineQuery
      Execute the query and return all distinct values of a field that match the query.

      This is useful if you need just a single field from an object, as it will only transfer that column over the network and will only deserialize that field.

      Sorting can be used, but only on the same column that is being selected.

      This is a terminal operation. As such, the query should not be reused after this method is called.

      The resulting Stream from the operation may be a lazy stream, meaning that the results are not fetched from the database until they are accessed. As such it is important that a terminal operation is performed on the stream within a reasonable time frame to avoid holding database connections open.

      Specified by:
      distinct in interface CrudRepository.InlineQuery<T,ValqueriesQuery<T>>
      Overrides:
      distinct in class CrudRepoBaseQuery<T,ValqueriesQuery<T>>
      Type Parameters:
      X - the type of the field
      Parameters:
      field - a method reference to the getter of the field
      Returns:
      a Stream of distinct values of the field

    • selectField

      public <X> Stream<X> selectField(Function<T,X> field)
      Description copied from interface: CrudRepository.InlineQuery
      Execute the query and return all values of a field that match the query.

      This is useful if you need just a single field from an object, as it will only transfer that column over the network and will only deserialize that field.

      This is a terminal operation. As such, the query should not be reused after this method is called.

      The resulting Stream from the operation may be a lazy stream, meaning that the results are not fetched from the database until they are accessed. As such it is important that a terminal operation is performed on the stream within a reasonable time frame to avoid holding database connections open.

      Specified by:
      selectField in interface CrudRepository.InlineQuery<T,ValqueriesQuery<T>>
      Overrides:
      selectField in class CrudRepoBaseQuery<T,ValqueriesQuery<T>>
      Type Parameters:
      X - the type of the field
      Parameters:
      field - a method reference to the getter of the field
      Returns:
      a Stream of values of the field