Type Parameters:

T - Element type

All Known Implementing Classes:

QueryableRecorder, QueryableRelBuilder
```
public interface QueryableFactory<T>
```
Factory for building Queryable objects.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`T`	`aggregate(Queryable<T> source, FunctionExpression<Function2<T,T,T>> selector)`	Applies an accumulator function over a sequence.
`<TAccumulate> TAccumulate`	`aggregate(Queryable<T> source, TAccumulate seed, FunctionExpression<Function2<TAccumulate,T,TAccumulate>> selector)`	Applies an accumulator function over a sequence.
`<TAccumulate,TResult> TResult`	`aggregate(Queryable<T> source, TAccumulate seed, FunctionExpression<Function2<TAccumulate,T,TAccumulate>> func, FunctionExpression<Function1<TAccumulate,TResult>> selector)`	Applies an accumulator function over a sequence.
`boolean`	`all(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Determines whether all the elements of a sequence satisfy a condition.
`boolean`	`any(Queryable<T> source)`	Determines whether a sequence contains any elements.
`boolean`	`any(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Determines whether any element of a sequence satisfies a condition.
`java.math.BigDecimal`	`averageBigDecimal(Queryable<T> source, FunctionExpression<BigDecimalFunction1<T>> selector)`	Computes the average of a sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.
`double`	`averageDouble(Queryable<T> source, FunctionExpression<DoubleFunction1<T>> selector)`	Computes the average of a sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.
`float`	`averageFloat(Queryable<T> source, FunctionExpression<FloatFunction1<T>> selector)`	Computes the average of a sequence of Float values that is obtained by invoking a projection function on each element of the input sequence.
`int`	`averageInteger(Queryable<T> source, FunctionExpression<IntegerFunction1<T>> selector)`	Computes the average of a sequence of int values that is obtained by invoking a projection function on each element of the input sequence.
`long`	`averageLong(Queryable<T> source, FunctionExpression<LongFunction1<T>> selector)`	Computes the average of a sequence of long values that is obtained by invoking a projection function on each element of the input sequence.
`java.math.BigDecimal`	`averageNullableBigDecimal(Queryable<T> source, FunctionExpression<NullableBigDecimalFunction1<T>> selector)`	Computes the average of a sequence of nullable Decimal values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Double`	`averageNullableDouble(Queryable<T> source, FunctionExpression<NullableDoubleFunction1<T>> selector)`	Computes the average of a sequence of nullable Double values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Float`	`averageNullableFloat(Queryable<T> source, FunctionExpression<NullableFloatFunction1<T>> selector)`	Computes the average of a sequence of nullable Float values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Integer`	`averageNullableInteger(Queryable<T> source, FunctionExpression<NullableIntegerFunction1<T>> selector)`	Computes the average of a sequence of nullable int values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Long`	`averageNullableLong(Queryable<T> source, FunctionExpression<NullableLongFunction1<T>> selector)`	Computes the average of a sequence of nullable long values that is obtained by invoking a projection function on each element of the input sequence.
`<T2> Queryable<T2>`	`cast(Queryable<T> source, java.lang.Class<T2> clazz)`
`Queryable<T>`	`concat(Queryable<T> source, Enumerable<T> source2)`	Concatenates two sequences.
`boolean`	`contains(Queryable<T> source, T element)`	Determines whether a sequence contains a specified element by using the default equality comparer.
`boolean`	`contains(Queryable<T> source, T element, EqualityComparer<T> comparer)`	Determines whether a sequence contains a specified element by using a specified `EqualityComparer<T>`.
`int`	`count(Queryable<T> source)`	Returns the number of elements in a sequence.
`int`	`count(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns the number of elements in the specified sequence that satisfies a condition.
`Queryable<T>`	`defaultIfEmpty(Queryable<T> source)`	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
`Queryable<T>`	`defaultIfEmpty(Queryable<T> source, T value)`	Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
`Queryable<T>`	`distinct(Queryable<T> source)`	Returns distinct elements from a sequence by using the default equality comparer to compare values.
`Queryable<T>`	`distinct(Queryable<T> source, EqualityComparer<T> comparer)`	Returns distinct elements from a sequence by using a specified `EqualityComparer<T>` to compare values.
`T`	`elementAt(Queryable<T> source, int index)`	Returns the element at a specified index in a sequence.
`T`	`elementAtOrDefault(Queryable<T> source, int index)`	Returns the element at a specified index in a sequence or a default value if the index is out of range.
`Queryable<T>`	`except(Queryable<T> source, Enumerable<T> enumerable)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`Queryable<T>`	`except(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<T>` to compare values.
`T`	`first(Queryable<T> source)`	Returns the first element of a sequence.
`T`	`first(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns the first element of a sequence that satisfies a specified condition.
`T`	`firstOrDefault(Queryable<T> source)`	Returns the first element of a sequence, or a default value if the sequence contains no elements.
`T`	`firstOrDefault(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.
`<TKey> Queryable<Grouping<TKey,T>>`	`groupBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector)`	Groups the elements of a sequence according to a specified key selector function.
`<TKey> Queryable<Grouping<TKey,T>>`	`groupBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
`<TKey,TElement> Queryable<Grouping<TKey,TElement>>`	`groupBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function1<T,TElement>> elementSelector)`	Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.
`<TKey,TElement> Queryable<Grouping<TKey,TElement>>`	`groupBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function1<T,TElement>> elementSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence and projects the elements for each group by using a specified function.
`<TKey,TElement,TResult> Queryable<TResult>`	`groupBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function1<T,TElement>> elementSelector, FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TElement,TResult> Queryable<TResult>`	`groupBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function1<T,TElement>> elementSelector, FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TResult> Queryable<TResult>`	`groupByK(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TKey,TResult> Queryable<TResult>`	`groupByK(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`<TInner,TKey,TResult> Queryable<TResult>`	`groupJoin(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)`	Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	`groupJoin(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`Queryable<T>`	`intersect(Queryable<T> source, Enumerable<T> enumerable)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`Queryable<T>`	`intersect(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set intersection of two sequences by using the specified EqualityComparer to compare values.
`<TInner,TKey,TResult> Queryable<TResult>`	`join(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	`join(Queryable<T> source, Enumerable<TInner> inner, FunctionExpression<Function1<T,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<T,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`T`	`last(Queryable<T> source)`	Returns the last element in a sequence.
`T`	`last(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns the last element of a sequence that satisfies a specified condition.
`T`	`lastOrDefault(Queryable<T> source)`	Returns the last element in a sequence, or a default value if the sequence contains no elements.
`T`	`lastOrDefault(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
`long`	`longCount(Queryable<T> source)`	Returns an long that represents the total number of elements in a sequence.
`long`	`longCount(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns an long that represents the number of elements in a sequence that satisfy a condition.
`T`	`max(Queryable<T> source)`	Returns the maximum value in a generic `IQueryable<T>`.
`<TResult extends java.lang.Comparable<TResult>> TResult`	`max(Queryable<T> source, FunctionExpression<Function1<T,TResult>> selector)`	Invokes a projection function on each element of a generic `IQueryable<T>` and returns the maximum resulting value.
`T`	`min(Queryable<T> source)`	Returns the minimum value in a generic `IQueryable<T>`.
`<TResult extends java.lang.Comparable<TResult>> TResult`	`min(Queryable<T> source, FunctionExpression<Function1<T,TResult>> selector)`	Invokes a projection function on each element of a generic `IQueryable<T>` and returns the minimum resulting value.
`<TResult> Queryable<TResult>`	`ofType(Queryable<T> source, java.lang.Class<TResult> clazz)`	Filters the elements of an IQueryable based on a specified type.
`<TKey extends java.lang.Comparable> OrderedQueryable<T>`	`orderBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector)`	Sorts the elements of a sequence in ascending order according to a key.
`<TKey> OrderedQueryable<T>`	`orderBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, java.util.Comparator<TKey> comparator)`	Sorts the elements of a sequence in ascending order by using a specified comparer.
`<TKey extends java.lang.Comparable> OrderedQueryable<T>`	`orderByDescending(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector)`	Sorts the elements of a sequence in descending order according to a key.
`<TKey> OrderedQueryable<T>`	`orderByDescending(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, java.util.Comparator<TKey> comparator)`	Sorts the elements of a sequence in descending order by using a specified comparer.
`Queryable<T>`	`reverse(Queryable<T> source)`	Inverts the order of the elements in a sequence.
`<TResult> Queryable<TResult>`	`select(Queryable<T> source, FunctionExpression<Function1<T,TResult>> selector)`	Projects each element of a sequence into a new form.
`<TResult> Queryable<TResult>`	`selectMany(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<T>` and combines the resulting sequences into one sequence.
`<TCollection,TResult> Queryable<TResult>`	`selectMany(Queryable<T> source, FunctionExpression<Function2<T,java.lang.Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<T>` that incorporates the index of the source element that produced it.
`<TCollection,TResult> Queryable<TResult>`	`selectManyN(Queryable<T> source, FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)`	Projects each element of a sequence to an `Enumerable<T>` and invokes a result selector function on each element therein.
`<TResult> Queryable<TResult>`	`selectManyN(Queryable<T> source, FunctionExpression<Function2<T,java.lang.Integer,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<T>` and combines the resulting sequences into one sequence.
`<TResult> Queryable<TResult>`	`selectN(Queryable<T> source, FunctionExpression<Function2<T,java.lang.Integer,TResult>> selector)`	Projects each element of a sequence into a new form by incorporating the element's index.
`boolean`	`sequenceEqual(Queryable<T> source, Enumerable<T> enumerable)`	Determines whether two sequences are equal by using the default equality comparer to compare elements.
`boolean`	`sequenceEqual(Queryable<T> source, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Determines whether two sequences are equal by using a specified EqualityComparer to compare elements.
`T`	`single(Queryable<T> source)`	Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.
`T`	`single(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.
`T`	`singleOrDefault(Queryable<T> source)`	Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.
`T`	`singleOrDefault(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.
`Queryable<T>`	`skip(Queryable<T> source, int count)`	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
`Queryable<T>`	`skipWhile(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`Queryable<T>`	`skipWhileN(Queryable<T> source, FunctionExpression<Predicate2<T,java.lang.Integer>> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`java.math.BigDecimal`	`sumBigDecimal(Queryable<T> source, FunctionExpression<BigDecimalFunction1<T>> selector)`	Computes the sum of the sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.
`double`	`sumDouble(Queryable<T> source, FunctionExpression<DoubleFunction1<T>> selector)`	Computes the sum of the sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.
`float`	`sumFloat(Queryable<T> source, FunctionExpression<FloatFunction1<T>> selector)`	Computes the sum of the sequence of Float values that is obtained by invoking a projection function on each element of the input sequence.
`int`	`sumInteger(Queryable<T> source, FunctionExpression<IntegerFunction1<T>> selector)`	Computes the sum of the sequence of int values that is obtained by invoking a projection function on each element of the input sequence.
`long`	`sumLong(Queryable<T> source, FunctionExpression<LongFunction1<T>> selector)`	Computes the sum of the sequence of long values that is obtained by invoking a projection function on each element of the input sequence.
`java.math.BigDecimal`	`sumNullableBigDecimal(Queryable<T> source, FunctionExpression<NullableBigDecimalFunction1<T>> selector)`	Computes the sum of the sequence of nullable Decimal values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Double`	`sumNullableDouble(Queryable<T> source, FunctionExpression<NullableDoubleFunction1<T>> selector)`	Computes the sum of the sequence of nullable Double values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Float`	`sumNullableFloat(Queryable<T> source, FunctionExpression<NullableFloatFunction1<T>> selector)`	Computes the sum of the sequence of nullable Float values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Integer`	`sumNullableInteger(Queryable<T> source, FunctionExpression<NullableIntegerFunction1<T>> selector)`	Computes the sum of the sequence of nullable int values that is obtained by invoking a projection function on each element of the input sequence.
`java.lang.Long`	`sumNullableLong(Queryable<T> source, FunctionExpression<NullableLongFunction1<T>> selector)`	Computes the sum of the sequence of nullable long values that is obtained by invoking a projection function on each element of the input sequence.
`Queryable<T>`	`take(Queryable<T> source, int count)`	Returns a specified number of contiguous elements from the start of a sequence.
`Queryable<T>`	`takeWhile(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`Queryable<T>`	`takeWhileN(Queryable<T> source, FunctionExpression<Predicate2<T,java.lang.Integer>> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`<TKey extends java.lang.Comparable<TKey>> OrderedQueryable<T>`	`thenBy(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector)`
`<TKey> OrderedQueryable<T>`	`thenBy(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, java.util.Comparator<TKey> comparator)`
`<TKey extends java.lang.Comparable<TKey>> OrderedQueryable<T>`	`thenByDescending(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector)`
`<TKey> OrderedQueryable<T>`	`thenByDescending(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, java.util.Comparator<TKey> comparator)`
`Queryable<T>`	`union(Queryable<T> source, Enumerable<T> source1)`	Produces the set union of two sequences by using the default equality comparer.
`Queryable<T>`	`union(Queryable<T> source, Enumerable<T> source1, EqualityComparer<T> comparer)`	Produces the set union of two sequences by using a specified `EqualityComparer<T>`.
`Queryable<T>`	`where(Queryable<T> source, FunctionExpression<? extends Predicate1<T>> predicate)`	Filters a sequence of values based on a predicate.
`Queryable<T>`	`whereN(Queryable<T> source, FunctionExpression<? extends Predicate2<T,java.lang.Integer>> predicate)`	Filters a sequence of values based on a predicate.
`<T1,TResult> Queryable<TResult>`	`zip(Queryable<T> source, Enumerable<T1> source1, FunctionExpression<Function2<T,T1,TResult>> resultSelector)`	Merges two sequences by using the specified predicate function.

Method Detail

aggregate

T aggregate(Queryable<T> source,
            FunctionExpression<Function2<T,T,T>> selector)

Applies an accumulator function over a sequence.

aggregate

<TAccumulate> TAccumulate aggregate(Queryable<T> source,
                                    TAccumulate seed,
                                    FunctionExpression<Function2<TAccumulate,T,TAccumulate>> selector)

Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.

aggregate

<TAccumulate,TResult> TResult aggregate(Queryable<T> source,
                                              TAccumulate seed,
                                              FunctionExpression<Function2<TAccumulate,T,TAccumulate>> func,
                                              FunctionExpression<Function1<TAccumulate,TResult>> selector)

Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

all

boolean all(Queryable<T> source,
            FunctionExpression<Predicate1<T>> predicate)

Determines whether all the elements of a sequence satisfy a condition.

any
```
boolean any(Queryable<T> source)
```
Determines whether a sequence contains any elements.

any

boolean any(Queryable<T> source,
            FunctionExpression<Predicate1<T>> predicate)

Determines whether any element of a sequence satisfies a condition.

averageBigDecimal

java.math.BigDecimal averageBigDecimal(Queryable<T> source,
                                       FunctionExpression<BigDecimalFunction1<T>> selector)

Computes the average of a sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.

averageNullableBigDecimal

java.math.BigDecimal averageNullableBigDecimal(Queryable<T> source,
                                               FunctionExpression<NullableBigDecimalFunction1<T>> selector)

Computes the average of a sequence of nullable Decimal values that is obtained by invoking a projection function on each element of the input sequence.

averageDouble
```
double averageDouble(Queryable<T> source,
                     FunctionExpression<DoubleFunction1<T>> selector)
```
Computes the average of a sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.

averageNullableDouble

java.lang.Double averageNullableDouble(Queryable<T> source,
                                       FunctionExpression<NullableDoubleFunction1<T>> selector)

Computes the average of a sequence of nullable Double values that is obtained by invoking a projection function on each element of the input sequence.

averageInteger
```
int averageInteger(Queryable<T> source,
                   FunctionExpression<IntegerFunction1<T>> selector)
```
Computes the average of a sequence of int values that is obtained by invoking a projection function on each element of the input sequence.

averageNullableInteger

java.lang.Integer averageNullableInteger(Queryable<T> source,
                                         FunctionExpression<NullableIntegerFunction1<T>> selector)

Computes the average of a sequence of nullable int values that is obtained by invoking a projection function on each element of the input sequence.

averageFloat
```
float averageFloat(Queryable<T> source,
                   FunctionExpression<FloatFunction1<T>> selector)
```
Computes the average of a sequence of Float values that is obtained by invoking a projection function on each element of the input sequence.

averageNullableFloat

java.lang.Float averageNullableFloat(Queryable<T> source,
                                     FunctionExpression<NullableFloatFunction1<T>> selector)

Computes the average of a sequence of nullable Float values that is obtained by invoking a projection function on each element of the input sequence.

averageLong
```
long averageLong(Queryable<T> source,
                 FunctionExpression<LongFunction1<T>> selector)
```
Computes the average of a sequence of long values that is obtained by invoking a projection function on each element of the input sequence.

averageNullableLong

java.lang.Long averageNullableLong(Queryable<T> source,
                                   FunctionExpression<NullableLongFunction1<T>> selector)

Computes the average of a sequence of nullable long values that is obtained by invoking a projection function on each element of the input sequence.

concat

Queryable<T> concat(Queryable<T> source,
                    Enumerable<T> source2)

Concatenates two sequences.

contains
```
boolean contains(Queryable<T> source,
                 T element)
```
Determines whether a sequence contains a specified element by using the default equality comparer.

contains

boolean contains(Queryable<T> source,
                 T element,
                 EqualityComparer<T> comparer)

Determines whether a sequence contains a specified element by using a specified EqualityComparer<T>.

count
```
int count(Queryable<T> source)
```
Returns the number of elements in a sequence.

count

int count(Queryable<T> source,
          FunctionExpression<Predicate1<T>> predicate)

Returns the number of elements in the specified sequence that satisfies a condition.

defaultIfEmpty
```
Queryable<T> defaultIfEmpty(Queryable<T> source)
```
Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

defaultIfEmpty
```
Queryable<T> defaultIfEmpty(Queryable<T> source,
                            T value)
```
Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

distinct
```
Queryable<T> distinct(Queryable<T> source)
```
Returns distinct elements from a sequence by using the default equality comparer to compare values.

distinct

Queryable<T> distinct(Queryable<T> source,
                      EqualityComparer<T> comparer)

Returns distinct elements from a sequence by using a specified EqualityComparer<T> to compare values.

elementAt
```
T elementAt(Queryable<T> source,
            int index)
```
Returns the element at a specified index in a sequence.

elementAtOrDefault
```
T elementAtOrDefault(Queryable<T> source,
                     int index)
```
Returns the element at a specified index in a sequence or a default value if the index is out of range.

except
```
Queryable<T> except(Queryable<T> source,
                    Enumerable<T> enumerable)
```
Produces the set difference of two sequences by using the default equality comparer to compare values. (Defined by Queryable.)

except

Queryable<T> except(Queryable<T> source,
                    Enumerable<T> enumerable,
                    EqualityComparer<T> comparer)

Produces the set difference of two sequences by using the specified EqualityComparer<T> to compare values.

first
```
T first(Queryable<T> source)
```
Returns the first element of a sequence. (Defined by Queryable.)

first

T first(Queryable<T> source,
        FunctionExpression<Predicate1<T>> predicate)

Returns the first element of a sequence that satisfies a specified condition.

firstOrDefault
```
T firstOrDefault(Queryable<T> source)
```
Returns the first element of a sequence, or a default value if the sequence contains no elements.

firstOrDefault
```
T firstOrDefault(Queryable<T> source,
                 FunctionExpression<Predicate1<T>> predicate)
```
Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.

groupBy

<TKey> Queryable<Grouping<TKey,T>> groupBy(Queryable<T> source,
                                                 FunctionExpression<Function1<T,TKey>> keySelector)

Groups the elements of a sequence according to a specified key selector function.

groupBy

<TKey> Queryable<Grouping<TKey,T>> groupBy(Queryable<T> source,
                                                 FunctionExpression<Function1<T,TKey>> keySelector,
                                                 EqualityComparer<TKey> comparer)

Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

groupBy

<TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(Queryable<T> source,
                                                                       FunctionExpression<Function1<T,TKey>> keySelector,
                                                                       FunctionExpression<Function1<T,TElement>> elementSelector)

Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

groupBy

<TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(Queryable<T> source,
                                                                       FunctionExpression<Function1<T,TKey>> keySelector,
                                                                       FunctionExpression<Function1<T,TElement>> elementSelector,
                                                                       EqualityComparer<TKey> comparer)

Groups the elements of a sequence and projects the elements for each group by using a specified function. Key values are compared by using a specified comparer.

groupByK

<TKey,TResult> Queryable<TResult> groupByK(Queryable<T> source,
                                                 FunctionExpression<Function1<T,TKey>> keySelector,
                                                 FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector)

Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

groupByK

<TKey,TResult> Queryable<TResult> groupByK(Queryable<T> source,
                                                 FunctionExpression<Function1<T,TKey>> keySelector,
                                                 FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector,
                                                 EqualityComparer<TKey> comparer)

Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Keys are compared by using a specified comparer.

groupBy

<TKey,TElement,TResult> Queryable<TResult> groupBy(Queryable<T> source,
                                                               FunctionExpression<Function1<T,TKey>> keySelector,
                                                               FunctionExpression<Function1<T,TElement>> elementSelector,
                                                               FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector)

Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function.

groupBy

<TKey,TElement,TResult> Queryable<TResult> groupBy(Queryable<T> source,
                                                               FunctionExpression<Function1<T,TKey>> keySelector,
                                                               FunctionExpression<Function1<T,TElement>> elementSelector,
                                                               FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector,
                                                               EqualityComparer<TKey> comparer)

Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Keys are compared by using a specified comparer and the elements of each group are projected by using a specified function.

groupJoin

<TInner,TKey,TResult> Queryable<TResult> groupJoin(Queryable<T> source,
                                                               Enumerable<TInner> inner,
                                                               FunctionExpression<Function1<T,TKey>> outerKeySelector,
                                                               FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                               FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)

Correlates the elements of two sequences based on key equality and groups the results. The default equality comparer is used to compare keys.

groupJoin

<TInner,TKey,TResult> Queryable<TResult> groupJoin(Queryable<T> source,
                                                               Enumerable<TInner> inner,
                                                               FunctionExpression<Function1<T,TKey>> outerKeySelector,
                                                               FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                               FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
                                                               EqualityComparer<TKey> comparer)

Correlates the elements of two sequences based on key equality and groups the results. A specified EqualityComparer is used to compare keys.

intersect
```
Queryable<T> intersect(Queryable<T> source,
                       Enumerable<T> enumerable)
```
Produces the set intersection of two sequences by using the default equality comparer to compare values. (Defined by Queryable.)

intersect

Queryable<T> intersect(Queryable<T> source,
                       Enumerable<T> enumerable,
                       EqualityComparer<T> comparer)

Produces the set intersection of two sequences by using the specified EqualityComparer to compare values.

join

<TInner,TKey,TResult> Queryable<TResult> join(Queryable<T> source,
                                                          Enumerable<TInner> inner,
                                                          FunctionExpression<Function1<T,TKey>> outerKeySelector,
                                                          FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                          FunctionExpression<Function2<T,TInner,TResult>> resultSelector)

Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.

join

<TInner,TKey,TResult> Queryable<TResult> join(Queryable<T> source,
                                                          Enumerable<TInner> inner,
                                                          FunctionExpression<Function1<T,TKey>> outerKeySelector,
                                                          FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                          FunctionExpression<Function2<T,TInner,TResult>> resultSelector,
                                                          EqualityComparer<TKey> comparer)

Correlates the elements of two sequences based on matching keys. A specified EqualityComparer is used to compare keys.

last
```
T last(Queryable<T> source)
```
Returns the last element in a sequence. (Defined by Queryable.)

last

T last(Queryable<T> source,
       FunctionExpression<Predicate1<T>> predicate)

Returns the last element of a sequence that satisfies a specified condition.

lastOrDefault
```
T lastOrDefault(Queryable<T> source)
```
Returns the last element in a sequence, or a default value if the sequence contains no elements.

lastOrDefault
```
T lastOrDefault(Queryable<T> source,
                FunctionExpression<Predicate1<T>> predicate)
```
Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

longCount
```
long longCount(Queryable<T> source)
```
Returns an long that represents the total number of elements in a sequence.

longCount

long longCount(Queryable<T> source,
               FunctionExpression<Predicate1<T>> predicate)

Returns an long that represents the number of elements in a sequence that satisfy a condition.

max
```
T max(Queryable<T> source)
```
Returns the maximum value in a generic IQueryable<T>.

max

<TResult extends java.lang.Comparable<TResult>> TResult max(Queryable<T> source,
                                                            FunctionExpression<Function1<T,TResult>> selector)

Invokes a projection function on each element of a generic IQueryable<T> and returns the maximum resulting value.

min
```
T min(Queryable<T> source)
```
Returns the minimum value in a generic IQueryable<T>.

min

<TResult extends java.lang.Comparable<TResult>> TResult min(Queryable<T> source,
                                                            FunctionExpression<Function1<T,TResult>> selector)

Invokes a projection function on each element of a generic IQueryable<T> and returns the minimum resulting value.

ofType

<TResult> Queryable<TResult> ofType(Queryable<T> source,
                                    java.lang.Class<TResult> clazz)

Filters the elements of an IQueryable based on a specified type.

cast

<T2> Queryable<T2> cast(Queryable<T> source,
                        java.lang.Class<T2> clazz)

orderBy

<TKey extends java.lang.Comparable> OrderedQueryable<T> orderBy(Queryable<T> source,
                                                                FunctionExpression<Function1<T,TKey>> keySelector)

Sorts the elements of a sequence in ascending order according to a key.

orderBy

<TKey> OrderedQueryable<T> orderBy(Queryable<T> source,
                                   FunctionExpression<Function1<T,TKey>> keySelector,
                                   java.util.Comparator<TKey> comparator)

Sorts the elements of a sequence in ascending order by using a specified comparer.

orderByDescending

<TKey extends java.lang.Comparable> OrderedQueryable<T> orderByDescending(Queryable<T> source,
                                                                          FunctionExpression<Function1<T,TKey>> keySelector)

Sorts the elements of a sequence in descending order according to a key.

orderByDescending

<TKey> OrderedQueryable<T> orderByDescending(Queryable<T> source,
                                             FunctionExpression<Function1<T,TKey>> keySelector,
                                             java.util.Comparator<TKey> comparator)

Sorts the elements of a sequence in descending order by using a specified comparer.

reverse
```
Queryable<T> reverse(Queryable<T> source)
```
Inverts the order of the elements in a sequence.

select

<TResult> Queryable<TResult> select(Queryable<T> source,
                                    FunctionExpression<Function1<T,TResult>> selector)

Projects each element of a sequence into a new form.

selectN

<TResult> Queryable<TResult> selectN(Queryable<T> source,
                                     FunctionExpression<Function2<T,java.lang.Integer,TResult>> selector)

Projects each element of a sequence into a new form by incorporating the element's index.

selectMany

<TResult> Queryable<TResult> selectMany(Queryable<T> source,
                                        FunctionExpression<Function1<T,Enumerable<TResult>>> selector)

Projects each element of a sequence to an Enumerable<T> and combines the resulting sequences into one sequence.

selectManyN

<TResult> Queryable<TResult> selectManyN(Queryable<T> source,
                                         FunctionExpression<Function2<T,java.lang.Integer,Enumerable<TResult>>> selector)

Projects each element of a sequence to an Enumerable<T> and combines the resulting sequences into one sequence. The index of each source element is used in the projected form of that element.

selectMany

<TCollection,TResult> Queryable<TResult> selectMany(Queryable<T> source,
                                                          FunctionExpression<Function2<T,java.lang.Integer,Enumerable<TCollection>>> collectionSelector,
                                                          FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)

Projects each element of a sequence to an Enumerable<T> that incorporates the index of the source element that produced it. A result selector function is invoked on each element of each intermediate sequence, and the resulting values are combined into a single, one-dimensional sequence and returned.

selectManyN

<TCollection,TResult> Queryable<TResult> selectManyN(Queryable<T> source,
                                                           FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
                                                           FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)

Projects each element of a sequence to an Enumerable<T> and invokes a result selector function on each element therein. The resulting values from each intermediate sequence are combined into a single, one-dimensional sequence and returned.

sequenceEqual

boolean sequenceEqual(Queryable<T> source,
                      Enumerable<T> enumerable)

Determines whether two sequences are equal by using the default equality comparer to compare elements.

sequenceEqual

boolean sequenceEqual(Queryable<T> source,
                      Enumerable<T> enumerable,
                      EqualityComparer<T> comparer)

Determines whether two sequences are equal by using a specified EqualityComparer to compare elements.

single
```
T single(Queryable<T> source)
```
Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

single
```
T single(Queryable<T> source,
         FunctionExpression<Predicate1<T>> predicate)
```
Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

singleOrDefault
```
T singleOrDefault(Queryable<T> source)
```
Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

singleOrDefault
```
T singleOrDefault(Queryable<T> source,
                  FunctionExpression<Predicate1<T>> predicate)
```
Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

skip
```
Queryable<T> skip(Queryable<T> source,
                  int count)
```
Bypasses a specified number of elements in a sequence and then returns the remaining elements.

skipWhile

Queryable<T> skipWhile(Queryable<T> source,
                       FunctionExpression<Predicate1<T>> predicate)

Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

skipWhileN
```
Queryable<T> skipWhileN(Queryable<T> source,
                        FunctionExpression<Predicate2<T,java.lang.Integer>> predicate)
```
Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.

sumBigDecimal

java.math.BigDecimal sumBigDecimal(Queryable<T> source,
                                   FunctionExpression<BigDecimalFunction1<T>> selector)

Computes the sum of the sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.

sumNullableBigDecimal

java.math.BigDecimal sumNullableBigDecimal(Queryable<T> source,
                                           FunctionExpression<NullableBigDecimalFunction1<T>> selector)

Computes the sum of the sequence of nullable Decimal values that is obtained by invoking a projection function on each element of the input sequence.

sumDouble
```
double sumDouble(Queryable<T> source,
                 FunctionExpression<DoubleFunction1<T>> selector)
```
Computes the sum of the sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.

sumNullableDouble

java.lang.Double sumNullableDouble(Queryable<T> source,
                                   FunctionExpression<NullableDoubleFunction1<T>> selector)

Computes the sum of the sequence of nullable Double values that is obtained by invoking a projection function on each element of the input sequence.

sumInteger
```
int sumInteger(Queryable<T> source,
               FunctionExpression<IntegerFunction1<T>> selector)
```
Computes the sum of the sequence of int values that is obtained by invoking a projection function on each element of the input sequence.

sumNullableInteger

java.lang.Integer sumNullableInteger(Queryable<T> source,
                                     FunctionExpression<NullableIntegerFunction1<T>> selector)

Computes the sum of the sequence of nullable int values that is obtained by invoking a projection function on each element of the input sequence.

sumLong
```
long sumLong(Queryable<T> source,
             FunctionExpression<LongFunction1<T>> selector)
```
Computes the sum of the sequence of long values that is obtained by invoking a projection function on each element of the input sequence.

sumNullableLong

java.lang.Long sumNullableLong(Queryable<T> source,
                               FunctionExpression<NullableLongFunction1<T>> selector)

Computes the sum of the sequence of nullable long values that is obtained by invoking a projection function on each element of the input sequence.

sumFloat
```
float sumFloat(Queryable<T> source,
               FunctionExpression<FloatFunction1<T>> selector)
```
Computes the sum of the sequence of Float values that is obtained by invoking a projection function on each element of the input sequence.

sumNullableFloat

java.lang.Float sumNullableFloat(Queryable<T> source,
                                 FunctionExpression<NullableFloatFunction1<T>> selector)

Computes the sum of the sequence of nullable Float values that is obtained by invoking a projection function on each element of the input sequence.

take
```
Queryable<T> take(Queryable<T> source,
                  int count)
```
Returns a specified number of contiguous elements from the start of a sequence.

takeWhile

Queryable<T> takeWhile(Queryable<T> source,
                       FunctionExpression<Predicate1<T>> predicate)

Returns elements from a sequence as long as a specified condition is true.

takeWhileN

Queryable<T> takeWhileN(Queryable<T> source,
                        FunctionExpression<Predicate2<T,java.lang.Integer>> predicate)

Returns elements from a sequence as long as a specified condition is true. The element's index is used in the logic of the predicate function.

thenBy

<TKey extends java.lang.Comparable<TKey>> OrderedQueryable<T> thenBy(OrderedQueryable<T> source,
                                                                     FunctionExpression<Function1<T,TKey>> keySelector)

thenBy

<TKey> OrderedQueryable<T> thenBy(OrderedQueryable<T> source,
                                  FunctionExpression<Function1<T,TKey>> keySelector,
                                  java.util.Comparator<TKey> comparator)

thenByDescending

<TKey extends java.lang.Comparable<TKey>> OrderedQueryable<T> thenByDescending(OrderedQueryable<T> source,
                                                                               FunctionExpression<Function1<T,TKey>> keySelector)

thenByDescending

<TKey> OrderedQueryable<T> thenByDescending(OrderedQueryable<T> source,
                                            FunctionExpression<Function1<T,TKey>> keySelector,
                                            java.util.Comparator<TKey> comparator)

union

Queryable<T> union(Queryable<T> source,
                   Enumerable<T> source1)

Produces the set union of two sequences by using the default equality comparer.

union

Queryable<T> union(Queryable<T> source,
                   Enumerable<T> source1,
                   EqualityComparer<T> comparer)

Produces the set union of two sequences by using a specified EqualityComparer<T>.

where

Queryable<T> where(Queryable<T> source,
                   FunctionExpression<? extends Predicate1<T>> predicate)

Filters a sequence of values based on a predicate.

whereN

Queryable<T> whereN(Queryable<T> source,
                    FunctionExpression<? extends Predicate2<T,java.lang.Integer>> predicate)

Filters a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function.

zip

<T1,TResult> Queryable<TResult> zip(Queryable<T> source,
                                          Enumerable<T1> source1,
                                          FunctionExpression<Function2<T,T1,TResult>> resultSelector)

Merges two sequences by using the specified predicate function.

Interface QueryableFactory<T>

Method Summary

Method Detail

aggregate

aggregate

aggregate

all

any

any

averageBigDecimal

averageNullableBigDecimal

averageDouble

averageNullableDouble

averageInteger

averageNullableInteger

averageFloat

averageNullableFloat

averageLong

averageNullableLong

concat

contains

contains

count

count

defaultIfEmpty

defaultIfEmpty

distinct

distinct

elementAt

elementAtOrDefault

except

except

first

first

firstOrDefault

firstOrDefault

groupBy

groupBy

groupBy

groupBy

groupByK

groupByK

groupBy

groupBy

groupJoin

groupJoin

intersect

intersect

join

join

last

last

lastOrDefault

lastOrDefault

longCount

longCount

max

max

min

min

ofType

cast

orderBy

orderBy

orderByDescending

orderByDescending

reverse

select

selectN

selectMany

selectManyN

selectMany

selectManyN

sequenceEqual

sequenceEqual

single

single

singleOrDefault

singleOrDefault

skip