QueryableDefaults.ReplayableQueryable (Apache Calcite linq4j API)

java.lang.Object
- org.apache.calcite.linq4j.DefaultEnumerable<T>
- - org.apache.calcite.linq4j.QueryableDefaults.ReplayableQueryable<T>

类型参数:

T - element type

所有已实现的接口:

Iterable<T>, Enumerable<T>, ExtendedEnumerable<T>, ExtendedOrderedEnumerable<T>, ExtendedOrderedQueryable<T>, OrderedEnumerable<T>, OrderedQueryable<T>, Queryable<T>, QueryableDefaults.Replayable<T>, RawEnumerable<T>, RawQueryable<T>

直接已知子类:

QueryableDefaults.NonLeafReplayableQueryable

封闭类:

QueryableDefaults
```
public abstract static class QueryableDefaults.ReplayableQueryable<T>
extends DefaultEnumerable<T>
implements QueryableDefaults.Replayable<T>
```
Replayable queryable.

构造器概要

构造器
构造器和说明

ReplayableQueryable()

构造器
构造器和说明
`ReplayableQueryable()`

方法概要

所有方法实例方法抽象方法具体方法
限定符和类型	方法和说明
`TSource`	`aggregate(FunctionExpression<Function2<TSource,TSource,TSource>> selector)` Applies an accumulator function over a sequence.
`T`	`aggregate(FunctionExpression<Function2<T,T,T>> selector)` Applies an accumulator function over a sequence.
`<TAccumulate> TAccumulate`	`aggregate(TAccumulate seed, FunctionExpression<Function2<TAccumulate,TSource,TAccumulate>> selector)` Applies an accumulator function over a sequence.
`<TAccumulate,TResult> TResult`	`aggregate(TAccumulate seed, FunctionExpression<Function2<TAccumulate,TSource,TAccumulate>> func, FunctionExpression<Function1<TAccumulate,TResult>> selector)` Applies an accumulator function over a sequence.
`<TAccumulate> TAccumulate`	`aggregate(TAccumulate seed, FunctionExpression<Function2<TAccumulate,T,TAccumulate>> selector)` Applies an accumulator function over a sequence.
`<TAccumulate,TResult> TResult`	`aggregate(TAccumulate seed, FunctionExpression<Function2<TAccumulate,T,TAccumulate>> func, FunctionExpression<Function1<TAccumulate,TResult>> selector)` Applies an accumulator function over a sequence.
`boolean`	`all(FunctionExpression<Predicate1<T>> predicate)` Determines whether all the elements of a sequence satisfy a condition.
`boolean`	`all(FunctionExpression<Predicate1<TSource>> predicate)` Determines whether all the elements of a sequence satisfy a condition.
`boolean`	`any(FunctionExpression<Predicate1<T>> predicate)` Determines whether any element of a sequence satisfies a condition.
`boolean`	`any(FunctionExpression<Predicate1<TSource>> predicate)` Determines whether any element of a sequence satisfies a condition.
`Enumerable<T>`	`asEnumerable()` Returns the input typed as `Enumerable<TSource>`.
`Queryable<T>`	`asQueryable()` Converts this Enumerable to a Queryable.
`BigDecimal`	`averageBigDecimal(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.
`BigDecimal`	`averageBigDecimal(FunctionExpression<BigDecimalFunction1<TSource>> 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(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.
`double`	`averageDouble(FunctionExpression<DoubleFunction1<TSource>> 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(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.
`float`	`averageFloat(FunctionExpression<FloatFunction1<TSource>> 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(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.
`int`	`averageInteger(FunctionExpression<IntegerFunction1<TSource>> 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(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.
`long`	`averageLong(FunctionExpression<LongFunction1<TSource>> 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.
`BigDecimal`	`averageNullableBigDecimal(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.
`BigDecimal`	`averageNullableBigDecimal(FunctionExpression<NullableBigDecimalFunction1<TSource>> 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.
`Double`	`averageNullableDouble(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.
`Double`	`averageNullableDouble(FunctionExpression<NullableDoubleFunction1<TSource>> 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.
`Float`	`averageNullableFloat(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.
`Float`	`averageNullableFloat(FunctionExpression<NullableFloatFunction1<TSource>> 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.
`Integer`	`averageNullableInteger(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.
`Integer`	`averageNullableInteger(FunctionExpression<NullableIntegerFunction1<TSource>> 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.
`Long`	`averageNullableLong(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.
`Long`	`averageNullableLong(FunctionExpression<NullableLongFunction1<TSource>> 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(Class<T2> clazz)` Converts the elements of this Enumerable to the specified type.
`<T2> Queryable<T2>`	`cast(Class<T2> clazz)` Converts the elements of this Enumerable to the specified type.
`<U> Queryable<U>`	`castQueryable()` Convenience method, for `QueryableRecorder` methods that return a Queryable of a different element type than the source.
`Queryable<T>`	`concat(Enumerable<T> source2)` Concatenates two sequences.
`Queryable<TSource>`	`concat(Enumerable<TSource> source2)` Concatenates two sequences.
`int`	`count(FunctionExpression<Predicate1<T>> func)` Returns the number of elements in the specified sequence that satisfies a condition.
`int`	`count(FunctionExpression<Predicate1<TSource>> predicate)` Returns the number of elements in the specified sequence that satisfies a condition.
`Queryable<TSource>`	`defaultIfEmpty()` 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()` Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
`Queryable<TSource>`	`distinct()` Returns distinct elements from a sequence by using the default equality comparer to compare values.
`Queryable<T>`	`distinct()` Returns distinct elements from a sequence by using the default equality comparer to compare values.
`Queryable<T>`	`distinct(EqualityComparer<T> comparer)` Returns distinct elements from a sequence by using a specified `EqualityComparer<TSource>` to compare values.
`Queryable<TSource>`	`distinct(EqualityComparer<TSource> comparer)` Returns distinct elements from a sequence by using a specified EqualityComparer<TSource> to compare values.
`Enumerator<T>`	`enumerator()` Returns an enumerator that iterates through a collection.
`Queryable<T>`	`except(Enumerable<T> enumerable1)` Produces the set difference of two sequences by using the default equality comparer to compare values, eliminate duplicates.
`Queryable<T>`	`except(Enumerable<T> enumerable1, boolean all)` Produces the set difference of two sequences by using the default equality comparer to compare values, using `all` to indicate whether to eliminate duplicates.
`Queryable<T>`	`except(Enumerable<T> enumerable1, EqualityComparer<T> comparer)` Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values, eliminate duplicates.
`Queryable<T>`	`except(Enumerable<T> enumerable1, EqualityComparer<T> comparer, boolean all)` Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values, using `all` to indicate whether to eliminate duplicates.
`Queryable<TSource>`	`except(Enumerable<TSource> enumerable)` Produces the set difference of two sequences by using the default equality comparer to compare values, eliminate duplicates.
`Queryable<TSource>`	`except(Enumerable<TSource> enumerable, boolean all)` Produces the set difference of two sequences by using the default equality comparer to compare values, using `all` to indicate whether to eliminate duplicates.
`Queryable<TSource>`	`except(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer)` Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values, eliminate duplicates.
`Queryable<TSource>`	`except(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer, boolean all)` Produces the set difference of two sequences by using the specified `EqualityComparer<TSource>` to compare values, using `all` to indicate whether to eliminate duplicates.
`T`	`first(FunctionExpression<Predicate1<T>> predicate)` Returns the first element of a sequence that satisfies a specified condition.
`TSource`	`first(FunctionExpression<Predicate1<TSource>> predicate)` Returns the first element of a sequence that satisfies a specified condition.
`T`	`firstOrDefault(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.
`TSource`	`firstOrDefault(FunctionExpression<Predicate1<TSource>> predicate)` Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.
`protected Queryable<T>`	`getThis()` Derived classes might wish to override this method to return the "outer" enumerable.
`protected OrderedQueryable<T>`	`getThisOrderedQueryable()`
`<TKey> Queryable<Grouping<TKey,TSource>>`	`groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector)` Groups the elements of a sequence according to a specified key selector function.
`<TKey> Queryable<Grouping<TKey,TSource>>`	`groupBy(FunctionExpression<Function1<TSource,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(FunctionExpression<Function1<TSource,TKey>> keySelector, FunctionExpression<Function1<TSource,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(FunctionExpression<Function1<TSource,TKey>> keySelector, FunctionExpression<Function1<TSource,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(FunctionExpression<Function1<TSource,TKey>> keySelector, FunctionExpression<Function1<TSource,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(FunctionExpression<Function1<TSource,TKey>> keySelector, FunctionExpression<Function1<TSource,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> Queryable<Grouping<TKey,T>>`	`groupBy(FunctionExpression<Function1<T,TKey>> keySelector)` Groups the elements of a sequence according to a specified key selector function.
`<TKey> Queryable<Grouping<TKey,T>>`	`groupBy(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(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(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(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(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(FunctionExpression<Function1<TSource,TKey>> keySelector, FunctionExpression<Function2<TKey,Enumerable<TSource>,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(FunctionExpression<Function1<TSource,TKey>> keySelector, FunctionExpression<Function2<TKey,Enumerable<TSource>,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(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(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(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector)` Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	`groupJoin(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector, EqualityComparer<TKey> comparer)` Correlates the elements of two sequences based on key equality and groups the results.
`<TInner,TKey,TResult> Queryable<TResult>`	`groupJoin(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(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(Enumerable<T> source1)` Produces the set intersection of two sequences by using the default equality comparer to compare values, eliminate duplicates.
`Queryable<T>`	`intersect(Enumerable<T> source1, boolean all)` Produces the set intersection of two sequences by using the default equality comparer to compare values, using `all` to indicate whether to eliminate duplicates.
`Queryable<T>`	`intersect(Enumerable<T> source1, EqualityComparer<T> comparer)` Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values, eliminate duplicates.
`Queryable<T>`	`intersect(Enumerable<T> source1, EqualityComparer<T> comparer, boolean all)` Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values, using `all` to indicate whether to eliminate duplicates.
`Queryable<TSource>`	`intersect(Enumerable<TSource> enumerable)` Produces the set intersection of two sequences by using the default equality comparer to compare values, eliminate duplicates.
`Queryable<TSource>`	`intersect(Enumerable<TSource> enumerable, boolean all)` Produces the set intersection of two sequences by using the default equality comparer to compare values, using `all` to indicate whether to eliminate duplicates.
`Queryable<TSource>`	`intersect(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer)` Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values, eliminate duplicates.
`Queryable<TSource>`	`intersect(Enumerable<TSource> enumerable, EqualityComparer<TSource> comparer, boolean all)` Produces the set intersection of two sequences by using the specified `EqualityComparer<TSource>` to compare values, using `all` to indicate whether to eliminate duplicates.
`Iterator<T>`	`iterator()`
`<TInner,TKey,TResult> Queryable<TResult>`	`join(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector)` Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	`join(Enumerable<TInner> inner, FunctionExpression<Function1<TSource,TKey>> outerKeySelector, FunctionExpression<Function1<TInner,TKey>> innerKeySelector, FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector, EqualityComparer<TKey> comparer)` Correlates the elements of two sequences based on matching keys.
`<TInner,TKey,TResult> Queryable<TResult>`	`join(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(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(FunctionExpression<Predicate1<T>> predicate)` Returns the last element of a sequence that satisfies a specified condition.
`TSource`	`last(FunctionExpression<Predicate1<TSource>> predicate)` Returns the last element of a sequence that satisfies a specified condition.
`T`	`lastOrDefault(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.
`TSource`	`lastOrDefault(FunctionExpression<Predicate1<TSource>> predicate)` Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
`long`	`longCount(FunctionExpression<Predicate1<T>> predicate)` Returns an long that represents the number of elements in a sequence that satisfy a condition.
`long`	`longCount(FunctionExpression<Predicate1<TSource>> predicate)` Returns an long that represents the number of elements in a sequence that satisfy a condition.
`<TResult extends Comparable<TResult>> TResult`	`max(FunctionExpression<Function1<TSource,TResult>> selector)` Invokes a projection function on each element of a generic `IQueryable<TSource>` and returns the maximum resulting value.
`<TResult extends Comparable<TResult>> TResult`	`max(FunctionExpression<Function1<T,TResult>> selector)` Invokes a projection function on each element of a generic `IQueryable<TSource>` and returns the maximum resulting value.
`<TResult extends Comparable<TResult>> TResult`	`min(FunctionExpression<Function1<TSource,TResult>> selector)` Invokes a projection function on each element of a generic `IQueryable<TSource>` and returns the minimum resulting value.
`<TResult extends Comparable<TResult>> TResult`	`min(FunctionExpression<Function1<T,TResult>> selector)` Invokes a projection function on each element of a generic `IQueryable<TSource>` and returns the minimum resulting value.
`<TResult> Queryable<TResult>`	`ofType(Class<TResult> clazz)` Filters the elements of an IQueryable based on a specified type.
`<TResult> Queryable<TResult>`	`ofType(Class<TResult> clazz)` Filters the elements of an Enumerable based on a specified type.
`<TKey extends Comparable> OrderedQueryable<TSource>`	`orderBy(FunctionExpression<Function1<TSource,TKey>> keySelector)` Sorts the elements of a sequence in ascending order according to a key.
`<TKey> OrderedQueryable<TSource>`	`orderBy(FunctionExpression<Function1<TSource,TKey>> keySelector, Comparator<TKey> comparator)` Sorts the elements of a sequence in ascending order by using a specified comparer.
`<TKey extends Comparable> OrderedQueryable<T>`	`orderBy(FunctionExpression<Function1<T,TKey>> keySelector)` Sorts the elements of a sequence in ascending order according to a key.
`<TKey> OrderedQueryable<T>`	`orderBy(FunctionExpression<Function1<T,TKey>> keySelector, Comparator<TKey> comparator)` Sorts the elements of a sequence in ascending order by using a specified comparer.
`<TKey extends Comparable> OrderedQueryable<TSource>`	`orderByDescending(FunctionExpression<Function1<TSource,TKey>> keySelector)` Sorts the elements of a sequence in descending order according to a key.
`<TKey> OrderedQueryable<TSource>`	`orderByDescending(FunctionExpression<Function1<TSource,TKey>> keySelector, Comparator<TKey> comparator)` Sorts the elements of a sequence in descending order by using a specified comparer.
`<TKey extends Comparable> OrderedQueryable<T>`	`orderByDescending(FunctionExpression<Function1<T,TKey>> keySelector)` Sorts the elements of a sequence in descending order according to a key.
`<TKey> OrderedQueryable<T>`	`orderByDescending(FunctionExpression<Function1<T,TKey>> keySelector, Comparator<TKey> comparator)` Sorts the elements of a sequence in descending order by using a specified comparer.
`void`	`replay(QueryableFactory<T> factory)`
`Queryable<TSource>`	`reverse()` Inverts the order of the elements in a sequence.
`Queryable<T>`	`reverse()` Inverts the order of the elements in a sequence.
`<TResult> Queryable<TResult>`	`select(FunctionExpression<Function1<TSource,TResult>> selector)` Projects each element of a sequence into a new form.
`<TResult> Queryable<TResult>`	`select(FunctionExpression<Function1<T,TResult>> selector)` Projects each element of a sequence into a new form.
`<TResult> Queryable<TResult>`	`selectMany(FunctionExpression<Function1<T,Enumerable<TResult>>> selector)` Projects each element of a sequence to an `Enumerable<TSource>` and combines the resulting sequences into one sequence.
`<TResult> Queryable<TResult>`	`selectMany(FunctionExpression<Function1<TSource,Enumerable<TResult>>> selector)` Projects each element of a sequence to an `Enumerable<TSource>` and combines the resulting sequences into one sequence.
`<TCollection,TResult> Queryable<TResult>`	`selectMany(FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)` Projects each element of a sequence to an `Enumerable<TSource>` that incorporates the index of the source element that produced it.
`<TCollection,TResult> Queryable<TResult>`	`selectMany(FunctionExpression<Function2<TSource,Integer,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)` Projects each element of a sequence to an `Enumerable<TSource>` that incorporates the index of the source element that produced it.
`<TCollection,TResult> Queryable<TResult>`	`selectManyN(FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)` Projects each element of a sequence to an `Enumerable<TSource>` and invokes a result selector function on each element therein.
`<TCollection,TResult> Queryable<TResult>`	`selectManyN(FunctionExpression<Function1<TSource,Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)` Projects each element of a sequence to an `Enumerable<TSource>` and invokes a result selector function on each element therein.
`<TResult> Queryable<TResult>`	`selectManyN(FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)` Projects each element of a sequence to an `Enumerable<TSource>` and combines the resulting sequences into one sequence.
`<TResult> Queryable<TResult>`	`selectManyN(FunctionExpression<Function2<TSource,Integer,Enumerable<TResult>>> selector)` Projects each element of a sequence to an `Enumerable<TSource>` and combines the resulting sequences into one sequence.
`<TResult> Queryable<TResult>`	`selectN(FunctionExpression<Function2<T,Integer,TResult>> selector)` Projects each element of a sequence into a new form by incorporating the element's index.
`<TResult> Queryable<TResult>`	`selectN(FunctionExpression<Function2<TSource,Integer,TResult>> selector)` Projects each element of a sequence into a new form by incorporating the element's index.
`T`	`single(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.
`TSource`	`single(FunctionExpression<Predicate1<TSource>> predicate)` Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.
`TSource`	`singleOrDefault()` 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(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.
`TSource`	`singleOrDefault(FunctionExpression<Predicate1<TSource>> 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<TSource>`	`skip(int count)` Bypasses a specified number of elements in a sequence and then returns the remaining elements.
`Queryable<T>`	`skip(int count)` Bypasses a specified number of elements in a sequence and then returns the remaining elements.
`Queryable<T>`	`skipWhile(FunctionExpression<Predicate1<T>> predicate)` Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`Queryable<TSource>`	`skipWhile(FunctionExpression<Predicate1<TSource>> predicate)` Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`Queryable<T>`	`skipWhileN(FunctionExpression<Predicate2<T,Integer>> predicate)` Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`Queryable<TSource>`	`skipWhileN(FunctionExpression<Predicate2<TSource,Integer>> predicate)` Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
`BigDecimal`	`sumBigDecimal(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.
`BigDecimal`	`sumBigDecimal(FunctionExpression<BigDecimalFunction1<TSource>> 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(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.
`double`	`sumDouble(FunctionExpression<DoubleFunction1<TSource>> 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(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.
`float`	`sumFloat(FunctionExpression<FloatFunction1<TSource>> 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(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.
`int`	`sumInteger(FunctionExpression<IntegerFunction1<TSource>> 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(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.
`long`	`sumLong(FunctionExpression<LongFunction1<TSource>> 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.
`BigDecimal`	`sumNullableBigDecimal(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.
`BigDecimal`	`sumNullableBigDecimal(FunctionExpression<NullableBigDecimalFunction1<TSource>> 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.
`Double`	`sumNullableDouble(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.
`Double`	`sumNullableDouble(FunctionExpression<NullableDoubleFunction1<TSource>> 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.
`Float`	`sumNullableFloat(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.
`Float`	`sumNullableFloat(FunctionExpression<NullableFloatFunction1<TSource>> 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.
`Integer`	`sumNullableInteger(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.
`Integer`	`sumNullableInteger(FunctionExpression<NullableIntegerFunction1<TSource>> 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.
`Long`	`sumNullableLong(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.
`Long`	`sumNullableLong(FunctionExpression<NullableLongFunction1<TSource>> 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<TSource>`	`take(int count)` Returns a specified number of contiguous elements from the start of a sequence.
`Queryable<T>`	`take(int count)` Returns a specified number of contiguous elements from the start of a sequence.
`Queryable<T>`	`takeWhile(FunctionExpression<Predicate1<T>> predicate)` Returns elements from a sequence as long as a specified condition is true.
`Queryable<TSource>`	`takeWhile(FunctionExpression<Predicate1<TSource>> predicate)` Returns elements from a sequence as long as a specified condition is true.
`Queryable<T>`	`takeWhileN(FunctionExpression<Predicate2<T,Integer>> predicate)` Returns elements from a sequence as long as a specified condition is true.
`Queryable<TSource>`	`takeWhileN(FunctionExpression<Predicate2<TSource,Integer>> predicate)` Returns elements from a sequence as long as a specified condition is true.
`<TKey extends Comparable<TKey>> OrderedQueryable<T>`	`thenBy(FunctionExpression<Function1<T,TKey>> keySelector)` Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
`<TKey> OrderedQueryable<T>`	`thenBy(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.
`<TKey extends Comparable<TKey>> OrderedQueryable<T>`	`thenByDescending(FunctionExpression<Function1<T,TKey>> keySelector)` Performs a subsequent ordering of the elements in a sequence in descending order according to a key.
`<TKey> OrderedQueryable<T>`	`thenByDescending(FunctionExpression<Function1<T,TKey>> keySelector, Comparator<TKey> comparator)` Performs a subsequent ordering of the elements in a sequence in descending order according to a key, using a specified comparator.
`Queryable<T>`	`union(Enumerable<T> source1)` Produces the set union of two sequences by using the default equality comparer.
`Queryable<T>`	`union(Enumerable<T> source1, EqualityComparer<T> comparer)` Produces the set union of two sequences by using a specified `EqualityComparer<TSource>`.
`Queryable<TSource>`	`union(Enumerable<TSource> source1)` Produces the set union of two sequences by using the default equality comparer.
`Queryable<TSource>`	`union(Enumerable<TSource> source1, EqualityComparer<TSource> comparer)` Produces the set union of two sequences by using a specified `EqualityComparer<TSource>`.
`Queryable<T>`	`where(FunctionExpression<? extends Predicate1<T>> predicate)` Filters a sequence of values based on a predicate.
`Queryable<TSource>`	`where(FunctionExpression<? extends Predicate1<TSource>> predicate)` Filters a sequence of values based on a predicate.
`Queryable<T>`	`whereN(FunctionExpression<? extends Predicate2<T,Integer>> predicate)` Filters a sequence of values based on a predicate.
`Queryable<TSource>`	`whereN(FunctionExpression<? extends Predicate2<TSource,Integer>> predicate)` Filters a sequence of values based on a predicate.
`<T1,TResult> Queryable<TResult>`	`zip(Enumerable<T1> source1, FunctionExpression<Function2<TSource,T1,TResult>> resultSelector)` Merges two sequences by using the specified predicate function.
`<T1,TResult> Queryable<TResult>`	`zip(Enumerable<T1> source1, FunctionExpression<Function2<T,T1,TResult>> resultSelector)` Merges two sequences by using the specified predicate function.

从类继承的方法 org.apache.calcite.linq4j.DefaultEnumerable
aggregate, aggregate, aggregate, all, any, any, asOrderedQueryable, average, average, average, average, average, average, average, average, average, average, contains, contains, correlateJoin, count, count, createOrderedEnumerable, defaultIfEmpty, elementAt, elementAtOrDefault, first, first, firstOrDefault, firstOrDefault, foreach, getThisOrdered, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupJoin, groupJoin, hashJoin, hashJoin, hashJoin, hashJoin, into, last, last, lastOrDefault, lastOrDefault, longCount, longCount, max, max, max, max, max, max, max, max, max, max, max, max, min, min, min, min, min, min, min, min, min, min, min, min, orderBy, orderBy, orderByDescending, orderByDescending, removeAll, select, select, selectMany, selectMany, selectMany, selectMany, sequenceEqual, sequenceEqual, single, single, singleOrDefault, singleOrDefault, skipWhile, skipWhile, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, takeWhile, takeWhile, thenBy, thenBy, thenByDescending, thenByDescending, toList, toLookup, toLookup, toLookup, toLookup, toMap, toMap, toMap, toMap, where, where, zip

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 org.apache.calcite.linq4j.RawQueryable
getElementType, getExpression, getProvider

从接口继承的方法 org.apache.calcite.linq4j.Enumerable
asQueryable

从接口继承的方法 java.lang.Iterable
forEach, spliterator

从接口继承的方法 org.apache.calcite.linq4j.ExtendedEnumerable
aggregate, aggregate, aggregate, all, any, any, asEnumerable, average, average, average, average, average, average, average, average, average, average, cast, concat, contains, contains, correlateJoin, count, count, defaultIfEmpty, defaultIfEmpty, distinct, distinct, elementAt, elementAtOrDefault, except, except, except, except, first, first, firstOrDefault, firstOrDefault, foreach, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupJoin, groupJoin, hashJoin, hashJoin, hashJoin, hashJoin, intersect, intersect, intersect, intersect, into, last, last, lastOrDefault, lastOrDefault, longCount, longCount, max, max, max, max, max, max, max, max, max, max, max, max, min, min, min, min, min, min, min, min, min, min, min, min, ofType, orderBy, orderBy, orderByDescending, orderByDescending, removeAll, reverse, select, select, selectMany, selectMany, selectMany, selectMany, sequenceEqual, sequenceEqual, single, single, singleOrDefault, singleOrDefault, skip, skipWhile, skipWhile, sum, sum, sum, sum, sum, sum, sum, sum, sum, sum, take, takeWhile, takeWhile, toList, toLookup, toLookup, toLookup, toLookup, toMap, toMap, toMap, toMap, union, union, where, where, zip

- 构造器详细资料
  - ReplayableQueryable
```
public ReplayableQueryable()
```
- 方法详细资料
  - replay
```
public void replay(QueryableFactory<T> factory)
```
    指定者:
    
    replay 在接口中 QueryableDefaults.Replayable<T>
  - iterator
```
public Iterator<T> iterator()
```
    指定者:
    
    iterator 在接口中 Iterable<T>
  - enumerator
```
public Enumerator<T> enumerator()
```
    从接口复制的说明: RawEnumerable
    
    Returns an enumerator that iterates through a collection.
    
    指定者:
    
    enumerator 在接口中 RawEnumerable<T>
  - castQueryable
```
public <U> Queryable<U> castQueryable()
```
    Convenience method, for QueryableRecorder methods that return a Queryable of a different element type than the source.
  - aggregate
```
public TSource aggregate(FunctionExpression<Function2<TSource,TSource,TSource>> selector)
```
    Applies an accumulator function over a sequence.
  - aggregate
```
public <TAccumulate> TAccumulate aggregate(TAccumulate seed,
                                           FunctionExpression<Function2<TAccumulate,TSource,TAccumulate>> selector)
```
    Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.
  - aggregate
```
public <TAccumulate,TResult> TResult aggregate(TAccumulate seed,
                                               FunctionExpression<Function2<TAccumulate,TSource,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 boolean all(FunctionExpression<Predicate1<TSource>> predicate)
```
    Determines whether all the elements of a sequence satisfy a condition.
  - any
```
public boolean any(FunctionExpression<Predicate1<TSource>> predicate)
```
    Determines whether any element of a sequence satisfies a condition.
  - averageBigDecimal
```
public BigDecimal averageBigDecimal(FunctionExpression<BigDecimalFunction1<TSource>> 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 BigDecimal averageNullableBigDecimal(FunctionExpression<NullableBigDecimalFunction1<TSource>> 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 double averageDouble(FunctionExpression<DoubleFunction1<TSource>> 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 Double averageNullableDouble(FunctionExpression<NullableDoubleFunction1<TSource>> 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 int averageInteger(FunctionExpression<IntegerFunction1<TSource>> 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 Integer averageNullableInteger(FunctionExpression<NullableIntegerFunction1<TSource>> 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 float averageFloat(FunctionExpression<FloatFunction1<TSource>> 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 Float averageNullableFloat(FunctionExpression<NullableFloatFunction1<TSource>> 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 long averageLong(FunctionExpression<LongFunction1<TSource>> 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 Long averageNullableLong(FunctionExpression<NullableLongFunction1<TSource>> 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
```
public Queryable<TSource> concat(Enumerable<TSource> source2)
```
    Concatenates two sequences.
    
    指定者:
    
    concat 在接口中 ExtendedEnumerable<TSource>
  - count
```
public int count(FunctionExpression<Predicate1<TSource>> predicate)
```
    Returns the number of elements in the specified sequence that satisfies a condition.
  - defaultIfEmpty
```
public Queryable<TSource> defaultIfEmpty()
```
    Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
    
    指定者:
    
    defaultIfEmpty 在接口中 ExtendedEnumerable<TSource>
  - distinct
```
public Queryable<TSource> distinct()
```
    Returns distinct elements from a sequence by using the default equality comparer to compare values.
    
    指定者:
    
    distinct 在接口中 ExtendedEnumerable<TSource>
  - distinct
```
public Queryable<TSource> distinct(EqualityComparer<TSource> comparer)
```
    Returns distinct elements from a sequence by using a specified EqualityComparer<TSource> to compare values.
    
    指定者:
    
    distinct 在接口中 ExtendedEnumerable<TSource>
  - except
```
public Queryable<TSource> except(Enumerable<TSource> enumerable)
```
    Produces the set difference of two sequences by using the default equality comparer to compare values, eliminate duplicates. (Defined by Enumerable.)
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<TSource>
  - except
```
public Queryable<TSource> except(Enumerable<TSource> enumerable,
                                 boolean all)
```
    Produces the set difference of two sequences by using the default equality comparer to compare values, using all to indicate whether to eliminate duplicates. (Defined by Enumerable.)
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<TSource>
  - except
```
public Queryable<TSource> except(Enumerable<TSource> enumerable,
                                 EqualityComparer<TSource> comparer)
```
    Produces the set difference of two sequences by using the specified EqualityComparer<TSource> to compare values, eliminate duplicates.
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<TSource>
  - except
```
public Queryable<TSource> except(Enumerable<TSource> enumerable,
                                 EqualityComparer<TSource> comparer,
                                 boolean all)
```
    Produces the set difference of two sequences by using the specified EqualityComparer<TSource> to compare values, using all to indicate whether to eliminate duplicates.
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<TSource>
  - first
```
public TSource first(FunctionExpression<Predicate1<TSource>> predicate)
```
    Returns the first element of a sequence that satisfies a specified condition.
  - firstOrDefault
```
public TSource firstOrDefault(FunctionExpression<Predicate1<TSource>> 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 <TKey> Queryable<Grouping<TKey,TSource>> groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector)
```
    Groups the elements of a sequence according to a specified key selector function.
  - groupBy
```
public <TKey> Queryable<Grouping<TKey,TSource>> groupBy(FunctionExpression<Function1<TSource,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
```
public <TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                                  FunctionExpression<Function1<TSource,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
```
public <TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                                  FunctionExpression<Function1<TSource,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
```
public <TKey,TResult> Queryable<TResult> groupByK(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                  FunctionExpression<Function2<TKey,Enumerable<TSource>,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.
    NOTE: Renamed from groupBy to distinguish from groupBy(org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression), which has the same erasure.
  - groupByK
```
public <TKey,TResult> Queryable<TResult> groupByK(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                  FunctionExpression<Function2<TKey,Enumerable<TSource>,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
```
public <TKey,TElement,TResult> Queryable<TResult> groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                          FunctionExpression<Function1<TSource,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 <TKey,TElement,TResult> Queryable<TResult> groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                          FunctionExpression<Function1<TSource,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 <TInner,TKey,TResult> Queryable<TResult> groupJoin(Enumerable<TInner> inner,
                                                          FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
                                                          FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                          FunctionExpression<Function2<TSource,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 <TInner,TKey,TResult> Queryable<TResult> groupJoin(Enumerable<TInner> inner,
                                                          FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
                                                          FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                          FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector,
                                                          EqualityComparer<TKey> comparer)
```
    Correlates the elements of two sequences based on key equality and groups the results. A specified EqualityComparer<TSource> is used to compare keys.
  - intersect
```
public Queryable<TSource> intersect(Enumerable<TSource> enumerable)
```
    Produces the set intersection of two sequences by using the default equality comparer to compare values, eliminate duplicates.(Defined by Queryable.)
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<TSource>
  - intersect
```
public Queryable<TSource> intersect(Enumerable<TSource> enumerable,
                                    boolean all)
```
    Produces the set intersection of two sequences by using the default equality comparer to compare values, using all to indicate whether to eliminate duplicates. (Defined by Queryable.)
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<TSource>
  - intersect
```
public Queryable<TSource> intersect(Enumerable<TSource> enumerable,
                                    EqualityComparer<TSource> comparer)
```
    Produces the set intersection of two sequences by using the specified EqualityComparer<TSource> to compare values, eliminate duplicates.
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<TSource>
  - intersect
```
public Queryable<TSource> intersect(Enumerable<TSource> enumerable,
                                    EqualityComparer<TSource> comparer,
                                    boolean all)
```
    Produces the set intersection of two sequences by using the specified EqualityComparer<TSource> to compare values, using all to indicate whether to eliminate duplicates.
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<TSource>
  - join
```
public <TInner,TKey,TResult> Queryable<TResult> join(Enumerable<TInner> inner,
                                                     FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
                                                     FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                     FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector)
```
    Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
  - join
```
public <TInner,TKey,TResult> Queryable<TResult> join(Enumerable<TInner> inner,
                                                     FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
                                                     FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
                                                     FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector,
                                                     EqualityComparer<TKey> comparer)
```
    Correlates the elements of two sequences based on matching keys. A specified EqualityComparer<TSource> is used to compare keys.
  - last
```
public TSource last(FunctionExpression<Predicate1<TSource>> predicate)
```
    Returns the last element of a sequence that satisfies a specified condition.
  - lastOrDefault
```
public TSource lastOrDefault(FunctionExpression<Predicate1<TSource>> predicate)
```
    Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
  - longCount
```
public long longCount(FunctionExpression<Predicate1<TSource>> predicate)
```
    Returns an long that represents the number of elements in a sequence that satisfy a condition.
  - max
```
public <TResult extends Comparable<TResult>> TResult max(FunctionExpression<Function1<TSource,TResult>> selector)
```
    Invokes a projection function on each element of a generic IQueryable<TSource> and returns the maximum resulting value.
  - min
```
public <TResult extends Comparable<TResult>> TResult min(FunctionExpression<Function1<TSource,TResult>> selector)
```
    Invokes a projection function on each element of a generic IQueryable<TSource> and returns the minimum resulting value.
  - ofType
```
public <TResult> Queryable<TResult> ofType(Class<TResult> clazz)
```
    Filters the elements of an IQueryable based on a specified type.
    The OfType method generates a MethodCallExpression that represents calling OfType itself as a constructed generic method. It then passes the MethodCallExpression to the CreateQuery(Expression) 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.
    
    指定者:
    
    ofType 在接口中 ExtendedEnumerable<TSource>
    
    类型参数:
    
    TResult - Target type
    
    参数:
    
    clazz - Target type
    
    返回:
    
    Collection of T2
  - cast
```
public <T2> Queryable<T2> cast(Class<T2> clazz)
```
    从接口复制的说明: ExtendedEnumerable
    
    Converts the elements of this Enumerable to the specified type.
    This method is implemented by using deferred execution. The immediate return value is an object that stores all the information that is required to perform the action. The query represented by this method is not executed until the object is enumerated either by calling its RawEnumerable.enumerator() method directly or by using for (... in ...).
    If an element cannot be cast to type TResult, the Enumerator.current() method will throw a ClassCastException a exception when the element it accessed. To obtain only those elements that can be cast to type TResult, use the ExtendedEnumerable.ofType(Class) method instead.
    
    指定者:
    
    cast 在接口中 ExtendedEnumerable<TSource>
    
    另请参阅:
    
    EnumerableDefaults.cast(org.apache.calcite.linq4j.Enumerable<TSource>, java.lang.Class<T2>), ExtendedEnumerable.ofType(Class)
  - orderBy
```
public <TKey extends Comparable> OrderedQueryable<TSource> orderBy(FunctionExpression<Function1<TSource,TKey>> keySelector)
```
    Sorts the elements of a sequence in ascending order according to a key.
  - orderBy
```
public <TKey> OrderedQueryable<TSource> orderBy(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                Comparator<TKey> comparator)
```
    Sorts the elements of a sequence in ascending order by using a specified comparer.
  - orderByDescending
```
public <TKey extends Comparable> OrderedQueryable<TSource> orderByDescending(FunctionExpression<Function1<TSource,TKey>> keySelector)
```
    Sorts the elements of a sequence in descending order according to a key.
  - orderByDescending
```
public <TKey> OrderedQueryable<TSource> orderByDescending(FunctionExpression<Function1<TSource,TKey>> keySelector,
                                                          Comparator<TKey> comparator)
```
    Sorts the elements of a sequence in descending order by using a specified comparer.
  - reverse
```
public Queryable<TSource> reverse()
```
    Inverts the order of the elements in a sequence.
    
    指定者:
    
    reverse 在接口中 ExtendedEnumerable<TSource>
  - select
```
public <TResult> Queryable<TResult> select(FunctionExpression<Function1<TSource,TResult>> selector)
```
    Projects each element of a sequence into a new form.
  - selectN
```
public <TResult> Queryable<TResult> selectN(FunctionExpression<Function2<TSource,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.tree.FunctionExpression).
  - selectMany
```
public <TResult> Queryable<TResult> selectMany(FunctionExpression<Function1<TSource,Enumerable<TResult>>> selector)
```
    Projects each element of a sequence to an Enumerable<TSource> and combines the resulting sequences into one sequence.
  - selectManyN
```
public <TResult> Queryable<TResult> selectManyN(FunctionExpression<Function2<TSource,Integer,Enumerable<TResult>>> selector)
```
    Projects each element of a sequence to an Enumerable<TSource> 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.tree.FunctionExpression)
  - selectMany
```
public <TCollection,TResult> Queryable<TResult> selectMany(FunctionExpression<Function2<TSource,Integer,Enumerable<TCollection>>> collectionSelector,
                                                           FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)
```
    Projects each element of a sequence to an Enumerable<TSource> 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 <TCollection,TResult> Queryable<TResult> selectManyN(FunctionExpression<Function1<TSource,Enumerable<TCollection>>> collectionSelector,
                                                            FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)
```
    Projects each element of a sequence to an Enumerable<TSource> 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.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression)
  - single
```
public TSource single(FunctionExpression<Predicate1<TSource>> 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 TSource singleOrDefault()
```
    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 在接口中 ExtendedEnumerable<TSource>
  - singleOrDefault
```
public TSource singleOrDefault(FunctionExpression<Predicate1<TSource>> 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 Queryable<TSource> skip(int count)
```
    Bypasses a specified number of elements in a sequence and then returns the remaining elements.
    
    指定者:
    
    skip 在接口中 ExtendedEnumerable<TSource>
  - skipWhile
```
public Queryable<TSource> skipWhile(FunctionExpression<Predicate1<TSource>> predicate)
```
    Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
  - skipWhileN
```
public Queryable<TSource> skipWhileN(FunctionExpression<Predicate2<TSource,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 BigDecimal sumBigDecimal(FunctionExpression<BigDecimalFunction1<TSource>> 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 BigDecimal sumNullableBigDecimal(FunctionExpression<NullableBigDecimalFunction1<TSource>> 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 double sumDouble(FunctionExpression<DoubleFunction1<TSource>> 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 Double sumNullableDouble(FunctionExpression<NullableDoubleFunction1<TSource>> 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 int sumInteger(FunctionExpression<IntegerFunction1<TSource>> 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 Integer sumNullableInteger(FunctionExpression<NullableIntegerFunction1<TSource>> 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 long sumLong(FunctionExpression<LongFunction1<TSource>> 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 Long sumNullableLong(FunctionExpression<NullableLongFunction1<TSource>> 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 float sumFloat(FunctionExpression<FloatFunction1<TSource>> 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 Float sumNullableFloat(FunctionExpression<NullableFloatFunction1<TSource>> 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 Queryable<TSource> take(int count)
```
    Returns a specified number of contiguous elements from the start of a sequence.
    
    指定者:
    
    take 在接口中 ExtendedEnumerable<TSource>
  - takeWhile
```
public Queryable<TSource> takeWhile(FunctionExpression<Predicate1<TSource>> predicate)
```
    Returns elements from a sequence as long as a specified condition is true.
  - takeWhileN
```
public Queryable<TSource> takeWhileN(FunctionExpression<Predicate2<TSource,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.
  - union
```
public Queryable<TSource> union(Enumerable<TSource> source1)
```
    Produces the set union of two sequences by using the default equality comparer.
    
    指定者:
    
    union 在接口中 ExtendedEnumerable<TSource>
  - union
```
public Queryable<TSource> union(Enumerable<TSource> source1,
                                EqualityComparer<TSource> comparer)
```
    Produces the set union of two sequences by using a specified EqualityComparer<TSource>.
    
    指定者:
    
    union 在接口中 ExtendedEnumerable<TSource>
  - where
```
public Queryable<TSource> where(FunctionExpression<? extends Predicate1<TSource>> predicate)
```
    Filters a sequence of values based on a predicate.
  - whereN
```
public Queryable<TSource> whereN(FunctionExpression<? extends Predicate2<TSource,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 <T1,TResult> Queryable<TResult> zip(Enumerable<T1> source1,
                                           FunctionExpression<Function2<TSource,T1,TResult>> resultSelector)
```
    Merges two sequences by using the specified predicate function.
  - getThis
```
protected Queryable<T> getThis()
```
    从类复制的说明: DefaultEnumerable
    
    Derived classes might wish to override this method to return the "outer" enumerable.
    
    覆盖:
    
    getThis 在类中 DefaultEnumerable<T>
  - getThisOrderedQueryable
```
protected OrderedQueryable<T> getThisOrderedQueryable()
```
  - asEnumerable
```
public Enumerable<T> asEnumerable()
```
    从接口复制的说明: ExtendedEnumerable
    
    Returns the input typed as Enumerable<TSource>.
    This method has no effect other than to change the compile-time type of source from a type that implements Enumerable<TSource> to Enumerable<TSource> itself.
    asEnumerable<TSource>(Enumerable<TSource>) can be used to choose between query implementations when a sequence implements Enumerable<TSource> but also has a different set of public query methods available. For example, given a generic class Table that implements Enumerable<TSource> and has its own methods such as where, select, and selectMany, a call to where would invoke the public where method of Table. A Table type that represents a database table could have a where method that takes the predicate argument as an expression tree and converts the tree to SQL for remote execution. If remote execution is not desired, for example because the predicate invokes a local method, the asEnumerable<TSource> method can be used to hide the custom methods and instead make the standard query operators available.
    
    指定者:
    
    asEnumerable 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    asEnumerable 在类中 DefaultEnumerable<T>
  - union
```
public Queryable<T> union(Enumerable<T> source1)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set union of two sequences by using the default equality comparer.
    
    指定者:
    
    union 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    union 在类中 DefaultEnumerable<T>
  - union
```
public Queryable<T> union(Enumerable<T> source1,
                          EqualityComparer<T> comparer)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set union of two sequences by using a specified EqualityComparer<TSource>.
    
    指定者:
    
    union 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    union 在类中 DefaultEnumerable<T>
  - intersect
```
public Queryable<T> intersect(Enumerable<T> source1)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set intersection of two sequences by using the default equality comparer to compare values, eliminate duplicates. (Defined by Enumerable.)
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    intersect 在类中 DefaultEnumerable<T>
  - intersect
```
public Queryable<T> intersect(Enumerable<T> source1,
                              boolean all)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set intersection of two sequences by using the default equality comparer to compare values, using all to indicate whether to eliminate duplicates. (Defined by Enumerable.)
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    intersect 在类中 DefaultEnumerable<T>
  - intersect
```
public Queryable<T> intersect(Enumerable<T> source1,
                              EqualityComparer<T> comparer)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set intersection of two sequences by using the specified EqualityComparer<TSource> to compare values, eliminate duplicates.
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    intersect 在类中 DefaultEnumerable<T>
  - intersect
```
public Queryable<T> intersect(Enumerable<T> source1,
                              EqualityComparer<T> comparer,
                              boolean all)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set intersection of two sequences by using the specified EqualityComparer<TSource> to compare values, using all to indicate whether to eliminate duplicates.
    
    指定者:
    
    intersect 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    intersect 在类中 DefaultEnumerable<T>
  - except
```
public Queryable<T> except(Enumerable<T> enumerable1,
                           EqualityComparer<T> comparer)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set difference of two sequences by using the specified EqualityComparer<TSource> to compare values, eliminate duplicates.
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    except 在类中 DefaultEnumerable<T>
  - except
```
public Queryable<T> except(Enumerable<T> enumerable1,
                           EqualityComparer<T> comparer,
                           boolean all)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set difference of two sequences by using the specified EqualityComparer<TSource> to compare values, using all to indicate whether to eliminate duplicates.
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    except 在类中 DefaultEnumerable<T>
  - except
```
public Queryable<T> except(Enumerable<T> enumerable1)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set difference of two sequences by using the default equality comparer to compare values, eliminate duplicates. (Defined by Enumerable.)
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    except 在类中 DefaultEnumerable<T>
  - except
```
public Queryable<T> except(Enumerable<T> enumerable1,
                           boolean all)
```
    从接口复制的说明: ExtendedEnumerable
    
    Produces the set difference of two sequences by using the default equality comparer to compare values, using all to indicate whether to eliminate duplicates. (Defined by Enumerable.)
    
    指定者:
    
    except 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    except 在类中 DefaultEnumerable<T>
  - take
```
public Queryable<T> take(int count)
```
    从接口复制的说明: ExtendedEnumerable
    
    Returns a specified number of contiguous elements from the start of a sequence.
    
    指定者:
    
    take 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    take 在类中 DefaultEnumerable<T>
  - skip
```
public Queryable<T> skip(int count)
```
    从接口复制的说明: ExtendedEnumerable
    
    Bypasses a specified number of elements in a sequence and then returns the remaining elements.
    
    指定者:
    
    skip 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    skip 在类中 DefaultEnumerable<T>
  - reverse
```
public Queryable<T> reverse()
```
    从接口复制的说明: ExtendedEnumerable
    
    Inverts the order of the elements in a sequence.
    
    指定者:
    
    reverse 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    reverse 在类中 DefaultEnumerable<T>
  - distinct
```
public Queryable<T> distinct()
```
    从接口复制的说明: ExtendedEnumerable
    
    Returns distinct elements from a sequence by using the default equality comparer to compare values.
    
    指定者:
    
    distinct 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    distinct 在类中 DefaultEnumerable<T>
  - distinct
```
public Queryable<T> distinct(EqualityComparer<T> comparer)
```
    从接口复制的说明: ExtendedEnumerable
    
    Returns distinct elements from a sequence by using a specified EqualityComparer<TSource> to compare values.
    
    指定者:
    
    distinct 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    distinct 在类中 DefaultEnumerable<T>
  - ofType
```
public <TResult> Queryable<TResult> ofType(Class<TResult> clazz)
```
    从接口复制的说明: ExtendedEnumerable
    
    Filters the elements of an Enumerable based on a specified type.
    Analogous to LINQ's Enumerable.OfType extension method.
    
    指定者:
    
    ofType 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    ofType 在类中 DefaultEnumerable<T>
    
    类型参数:
    
    TResult - Target type
    
    参数:
    
    clazz - Target type
    
    返回:
    
    Collection of T2
  - defaultIfEmpty
```
public Queryable<T> defaultIfEmpty()
```
    从接口复制的说明: ExtendedEnumerable
    
    Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
    
    指定者:
    
    defaultIfEmpty 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    defaultIfEmpty 在类中 DefaultEnumerable<T>
  - asQueryable
```
public Queryable<T> asQueryable()
```
    从接口复制的说明: Enumerable
    
    Converts this Enumerable to a Queryable.
    
    指定者:
    
    asQueryable 在接口中 Enumerable<T>
    
    指定者:
    
    asQueryable 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    asQueryable 在类中 DefaultEnumerable<T>
    
    返回:
    
    A queryable
    
    另请参阅:
    
    EnumerableDefaults.asQueryable(Enumerable)
  - cast
```
public <T2> Queryable<T2> cast(Class<T2> clazz)
```
    从接口复制的说明: ExtendedEnumerable
    
    Converts the elements of this Enumerable to the specified type.
    This method is implemented by using deferred execution. The immediate return value is an object that stores all the information that is required to perform the action. The query represented by this method is not executed until the object is enumerated either by calling its RawEnumerable.enumerator() method directly or by using for (... in ...).
    If an element cannot be cast to type TResult, the Enumerator.current() method will throw a ClassCastException a exception when the element it accessed. To obtain only those elements that can be cast to type TResult, use the ExtendedEnumerable.ofType(Class) method instead.
    
    指定者:
    
    cast 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    cast 在类中 DefaultEnumerable<T>
    
    另请参阅:
    
    EnumerableDefaults.cast(org.apache.calcite.linq4j.Enumerable<TSource>, java.lang.Class<T2>), ExtendedEnumerable.ofType(Class)
  - aggregate
```
public T aggregate(FunctionExpression<Function2<T,T,T>> selector)
```
    Applies an accumulator function over a sequence.
  - aggregate
```
public <TAccumulate> TAccumulate aggregate(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
```
public <TAccumulate,TResult> TResult aggregate(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 boolean all(FunctionExpression<Predicate1<T>> predicate)
```
    Determines whether all the elements of a sequence satisfy a condition.
  - any
```
public boolean any(FunctionExpression<Predicate1<T>> predicate)
```
    Determines whether any element of a sequence satisfies a condition.
  - averageBigDecimal
```
public BigDecimal averageBigDecimal(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 BigDecimal averageNullableBigDecimal(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 double averageDouble(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 Double averageNullableDouble(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 int averageInteger(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 Integer averageNullableInteger(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 float averageFloat(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 Float averageNullableFloat(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 long averageLong(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 Long averageNullableLong(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
```
public Queryable<T> concat(Enumerable<T> source2)
```
    从接口复制的说明: ExtendedEnumerable
    
    Concatenates two sequences.
    
    指定者:
    
    concat 在接口中 ExtendedEnumerable<T>
    
    覆盖:
    
    concat 在类中 DefaultEnumerable<T>
  - count
```
public int count(FunctionExpression<Predicate1<T>> func)
```
    Returns the number of elements in the specified sequence that satisfies a condition.
  - first
```
public T first(FunctionExpression<Predicate1<T>> predicate)
```
    Returns the first element of a sequence that satisfies a specified condition.
  - firstOrDefault
```
public T firstOrDefault(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 <TKey> Queryable<Grouping<TKey,T>> groupBy(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Groups the elements of a sequence according to a specified key selector function.
  - groupBy
```
public <TKey> Queryable<Grouping<TKey,T>> groupBy(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
```
public <TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(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
```
public <TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(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
```
public <TKey,TResult> Queryable<TResult> groupByK(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.
    NOTE: Renamed from groupBy to distinguish from groupBy(org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression), which has the same erasure.
  - groupByK
```
public <TKey,TResult> Queryable<TResult> groupByK(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
```
public <TKey,TElement,TResult> Queryable<TResult> groupBy(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 <TKey,TElement,TResult> Queryable<TResult> groupBy(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 <TInner,TKey,TResult> Queryable<TResult> groupJoin(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
```
public <TInner,TKey,TResult> Queryable<TResult> groupJoin(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<TSource> is used to compare keys.
  - join
```
public <TInner,TKey,TResult> Queryable<TResult> join(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
```
public <TInner,TKey,TResult> Queryable<TResult> join(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<TSource> is used to compare keys.
  - last
```
public T last(FunctionExpression<Predicate1<T>> predicate)
```
    Returns the last element of a sequence that satisfies a specified condition.
  - lastOrDefault
```
public T lastOrDefault(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 long longCount(FunctionExpression<Predicate1<T>> predicate)
```
    Returns an long that represents the number of elements in a sequence that satisfy a condition.
  - max
```
public <TResult extends Comparable<TResult>> TResult max(FunctionExpression<Function1<T,TResult>> selector)
```
    Invokes a projection function on each element of a generic IQueryable<TSource> and returns the maximum resulting value.
  - min
```
public <TResult extends Comparable<TResult>> TResult min(FunctionExpression<Function1<T,TResult>> selector)
```
    Invokes a projection function on each element of a generic IQueryable<TSource> and returns the minimum resulting value.
  - orderBy
```
public <TKey extends Comparable> OrderedQueryable<T> orderBy(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Sorts the elements of a sequence in ascending order according to a key.
  - orderBy
```
public <TKey> OrderedQueryable<T> orderBy(FunctionExpression<Function1<T,TKey>> keySelector,
                                          Comparator<TKey> comparator)
```
    Sorts the elements of a sequence in ascending order by using a specified comparer.
  - orderByDescending
```
public <TKey extends Comparable> OrderedQueryable<T> orderByDescending(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Sorts the elements of a sequence in descending order according to a key.
  - orderByDescending
```
public <TKey> OrderedQueryable<T> orderByDescending(FunctionExpression<Function1<T,TKey>> keySelector,
                                                    Comparator<TKey> comparator)
```
    Sorts the elements of a sequence in descending order by using a specified comparer.
  - select
```
public <TResult> Queryable<TResult> select(FunctionExpression<Function1<T,TResult>> selector)
```
    Projects each element of a sequence into a new form.
  - selectN
```
public <TResult> Queryable<TResult> selectN(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.tree.FunctionExpression).
  - selectMany
```
public <TResult> Queryable<TResult> selectMany(FunctionExpression<Function1<T,Enumerable<TResult>>> selector)
```
    Projects each element of a sequence to an Enumerable<TSource> and combines the resulting sequences into one sequence.
  - selectManyN
```
public <TResult> Queryable<TResult> selectManyN(FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)
```
    Projects each element of a sequence to an Enumerable<TSource> 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.tree.FunctionExpression)
  - selectMany
```
public <TCollection,TResult> Queryable<TResult> selectMany(FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector,
                                                           FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
```
    Projects each element of a sequence to an Enumerable<TSource> 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 <TCollection,TResult> Queryable<TResult> selectManyN(FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
                                                            FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
```
    Projects each element of a sequence to an Enumerable<TSource> 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.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression)
  - single
```
public T single(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 T singleOrDefault(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.
  - skipWhile
```
public Queryable<T> skipWhile(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 Queryable<T> skipWhileN(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 BigDecimal sumBigDecimal(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 BigDecimal sumNullableBigDecimal(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 double sumDouble(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 Double sumNullableDouble(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 int sumInteger(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 Integer sumNullableInteger(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 long sumLong(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 Long sumNullableLong(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 float sumFloat(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 Float sumNullableFloat(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.
  - takeWhile
```
public Queryable<T> takeWhile(FunctionExpression<Predicate1<T>> predicate)
```
    Returns elements from a sequence as long as a specified condition is true.
  - takeWhileN
```
public Queryable<T> takeWhileN(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 <TKey extends Comparable<TKey>> OrderedQueryable<T> thenBy(FunctionExpression<Function1<T,TKey>> keySelector)
```
    从接口复制的说明: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
    
    指定者:
    
    thenBy 在接口中 ExtendedOrderedQueryable<T>
  - thenBy
```
public <TKey> OrderedQueryable<T> thenBy(FunctionExpression<Function1<T,TKey>> keySelector,
                                         Comparator<TKey> comparator)
```
    从接口复制的说明: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in ascending order according to a key, using a specified comparator.
    
    指定者:
    
    thenBy 在接口中 ExtendedOrderedQueryable<T>
  - thenByDescending
```
public <TKey extends Comparable<TKey>> OrderedQueryable<T> thenByDescending(FunctionExpression<Function1<T,TKey>> keySelector)
```
    从接口复制的说明: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in descending order according to a key.
    
    指定者:
    
    thenByDescending 在接口中 ExtendedOrderedQueryable<T>
  - thenByDescending
```
public <TKey> OrderedQueryable<T> thenByDescending(FunctionExpression<Function1<T,TKey>> keySelector,
                                                   Comparator<TKey> comparator)
```
    从接口复制的说明: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in descending order according to a key, using a specified comparator.
    
    指定者:
    
    thenByDescending 在接口中 ExtendedOrderedQueryable<T>
  - where
```
public Queryable<T> where(FunctionExpression<? extends Predicate1<T>> predicate)
```
    Filters a sequence of values based on a predicate.
  - whereN
```
public Queryable<T> whereN(FunctionExpression<? extends 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 <T1,TResult> Queryable<TResult> zip(Enumerable<T1> source1,
                                           FunctionExpression<Function2<T,T1,TResult>> resultSelector)
```
    Merges two sequences by using the specified predicate function.

类 QueryableDefaults.ReplayableQueryable<T>

构造器概要

方法概要

从类继承的方法 org.apache.calcite.linq4j.DefaultEnumerable

从类继承的方法 java.lang.Object

从接口继承的方法 org.apache.calcite.linq4j.RawQueryable

从接口继承的方法 org.apache.calcite.linq4j.Enumerable

从接口继承的方法 java.lang.Iterable

从接口继承的方法 org.apache.calcite.linq4j.ExtendedEnumerable

构造器详细资料

ReplayableQueryable

方法详细资料

replay

iterator

enumerator

castQueryable

aggregate

aggregate

aggregate

all

any

averageBigDecimal

averageNullableBigDecimal

averageDouble

averageNullableDouble

averageInteger

averageNullableInteger

averageFloat

averageNullableFloat

averageLong

averageNullableLong

concat

count

defaultIfEmpty

distinct

distinct

except

except

except

except

first

firstOrDefault

groupBy

groupBy

groupBy

groupBy

groupByK

groupByK

groupBy

groupBy

groupJoin

groupJoin

intersect

intersect

intersect

intersect

join

join

last

lastOrDefault

longCount

max

min

ofType

cast

orderBy

orderBy

orderByDescending

orderByDescending

reverse

select

selectN

selectMany

selectManyN

selectMany

selectManyN

single

singleOrDefault

singleOrDefault

skip