io.ebeaninternal.server.query.DefaultFetchGroupQuery Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ebean-core Show documentation
ebean core module
There is a newer version: 15.8.0
package io.ebeaninternal.server.query;

import io.avaje.lang.NonNullApi;
import io.avaje.lang.Nullable;
import io.ebean.*;
import io.ebean.service.SpiFetchGroupQuery;
import io.ebeaninternal.api.SpiQueryFetch;
import io.ebeaninternal.server.expression.DefaultExpressionList;
import io.ebeaninternal.server.querydefn.OrmQueryDetail;
import io.ebeaninternal.server.querydefn.SpiFetchGroup;

import java.sql.Connection;
import java.sql.Timestamp;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * Implementation of FetchGroup query for use to create FetchGroup via query beans.
 */
@NonNullApi
final class DefaultFetchGroupQuery implements SpiFetchGroupQuery, SpiQueryFetch {

  private static final FetchConfig FETCH_CACHE = FetchConfig.ofCache();
  private static final FetchConfig FETCH_QUERY = FetchConfig.ofQuery();
  private static final FetchConfig FETCH_LAZY = FetchConfig.ofLazy();

  private OrmQueryDetail detail = new OrmQueryDetail();
  private OrderBy orderBy;

  @Override
  public FetchGroup buildFetchGroup() {
    return new DFetchGroup<>(detail);
  }

  @Override
  public Query distinctOn(String distinctOn) {
    throw new UnsupportedOperationException();
  }

  @Override
  public Query select(String columns) {
    detail.select(columns);
    return this;
  }

  @SuppressWarnings("rawtypes")
  @Override
  public Query select(FetchGroup fetchGroup) {
    this.detail = ((SpiFetchGroup) fetchGroup).detail();
    return this;
  }

  @Override
  public Query fetch(String property) {
    return fetch(property, null, null);
  }

  @Override
  public Query fetchQuery(String property) {
    return fetch(property, null, FETCH_QUERY);
  }

  @Override
  public Query fetchCache(String property) {
    return fetch(property, null, FETCH_CACHE);
  }

  @Override
  public Query fetchLazy(String property) {
    return fetch(property, null, FETCH_LAZY);
  }

  @Override
  public Query fetch(String property, FetchConfig joinConfig) {
    return fetch(property, null, joinConfig);
  }

  @Override
  public Query fetch(String property, String columns) {
    return fetch(property, columns, null);
  }

  @Override
  public Query fetchQuery(String property, String columns) {
    return fetch(property, columns, FETCH_QUERY);
  }

  @Override
  public Query fetchCache(String property, String columns) {
    return fetch(property, columns, FETCH_CACHE);
  }

  @Override
  public Query fetchLazy(String property, String columns) {
    return fetch(property, columns, FETCH_LAZY);
  }

  @Override
  public Query fetch(String property, @Nullable String columns, @Nullable FetchConfig config) {
    detail.fetch(property, columns, config);
    return this;
  }

  @Override
  public Query setProfileLocation(ProfileLocation profileLocation) {
    return this;
  }

  @Override
  public Query setLabel(String label) {
    return this;
  }

  @Override
  public Query setHint(String hint) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  // Everything else deemed invalid

  @Override
  public Query copy() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setRawSql(RawSql rawSql) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query asOf(Timestamp asOf) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query asDraft() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public  DtoQuery asDto(Class dtoClass) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public UpdateQuery asUpdate() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public void cancel() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setPersistenceContextScope(PersistenceContextScope scope) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setDocIndexName(String indexName) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public ExpressionFactory getExpressionFactory() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public boolean isAutoTuned() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setAutoTune(boolean autoTune) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setAllowLoadErrors() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setLazyLoadBatchSize(int lazyLoadBatchSize) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setIncludeSoftDeletes() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setDisableReadAuditing() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query apply(FetchPath fetchPath) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query also(Consumer> apply) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query alsoIf(BooleanSupplier predicate, Consumer> apply) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query usingTransaction(Transaction transaction) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query usingConnection(Connection connection) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query usingDatabase(Database database) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query usingMaster() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public  List findIds() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public QueryIterator findIterate() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Stream findStream() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public void findEach(Consumer consumer) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public void findEach(int batch, Consumer> consumer) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public void findEachWhile(Predicate consumer) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public List findList() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Set findSet() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public  Map findMap() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public  List findSingleAttributeList() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public  Set findSingleAttributeSet() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public  A findSingleAttribute() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public  Optional findSingleAttributeOrEmpty() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public boolean isCountDistinct() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public boolean exists() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Nullable
  @Override
  public T findOne() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Optional findOneOrEmpty() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public List> findVersions() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public List> findVersionsBetween(Timestamp start, Timestamp end) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public int delete() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public int delete(Transaction transaction) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public int update() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public int update(Transaction transaction) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public int findCount() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public FutureRowCount findFutureCount() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public FutureIds findFutureIds() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public FutureList findFutureList() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public PagedList findPagedList() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setParameter(String name, Object value) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setParameter(int position, Object value) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setParameter(Object value) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setParameters(Object... values) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setId(Object id) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Object getId() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query where(Expression expression) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public ExpressionList where() {
    return DefaultExpressionList.forFetchGroup(this);
  }

  @Override
  public ExpressionList text() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public ExpressionList filterMany(String propertyName) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public ExpressionList having() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query having(Expression addExpressionToHaving) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query orderBy(String orderByClause) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public OrderBy orderBy() {
    if (orderBy == null) {
      orderBy = new OrderBy<>();
    }
    return orderBy;
  }

  @Override
  public Query setOrderBy(OrderBy orderBy) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setDistinct(boolean isDistinct) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setCountDistinct(CountDistinctOrder orderBy) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public int getFirstRow() {
    return 0;
  }

  @Override
  public Query setFirstRow(int firstRow) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public int getMaxRows() {
    return 0;
  }

  @Override
  public Query setMaxRows(int maxRows) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setPaging(Paging paging) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setMapKey(String mapKey) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setBeanCacheMode(CacheMode beanCacheMode) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setUseQueryCache(CacheMode queryCacheMode) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setUseDocStore(boolean useDocStore) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setReadOnly(boolean readOnly) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setTimeout(int secs) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setBufferFetchSizeHint(int fetchSize) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public String getGeneratedSql() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query withLock(LockType lockType) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query withLock(LockType lockType, LockWait lockWait) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query forUpdate() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query forUpdateNoWait() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query forUpdateSkipLocked() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public boolean isForUpdate() {
    return false;
  }

  @Override
  public LockWait getForUpdateLockWait() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public LockType getForUpdateLockType() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query alias(String alias) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setBaseTable(String baseTable) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Class getBeanType() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setInheritType(Class type) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Class getInheritType() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public QueryType getQueryType() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query setDisableLazyLoading(boolean disableLazyLoading) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Set validate() {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public Query orderById(boolean orderById) {
    throw new RuntimeException("EB102: Only select() and fetch() clause is allowed on FetchGroup");
  }

  @Override
  public void selectProperties(Set props) {
    detail.selectProperties(props);
  }

  @Override
  public void fetchProperties(String property, Set columns, FetchConfig config) {
    detail.fetchProperties(property, columns, config);
  }

  @Override
  public void addNested(String name, OrmQueryDetail nestedDetail, FetchConfig config) {
    detail.addNested(name, nestedDetail, config);
  }
}