java.lang.Object
- org.apache.calcite.linq4j.QueryableDefaults

```
public abstract class QueryableDefaults
extends Object
```
Default implementations for methods in the Queryable interface.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`QueryableDefaults.NonLeafReplayableQueryable<T>`	Non-leaf replayable queryable.
`static interface`	`QueryableDefaults.Replayable<T>`	Replayable.
`static class`	`QueryableDefaults.ReplayableQueryable<T>`	Replayable queryable.

Constructor Summary

Constructors
Constructor Description

QueryableDefaults()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static <T> T`	`aggregate(Queryable<T> queryable, FunctionExpression<Function2<T,T,T>> func)`	Applies an accumulator function over a sequence.
`static <T,TAccumulate> TAccumulate`	`aggregate(Queryable<T> queryable, TAccumulate seed, FunctionExpression<Function2<TAccumulate,T,TAccumulate>> func)`	Applies an accumulator function over a sequence.
`static <T,TAccumulate,TResult> TResult`	`aggregate(Queryable<T> queryable, TAccumulate seed, FunctionExpression<Function2<TAccumulate,T,TAccumulate>> func, FunctionExpression<Function1<TAccumulate,TResult>> selector)`	Applies an accumulator function over a sequence.
`static <T> boolean`	`all(Queryable<T> queryable, FunctionExpression<Predicate1<T>> predicate)`	Determines whether all the elements of a sequence satisfy a condition.
`static <T> void`	`any(Queryable<T> queryable)`	Determines whether a sequence contains any elements.
`static <T> boolean`	`any(Queryable<T> queryable, FunctionExpression<Predicate1<T>> predicate)`	Determines whether any element of a sequence satisfies a condition.
`static <T> Queryable<T>`	`asQueryable(Queryable<T> queryable)`	Converts a generic `Enumerable<T>` to a generic `IQueryable<T>`.
`static <T> BigDecimal`	`averageBigDecimal(Queryable<T> queryable, 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.
`static <T> double`	`averageDouble(Queryable<T> queryable, 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.
`static <T> float`	`averageFloat(Queryable<T> queryable, 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.
`static <T> int`	`averageInteger(Queryable<T> queryable, 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.
`static <T> long`	`averageLong(Queryable<T> queryable, 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.
`static <T> BigDecimal`	`averageNullableBigDecimal(Queryable<T> queryable, 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.
`static <T> Double`	`averageNullableDouble(Queryable<T> queryable, 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.
`static <T> Float`	`averageNullableFloat(Queryable<T> queryable, 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.
`static <T> Integer`	`averageNullableInteger(Queryable<T> queryable, 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.
`static <T> Long`	`averageNullableLong(Queryable<T> queryable, 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.
`static <T,T2> Queryable<T2>`	`cast(Queryable<T> source, Class<T2> clazz)`	Analogous to LINQ's Enumerable.Cast extension method.
`static <T> Queryable<T>`	`concat(Queryable<T> queryable0, Enumerable<T> source2)`	Concatenates two sequences.
`static <T> boolean`	`contains(Queryable<T> queryable, T element)`	Determines whether a sequence contains a specified element by using the default equality comparer.
`static <T> boolean`	`contains(Queryable<T> queryable, T element, EqualityComparer comparer)`	Determines whether a sequence contains a specified element by using a specified `EqualityComparer<T>`.
`static <T> int`	`count(Queryable<T> queryable)`	Returns the number of elements in a sequence.
`static <T> int`	`count(Queryable<T> queryable, FunctionExpression<Predicate1<T>> func)`	Returns the number of elements in the specified sequence that satisfies a condition.
`static <T> Queryable<T>`	`defaultIfEmpty(Queryable<T> queryable)`	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
`static <T> T`	`defaultIfEmpty(Queryable<T> queryable, T value)`	Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
`static <T> Queryable<T>`	`distinct(Queryable<T> queryable)`	Returns distinct elements from a sequence by using the default equality comparer to compare values.
`static <T> Queryable<T>`	`distinct(Queryable<T> queryable, EqualityComparer comparer)`	Returns distinct elements from a sequence by using a specified `EqualityComparer<T>` to compare values.
`static <T> T`	`elementAt(Queryable<T> queryable, int index)`	Returns the element at a specified index in a sequence.
`static <T> T`	`elementAtOrDefault(Queryable<T> queryable, int index)`	Returns the element at a specified index in a sequence or a default value if the index is out of range.
`static <T> Queryable<T>`	`except(Queryable<T> queryable, Enumerable<T> enumerable)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`static <T> Queryable<T>`	`except(Queryable<T> queryable, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set difference of two sequences by using the specified `EqualityComparer<T>` to compare values.
`static <T> T`	`first(Queryable<T> queryable)`	Returns the first element of a sequence.
`static <T> T`	`first(Queryable<T> queryable, FunctionExpression<Predicate1<T>> predicate)`	Returns the first element of a sequence that satisfies a specified condition.
`static <T> T`	`firstOrDefault(Queryable<T> queryable)`	Returns the first element of a sequence, or a default value if the sequence contains no elements.
`static <T> T`	`firstOrDefault(Queryable<T> queryable, 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.
`private static <P0,R> Type`	`functionResultType(FunctionExpression<Function1<P0,R>> selector)`
`static <T,TKey> Queryable<Grouping<TKey,T>>`	`groupBy(Queryable<T> queryable, FunctionExpression<Function1<T,TKey>> keySelector)`	Groups the elements of a sequence according to a specified key selector function.
`static <T,TKey> Queryable<Grouping<TKey,T>>`	`groupBy(Queryable<T> queryable, FunctionExpression<Function1<T,TKey>> keySelector, EqualityComparer comparer)`	Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
`static <T,TKey,TElement> Queryable<Grouping<TKey,TElement>>`	`groupBy(Queryable<T> queryable, 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.
`static <T,TKey,TElement> Queryable<Grouping<TKey,TElement>>`	`groupBy(Queryable<T> queryable, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function1<T,TElement>> elementSelector, EqualityComparer comparer)`	Groups the elements of a sequence and projects the elements for each group by using a specified function.
`static <T,TKey,TElement,TResult> Queryable<TResult>`	`groupBy(Queryable<T> queryable, 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.
`static <T,TKey,TElement,TResult> Queryable<TResult>`	`groupBy(Queryable<T> queryable, 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.
`static <T,TKey,TResult> Queryable<Grouping<TKey,TResult>>`	`groupByK(Queryable<T> queryable, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> elementSelector)`	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
`static <T,TKey,TResult> Queryable<TResult>`	`groupByK(Queryable<T> queryable, FunctionExpression<Function1<T,TKey>> keySelector, FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> elementSelector, EqualityComparer 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.
`static <TOuter,TInner,TKey,TResult> Queryable<TResult>`	`groupJoin(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector)`	Correlates the elements of two sequences based on key equality and groups the results.
`static <TOuter,TInner,TKey,TResult> Enumerable<TResult>`	`groupJoin(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on key equality and groups the results.
`static <T> Queryable<T>`	`intersect(Queryable<T> queryable, Enumerable<T> enumerable)`	Produces the set intersection of two sequences by using the default equality comparer to compare values.
`static <T> Queryable<T>`	`intersect(Queryable<T> queryable, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Produces the set intersection of two sequences by using the specified `EqualityComparer<T>` to compare values.
`static <TOuter,TInner,TKey,TResult> Queryable<TResult>`	`join(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector)`	Correlates the elements of two sequences based on matching keys.
`static <TOuter,TInner,TKey,TResult> Queryable<TResult>`	`join(Queryable<TOuter> outer, Enumerable<TInner> inner, FunctionExpression<Function1<TOuter,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)`	Correlates the elements of two sequences based on matching keys.
`static <T> T`	`last(Queryable<T> queryable)`	Returns the last element in a sequence.
`static <T> T`	`last(Queryable<T> queryable, FunctionExpression<Predicate1<T>> predicate)`	Returns the last element of a sequence that satisfies a specified condition.
`static <T> T`	`lastOrDefault(Queryable<T> queryable)`	Returns the last element in a sequence, or a default value if the sequence contains no elements.
`static <T> T`	`lastOrDefault(Queryable<T> queryable, 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.
`static <T> long`	`longCount(Queryable<T> xable)`	Returns an long that represents the total number of elements in a sequence.
`static <T> long`	`longCount(Queryable<T> queryable, FunctionExpression<Predicate1<T>> predicate)`	Returns an long that represents the number of elements in a sequence that satisfy a condition.
`static <T> T`	`max(Queryable<T> queryable)`	Returns the maximum value in a generic `IQueryable<T>`.
`static <T,TResult> TResult`	`max(Queryable<T> queryable, FunctionExpression<Function1<T,TResult>> selector)`	Invokes a projection function on each element of a generic `IQueryable<T>` and returns the maximum resulting value.
`static <T> T`	`min(Queryable<T> queryable)`	Returns the minimum value in a generic `IQueryable<T>`.
`static <T,TResult> TResult`	`min(Queryable<T> queryable, FunctionExpression<Function1<T,TResult>> selector)`	Invokes a projection function on each element of a generic `IQueryable<T>` and returns the minimum resulting value.
`static <TResult> Queryable<TResult>`	`ofType(Queryable<?> queryable, Class<TResult> clazz)`	Filters the elements of an IQueryable based on a specified type.
`static <T,TKey extends 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.
`static <T,TKey> OrderedQueryable<T>`	`orderBy(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in ascending order by using a specified comparer.
`static <T,TKey extends 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.
`static <T,TKey> OrderedQueryable<T>`	`orderByDescending(Queryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, Comparator<TKey> comparator)`	Sorts the elements of a sequence in descending order by using a specified comparer.
`static <T> Queryable<T>`	`reverse(Queryable<T> source)`	Inverts the order of the elements in a sequence.
`static <T,TResult> Queryable<TResult>`	`select(Queryable<T> source, FunctionExpression<Function1<T,TResult>> selector)`	Projects each element of a sequence into a new form.
`static <T,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.
`static <T,TCollection,TResult> Queryable<TResult>`	`selectMany(Queryable<T> source, FunctionExpression<Function2<T,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.
`static <T,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.
`static <T,TResult> Queryable<TResult>`	`selectManyN(Queryable<T> source, FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)`	Projects each element of a sequence to an `Enumerable<T>` and combines the resulting sequences into one sequence.
`static <T,TResult> Queryable<TResult>`	`selectN(Queryable<T> source, FunctionExpression<Function2<T,Integer,TResult>> selector)`	Projects each element of a sequence into a new form by incorporating the element's index.
`static <T> boolean`	`sequenceEqual(Queryable<T> queryable, Enumerable<T> enumerable)`	Determines whether two sequences are equal by using the default equality comparer to compare elements.
`static <T> boolean`	`sequenceEqual(Queryable<T> queryable, Enumerable<T> enumerable, EqualityComparer<T> comparer)`	Determines whether two sequences are equal by using a specified `EqualityComparer<T>` to compare elements.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> Queryable<T>`	`skip(Queryable<T> source, int count)`	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
`static <T> 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.
`static <T> Queryable<T>`	`skipWhileN(Queryable<T> source, FunctionExpression<Predicate2<T,Integer>> predicate)`	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`static <T> BigDecimal`	`sumBigDecimal(Queryable<T> sources, 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> 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.
`static <T> Queryable<T>`	`take(Queryable<T> source, int count)`	Returns a specified number of contiguous elements from the start of a sequence.
`static <T> Queryable<T>`	`takeWhile(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <T> Queryable<T>`	`takeWhileN(Queryable<T> source, FunctionExpression<Predicate2<T,Integer>> predicate)`	Returns elements from a sequence as long as a specified condition is true.
`static <T,TKey extends Comparable<TKey>> OrderedQueryable<T>`	`thenBy(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector)`	Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
`static <T,TKey> OrderedQueryable<T>`	`thenBy(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, Comparator<TKey> comparator)`	Performs a subsequent ordering of the elements in a sequence in ascending order according to a key, using a specified comparator.
`static <T,TKey extends Comparable<TKey>> OrderedQueryable<T>`	`thenByDescending(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector)`	Performs a subsequent ordering of the elements in a sequence in descending order according to a key.
`static <T,TKey> OrderedQueryable<T>`	`thenByDescending(OrderedQueryable<T> source, FunctionExpression<Function1<T,TKey>> keySelector, Comparator<TKey> comparator)`	Performs a subsequent ordering of the elements in a sequence in dscending order according to a key, using a specified comparator.
`static <T> Queryable<T>`	`union(Queryable<T> source0, Enumerable<T> source1)`	Produces the set union of two sequences by using the default equality comparer.
`static <T> Queryable<T>`	`union(Queryable<T> source0, Enumerable<T> source1, EqualityComparer<T> comparer)`	Produces the set union of two sequences by using a specified `EqualityComparer<T>`.
`static <T> Queryable<T>`	`where(Queryable<T> source, FunctionExpression<Predicate1<T>> predicate)`	Filters a sequence of values based on a predicate.
`static <T> Queryable<T>`	`whereN(Queryable<T> source, FunctionExpression<Predicate2<T,Integer>> predicate)`	Filters a sequence of values based on a predicate.
`static <T0,T1,TResult> Queryable<TResult>`	`zip(Queryable<T0> source0, Enumerable<T1> source1, FunctionExpression<Function2<T0,T1,TResult>> resultSelector)`	Merges two sequences by using the specified predicate function.

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

Constructor Detail
- QueryableDefaults
```
public QueryableDefaults()
```

Method Detail

aggregate

public static <T> T aggregate(Queryable<T> queryable,
                              FunctionExpression<Function2<T,T,T>> func)

Applies an accumulator function over a sequence.

aggregate

public static <T,TAccumulate> TAccumulate aggregate(Queryable<T> queryable,
                                                    TAccumulate seed,
                                                    FunctionExpression<Function2<TAccumulate,T,TAccumulate>> func)

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

aggregate

public static <T,TAccumulate,TResult> TResult aggregate(Queryable<T> queryable,
                                                        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

public static <T> boolean all(Queryable<T> queryable,
                              FunctionExpression<Predicate1<T>> predicate)

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

any

public static <T> void any(Queryable<T> queryable)

Determines whether a sequence contains any elements.

any

public static <T> boolean any(Queryable<T> queryable,
                              FunctionExpression<Predicate1<T>> predicate)

Determines whether any element of a sequence satisfies a condition.

asQueryable

public static <T> Queryable<T> asQueryable(Queryable<T> queryable)

Converts a generic Enumerable<T> to a generic IQueryable<T>.

averageBigDecimal

public static <T> BigDecimal averageBigDecimal(Queryable<T> queryable,
                                               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

public static <T> BigDecimal averageNullableBigDecimal(Queryable<T> queryable,
                                                       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

public static <T> double averageDouble(Queryable<T> queryable,
                                       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

public static <T> Double averageNullableDouble(Queryable<T> queryable,
                                               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

public static <T> int averageInteger(Queryable<T> queryable,
                                     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

public static <T> Integer averageNullableInteger(Queryable<T> queryable,
                                                 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

public static <T> float averageFloat(Queryable<T> queryable,
                                     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

public static <T> Float averageNullableFloat(Queryable<T> queryable,
                                             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

public static <T> long averageLong(Queryable<T> queryable,
                                   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

public static <T> Long averageNullableLong(Queryable<T> queryable,
                                           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.

cast

public static <T,T2> Queryable<T2> cast(Queryable<T> source,
                                        Class<T2> clazz)

Analogous to LINQ's Enumerable.Cast extension method.

Type Parameters:: T2 - Target type
Parameters:: clazz - Target type
Returns:: Collection of T2

concat

public static <T> Queryable<T> concat(Queryable<T> queryable0,
                                      Enumerable<T> source2)

Concatenates two sequences.

contains

public static <T> boolean contains(Queryable<T> queryable,
                                   T element)

Determines whether a sequence contains a specified element by using the default equality comparer.

contains

public static <T> boolean contains(Queryable<T> queryable,
                                   T element,
                                   EqualityComparer comparer)

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

count

public static <T> int count(Queryable<T> queryable)

Returns the number of elements in a sequence.

count

public static <T> int count(Queryable<T> queryable,
                            FunctionExpression<Predicate1<T>> func)

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

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

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

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

distinct

public static <T> Queryable<T> distinct(Queryable<T> queryable,
                                        EqualityComparer comparer)

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

elementAt

public static <T> T elementAt(Queryable<T> queryable,
                              int index)

Returns the element at a specified index in a sequence.

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

except

public static <T> Queryable<T> except(Queryable<T> queryable,
                                      Enumerable<T> enumerable)

Produces the set difference of two sequences by using the default equality comparer to compare values. (Defined by Queryable.)

except

public static <T> Queryable<T> except(Queryable<T> queryable,
                                      Enumerable<T> enumerable,
                                      EqualityComparer<T> comparer)

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

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

first

public static <T> T first(Queryable<T> queryable,
                          FunctionExpression<Predicate1<T>> predicate)

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

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

firstOrDefault

public static <T> T firstOrDefault(Queryable<T> queryable,
                                   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

public static <T,TKey> Queryable<Grouping<TKey,T>> groupBy(Queryable<T> queryable,
                                                           FunctionExpression<Function1<T,TKey>> keySelector)

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

groupBy

public static <T,TKey> Queryable<Grouping<TKey,T>> groupBy(Queryable<T> queryable,
                                                           FunctionExpression<Function1<T,TKey>> keySelector,
                                                           EqualityComparer comparer)

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

groupBy

public static <T,TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(Queryable<T> queryable,
                                                                           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.

groupByK

public static <T,TKey,TResult> Queryable<Grouping<TKey,TResult>> groupByK(Queryable<T> queryable,
                                                                          FunctionExpression<Function1<T,TKey>> keySelector,
                                                                          FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> elementSelector)

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

NOTE: Renamed from groupBy to distinguish from groupBy(org.apache.calcite.linq4j.Queryable, org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression), which has the same erasure.

groupBy

public static <T,TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(Queryable<T> queryable,
                                                                           FunctionExpression<Function1<T,TKey>> keySelector,
                                                                           FunctionExpression<Function1<T,TElement>> elementSelector,
                                                                           EqualityComparer 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

public static <T,TKey,TResult> Queryable<TResult> groupByK(Queryable<T> queryable,
                                                           FunctionExpression<Function1<T,TKey>> keySelector,
                                                           FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> elementSelector,
                                                           EqualityComparer 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.

NOTE: Renamed from groupBy to distinguish from groupBy(org.apache.calcite.linq4j.Queryable, org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.function.EqualityComparer), which has the same erasure.

groupBy

public static <T,TKey,TElement,TResult> Queryable<TResult> groupBy(Queryable<T> queryable,
                                                                   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

public static <T,TKey,TElement,TResult> Queryable<TResult> groupBy(Queryable<T> queryable,
                                                                   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

public static <TOuter,TInner,TKey,TResult> Queryable<TResult> groupJoin(Queryable<TOuter> outer,
                                                                        Enumerable<TInner> inner,
                                                                        FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
                                                                        FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                                        FunctionExpression<Function2<TOuter,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

public static <TOuter,TInner,TKey,TResult> Enumerable<TResult> groupJoin(Queryable<TOuter> outer,
                                                                         Enumerable<TInner> inner,
                                                                         FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
                                                                         FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                                         FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector,
                                                                         EqualityComparer<TKey> comparer)

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

intersect

public static <T> Queryable<T> intersect(Queryable<T> queryable,
                                         Enumerable<T> enumerable)

Produces the set intersection of two sequences by using the default equality comparer to compare values. (Defined by Queryable.)

intersect

public static <T> Queryable<T> intersect(Queryable<T> queryable,
                                         Enumerable<T> enumerable,
                                         EqualityComparer<T> comparer)

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

join

public static <TOuter,TInner,TKey,TResult> Queryable<TResult> join(Queryable<TOuter> outer,
                                                                   Enumerable<TInner> inner,
                                                                   FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
                                                                   FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                                   FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector)

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

join

public static <TOuter,TInner,TKey,TResult> Queryable<TResult> join(Queryable<TOuter> outer,
                                                                   Enumerable<TInner> inner,
                                                                   FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
                                                                   FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                                   FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector,
                                                                   EqualityComparer<TKey> comparer)

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

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

last

public static <T> T last(Queryable<T> queryable,
                         FunctionExpression<Predicate1<T>> predicate)

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

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

lastOrDefault

public static <T> T lastOrDefault(Queryable<T> queryable,
                                  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
```
public static <T> long longCount(Queryable<T> xable)
```
Returns an long that represents the total number of elements in a sequence.

longCount

public static <T> long longCount(Queryable<T> queryable,
                                 FunctionExpression<Predicate1<T>> predicate)

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

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

max

public static <T,TResult> TResult max(Queryable<T> queryable,
                                      FunctionExpression<Function1<T,TResult>> selector)

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

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

min

public static <T,TResult> TResult min(Queryable<T> queryable,
                                      FunctionExpression<Function1<T,TResult>> selector)

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

ofType
```
public static <TResult> Queryable<TResult> ofType(Queryable<?> queryable,
                                                  Class<TResult> clazz)
```
Filters the elements of an IQueryable based on a specified type.
This method generates a MethodCallExpression that represents calling ofType itself as a constructed generic method. It then passes the MethodCallExpression to the createQuery method of the QueryProvider represented by the Provider property of the source parameter.

The query behavior that occurs as a result of executing an expression tree that represents calling OfType depends on the implementation of the type of the source parameter. The expected behavior is that it filters out any elements in source that are not of type TResult.
NOTE: clazz parameter not present in C# LINQ; necessary because of Java type erasure.

orderBy

public static <T,TKey extends 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.

See Also:: thenBy(org.apache.calcite.linq4j.OrderedQueryable<T>, org.apache.calcite.linq4j.tree.FunctionExpression<org.apache.calcite.linq4j.function.Function1<T, TKey>>)

orderBy

public static <T,TKey> OrderedQueryable<T> orderBy(Queryable<T> source,
                                                   FunctionExpression<Function1<T,TKey>> keySelector,
                                                   Comparator<TKey> comparator)

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

orderByDescending

public static <T,TKey extends 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

public static <T,TKey> OrderedQueryable<T> orderByDescending(Queryable<T> source,
                                                             FunctionExpression<Function1<T,TKey>> keySelector,
                                                             Comparator<TKey> comparator)

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

reverse

public static <T> Queryable<T> reverse(Queryable<T> source)

Inverts the order of the elements in a sequence.

select

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

Projects each element of a sequence into a new form.

functionResultType

private static <P0,R> Type functionResultType(FunctionExpression<Function1<P0,R>> selector)

selectN

public static <T,TResult> Queryable<TResult> selectN(Queryable<T> source,
                                                     FunctionExpression<Function2<T,Integer,TResult>> selector)

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

NOTE: Renamed from select because had same erasure as select(org.apache.calcite.linq4j.Queryable, org.apache.calcite.linq4j.tree.FunctionExpression).

selectMany

public static <T,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
```
public static <T,TResult> Queryable<TResult> selectManyN(Queryable<T> source,
                                                         FunctionExpression<Function2<T,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.
NOTE: Renamed from selectMany because had same erasure as selectMany(org.apache.calcite.linq4j.Queryable, org.apache.calcite.linq4j.tree.FunctionExpression).

selectMany

public static <T,TCollection,TResult> Queryable<TResult> selectMany(Queryable<T> source,
                                                                    FunctionExpression<Function2<T,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

public static <T,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.

NOTE: Renamed from selectMany because had same erasure as selectMany(org.apache.calcite.linq4j.Queryable, org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression).

sequenceEqual

public static <T> boolean sequenceEqual(Queryable<T> queryable,
                                        Enumerable<T> enumerable)

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

sequenceEqual

public static <T> boolean sequenceEqual(Queryable<T> queryable,
                                        Enumerable<T> enumerable,
                                        EqualityComparer<T> comparer)

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

single
```
public static <T> 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

public static <T> 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
```
public static <T> 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
```
public static <T> 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

public static <T> Queryable<T> skip(Queryable<T> source,
                                    int count)

Bypasses a specified number of elements in a sequence and then returns the remaining elements.

skipWhile

public static <T> 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

public static <T> Queryable<T> skipWhileN(Queryable<T> source,
                                          FunctionExpression<Predicate2<T,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

public static <T> BigDecimal sumBigDecimal(Queryable<T> sources,
                                           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

public static <T> 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

public static <T> 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

public static <T> 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

public static <T> 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

public static <T> 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

public static <T> 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

public static <T> 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

public static <T> 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

public static <T> 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

public static <T> Queryable<T> take(Queryable<T> source,
                                    int count)

Returns a specified number of contiguous elements from the start of a sequence.

takeWhile

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

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

takeWhileN

public static <T> Queryable<T> takeWhileN(Queryable<T> source,
                                          FunctionExpression<Predicate2<T,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

public static <T,TKey extends Comparable<TKey>> OrderedQueryable<T> thenBy(OrderedQueryable<T> source,
                                                                           FunctionExpression<Function1<T,TKey>> keySelector)

Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.

thenBy

public static <T,TKey> OrderedQueryable<T> thenBy(OrderedQueryable<T> source,
                                                  FunctionExpression<Function1<T,TKey>> keySelector,
                                                  Comparator<TKey> comparator)

Performs a subsequent ordering of the elements in a sequence in ascending order according to a key, using a specified comparator.

thenByDescending

public static <T,TKey extends Comparable<TKey>> OrderedQueryable<T> thenByDescending(OrderedQueryable<T> source,
                                                                                     FunctionExpression<Function1<T,TKey>> keySelector)

Performs a subsequent ordering of the elements in a sequence in descending order according to a key.

thenByDescending

public static <T,TKey> OrderedQueryable<T> thenByDescending(OrderedQueryable<T> source,
                                                            FunctionExpression<Function1<T,TKey>> keySelector,
                                                            Comparator<TKey> comparator)

Performs a subsequent ordering of the elements in a sequence in dscending order according to a key, using a specified comparator.

union

public static <T> Queryable<T> union(Queryable<T> source0,
                                     Enumerable<T> source1)

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

union

public static <T> Queryable<T> union(Queryable<T> source0,
                                     Enumerable<T> source1,
                                     EqualityComparer<T> comparer)

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

where

public static <T> Queryable<T> where(Queryable<T> source,
                                     FunctionExpression<Predicate1<T>> predicate)

Filters a sequence of values based on a predicate.

whereN

public static <T> Queryable<T> whereN(Queryable<T> source,
                                      FunctionExpression<Predicate2<T,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

public static <T0,T1,TResult> Queryable<TResult> zip(Queryable<T0> source0,
                                                     Enumerable<T1> source1,
                                                     FunctionExpression<Function2<T0,T1,TResult>> resultSelector)

Merges two sequences by using the specified predicate function.

Class QueryableDefaults

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QueryableDefaults

Method Detail

aggregate

aggregate

aggregate

all

any

any

asQueryable

averageBigDecimal

averageNullableBigDecimal

averageDouble

averageNullableDouble

averageInteger

averageNullableInteger

averageFloat

averageNullableFloat

averageLong

averageNullableLong

cast

concat

contains

contains

count

count

defaultIfEmpty

defaultIfEmpty

distinct

distinct

elementAt

elementAtOrDefault

except

except

first

first

firstOrDefault

firstOrDefault

groupBy

groupBy

groupBy

groupByK

groupBy

groupByK

groupBy

groupBy

groupJoin

groupJoin

intersect

intersect

join

join

last

last

lastOrDefault

lastOrDefault

longCount

longCount

max

max

min

min

ofType

orderBy

orderBy

orderByDescending

orderByDescending

reverse

select

functionResultType

selectN

selectMany

selectManyN

selectMany

selectManyN