com.hazelcast.org.apache.calcite.linq4j.DefaultQueryable Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.hazelcast.org.apache.calcite.linq4j;

import com.hazelcast.org.apache.calcite.linq4j.function.BigDecimalFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.DoubleFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.EqualityComparer;
import com.hazelcast.org.apache.calcite.linq4j.function.FloatFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.Function1;
import com.hazelcast.org.apache.calcite.linq4j.function.Function2;
import com.hazelcast.org.apache.calcite.linq4j.function.IntegerFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.LongFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.NullableBigDecimalFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.NullableDoubleFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.NullableFloatFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.NullableIntegerFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.NullableLongFunction1;
import com.hazelcast.org.apache.calcite.linq4j.function.Predicate1;
import com.hazelcast.org.apache.calcite.linq4j.function.Predicate2;
import com.hazelcast.org.apache.calcite.linq4j.tree.FunctionExpression;

import java.math.BigDecimal;
import java.util.Comparator;

/**
 * Implementation of the {@link Queryable} interface that
 * implements the extension methods by calling into the {@link Extensions}
 * class.
 *
 * @param  Element type
 */
abstract class DefaultQueryable extends DefaultEnumerable
    implements Queryable, OrderedQueryable {
  private final QueryableFactory factory;

  /**
   * Creates a DefaultQueryable using a factory that records events.
   */
  protected DefaultQueryable() {
    this(QueryableRecorder.instance());
  }

  /**
   * Creates a DefaultQueryable using a particular factory.
   */
  protected DefaultQueryable(QueryableFactory factory) {
    this.factory = factory;
  }

  // override return type
  @Override protected Queryable getThis() {
    return this;
  }

  protected OrderedQueryable getThisOrderedQueryable() {
    return this;
  }

  @Override public Enumerable asEnumerable() {
    return new AbstractEnumerable() {
      public Enumerator enumerator() {
        return DefaultQueryable.this.enumerator();
      }
    };
  }

  // Disambiguate

  @Override public Queryable union(Enumerable source1) {
    return factory.union(getThis(), source1);
  }

  @Override public Queryable union(Enumerable source1,
      EqualityComparer comparer) {
    return factory.union(getThis(), source1, comparer);
  }

  @Override public Queryable intersect(Enumerable source1) {
    return intersect(source1, false);
  }

  @Override public Queryable intersect(Enumerable source1, boolean all) {
    return factory.intersect(getThis(), source1, all);
  }

  @Override public Queryable intersect(Enumerable source1,
      EqualityComparer comparer) {
    return intersect(source1, comparer, false);
  }

  @Override public Queryable intersect(Enumerable source1,
      EqualityComparer comparer, boolean all) {
    return factory.intersect(getThis(), source1, comparer, all);
  }

  @Override public Queryable except(Enumerable enumerable1,
      EqualityComparer comparer) {
    return except(enumerable1, comparer, false);
  }
  @Override public Queryable except(Enumerable enumerable1,
      EqualityComparer comparer, boolean all) {
    return factory.except(getThis(), enumerable1, comparer, all);
  }

  @Override public Queryable except(Enumerable enumerable1) {
    return except(enumerable1, false);
  }

  @Override public Queryable except(Enumerable enumerable1, boolean all) {
    return factory.except(getThis(), enumerable1, all);
  }

  @Override public Queryable take(int count) {
    return factory.take(getThis(), count);
  }

  @Override public Queryable skip(int count) {
    return factory.skip(getThis(), count);
  }

  @Override public Queryable reverse() {
    return factory.reverse(getThis());
  }

  @Override public Queryable distinct() {
    return factory.distinct(getThis());
  }

  @Override public Queryable distinct(EqualityComparer comparer) {
    return factory.distinct(getThis(), comparer);
  }

  @Override public  Queryable ofType(Class clazz) {
    return factory.ofType(getThis(), clazz);
  }

  @Override public Queryable defaultIfEmpty() {
    return factory.defaultIfEmpty(getThis());
  }

  @Override public Queryable asQueryable() {
    return this;
  }

  @Override public  Queryable cast(Class clazz) {
    return factory.cast(getThis(), clazz);
  }

  // End disambiguate

  public T aggregate(FunctionExpression> selector) {
    return factory.aggregate(getThis(), selector);
  }

  public  TAccumulate aggregate(TAccumulate seed,
      FunctionExpression> selector) {
    return factory.aggregate(getThis(), seed, selector);
  }

  public  TResult aggregate(TAccumulate seed,
      FunctionExpression> func,
      FunctionExpression> selector) {
    return factory.aggregate(getThis(), seed, func, selector);
  }

  public boolean all(FunctionExpression> predicate) {
    return factory.all(getThis(), predicate);
  }

  public boolean any(FunctionExpression> predicate) {
    return factory.any(getThis(), predicate);
  }

  public BigDecimal averageBigDecimal(
      FunctionExpression> selector) {
    return factory.averageBigDecimal(getThis(), selector);
  }

  public BigDecimal averageNullableBigDecimal(
      FunctionExpression> selector) {
    return factory.averageNullableBigDecimal(getThis(), selector);
  }

  public double averageDouble(FunctionExpression> selector) {
    return factory.averageDouble(getThis(), selector);
  }

  public Double averageNullableDouble(
      FunctionExpression> selector) {
    return factory.averageNullableDouble(getThis(), selector);
  }

  public int averageInteger(FunctionExpression> selector) {
    return factory.averageInteger(getThis(), selector);
  }

  public Integer averageNullableInteger(
      FunctionExpression> selector) {
    return factory.averageNullableInteger(getThis(), selector);
  }

  public float averageFloat(FunctionExpression> selector) {
    return factory.averageFloat(getThis(), selector);
  }

  public Float averageNullableFloat(
      FunctionExpression> selector) {
    return factory.averageNullableFloat(getThis(), selector);
  }

  public long averageLong(FunctionExpression> selector) {
    return factory.averageLong(getThis(), selector);
  }

  public Long averageNullableLong(
      FunctionExpression> selector) {
    return factory.averageNullableLong(getThis(), selector);
  }

  public Queryable concat(Enumerable source2) {
    return factory.concat(getThis(), source2);
  }

  public int count(FunctionExpression> func) {
    return factory.count(getThis(), func);
  }

  public T first(FunctionExpression> predicate) {
    return factory.first(getThis(), predicate);
  }

  public T firstOrDefault(FunctionExpression> predicate) {
    return factory.firstOrDefault(getThis(), predicate);
  }

  public  Queryable> groupBy(
      FunctionExpression> keySelector) {
    return factory.groupBy(getThis(), keySelector);
  }

  public  Queryable> groupBy(
      FunctionExpression> keySelector,
      EqualityComparer comparer) {
    return factory.groupBy(getThis(), keySelector, comparer);
  }

  public  Queryable> groupBy(
      FunctionExpression> keySelector,
      FunctionExpression> elementSelector) {
    return factory.groupBy(getThis(), keySelector, elementSelector);
  }

  public  Queryable> groupBy(
      FunctionExpression> keySelector,
      FunctionExpression> elementSelector,
      EqualityComparer comparer) {
    return factory.groupBy(getThis(), keySelector, elementSelector, comparer);
  }

  public  Queryable groupByK(
      FunctionExpression> keySelector,
      FunctionExpression, TResult>> resultSelector) {
    return factory.groupByK(getThis(), keySelector, resultSelector);
  }

  public  Queryable groupByK(
      FunctionExpression> keySelector,
      FunctionExpression, TResult>> resultSelector,
      EqualityComparer comparer) {
    return factory.groupByK(getThis(), keySelector, resultSelector, comparer);
  }

  public  Queryable groupBy(
      FunctionExpression> keySelector,
      FunctionExpression> elementSelector,
      FunctionExpression, TResult>> resultSelector) {
    return factory.groupBy(getThis(), keySelector, elementSelector,
        resultSelector);
  }

  public  Queryable groupBy(
      FunctionExpression> keySelector,
      FunctionExpression> elementSelector,
      FunctionExpression, TResult>> resultSelector,
      EqualityComparer comparer) {
    return factory.groupBy(getThis(), keySelector, elementSelector,
        resultSelector, comparer);
  }

  public  Queryable groupJoin(
      Enumerable inner,
      FunctionExpression> outerKeySelector,
      FunctionExpression> innerKeySelector,
      FunctionExpression, TResult>> resultSelector) {
    return factory.groupJoin(getThis(), inner, outerKeySelector,
        innerKeySelector, resultSelector);
  }

  public  Queryable groupJoin(
      Enumerable inner,
      FunctionExpression> outerKeySelector,
      FunctionExpression> innerKeySelector,
      FunctionExpression, TResult>> resultSelector,
      EqualityComparer comparer) {
    return factory.groupJoin(getThis(), inner, outerKeySelector,
        innerKeySelector, resultSelector, comparer);
  }

  public  Queryable join(
      Enumerable inner,
      FunctionExpression> outerKeySelector,
      FunctionExpression> innerKeySelector,
      FunctionExpression> resultSelector) {
    return factory.join(getThis(), inner, outerKeySelector, innerKeySelector,
        resultSelector);
  }

  public  Queryable join(
      Enumerable inner,
      FunctionExpression> outerKeySelector,
      FunctionExpression> innerKeySelector,
      FunctionExpression> resultSelector,
      EqualityComparer comparer) {
    return factory.join(getThis(), inner, outerKeySelector, innerKeySelector,
        resultSelector, comparer);
  }

  public T last(FunctionExpression> predicate) {
    return factory.last(getThis(), predicate);
  }

  public T lastOrDefault(FunctionExpression> predicate) {
    return factory.lastOrDefault(getThis(), predicate);
  }

  public long longCount(FunctionExpression> predicate) {
    return factory.longCount(getThis(), predicate);
  }

  public > TResult max(
      FunctionExpression> selector) {
    return factory.max(getThis(), selector);
  }

  public > TResult min(
      FunctionExpression> selector) {
    return factory.min(getThis(), selector);
  }

  public  OrderedQueryable orderBy(
      FunctionExpression> keySelector) {
    return factory.orderBy(getThis(), keySelector);
  }

  public  OrderedQueryable orderBy(
      FunctionExpression> keySelector,
      Comparator comparator) {
    return factory.orderBy(getThis(), keySelector, comparator);
  }

  public  OrderedQueryable orderByDescending(
      FunctionExpression> keySelector) {
    return factory.orderByDescending(getThis(), keySelector);
  }

  public  OrderedQueryable orderByDescending(
      FunctionExpression> keySelector,
      Comparator comparator) {
    return factory.orderByDescending(getThis(), keySelector, comparator);
  }

  public  Queryable select(
      FunctionExpression> selector) {
    return factory.select(getThis(), selector);
  }

  public  Queryable selectN(
      FunctionExpression> selector) {
    return factory.selectN(getThis(), selector);
  }

  public  Queryable selectMany(
      FunctionExpression>> selector) {
    return factory.selectMany(getThis(), selector);
  }

  public  Queryable selectManyN(
      FunctionExpression>> selector) {
    return factory.selectManyN(getThis(), selector);
  }

  public  Queryable selectMany(
      FunctionExpression>>
        collectionSelector,
      FunctionExpression> resultSelector) {
    return factory.selectMany(getThis(), collectionSelector, resultSelector);
  }

  public  Queryable selectManyN(
      FunctionExpression>>
        collectionSelector,
      FunctionExpression> resultSelector) {
    return factory.selectManyN(getThis(), collectionSelector, resultSelector);
  }

  public T single(FunctionExpression> predicate) {
    return factory.single(getThis(), predicate);
  }

  public T singleOrDefault(FunctionExpression> predicate) {
    return factory.singleOrDefault(getThis(), predicate);
  }

  public Queryable skipWhile(FunctionExpression> predicate) {
    return factory.skipWhile(getThis(), predicate);
  }

  public Queryable skipWhileN(
      FunctionExpression> predicate) {
    return factory.skipWhileN(getThis(), predicate);
  }

  public BigDecimal sumBigDecimal(
      FunctionExpression> selector) {
    return factory.sumBigDecimal(getThis(), selector);
  }

  public BigDecimal sumNullableBigDecimal(
      FunctionExpression> selector) {
    return factory.sumNullableBigDecimal(getThis(), selector);
  }

  public double sumDouble(FunctionExpression> selector) {
    return factory.sumDouble(getThis(), selector);
  }

  public Double sumNullableDouble(
      FunctionExpression> selector) {
    return factory.sumNullableDouble(getThis(), selector);
  }

  public int sumInteger(FunctionExpression> selector) {
    return factory.sumInteger(getThis(), selector);
  }

  public Integer sumNullableInteger(
      FunctionExpression> selector) {
    return factory.sumNullableInteger(getThis(), selector);
  }

  public long sumLong(FunctionExpression> selector) {
    return factory.sumLong(getThis(), selector);
  }

  public Long sumNullableLong(
      FunctionExpression> selector) {
    return factory.sumNullableLong(getThis(), selector);
  }

  public float sumFloat(FunctionExpression> selector) {
    return factory.sumFloat(getThis(), selector);
  }

  public Float sumNullableFloat(
      FunctionExpression> selector) {
    return factory.sumNullableFloat(getThis(), selector);
  }

  public Queryable takeWhile(FunctionExpression> predicate) {
    return factory.takeWhile(getThis(), predicate);
  }

  public Queryable takeWhileN(
      FunctionExpression> predicate) {
    return factory.takeWhileN(getThis(), predicate);
  }

  public > OrderedQueryable thenBy(
      FunctionExpression> keySelector) {
    return factory.thenBy(getThisOrderedQueryable(), keySelector);
  }

  public  OrderedQueryable thenBy(
      FunctionExpression> keySelector,
      Comparator comparator) {
    return factory.thenByDescending(getThisOrderedQueryable(), keySelector,
        comparator);
  }

  public > OrderedQueryable thenByDescending(
      FunctionExpression> keySelector) {
    return factory.thenByDescending(getThisOrderedQueryable(), keySelector);
  }

  public  OrderedQueryable thenByDescending(
      FunctionExpression> keySelector,
      Comparator comparator) {
    return factory.thenBy(getThisOrderedQueryable(), keySelector, comparator);
  }

  public Queryable where(
      FunctionExpression> predicate) {
    return factory.where(getThis(), predicate);
  }

  public Queryable whereN(
      FunctionExpression> predicate) {
    return factory.whereN(getThis(), predicate);
  }

  public  Queryable zip(Enumerable source1,
      FunctionExpression> resultSelector) {
    return factory.zip(getThis(), source1, resultSelector);
  }
}