org.immutables.criteria.repository.sync

Class SyncReader<T>

java.lang.Object

org.immutables.criteria.repository.AbstractReader<SyncReader<T>>

org.immutables.criteria.repository.sync.SyncReader<T>

Type Parameters:

T - entity type

All Implemented Interfaces:

Fetcher<T>, Reader<SyncReader<T>>, SyncFetcher<T>, SyncFetcher.LimitOffset<T>, SyncFetcher.Offset<T>

public class SyncReader<T>
extends AbstractReader<SyncReader<T>>
implements SyncFetcher.LimitOffset<T>

Nested Class Summary

Nested classes/interfaces inherited from interface org.immutables.criteria.repository.sync.SyncFetcher

SyncFetcher.DistinctLimitOffset<T>, SyncFetcher.LimitOffset<T>, SyncFetcher.Offset<T>

Constructor Summary

Constructors

Constructor and Description
SyncReader(Query query, Backend.Session session)

Method Summary

Modifier and Type	Method and Description
long	count()
boolean	exists()
List<T>	fetch()
SyncFetcher.Offset<T>	limit(long limit)
protected SyncReader<T>	newReader(Query query)
SyncFetcher<T>	offset(long offset)
T	one()
Optional<T>	oneOrNone()
SyncMapperTuple.DistinctLimitOffset	select(Iterable<Projection<?>> projections)
<T1> SyncMapper1.DistinctLimitOffset<T1>	select(Projection<T1> proj1)
<T1,T2> SyncMapper2.DistinctLimitOffset<T1,T2>	select(Projection<T1> proj1, Projection<T2> proj2)
<T1,T2,T3> SyncMapper3.DistinctLimitOffset<T1,T2,T3>	select(Projection<T1> proj1, Projection<T2> proj2, Projection<T3> proj3)
<T1,T2,T3,T4> SyncMapper4.DistinctLimitOffset<T1,T2,T3,T4>	select(Projection<T1> proj1, Projection<T2> proj2, Projection<T3> proj3, Projection<T4> proj4)
<T1,T2,T3,T4,T5> SyncMapper5.DistinctLimitOffset<T1,T2,T3,T4,T5>	select(Projection<T1> proj1, Projection<T2> proj2, Projection<T3> proj3, Projection<T4> proj4, Projection<T5> proj5)

Methods inherited from class org.immutables.criteria.repository.AbstractReader

groupBy, orderBy

Methods inherited from class java.lang.Object

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

Constructor Detail

SyncReader

public SyncReader(Query query,
                  Backend.Session session)

Method Detail

newReader

protected SyncReader<T> newReader(Query query)

select

public <T1> SyncMapper1.DistinctLimitOffset<T1> select(Projection<T1> proj1)

select

public <T1,T2> SyncMapper2.DistinctLimitOffset<T1,T2> select(Projection<T1> proj1,
                                                             Projection<T2> proj2)

select

public <T1,T2,T3> SyncMapper3.DistinctLimitOffset<T1,T2,T3> select(Projection<T1> proj1,
                                                                   Projection<T2> proj2,
                                                                   Projection<T3> proj3)

select

public <T1,T2,T3,T4> SyncMapper4.DistinctLimitOffset<T1,T2,T3,T4> select(Projection<T1> proj1,
                                                                         Projection<T2> proj2,
                                                                         Projection<T3> proj3,
                                                                         Projection<T4> proj4)

select

public <T1,T2,T3,T4,T5> SyncMapper5.DistinctLimitOffset<T1,T2,T3,T4,T5> select(Projection<T1> proj1,
                                                                               Projection<T2> proj2,
                                                                               Projection<T3> proj3,
                                                                               Projection<T4> proj4,
                                                                               Projection<T5> proj5)

select

public SyncMapperTuple.DistinctLimitOffset select(Iterable<Projection<?>> projections)

fetch

public List<T> fetch()

one

public T one()

oneOrNone

public Optional<T> oneOrNone()

exists

public boolean exists()

count

public long count()

limit

public SyncFetcher.Offset<T> limit(long limit)

offset

public SyncFetcher<T> offset(long offset)