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);
 }