one.microstream.util.cql

Class CQL

java.lang.Object

one.microstream.util.cql.CQL

public final class CQL
extends Object

Collection Query Library

API for fluent query syntax and query instance definition.

Method Summary

Modifier and Type	Method and Description
static <I,R> CqlAggregation<I,R>	aggregate(CqlResultor<I,R> aggregator)
static <I,R> CqlAggregation<I,R>	aggregate(Supplier<R> supplier, BiConsumer<I,R> linker)
static <I,R extends Sortable<I>> CqlAggregation<I,R>	aggregate(Supplier<R> supplier, BiConsumer<I,R> linker, Comparator<? super I> order)
static <I,R> CqlAggregation<I,R>	aggregate(Supplier<R> supplier, BiConsumer<I,R> linker, Consumer<? super R> finalizer)
static <I,R> CqlAggregation<I,R>	Aggregation()
static <E> Comparator<? super E>	chain(Comparator<? super E>... comparators)
static <T> Comparator<T>	comparing(Comparator<T> order) Helper method to make a lambda or method reference expression chainable.
static <E,T> Comparator<E>	comparing(Function<E,T> getter, Comparator<T> order)
static <E> XSequence<E>	executeQuery(XIterable<? extends E> source)
static <E,T extends Consumer<? super E>> T	executeQuery(XIterable<? extends E> source, T target)
static <I,R> R	executeQuery(XIterable<? extends I> source, Long skip, Long limit, Predicate<? super I> selector, CqlResultor<I,R> resultor, Comparator<? super I> order)
static <I,O,R> R	executeQuery(XIterable<? extends I> source, Long skip, Long limit, Predicate<? super I> selector, Function<? super I,O> projector, CqlResultor<O,R> resultor, Comparator<? super O> order)
static <I,O,P extends Consumer<O>> P	executeQuery(XIterable<? extends I> source, Long skip, Long limit, Predicate<? super I> selector, Function<? super I,O> projector, P target, Comparator<? super O> order)
static <I,P extends Consumer<? super I>> P	executeQuery(XIterable<? extends I> source, Long skip, Long limit, Predicate<? super I> selector, P target)
static <I,P extends Consumer<I>> P	executeQuery(XIterable<? extends I> source, Long skip, Long limit, Predicate<? super I> selector, P target, Comparator<? super I> order)
static <I> CqlSelection<I>	from(XIterable<? extends I> source)
static <I> Function<I,I>	identity()
static <T> boolean	isNotNull(T instance)
static <T> boolean	isNull(T instance)
static <I,O,R extends XIterable<O>> CqlIteration<I,O,R>	Iteration()
static <O> CqlResultor<O,Double>	min(To_double<? super O> getter)
static <T> Predicate<T>	not(Predicate<T> predicate) Fluent alias for predicate.negate().
static <I> XIterable<? extends I>	prepareSource(XIterable<? extends I> source)
static <I> Consumer<I>	prepareSourceIterator(Long skip, Long limit, Consumer<? super I> target)
static <I,O> Consumer<I>	prepareSourceIterator(Long skip, Long limit, Function<? super I,O> projector, Consumer<? super O> target)
static <I> Consumer<I>	prepareSourceIterator(Long skip, Long limit, Predicate<? super I> selector, Consumer<? super I> target)
static <I,O> Consumer<I>	prepareSourceIterator(Long skip, Long limit, Predicate<? super I> selector, Function<? super I,O> projector, Consumer<? super O> target)
static <E> XSequence<E>	prepareTargetCollection(XIterable<?> source)
static <I,O> CqlProjection<I,O>	project(Function<? super I,O> projector)
static <I> CqlProjection<I,Object[]>	project(Function<? super I,Object>... projectors)
static <I,O> CqlProjection<I,O>	Projection()
static <I,O,R> CqlQuery<I,O,R>	Query()
static <O,T extends Consumer<O>> CqlResultor<O,T>	resulting(Supplier<T> supplier)
static <O> CqlResultor<O,BulkList<O>>	resultingBulkList()
static <O> CqlResultor<O,BulkList<O>>	resultingBulkList(int initialCapacity)
static <O> CqlResultor<O,EqHashEnum<O>>	resultingEqHashEnum()
static <O> CqlResultor<O,EqHashEnum<O>>	resultingEqHashEnum(HashEqualator<? super O> hashEqualator)
static <K,V> CqlResultor<KeyValue<K,V>,EqHashTable<K,V>>	resultingEqHashTable()
static <K,V> CqlResultor<KeyValue<K,V>,EqHashTable<K,V>>	resultingEqHashTable(HashEqualator<? super K> hashEqualator)
static <O> CqlResultor<O,HashEnum<O>>	resultingHashEnum()
static <K,V> CqlResultor<KeyValue<K,V>,HashTable<K,V>>	resultingHashTable()
static <O,T extends Consumer<O> & XIterable<O>> CqlResultor<O,T>	resultingIterable(Supplier<T> supplier)
static <O> CqlResultor<O,LimitList<O>>	resultingLimitList(int initialCapacity)
static <T> Comparator<T>	reversed(Comparator<T> order) Fluent alias for Comparator#reversed()
static <I> CqlSelection<I>	select(Predicate<? super I> predicate)
static <I> CqlSelection<I>	Selection()
static <O> CqlResultor<O,Double>	sum(To_double<? super O> getter)
static <I> CqlTransfer<I,XSequence<I>>	Transfer()
static <T> Predicate<T>	where(Predicate<T> predicate) Helper method to make a lambda or method reference expression chainable.

Methods inherited from class java.lang.Object

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

Method Detail

Selection

public static <I> CqlSelection<I> Selection()

Transfer

public static <I> CqlTransfer<I,XSequence<I>> Transfer()

Aggregation

public static <I,R> CqlAggregation<I,R> Aggregation()

Projection

public static <I,O> CqlProjection<I,O> Projection()

Iteration

public static <I,O,R extends XIterable<O>> CqlIteration<I,O,R> Iteration()

Query

public static <I,O,R> CqlQuery<I,O,R> Query()

isNotNull

public static <T> boolean isNotNull(T instance)

isNull

public static <T> boolean isNull(T instance)

select

public static <I> CqlSelection<I> select(Predicate<? super I> predicate)

aggregate

public static <I,R> CqlAggregation<I,R> aggregate(CqlResultor<I,R> aggregator)

aggregate

public static <I,R> CqlAggregation<I,R> aggregate(Supplier<R> supplier,
                                                  BiConsumer<I,R> linker)

aggregate

public static <I,R extends Sortable<I>> CqlAggregation<I,R> aggregate(Supplier<R> supplier,
                                                                      BiConsumer<I,R> linker,
                                                                      Comparator<? super I> order)

aggregate

public static <I,R> CqlAggregation<I,R> aggregate(Supplier<R> supplier,
                                                  BiConsumer<I,R> linker,
                                                  Consumer<? super R> finalizer)

from

public static <I> CqlSelection<I> from(XIterable<? extends I> source)

project

public static <I,O> CqlProjection<I,O> project(Function<? super I,O> projector)

project

@SafeVarargs
public static <I> CqlProjection<I,Object[]> project(Function<? super I,Object>... projectors)

not

public static <T> Predicate<T> not(Predicate<T> predicate)

Fluent alias for predicate.negate().

Type Parameters:

T - the type of the input to the predicate

Parameters:

predicate - the predicate to negate

Returns:

the negated predicate

where

public static <T> Predicate<T> where(Predicate<T> predicate)

Helper method to make a lambda or method reference expression chainable. They somehow forgot that in the lambda language extension, so it has to be worked around, sadly.

Type Parameters:

T - the type of the input to the predicate

Parameters:

predicate - the condiation

Returns:

the given predicate

reversed

public static <T> Comparator<T> reversed(Comparator<T> order)

Fluent alias for Comparator#reversed()

Type Parameters:

T - the type of objects that may be compared by this comparator

Parameters:

order - the comparator the be reversed

Returns:

the reversed comparator

comparing

public static <T> Comparator<T> comparing(Comparator<T> order)

Helper method to make a lambda or method reference expression chainable. They somehow forgot that in the lambda language extension, so it has to be worked around, sadly.

Type Parameters:

T - the type of objects that may be compared by this comparator

Parameters:

order - the comparator

Returns:

the given comparator

comparing

public static <E,T> Comparator<E> comparing(Function<E,T> getter,
                                            Comparator<T> order)

identity

public static <I> Function<I,I> identity()

prepareSource

public static <I> XIterable<? extends I> prepareSource(XIterable<? extends I> source)

prepareTargetCollection

public static <E> XSequence<E> prepareTargetCollection(XIterable<?> source)

prepareSourceIterator

public static <I> Consumer<I> prepareSourceIterator(Long skip,
                                                    Long limit,
                                                    Predicate<? super I> selector,
                                                    Consumer<? super I> target)

prepareSourceIterator

public static <I> Consumer<I> prepareSourceIterator(Long skip,
                                                    Long limit,
                                                    Consumer<? super I> target)

prepareSourceIterator

public static <I,O> Consumer<I> prepareSourceIterator(Long skip,
                                                      Long limit,
                                                      Predicate<? super I> selector,
                                                      Function<? super I,O> projector,
                                                      Consumer<? super O> target)

prepareSourceIterator

public static <I,O> Consumer<I> prepareSourceIterator(Long skip,
                                                      Long limit,
                                                      Function<? super I,O> projector,
                                                      Consumer<? super O> target)

executeQuery

public static <E> XSequence<E> executeQuery(XIterable<? extends E> source)

executeQuery

public static <E,T extends Consumer<? super E>> T executeQuery(XIterable<? extends E> source,
                                                               T target)

executeQuery

public static <I,P extends Consumer<? super I>> P executeQuery(XIterable<? extends I> source,
                                                               Long skip,
                                                               Long limit,
                                                               Predicate<? super I> selector,
                                                               P target)

executeQuery

public static <I,P extends Consumer<I>> P executeQuery(XIterable<? extends I> source,
                                                       Long skip,
                                                       Long limit,
                                                       Predicate<? super I> selector,
                                                       P target,
                                                       Comparator<? super I> order)

executeQuery

public static <I,R> R executeQuery(XIterable<? extends I> source,
                                   Long skip,
                                   Long limit,
                                   Predicate<? super I> selector,
                                   CqlResultor<I,R> resultor,
                                   Comparator<? super I> order)

executeQuery

public static <I,O,R> R executeQuery(XIterable<? extends I> source,
                                     Long skip,
                                     Long limit,
                                     Predicate<? super I> selector,
                                     Function<? super I,O> projector,
                                     CqlResultor<O,R> resultor,
                                     Comparator<? super O> order)

executeQuery

public static <I,O,P extends Consumer<O>> P executeQuery(XIterable<? extends I> source,
                                                         Long skip,
                                                         Long limit,
                                                         Predicate<? super I> selector,
                                                         Function<? super I,O> projector,
                                                         P target,
                                                         Comparator<? super O> order)

resulting

public static <O,T extends Consumer<O>> CqlResultor<O,T> resulting(Supplier<T> supplier)

resultingIterable

public static <O,T extends Consumer<O> & XIterable<O>> CqlResultor<O,T> resultingIterable(Supplier<T> supplier)

resultingBulkList

public static <O> CqlResultor<O,BulkList<O>> resultingBulkList()

resultingBulkList

public static <O> CqlResultor<O,BulkList<O>> resultingBulkList(int initialCapacity)

resultingLimitList

public static <O> CqlResultor<O,LimitList<O>> resultingLimitList(int initialCapacity)

resultingHashEnum

public static <O> CqlResultor<O,HashEnum<O>> resultingHashEnum()

resultingEqHashEnum

public static <O> CqlResultor<O,EqHashEnum<O>> resultingEqHashEnum()

resultingEqHashEnum

public static <O> CqlResultor<O,EqHashEnum<O>> resultingEqHashEnum(HashEqualator<? super O> hashEqualator)

resultingHashTable

public static <K,V> CqlResultor<KeyValue<K,V>,HashTable<K,V>> resultingHashTable()

resultingEqHashTable

public static <K,V> CqlResultor<KeyValue<K,V>,EqHashTable<K,V>> resultingEqHashTable()

resultingEqHashTable

public static <K,V> CqlResultor<KeyValue<K,V>,EqHashTable<K,V>> resultingEqHashTable(HashEqualator<? super K> hashEqualator)

sum

public static <O> CqlResultor<O,Double> sum(To_double<? super O> getter)

min

public static <O> CqlResultor<O,Double> min(To_double<? super O> getter)

chain

@SafeVarargs
public static final <E> Comparator<? super E> chain(Comparator<? super E>... comparators)