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) { return factory.join(getThis(), inner, outerKeySelector, innerKeySelector, resultSelector); }
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) { return factory.groupBy(getThis(), keySelector, elementSelector, resultSelector, comparer); }
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) { return factory.groupJoin( getThis(), inner, outerKeySelector, innerKeySelector, resultSelector, comparer); }
@Override public Queryable<T> except(Enumerable<T> enumerable1) { return factory.except(getThis(), enumerable1); }
@Override public Queryable<T> intersect(Enumerable<T> source1, EqualityComparer<T> comparer) { return factory.intersect(getThis(), source1, comparer); }
@Override public Queryable<T> union(Enumerable<T> source1, EqualityComparer<T> comparer) { return factory.union(getThis(), source1, comparer); }
public <T1, TResult> Queryable<TResult> zip( Enumerable<T1> source1, FunctionExpression<Function2<T, T1, TResult>> resultSelector) { return factory.zip(getThis(), source1, resultSelector); }
public Queryable<T> where(FunctionExpression<? extends Predicate1<T>> predicate) { return factory.where(getThis(), predicate); }
public <TKey extends Comparable<TKey>> OrderedQueryable<T> thenBy( FunctionExpression<Function1<T, TKey>> keySelector) { return factory.thenBy(getThisOrderedQueryable(), keySelector); }
public double sumDouble(FunctionExpression<DoubleFunction1<T>> selector) { return factory.sumDouble(getThis(), selector); }
public BigDecimal sumNullableBigDecimal( FunctionExpression<NullableBigDecimalFunction1<T>> selector) { return factory.sumNullableBigDecimal(getThis(), selector); }
public T singleOrDefault(FunctionExpression<Predicate1<T>> predicate) { return factory.singleOrDefault(getThis(), predicate); }
public <TCollection, TResult> Queryable<TResult> selectManyN( FunctionExpression<Function1<T, Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T, TCollection, TResult>> resultSelector) { return factory.selectManyN(getThis(), collectionSelector, resultSelector); }
public <TResult> Queryable<TResult> selectManyN( FunctionExpression<Function2<T, Integer, Enumerable<TResult>>> selector) { return factory.selectManyN(getThis(), selector); }
public <TResult> Queryable<TResult> select(FunctionExpression<Function1<T, TResult>> selector) { return factory.select(getThis(), selector); }
public Queryable<T> takeWhile(FunctionExpression<Predicate1<T>> predicate) { return factory.takeWhile(getThis(), predicate); }
public Queryable<T> takeWhileN(FunctionExpression<Predicate2<T, Integer>> predicate) { return factory.takeWhileN(getThis(), predicate); }
public Double sumNullableDouble(FunctionExpression<NullableDoubleFunction1<T>> selector) { return factory.sumNullableDouble(getThis(), selector); }
public <TKey> OrderedQueryable<T> thenByDescending( FunctionExpression<Function1<T, TKey>> keySelector, Comparator<TKey> comparator) { return factory.thenBy(getThisOrderedQueryable(), keySelector, comparator); }
public int sumInteger(FunctionExpression<IntegerFunction1<T>> selector) { return factory.sumInteger(getThis(), selector); }
public Queryable<T> whereN(FunctionExpression<? extends Predicate2<T, Integer>> predicate) { return factory.whereN(getThis(), predicate); }
public Integer sumNullableInteger(FunctionExpression<NullableIntegerFunction1<T>> selector) { return factory.sumNullableInteger(getThis(), selector); }
@Override public Queryable<T> union(Enumerable<T> source1) { return factory.union(getThis(), source1); }
public long sumLong(FunctionExpression<LongFunction1<T>> selector) { return factory.sumLong(getThis(), selector); }
@Override public Queryable<T> intersect(Enumerable<T> source1) { return factory.intersect(getThis(), source1); }
public Long sumNullableLong(FunctionExpression<NullableLongFunction1<T>> selector) { return factory.sumNullableLong(getThis(), selector); }
@Override public Queryable<T> except(Enumerable<T> enumerable1, EqualityComparer<T> comparer) { return factory.except(getThis(), enumerable1, comparer); }
public float sumFloat(FunctionExpression<FloatFunction1<T>> selector) { return factory.sumFloat(getThis(), selector); }
@Override public Queryable<T> take(int count) { return factory.take(getThis(), count); }
public Float sumNullableFloat(FunctionExpression<NullableFloatFunction1<T>> selector) { return factory.sumNullableFloat(getThis(), selector); }