QueryJinqStream (Jinq API 1.6.2 API)

java.lang.Object
- org.jinq.orm.stream.LazyWrappedStream<T>
- - org.jinq.orm.stream.NonQueryJinqStream<T>
 - - org.jinq.orm.stream.QueryJinqStream<T>

All Implemented Interfaces:

AutoCloseable, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.util.stream.Stream<T>, JinqStream<T>
```
public class QueryJinqStream<T>
extends NonQueryJinqStream<T>
implements JinqStream<T>
```

Nested Class Summary
- Nested classes/interfaces inherited from class org.jinq.orm.stream.NonQueryJinqStream
 NonQueryJinqStream.IteratorTee<T>
- Nested classes/interfaces inherited from interface org.jinq.orm.stream.JinqStream
 JinqStream.AggregateGroup<W,U,V>, JinqStream.AggregateSelect<U,V>, JinqStream.CollectBigDecimal, JinqStream.CollectBigInteger, JinqStream.CollectComparable<U,V extends Comparable<V>>, JinqStream.CollectDouble, JinqStream.CollectInteger, JinqStream.CollectLong, JinqStream.CollectNumber<U,V extends Number & Comparable<V>>, JinqStream.Join<U,V>, JinqStream.JoinToIterable<U,V>, JinqStream.JoinWithSource<U,V>, JinqStream.Select<U,V>, JinqStream.SelectWithSource<U,V>, JinqStream.Where<U,E extends Exception>, JinqStream.WhereWithSource<U,E extends Exception>
- Nested classes/interfaces inherited from interface java.util.stream.Stream
 java.util.stream.Stream.Builder<T>

Field Summary
- Fields inherited from class org.jinq.orm.stream.NonQueryJinqStream
  inQueryStreamSource, recordedExceptions

Constructor Summary

Constructors
Constructor and Description

QueryJinqStream(QueryComposer<T> query)

QueryJinqStream(QueryComposer<T> query, InQueryStreamSource inQueryStreamSource)

Constructors
Constructor and Description
`QueryJinqStream(QueryComposer<T> query)`
`QueryJinqStream(QueryComposer<T> query, InQueryStreamSource inQueryStreamSource)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<V extends Number & Comparable<V>> Double`	`avg(JinqStream.CollectNumber<T,V> aggregate)` Finds the average of the elements of a stream.
`long`	`count()` Counts the elements in the stream.
`protected java.util.stream.Stream<T>`	`createWrappedStream()`
`JinqStream<T>`	`distinct()`
`String`	`getDebugQueryString()` Returns the query that Jinq will send to the database to generate the values of the stream.
`protected <U,W extends Tuple> JinqStream<W>`	`groupToTuple(JinqStream.Select<T,U> select, JinqStream.AggregateGroup<U,T,?>[] aggregates)`
`<U> JinqStream<Pair<T,U>>`	`join(JinqStream.Join<T,U> join)` Pairs up each entry of the stream with a stream of related elements.
`<U> JinqStream<Pair<T,U>>`	`join(JinqStream.JoinWithSource<T,U> join)` Pairs up each entry of the stream with a stream of related elements.
`<U> JinqStream<Pair<T,U>>`	`joinList(JinqStream.JoinToIterable<T,U> join)` A variant of join() that can be used if you want to join to a collection without the trouble of converting it to a JinqStream first.
`<U> JinqStream<Pair<T,U>>`	`leftOuterJoin(JinqStream.Join<T,U> join)` Pairs up each entry of the stream with a stream of related elements.
`<U> JinqStream<Pair<T,U>>`	`leftOuterJoinList(JinqStream.JoinToIterable<T,U> join)` A variant of leftOuterJoin() that can be used if you want to join to a collection without the trouble of converting it to a JinqStream first.
`JinqStream<T>`	`limit(long n)`
`protected <U> JinqStream<U>`	`makeQueryStream(QueryComposer<U> query, InQueryStreamSource inQueryStreamSource)`
`<V extends Comparable<V>> V`	`max(JinqStream.CollectComparable<T,V> aggregate)` Finds the largest or maximum element of a stream.
`<V extends Comparable<V>> V`	`min(JinqStream.CollectComparable<T,V> aggregate)` Finds the smallest or minimum element of a stream.
`<U> JinqStream<U>`	`select(JinqStream.Select<T,U> select)` Transforms the elements in the stream.
`<U> JinqStream<U>`	`select(JinqStream.SelectWithSource<T,U> select)` Transforms the elements in the stream.
`<U> JinqStream<U>`	`selectAll(JinqStream.Join<T,U> select)` Transforms the elements in the stream.
`<U> JinqStream<U>`	`selectAll(JinqStream.JoinWithSource<T,U> select)` Transforms the elements in the stream.
`<U> JinqStream<U>`	`selectAllList(JinqStream.JoinToIterable<T,U> select)` A variant of selectAll() that can be used if you want to join to a collection without the trouble of converting it to a JinqStream first.
`JinqStream<T>`	`setHint(String name, Object value)` Sets a hint on the stream for how the query should be executed
`JinqStream<T>`	`skip(long n)`
`<V extends Comparable<V>> JinqStream<T>`	`sortedBy(JinqStream.CollectComparable<T,V> sorter)` Sorts the elements of a stream in ascending order based on the value returned.
`<V extends Comparable<V>> JinqStream<T>`	`sortedDescendingBy(JinqStream.CollectComparable<T,V> sorter)` Sorts the elements of a stream in descending order based on the value returned.
`BigDecimal`	`sumBigDecimal(JinqStream.CollectBigDecimal<T> aggregate)`
`BigInteger`	`sumBigInteger(JinqStream.CollectBigInteger<T> aggregate)`
`Double`	`sumDouble(JinqStream.CollectDouble<T> aggregate)`
`Long`	`sumInteger(JinqStream.CollectInteger<T> aggregate)` Calculates a sum over the elements of a stream.
`Long`	`sumLong(JinqStream.CollectLong<T> aggregate)`
`<E extends Exception> JinqStream<T>`	`where(JinqStream.Where<T,E> test)` Filters the elements of the stream.
`<E extends Exception> JinqStream<T>`	`where(JinqStream.WhereWithSource<T,E> test)` Filters the elements of the stream.

Methods inherited from class org.jinq.orm.stream.NonQueryJinqStream
aggregate, aggregate, aggregate, aggregate, getExceptions, getOnlyValue, group, group, group, group, propagateException, toList, wrap

Methods inherited from class org.jinq.orm.stream.LazyWrappedStream
allMatch, anyMatch, close, collect, collect, filter, findAny, findFirst, flatMap, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, isParallel, iterator, map, mapToDouble, mapToInt, mapToLong, max, min, noneMatch, onClose, parallel, peek, realizeStream, reduce, reduce, reduce, sequential, sorted, sorted, spliterator, toArray, toArray, unordered

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.jinq.orm.stream.JinqStream
aggregate, aggregate, aggregate, aggregate, from, getExceptions, getOnlyValue, group, group, group, group, of, propagateException, toList

Methods inherited from interface java.util.stream.Stream
allMatch, anyMatch, builder, collect, collect, concat, empty, filter, findAny, findFirst, flatMap, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, generate, iterate, map, mapToDouble, mapToInt, mapToLong, max, min, noneMatch, peek, reduce, reduce, reduce, sorted, sorted, toArray, toArray

Methods inherited from interface java.util.stream.BaseStream
close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

- Constructor Detail
 - QueryJinqStream
```
public QueryJinqStream(QueryComposer<T> query)
```
 - QueryJinqStream
```
public QueryJinqStream(QueryComposer<T> query,
 InQueryStreamSource inQueryStreamSource)
```
- Method Detail
 - makeQueryStream
```
protected  JinqStream makeQueryStream(QueryComposer query,
 InQueryStreamSource inQueryStreamSource)
```
 - createWrappedStream
```
protected java.util.stream.Stream<T> createWrappedStream()
```
 Overrides:
 
 createWrappedStream in class LazyWrappedStream<T>
 - where
```
public <E extends Exception> JinqStream<T> where(JinqStream.Where<T,E> test)
```
 Description copied from interface: JinqStream
 Filters the elements of the stream.
```
 JinqStream<Customer> stream = ...;
 JinqStream<Customer> result = stream.where(c -> c.getName().equals("Alice"));
 
 
```
 Specified by:
 
 where in interface JinqStream<T>
 
 Overrides:
 
 where in class NonQueryJinqStream<T>
 
 Parameters:
 
 test - function applied to the elements of the stream. When passed an element from the stream, the function should return true if the element should be kept. if the function returns false, the element is discarded.
 
 Returns:
 
 a new stream that returns only the elements satisfying the filter
 - where
```
public <E extends Exception> JinqStream<T> where(JinqStream.WhereWithSource<T,E> test)
```
 Description copied from interface: JinqStream
 
 Filters the elements of the stream. This version allows the filter function to take a second parameter with an InQueryStreamSource. This lets the function create new streams of elements that it can use in subqueries.
 
 Specified by:
 
 where in interface JinqStream<T>
 
 Overrides:
 
 where in class NonQueryJinqStream<T>
 
 Parameters:
 
 test - function applied to each element of the stream. The function is passed an element from the stream as well as an InQueryStreamSource. The function should return true if the element should be kept. if the function returns false, the element is discarded.
 
 Returns:
 
 a new stream that returns only the elements satisfying the filter
 
 See Also:
 
 JinqStream.where(Where)
 - select
```
public  JinqStream select(JinqStream.Select<T,U> select)
```
 Description copied from interface: JinqStream
 Transforms the elements in the stream. The method allows you to rewrite each element from the stream, so that they contain only certain fields or to do some calculation based on the values of the fields.
```
 JinqStream<Customer> stream = ...;
 JinqStream<String> result = stream.select(c -> c.getName());
 
 
```
 Specified by:
 
 select in interface JinqStream<T>
 
 Overrides:
 
 select in class NonQueryJinqStream<T>
 
 Parameters:
 
 select - function applied to the elements of the stream. When passed an element from the stream, the function should return a new value that should be used instead of the element in the stream.
 
 Returns:
 
 a new stream that uses only the new rewritten stream elements
 - select
```
public  JinqStream select(JinqStream.SelectWithSource<T,U> select)
```
 Description copied from interface: JinqStream
 
 Transforms the elements in the stream. This version also passes an InQueryStreamSource to the select function so that the function can create new streams of elements to use in subqueries.
 
 Specified by:
 
 select in interface JinqStream<T>
 
 Overrides:
 
 select in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.select(Select)
 - selectAll
```
public  JinqStream selectAll(JinqStream.Join<T,U> select)
```
 Description copied from interface: JinqStream
 Transforms the elements in the stream. The method allows you to rewrite each element from the stream, so that they contain only certain fields or to do some calculation based on the values of the fields. Unlike a normal select(), this method allows you to return a stream of elements. The stream elements will all be added to the final stream.
```
 JinqStream<Country> stream = ...;
 JinqStream<City> result = stream.selectAll(c -> JinqStream.from(c.getCities()));
 
 
```
 Specified by:
 
 selectAll in interface JinqStream<T>
 
 Overrides:
 
 selectAll in class NonQueryJinqStream<T>
 
 Parameters:
 
 select - function applied to the elements of the stream. When passed an element from the stream, the function should return a stream of new values that will be flattened and placed in the new stream
 
 Returns:
 
 a new stream that uses only the new rewritten stream elements
 
 See Also:
 
 JinqStream.select(Select)
 - selectAll
```
public  JinqStream selectAll(JinqStream.JoinWithSource<T,U> select)
```
 Description copied from interface: JinqStream
 
 Transforms the elements in the stream. This version also passes an InQueryStreamSource to the select function so that the function can create new streams of elements to use in subqueries.
 
 Specified by:
 
 selectAll in interface JinqStream<T>
 
 Overrides:
 
 selectAll in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.selectAll(Join)
 - selectAllList
```
public  JinqStream selectAllList(JinqStream.JoinToIterable<T,U> select)
```
 Description copied from interface: JinqStream
 A variant of selectAll() that can be used if you want to join to a collection without the trouble of converting it to a JinqStream first.
```
 JinqStream<Country> stream = ...;
 JinqStream<City> result = stream.selectAll(c -> c.getCities());
 
 
```
 Specified by:
 
 selectAllList in interface JinqStream<T>
 
 Overrides:
 
 selectAllList in class NonQueryJinqStream<T>
 
 Parameters:
 
 select - function applied to the elements of the stream. When passed an element from the stream, the function should return a collection of new values that will be flattened and placed in the new stream
 
 Returns:
 
 a new stream that uses only the new rewritten stream elements
 
 See Also:
 
 JinqStream.selectAll(Join)
 - join
```
public  JinqStream<Pair<T,U>> join(JinqStream.Join<T,U> join)
```
 Description copied from interface: JinqStream
 Pairs up each entry of the stream with a stream of related elements.
```
 JinqStream<Country> stream = ...;
 JinqStream<Pair<Country, City>> result = 
 stream.join(c -> JinqStream.from(c.getCities()));
 
 
```
 Specified by:
 
 join in interface JinqStream<T>
 
 Overrides:
 
 join in class NonQueryJinqStream<T>
 
 Parameters:
 
 join - function applied to the elements of the stream. When passed an element from the stream, the function should return a stream of values that should be paired up with that stream element.
 
 Returns:
 
 a new stream with the paired up elements
 - join
```
public  JinqStream<Pair<T,U>> join(JinqStream.JoinWithSource<T,U> join)
```
 Description copied from interface: JinqStream
 
 Pairs up each entry of the stream with a stream of related elements. This version also passes an InQueryStreamSource to the join function so that the function can join elements with unrelated streams of entities from a database.
 
 Specified by:
 
 join in interface JinqStream<T>
 
 Overrides:
 
 join in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.join(Join)
 - joinList
```
public  JinqStream<Pair<T,U>> joinList(JinqStream.JoinToIterable<T,U> join)
```
 Description copied from interface: JinqStream
 
 A variant of join() that can be used if you want to join to a collection without the trouble of converting it to a JinqStream first.
 
 Specified by:
 
 joinList in interface JinqStream<T>
 
 Overrides:
 
 joinList in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.join(Join)
 - leftOuterJoin
```
public  JinqStream<Pair<T,U>> leftOuterJoin(JinqStream.Join<T,U> join)
```
 Description copied from interface: JinqStream
 Pairs up each entry of the stream with a stream of related elements. Uses a left outer join during the pairing up process, so even if an element is not joined with anything, a pair will still be created in the output stream consisting of the element paired with null.
```
 JinqStream<Country> stream = ...;
 JinqStream<Pair<Country, Mountain>> result = 
 stream.leftOuterJoin(c -> JinqStream.from(c.getMountain()));
 JinqStream<Pair<Country, Mountain>> result = 
 stream.leftOuterJoin(c -> JinqStream.of(c.getHighestMountain()));
 
 
```
 Specified by:
 
 leftOuterJoin in interface JinqStream<T>
 
 Overrides:
 
 leftOuterJoin in class NonQueryJinqStream<T>
 
 Parameters:
 
 join - function applied to the elements of the stream. When passed an element from the stream, the function should return a stream of values that should be paired up with that stream element. The function must use a JPA association or navigational link as the base for the stream returned. Both singular or plural associations are allowed.
 
 Returns:
 
 a new stream with the paired up elements
 
 See Also:
 
 JinqStream.join(Join)
 - leftOuterJoinList
```
public  JinqStream<Pair<T,U>> leftOuterJoinList(JinqStream.JoinToIterable<T,U> join)
```
 Description copied from interface: JinqStream
 
 A variant of leftOuterJoin() that can be used if you want to join to a collection without the trouble of converting it to a JinqStream first.
 
 Specified by:
 
 leftOuterJoinList in interface JinqStream<T>
 
 Overrides:
 
 leftOuterJoinList in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.leftOuterJoin(Join)
 - groupToTuple
```
protected <U,W extends Tuple> JinqStream<W> groupToTuple(JinqStream.Select<T,U> select,
 JinqStream.AggregateGroup<U,T,?>[] aggregates)
```
 Overrides:
 
 groupToTuple in class NonQueryJinqStream<T>
 - count
```
public long count()
```
 Description copied from interface: JinqStream
 
 Counts the elements in the stream. If the stream contains only a single field of data (i.e. not a tuple) as derived from a database query, then the count will be of non-NULL elements only. If the stream contains more than one field of data (i.e. a tuple) or if the stream is streaming in-memory data, then the count will include NULL values.
 
 Specified by:
 
 count in interface java.util.stream.Stream<T>
 
 Specified by:
 
 count in interface JinqStream<T>
 
 Overrides:
 
 count in class LazyWrappedStream<T>
 
 See Also:
 
 Stream.count()
 - sumInteger
```
public Long sumInteger(JinqStream.CollectInteger<T> aggregate)
```
 Description copied from interface: JinqStream
 Calculates a sum over the elements of a stream. Different sum methods are provided for calculating the sum of integer, long, double, BigDecimal, and BigInteger values.
```
 JinqStream<City> stream = ...;
 long totalPopulation = stream.sumInteger(c -> c.getPopulation()); 
 
 
```
 Specified by:
 
 sumInteger in interface JinqStream<T>
 
 Overrides:
 
 sumInteger in class NonQueryJinqStream<T>
 
 Parameters:
 
 aggregate - function applied to each element of the stream. When passed an element of the stream, it should return the value that should be added to the sum.
 
 Returns:
 
 the sum of the values returned by the function
 - sumLong
```
public Long sumLong(JinqStream.CollectLong<T> aggregate)
```
 Specified by:
 
 sumLong in interface JinqStream<T>
 
 Overrides:
 
 sumLong in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.sumInteger(CollectInteger)
 - sumDouble
```
public Double sumDouble(JinqStream.CollectDouble<T> aggregate)
```
 Specified by:
 
 sumDouble in interface JinqStream<T>
 
 Overrides:
 
 sumDouble in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.sumInteger(CollectInteger)
 - sumBigDecimal
```
public BigDecimal sumBigDecimal(JinqStream.CollectBigDecimal<T> aggregate)
```
 Specified by:
 
 sumBigDecimal in interface JinqStream<T>
 
 Overrides:
 
 sumBigDecimal in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.sumInteger(CollectInteger)
 - sumBigInteger
```
public BigInteger sumBigInteger(JinqStream.CollectBigInteger<T> aggregate)
```
 Specified by:
 
 sumBigInteger in interface JinqStream<T>
 
 Overrides:
 
 sumBigInteger in class NonQueryJinqStream<T>
 
 See Also:
 
 JinqStream.sumInteger(CollectInteger)
 - max
```
public <V extends Comparable<V>> V max(JinqStream.CollectComparable<T,V> aggregate)
```
 Description copied from interface: JinqStream
 Finds the largest or maximum element of a stream.
```
 JinqStream<Student> stream = ...;
 Date birthdayOfYoungest = stream.max(s -> s.getBirthday()); 
 
 
```
 Specified by:
 
 max in interface JinqStream<T>
 
 Overrides:
 
 max in class NonQueryJinqStream<T>
 
 Parameters:
 
 aggregate - function applied to each element of the stream. When passed an element of the stream, it should return the value that should be compared.
 
 Returns:
 
 the maximum of the values returned by the function
 - min
```
public <V extends Comparable<V>> V min(JinqStream.CollectComparable<T,V> aggregate)
```
 Description copied from interface: JinqStream
 Finds the smallest or minimum element of a stream.
```
 JinqStream<Student> stream = ...;
 Date birthdayOfOldest = stream.min(s -> s.getBirthday()); 
 
 
```
 Specified by:
 
 min in interface JinqStream<T>
 
 Overrides:
 
 min in class NonQueryJinqStream<T>
 
 Parameters:
 
 aggregate - function applied to each element of the stream. When passed an element of the stream, it should return the value that should be compared.
 
 Returns:
 
 the minimum of the values returned by the function
 
 See Also:
 
 JinqStream.max(CollectComparable)
 - avg
```
public <V extends Number & Comparable<V>> Double avg(JinqStream.CollectNumber<T,V> aggregate)
```
 Description copied from interface: JinqStream
 Finds the average of the elements of a stream.
```
 JinqStream<Student> stream = ...;
 double averageAge = stream.avg(s -> s.getage()); 
 
 
```
 Specified by:
 
 avg in interface JinqStream<T>
 
 Overrides:
 
 avg in class NonQueryJinqStream<T>
 
 Parameters:
 
 aggregate - function applied to each element of the stream. When passed an element of the stream, it should return the value that should be included in the average
 
 Returns:
 
 the average of the values returned by the function
 - sortedBy
```
public <V extends Comparable<V>> JinqStream<T> sortedBy(JinqStream.CollectComparable<T,V> sorter)
```
 Description copied from interface: JinqStream
 
 Sorts the elements of a stream in ascending order based on the value returned. The sort is stable, so it is possible to sort the stream multiple times in order to have multiple sort keys. The last sort becomes the primary sort key, and earlier sorts become lesser keys.
 
 Specified by:
 
 sortedBy in interface JinqStream<T>
 
 Overrides:
 
 sortedBy in class NonQueryJinqStream<T>
 
 Parameters:
 
 sorter - function applied to each element of the stream. When passed an element of the stream, it should return the value that should be used as the sorting value of the element
 
 Returns:
 
 sorted stream
 - sortedDescendingBy
```
public <V extends Comparable<V>> JinqStream<T> sortedDescendingBy(JinqStream.CollectComparable<T,V> sorter)
```
 Description copied from interface: JinqStream
 
 Sorts the elements of a stream in descending order based on the value returned.
 
 Specified by:
 
 sortedDescendingBy in interface JinqStream<T>
 
 Overrides:
 
 sortedDescendingBy in class NonQueryJinqStream<T>
 
 Parameters:
 
 sorter - function applied to each element of the stream. When passed an element of the stream, it should return the value that should be used as the sorting value of the element
 
 Returns:
 
 sorted stream
 
 See Also:
 
 JinqStream.sortedBy(CollectComparable)
 - limit
```
public JinqStream<T> limit(long n)
```
 Specified by:
 
 limit in interface java.util.stream.Stream<T>
 
 Specified by:
 
 limit in interface JinqStream<T>
 
 Overrides:
 
 limit in class NonQueryJinqStream<T>
 - skip
```
public JinqStream<T> skip(long n)
```
 Specified by:
 
 skip in interface java.util.stream.Stream<T>
 
 Specified by:
 
 skip in interface JinqStream<T>
 
 Overrides:
 
 skip in class NonQueryJinqStream<T>
 - distinct
```
public JinqStream<T> distinct()
```
 Specified by:
 
 distinct in interface java.util.stream.Stream<T>
 
 Specified by:
 
 distinct in interface JinqStream<T>
 
 Overrides:
 
 distinct in class NonQueryJinqStream<T>
 - getDebugQueryString
```
public String getDebugQueryString()
```
 Description copied from interface: JinqStream
 
 Returns the query that Jinq will send to the database to generate the values of the stream.
 
 Specified by:
 
 getDebugQueryString in interface JinqStream<T>
 
 Overrides:
 
 getDebugQueryString in class NonQueryJinqStream<T>
 
 Returns:
 
 the database query string or null if Jinq cannot find a database query equivalent to the contents of the stream.
 - setHint
```
public JinqStream<T> setHint(String name,
 Object value)
```
 Description copied from interface: JinqStream
 
 Sets a hint on the stream for how the query should be executed
 
 Specified by:
 
 setHint in interface JinqStream<T>
 
 Overrides:
 
 setHint in class NonQueryJinqStream<T>
 
 Parameters:
 
 name - name of the hint to change
 
 value - value to assign to the hint
 
 Returns:
 
 a pointer to the stream, to make it easier to chain method calls on the stream

Class QueryJinqStream<T>

Nested Class Summary

Nested classes/interfaces inherited from class org.jinq.orm.stream.NonQueryJinqStream

Nested classes/interfaces inherited from interface org.jinq.orm.stream.JinqStream

Nested classes/interfaces inherited from interface java.util.stream.Stream

Field Summary

Fields inherited from class org.jinq.orm.stream.NonQueryJinqStream

Constructor Summary

Method Summary

Methods inherited from class org.jinq.orm.stream.NonQueryJinqStream

Methods inherited from class org.jinq.orm.stream.LazyWrappedStream

Methods inherited from class java.lang.Object

Methods inherited from interface org.jinq.orm.stream.JinqStream

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface java.util.stream.BaseStream

Constructor Detail

QueryJinqStream

QueryJinqStream

Method Detail

makeQueryStream

createWrappedStream

where

where

select

select

selectAll

selectAll

selectAllList

join

join

joinList

leftOuterJoin

leftOuterJoinList

groupToTuple

count

sumInteger

sumLong

sumDouble

sumBigDecimal

sumBigInteger

max

min

avg

sortedBy

sortedDescendingBy

limit

skip

distinct

getDebugQueryString

setHint