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

Type Parameters:

T - Element type

All Implemented Interfaces:

Iterable<T>, Enumerable<T>, ExtendedEnumerable<T>, ExtendedOrderedEnumerable<T>, ExtendedOrderedQueryable<T>, ExtendedQueryable<T>, OrderedEnumerable<T>, OrderedQueryable<T>, Queryable<T>, RawEnumerable<T>, RawQueryable<T>

Direct Known Subclasses:

AbstractQueryable, QueryableDefaults.ReplayableQueryable
```
abstract class DefaultQueryable<T>
extends DefaultEnumerable<T>
implements Queryable<T>, OrderedQueryable<T>
```
Implementation of the Queryable interface that implements the extension methods by calling into the Extensions class.

Field Summary

Fields
Modifier and Type Field Description

private QueryableFactory<T> factory

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`DefaultQueryable()`	Creates a DefaultQueryable using a factory that records events.
`protected`	`DefaultQueryable(QueryableFactory<T> factory)`	Creates a DefaultQueryable using a particular factory.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`T`	`aggregate(FunctionExpression<Function2<T,T,T>> 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`	`any(FunctionExpression<Predicate1<T>> 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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`<T2> Queryable<T2>`	`cast(Class<T2> clazz)`	Converts the elements of this Enumerable to the specified type.
`Queryable<T>`	`concat(Enumerable<T> source2)`	Concatenates two sequences.
`int`	`count(FunctionExpression<Predicate1<T>> func)`	Returns the number of elements in the specified sequence that satisfies a condition.
`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<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<T>`	`except(Enumerable<T> enumerable1)`	Produces the set difference of two sequences by using the default equality comparer to compare values.
`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.
`T`	`first(FunctionExpression<Predicate1<T>> 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.
`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,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<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<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.
`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.
`<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.
`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.
`long`	`longCount(FunctionExpression<Predicate1<T>> 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<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<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 Enumerable based on a specified type.
`<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<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.
`Queryable<T>`	`reverse()`	Inverts the order of the elements in a sequence.
`<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.
`<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>`	`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.
`<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>`	`selectN(FunctionExpression<Function2<T,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.
`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.
`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<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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`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.
`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<T>`	`takeWhileN(FunctionExpression<Predicate2<T,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<T>`	`where(FunctionExpression<? extends Predicate1<T>> 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.
`<T1,TResult> Queryable<TResult>`	`zip(Enumerable<T1> source1, FunctionExpression<Function2<T,T1,TResult>> resultSelector)`	Merges two sequences by using the specified predicate function.

Methods inherited from class 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, into, join, join, join, 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

Methods inherited from interface org.apache.calcite.linq4j.ExtendedQueryable
singleOrDefault

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

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

Methods inherited from interface org.apache.calcite.linq4j.RawEnumerable
enumerator

Methods inherited from interface org.apache.calcite.linq4j.RawQueryable
getElementType, getExpression, getProvider

- Field Detail
  - factory
```
private final QueryableFactory<T> factory
```
- Constructor Detail
  - DefaultQueryable
```
protected DefaultQueryable()
```
    Creates a DefaultQueryable using a factory that records events.
  - DefaultQueryable
```
protected DefaultQueryable(QueryableFactory<T> factory)
```
    Creates a DefaultQueryable using a particular factory.
- Method Detail
  - getThis
```
protected Queryable<T> getThis()
```
    Description copied from class: DefaultEnumerable
    
    Derived classes might wish to override this method to return the "outer" enumerable.
    
    Overrides:
    
    getThis in class DefaultEnumerable<T>
  - getThisOrderedQueryable
```
protected OrderedQueryable<T> getThisOrderedQueryable()
```
  - asEnumerable
```
public Enumerable<T> asEnumerable()
```
    Description copied from interface: 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.
    
    Specified by:
    
    asEnumerable in interface ExtendedEnumerable<T>
    
    Overrides:
    
    asEnumerable in class DefaultEnumerable<T>
  - union
```
public Queryable<T> union(Enumerable<T> source1)
```
    Description copied from interface: ExtendedEnumerable
    
    Produces the set union of two sequences by using the default equality comparer.
    
    Specified by:
    
    union in interface ExtendedEnumerable<T>
    
    Specified by:
    
    union in interface ExtendedQueryable<T>
    
    Overrides:
    
    union in class DefaultEnumerable<T>
  - union
```
public Queryable<T> union(Enumerable<T> source1,
                          EqualityComparer<T> comparer)
```
    Description copied from interface: ExtendedEnumerable
    
    Produces the set union of two sequences by using a specified EqualityComparer<TSource>.
    
    Specified by:
    
    union in interface ExtendedEnumerable<T>
    
    Specified by:
    
    union in interface ExtendedQueryable<T>
    
    Overrides:
    
    union in class DefaultEnumerable<T>
  - intersect
```
public Queryable<T> intersect(Enumerable<T> source1)
```
    Description copied from interface: ExtendedEnumerable
    
    Produces the set intersection of two sequences by using the default equality comparer to compare values. (Defined by Enumerable.)
    
    Specified by:
    
    intersect in interface ExtendedEnumerable<T>
    
    Specified by:
    
    intersect in interface ExtendedQueryable<T>
    
    Overrides:
    
    intersect in class DefaultEnumerable<T>
  - intersect
```
public Queryable<T> intersect(Enumerable<T> source1,
                              EqualityComparer<T> comparer)
```
    Description copied from interface: ExtendedEnumerable
    
    Produces the set intersection of two sequences by using the specified EqualityComparer<TSource> to compare values.
    
    Specified by:
    
    intersect in interface ExtendedEnumerable<T>
    
    Specified by:
    
    intersect in interface ExtendedQueryable<T>
    
    Overrides:
    
    intersect in class DefaultEnumerable<T>
  - except
```
public Queryable<T> except(Enumerable<T> enumerable1,
                           EqualityComparer<T> comparer)
```
    Description copied from interface: ExtendedEnumerable
    
    Produces the set difference of two sequences by using the specified EqualityComparer<TSource> to compare values.
    
    Specified by:
    
    except in interface ExtendedEnumerable<T>
    
    Specified by:
    
    except in interface ExtendedQueryable<T>
    
    Overrides:
    
    except in class DefaultEnumerable<T>
  - except
```
public Queryable<T> except(Enumerable<T> enumerable1)
```
    Description copied from interface: ExtendedEnumerable
    
    Produces the set difference of two sequences by using the default equality comparer to compare values. (Defined by Enumerable.)
    
    Specified by:
    
    except in interface ExtendedEnumerable<T>
    
    Specified by:
    
    except in interface ExtendedQueryable<T>
    
    Overrides:
    
    except in class DefaultEnumerable<T>
  - take
```
public Queryable<T> take(int count)
```
    Description copied from interface: ExtendedEnumerable
    
    Returns a specified number of contiguous elements from the start of a sequence.
    
    Specified by:
    
    take in interface ExtendedEnumerable<T>
    
    Specified by:
    
    take in interface ExtendedQueryable<T>
    
    Overrides:
    
    take in class DefaultEnumerable<T>
  - skip
```
public Queryable<T> skip(int count)
```
    Description copied from interface: ExtendedEnumerable
    
    Bypasses a specified number of elements in a sequence and then returns the remaining elements.
    
    Specified by:
    
    skip in interface ExtendedEnumerable<T>
    
    Specified by:
    
    skip in interface ExtendedQueryable<T>
    
    Overrides:
    
    skip in class DefaultEnumerable<T>
  - reverse
```
public Queryable<T> reverse()
```
    Description copied from interface: ExtendedEnumerable
    
    Inverts the order of the elements in a sequence.
    
    Specified by:
    
    reverse in interface ExtendedEnumerable<T>
    
    Specified by:
    
    reverse in interface ExtendedQueryable<T>
    
    Overrides:
    
    reverse in class DefaultEnumerable<T>
  - distinct
```
public Queryable<T> distinct()
```
    Description copied from interface: ExtendedEnumerable
    
    Returns distinct elements from a sequence by using the default equality comparer to compare values.
    
    Specified by:
    
    distinct in interface ExtendedEnumerable<T>
    
    Specified by:
    
    distinct in interface ExtendedQueryable<T>
    
    Overrides:
    
    distinct in class DefaultEnumerable<T>
  - distinct
```
public Queryable<T> distinct(EqualityComparer<T> comparer)
```
    Description copied from interface: ExtendedEnumerable
    
    Returns distinct elements from a sequence by using a specified EqualityComparer<TSource> to compare values.
    
    Specified by:
    
    distinct in interface ExtendedEnumerable<T>
    
    Specified by:
    
    distinct in interface ExtendedQueryable<T>
    
    Overrides:
    
    distinct in class DefaultEnumerable<T>
  - ofType
```
public <TResult> Queryable<TResult> ofType(Class<TResult> clazz)
```
    Description copied from interface: ExtendedEnumerable
    
    Filters the elements of an Enumerable based on a specified type.
    Analogous to LINQ's Enumerable.OfType extension method.
    
    Specified by:
    
    ofType in interface ExtendedEnumerable<T>
    
    Specified by:
    
    ofType in interface ExtendedQueryable<T>
    
    Overrides:
    
    ofType in class DefaultEnumerable<T>
    
    Type Parameters:
    
    TResult - Target type
    
    Parameters:
    
    clazz - Target type
    
    Returns:
    
    Collection of T2
  - defaultIfEmpty
```
public Queryable<T> defaultIfEmpty()
```
    Description copied from interface: ExtendedEnumerable
    
    Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
    
    Specified by:
    
    defaultIfEmpty in interface ExtendedEnumerable<T>
    
    Specified by:
    
    defaultIfEmpty in interface ExtendedQueryable<T>
    
    Overrides:
    
    defaultIfEmpty in class DefaultEnumerable<T>
  - asQueryable
```
public Queryable<T> asQueryable()
```
    Description copied from interface: Enumerable
    
    Converts this Enumerable to a Queryable.
    
    Specified by:
    
    asQueryable in interface Enumerable<T>
    
    Specified by:
    
    asQueryable in interface ExtendedEnumerable<T>
    
    Overrides:
    
    asQueryable in class DefaultEnumerable<T>
    
    Returns:
    
    A queryable
    
    See Also:
    
    EnumerableDefaults.asQueryable(Enumerable)
  - cast
```
public <T2> Queryable<T2> cast(Class<T2> clazz)
```
    Description copied from interface: 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.
    
    Specified by:
    
    cast in interface ExtendedEnumerable<T>
    
    Specified by:
    
    cast in interface ExtendedQueryable<T>
    
    Overrides:
    
    cast in class DefaultEnumerable<T>
    
    See Also:
    
    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)
```
    Description copied from interface: ExtendedQueryable
    
    Applies an accumulator function over a sequence.
    
    Specified by:
    
    aggregate in interface ExtendedQueryable<T>
  - aggregate
```
public <TAccumulate> TAccumulate aggregate(TAccumulate seed,
                                           FunctionExpression<Function2<TAccumulate,T,TAccumulate>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.
    
    Specified by:
    
    aggregate in interface ExtendedQueryable<T>
  - aggregate
```
public <TAccumulate,TResult> TResult aggregate(TAccumulate seed,
                                               FunctionExpression<Function2<TAccumulate,T,TAccumulate>> func,
                                               FunctionExpression<Function1<TAccumulate,TResult>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    aggregate in interface ExtendedQueryable<T>
  - all
```
public boolean all(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Determines whether all the elements of a sequence satisfy a condition.
    
    Specified by:
    
    all in interface ExtendedQueryable<T>
  - any
```
public boolean any(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Determines whether any element of a sequence satisfies a condition.
    
    Specified by:
    
    any in interface ExtendedQueryable<T>
  - averageBigDecimal
```
public BigDecimal averageBigDecimal(FunctionExpression<BigDecimalFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the average of a sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    averageBigDecimal in interface ExtendedQueryable<T>
  - averageNullableBigDecimal
```
public BigDecimal averageNullableBigDecimal(FunctionExpression<NullableBigDecimalFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    averageNullableBigDecimal in interface ExtendedQueryable<T>
  - averageDouble
```
public double averageDouble(FunctionExpression<DoubleFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the average of a sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    averageDouble in interface ExtendedQueryable<T>
  - averageNullableDouble
```
public Double averageNullableDouble(FunctionExpression<NullableDoubleFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    averageNullableDouble in interface ExtendedQueryable<T>
  - averageInteger
```
public int averageInteger(FunctionExpression<IntegerFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the average of a sequence of int values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    averageInteger in interface ExtendedQueryable<T>
  - averageNullableInteger
```
public Integer averageNullableInteger(FunctionExpression<NullableIntegerFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    averageNullableInteger in interface ExtendedQueryable<T>
  - averageFloat
```
public float averageFloat(FunctionExpression<FloatFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the average of a sequence of Float values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    averageFloat in interface ExtendedQueryable<T>
  - averageNullableFloat
```
public Float averageNullableFloat(FunctionExpression<NullableFloatFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    averageNullableFloat in interface ExtendedQueryable<T>
  - averageLong
```
public long averageLong(FunctionExpression<LongFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the average of a sequence of long values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    averageLong in interface ExtendedQueryable<T>
  - averageNullableLong
```
public Long averageNullableLong(FunctionExpression<NullableLongFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    averageNullableLong in interface ExtendedQueryable<T>
  - concat
```
public Queryable<T> concat(Enumerable<T> source2)
```
    Description copied from interface: ExtendedEnumerable
    
    Concatenates two sequences.
    
    Specified by:
    
    concat in interface ExtendedEnumerable<T>
    
    Specified by:
    
    concat in interface ExtendedQueryable<T>
    
    Overrides:
    
    concat in class DefaultEnumerable<T>
  - count
```
public int count(FunctionExpression<Predicate1<T>> func)
```
    Description copied from interface: ExtendedQueryable
    
    Returns the number of elements in the specified sequence that satisfies a condition.
    
    Specified by:
    
    count in interface ExtendedQueryable<T>
  - first
```
public T first(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Returns the first element of a sequence that satisfies a specified condition.
    
    Specified by:
    
    first in interface ExtendedQueryable<T>
  - firstOrDefault
```
public T firstOrDefault(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.
    
    Specified by:
    
    firstOrDefault in interface ExtendedQueryable<T>
  - groupBy
```
public <TKey> Queryable<Grouping<TKey,T>> groupBy(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Description copied from interface: ExtendedQueryable
    
    Groups the elements of a sequence according to a specified key selector function.
    
    Specified by:
    
    groupBy in interface ExtendedQueryable<T>
  - groupBy
```
public <TKey> Queryable<Grouping<TKey,T>> groupBy(FunctionExpression<Function1<T,TKey>> keySelector,
                                                  EqualityComparer<TKey> comparer)
```
    Description copied from interface: ExtendedQueryable
    
    Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
    
    Specified by:
    
    groupBy in interface ExtendedQueryable<T>
  - groupBy
```
public <TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(FunctionExpression<Function1<T,TKey>> keySelector,
                                                                  FunctionExpression<Function1<T,TElement>> elementSelector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    groupBy in interface ExtendedQueryable<T>
  - groupBy
```
public <TKey,TElement> Queryable<Grouping<TKey,TElement>> groupBy(FunctionExpression<Function1<T,TKey>> keySelector,
                                                                  FunctionExpression<Function1<T,TElement>> elementSelector,
                                                                  EqualityComparer<TKey> comparer)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    groupBy in interface ExtendedQueryable<T>
  - groupByK
```
public <TKey,TResult> Queryable<TResult> groupByK(FunctionExpression<Function1<T,TKey>> keySelector,
                                                  FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector)
```
    Description copied from interface: ExtendedQueryable
    
    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 ExtendedQueryable.groupBy(org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression), which has the same erasure.
    
    Specified by:
    
    groupByK in interface ExtendedQueryable<T>
  - groupByK
```
public <TKey,TResult> Queryable<TResult> groupByK(FunctionExpression<Function1<T,TKey>> keySelector,
                                                  FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector,
                                                  EqualityComparer<TKey> comparer)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    groupByK in interface ExtendedQueryable<T>
  - 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)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    groupBy in interface ExtendedQueryable<T>
  - 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)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    groupBy in interface ExtendedQueryable<T>
  - 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)
```
    Description copied from interface: ExtendedQueryable
    
    Correlates the elements of two sequences based on key equality and groups the results. The default equality comparer is used to compare keys.
    
    Specified by:
    
    groupJoin in interface ExtendedQueryable<T>
  - 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)
```
    Description copied from interface: ExtendedQueryable
    
    Correlates the elements of two sequences based on key equality and groups the results. A specified EqualityComparer<TSource> is used to compare keys.
    
    Specified by:
    
    groupJoin in interface ExtendedQueryable<T>
  - 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)
```
    Description copied from interface: ExtendedQueryable
    
    Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
    
    Specified by:
    
    join in interface ExtendedQueryable<T>
  - 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)
```
    Description copied from interface: ExtendedQueryable
    
    Correlates the elements of two sequences based on matching keys. A specified EqualityComparer<TSource> is used to compare keys.
    
    Specified by:
    
    join in interface ExtendedQueryable<T>
  - last
```
public T last(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Returns the last element of a sequence that satisfies a specified condition.
    
    Specified by:
    
    last in interface ExtendedQueryable<T>
  - lastOrDefault
```
public T lastOrDefault(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
    
    Specified by:
    
    lastOrDefault in interface ExtendedQueryable<T>
  - longCount
```
public long longCount(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Returns an long that represents the number of elements in a sequence that satisfy a condition.
    
    Specified by:
    
    longCount in interface ExtendedQueryable<T>
  - max
```
public <TResult extends Comparable<TResult>> TResult max(FunctionExpression<Function1<T,TResult>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Invokes a projection function on each element of a generic IQueryable<TSource> and returns the maximum resulting value.
    
    Specified by:
    
    max in interface ExtendedQueryable<T>
  - min
```
public <TResult extends Comparable<TResult>> TResult min(FunctionExpression<Function1<T,TResult>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Invokes a projection function on each element of a generic IQueryable<TSource> and returns the minimum resulting value.
    
    Specified by:
    
    min in interface ExtendedQueryable<T>
  - orderBy
```
public <TKey extends Comparable> OrderedQueryable<T> orderBy(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Description copied from interface: ExtendedQueryable
    
    Sorts the elements of a sequence in ascending order according to a key.
    
    Specified by:
    
    orderBy in interface ExtendedQueryable<T>
  - orderBy
```
public <TKey> OrderedQueryable<T> orderBy(FunctionExpression<Function1<T,TKey>> keySelector,
                                          Comparator<TKey> comparator)
```
    Description copied from interface: ExtendedQueryable
    
    Sorts the elements of a sequence in ascending order by using a specified comparer.
    
    Specified by:
    
    orderBy in interface ExtendedQueryable<T>
  - orderByDescending
```
public <TKey extends Comparable> OrderedQueryable<T> orderByDescending(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Description copied from interface: ExtendedQueryable
    
    Sorts the elements of a sequence in descending order according to a key.
    
    Specified by:
    
    orderByDescending in interface ExtendedQueryable<T>
  - orderByDescending
```
public <TKey> OrderedQueryable<T> orderByDescending(FunctionExpression<Function1<T,TKey>> keySelector,
                                                    Comparator<TKey> comparator)
```
    Description copied from interface: ExtendedQueryable
    
    Sorts the elements of a sequence in descending order by using a specified comparer.
    
    Specified by:
    
    orderByDescending in interface ExtendedQueryable<T>
  - select
```
public <TResult> Queryable<TResult> select(FunctionExpression<Function1<T,TResult>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Projects each element of a sequence into a new form.
    
    Specified by:
    
    select in interface ExtendedQueryable<T>
  - selectN
```
public <TResult> Queryable<TResult> selectN(FunctionExpression<Function2<T,Integer,TResult>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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 ExtendedQueryable.select(org.apache.calcite.linq4j.tree.FunctionExpression).
    
    Specified by:
    
    selectN in interface ExtendedQueryable<T>
  - selectMany
```
public <TResult> Queryable<TResult> selectMany(FunctionExpression<Function1<T,Enumerable<TResult>>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Projects each element of a sequence to an Enumerable<TSource> and combines the resulting sequences into one sequence.
    
    Specified by:
    
    selectMany in interface ExtendedQueryable<T>
  - selectManyN
```
public <TResult> Queryable<TResult> selectManyN(FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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 ExtendedQueryable.selectMany(org.apache.calcite.linq4j.tree.FunctionExpression)
    
    Specified by:
    
    selectManyN in interface ExtendedQueryable<T>
  - selectMany
```
public <TCollection,TResult> Queryable<TResult> selectMany(FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector,
                                                           FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    selectMany in interface ExtendedQueryable<T>
  - selectManyN
```
public <TCollection,TResult> Queryable<TResult> selectManyN(FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
                                                            FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
```
    Description copied from interface: ExtendedQueryable
    
    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 ExtendedQueryable.selectMany(org.apache.calcite.linq4j.tree.FunctionExpression, org.apache.calcite.linq4j.tree.FunctionExpression)
    
    Specified by:
    
    selectManyN in interface ExtendedQueryable<T>
  - single
```
public T single(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.
    
    Specified by:
    
    single in interface ExtendedQueryable<T>
  - singleOrDefault
```
public T singleOrDefault(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    singleOrDefault in interface ExtendedQueryable<T>
  - skipWhile
```
public Queryable<T> skipWhile(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
    
    Specified by:
    
    skipWhile in interface ExtendedQueryable<T>
  - skipWhileN
```
public Queryable<T> skipWhileN(FunctionExpression<Predicate2<T,Integer>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    skipWhileN in interface ExtendedQueryable<T>
  - sumBigDecimal
```
public BigDecimal sumBigDecimal(FunctionExpression<BigDecimalFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the sum of the sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    sumBigDecimal in interface ExtendedQueryable<T>
  - sumNullableBigDecimal
```
public BigDecimal sumNullableBigDecimal(FunctionExpression<NullableBigDecimalFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    sumNullableBigDecimal in interface ExtendedQueryable<T>
  - sumDouble
```
public double sumDouble(FunctionExpression<DoubleFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the sum of the sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    sumDouble in interface ExtendedQueryable<T>
  - sumNullableDouble
```
public Double sumNullableDouble(FunctionExpression<NullableDoubleFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    sumNullableDouble in interface ExtendedQueryable<T>
  - sumInteger
```
public int sumInteger(FunctionExpression<IntegerFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the sum of the sequence of int values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    sumInteger in interface ExtendedQueryable<T>
  - sumNullableInteger
```
public Integer sumNullableInteger(FunctionExpression<NullableIntegerFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    sumNullableInteger in interface ExtendedQueryable<T>
  - sumLong
```
public long sumLong(FunctionExpression<LongFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the sum of the sequence of long values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    sumLong in interface ExtendedQueryable<T>
  - sumNullableLong
```
public Long sumNullableLong(FunctionExpression<NullableLongFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    sumNullableLong in interface ExtendedQueryable<T>
  - sumFloat
```
public float sumFloat(FunctionExpression<FloatFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    Computes the sum of the sequence of Float values that is obtained by invoking a projection function on each element of the input sequence.
    
    Specified by:
    
    sumFloat in interface ExtendedQueryable<T>
  - sumNullableFloat
```
public Float sumNullableFloat(FunctionExpression<NullableFloatFunction1<T>> selector)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    sumNullableFloat in interface ExtendedQueryable<T>
  - takeWhile
```
public Queryable<T> takeWhile(FunctionExpression<Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Returns elements from a sequence as long as a specified condition is true.
    
    Specified by:
    
    takeWhile in interface ExtendedQueryable<T>
  - takeWhileN
```
public Queryable<T> takeWhileN(FunctionExpression<Predicate2<T,Integer>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    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.
    
    Specified by:
    
    takeWhileN in interface ExtendedQueryable<T>
  - thenBy
```
public <TKey extends Comparable<TKey>> OrderedQueryable<T> thenBy(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Description copied from interface: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
    
    Specified by:
    
    thenBy in interface ExtendedOrderedQueryable<T>
  - thenBy
```
public <TKey> OrderedQueryable<T> thenBy(FunctionExpression<Function1<T,TKey>> keySelector,
                                         Comparator<TKey> comparator)
```
    Description copied from interface: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in ascending order according to a key, using a specified comparator.
    
    Specified by:
    
    thenBy in interface ExtendedOrderedQueryable<T>
  - thenByDescending
```
public <TKey extends Comparable<TKey>> OrderedQueryable<T> thenByDescending(FunctionExpression<Function1<T,TKey>> keySelector)
```
    Description copied from interface: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in descending order according to a key.
    
    Specified by:
    
    thenByDescending in interface ExtendedOrderedQueryable<T>
  - thenByDescending
```
public <TKey> OrderedQueryable<T> thenByDescending(FunctionExpression<Function1<T,TKey>> keySelector,
                                                   Comparator<TKey> comparator)
```
    Description copied from interface: ExtendedOrderedQueryable
    
    Performs a subsequent ordering of the elements in a sequence in descending order according to a key, using a specified comparator.
    
    Specified by:
    
    thenByDescending in interface ExtendedOrderedQueryable<T>
  - where
```
public Queryable<T> where(FunctionExpression<? extends Predicate1<T>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Filters a sequence of values based on a predicate.
    
    Specified by:
    
    where in interface ExtendedQueryable<T>
  - whereN
```
public Queryable<T> whereN(FunctionExpression<? extends Predicate2<T,Integer>> predicate)
```
    Description copied from interface: ExtendedQueryable
    
    Filters a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function.
    
    Specified by:
    
    whereN in interface ExtendedQueryable<T>
  - zip
```
public <T1,TResult> Queryable<TResult> zip(Enumerable<T1> source1,
                                           FunctionExpression<Function2<T,T1,TResult>> resultSelector)
```
    Description copied from interface: ExtendedQueryable
    
    Merges two sequences by using the specified predicate function.
    
    Specified by:
    
    zip in interface ExtendedQueryable<T>

Class DefaultQueryable<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.apache.calcite.linq4j.DefaultEnumerable

Methods inherited from interface org.apache.calcite.linq4j.ExtendedQueryable

Methods inherited from interface java.lang.Iterable

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.calcite.linq4j.RawEnumerable

Methods inherited from interface org.apache.calcite.linq4j.RawQueryable

Field Detail

factory

Constructor Detail

DefaultQueryable

DefaultQueryable

Method Detail

getThis

getThisOrderedQueryable

asEnumerable

union

union

intersect

intersect

except

except

take

skip

reverse

distinct

distinct

ofType

defaultIfEmpty

asQueryable

cast

aggregate

aggregate

aggregate

all

any

averageBigDecimal

averageNullableBigDecimal

averageDouble

averageNullableDouble

averageInteger

averageNullableInteger

averageFloat

averageNullableFloat

averageLong

averageNullableLong

concat

count

first

firstOrDefault

groupBy

groupBy

groupBy

groupBy

groupByK

groupByK

groupBy

groupBy

groupJoin

groupJoin

join

join

last

lastOrDefault

longCount

max

min

orderBy

orderBy

orderByDescending

orderByDescending

select

selectN

selectMany

selectManyN

selectMany

selectManyN