All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.avaje.ebeaninternal.api.SpiQuery Maven / Gradle / Ivy

    /**
 * Copyright (C) 2009  Robin Bygrave
 * 
 * This file is part of Ebean.
 * 
 * Ebean is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *  
 * Ebean is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with Ebean; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA  
 */
package com.avaje.ebeaninternal.api;

import java.util.ArrayList;
import java.util.List;

import com.avaje.ebean.ExpressionList;
import com.avaje.ebean.OrderBy;
import com.avaje.ebean.Query;
import com.avaje.ebean.QueryListener;
import com.avaje.ebean.bean.BeanCollectionTouched;
import com.avaje.ebean.bean.CallStack;
import com.avaje.ebean.bean.EntityBean;
import com.avaje.ebean.bean.ObjectGraphNode;
import com.avaje.ebean.bean.PersistenceContext;
import com.avaje.ebean.event.BeanQueryRequest;
import com.avaje.ebeaninternal.server.autofetch.AutoFetchManager;
import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
import com.avaje.ebeaninternal.server.deploy.TableJoin;
import com.avaje.ebeaninternal.server.query.CancelableQuery;
import com.avaje.ebeaninternal.server.querydefn.OrmQueryDetail;
import com.avaje.ebeaninternal.server.querydefn.OrmQueryProperties;

/**
 * Object Relational query - Internal extension to Query object.
 */
public interface SpiQuery extends Query {

    public enum Mode {
        NORMAL(false), LAZYLOAD_MANY(false), LAZYLOAD_BEAN(true), REFRESH_BEAN(true);
        Mode(boolean loadContextBean) {
            this.loadContextBean = loadContextBean;
        }

        private final boolean loadContextBean;

        public boolean isLoadContextBean() {
            return loadContextBean;
        }
    }

    /**
     * Return true if select all properties was used to ensure the property
     * invoking a lazy load was included in the query.
     */
    public boolean selectAllForLazyLoadProperty();

    /**
     * Set the query mode.
     */
    public void setMode(Mode m);

    /**
     * Return the query mode.
     */
    public Mode getMode();

    /**
     * Check other combinations that can make this a sharedInstance query.
     */
    public void deriveSharedInstance();

    /**
     * This is a lazy loading query for a shared instance. That means all the
     * beans returned by this query will also be marked as 'sharedInstance'.
     */
    public void setSharedInstance();

    /**
     * Return true if this is a lazy loading query for a shared instance.
     */
    public boolean isSharedInstance();

    /**
     * Propagate the sharedInstance or readOnly state from a parent.
     */
    public void setParentState(int parentState);

    /**
     * Return a listener that wants to be notified when the bean collection is
     * first used.
     */
    public BeanCollectionTouched getBeanCollectionTouched();

    /**
     * Set a listener to be notified when the bean collection has been touched
     * (when the list/set/map is first used).
     */
    public void setBeanCollectionTouched(BeanCollectionTouched notify);

    /**
     * Set the list of Id's that is being populated.
     * 
    
     * This is a mutating list of id's and we are setting this so that other
     * threads have access to the id's before the id query has finished.
     * 
    
     */
    public void setIdList(List ids);

    /**
     * Return the list of Id's that is currently being fetched by a background
     * thread.
     */
    public List getIdList();

    /**
     * Return a copy of the query.
     */
    public SpiQuery copy();

    /**
     * Set the query type (List, Set etc).
     */
    public void setType(Type type);

    /**
     * Return a more detailed description of the lazy or query load.
     */
    public String getLoadDescription();

    /**
     * Return the load mode (+lazy or +query).
     */
    public String getLoadMode();

    /**
     * Set the load mode (+lazy or +query) and the load description.
     * 
     * @param loadMode
     * @param loadDescription
     */
    public void setLoadDescription(String loadMode, String loadDescription);

    /**
     * Set the BeanDescriptor for the root type of this query.
     */
    public void setBeanDescriptor(BeanDescriptor desc);

    /**
     * Initialise/determine the joins required to support 'many' where clause predicates.
     */
    public boolean initManyWhereJoins();

    /**
     * Return the joins required to support predicates on the many properties.
     */
    public ManyWhereJoins getManyWhereJoins();

    /**
     * Set the query to select the id property only.
     */
    public void setSelectId();

    /**
     * Set a filter to a join path.
     */
    public void setFilterMany(String prop, ExpressionList filterMany);
    
    /**
     * Remove the query joins from query detail.
     * 
    
     * These are registered with the Load Context.
     * 
    
     */
    public List removeQueryJoins();

    /**
     * Remove the lazy joins from query detail.
     * 
    
     * These are registered with the Load Context.
     * 
    
     */
    public List removeLazyJoins();

    /**
     * Set the path of the many when +query/+lazy loading query is executed.
     */
    public void setLazyLoadManyPath(String lazyLoadManyPath);
    
    /**
     * Convert any many joins fetch joins to query joins.
     */
    public void convertManyFetchJoinsToQueryJoins(boolean allowOne, int queryBatch);

    /**
     * Return the TransactionContext.
     * 
    
     * If no TransactionContext is present on the query then the
     * TransactionContext from the Transaction is used (transaction scoped
     * persistence context).
     * 
    
     */
    public PersistenceContext getPersistenceContext();

    /**
     * Set an explicit TransactionContext (typically for a refresh query).
     * 
    
     * If no TransactionContext is present on the query then the
     * TransactionContext from the Transaction is used (transaction scoped
     * persistence context).
     * 
    
     */
    public void setPersistenceContext(PersistenceContext transactionContext);

    /**
     * Return true if the query detail has neither select or joins specified.
     */
    public boolean isDetailEmpty();

    /**
     * Return explicit autoFetch setting or null. If null then not explicitly
     * set so we use the default behaviour.
     */
    public Boolean isAutofetch();

    /**
     * If return null then no autoFetch profiling for this query. If a
     * AutoFetchManager is returned this implies that profiling is turned on for
     * this query (and all the objects this query creates).
     */
    public AutoFetchManager getAutoFetchManager();

    /**
     * This has the effect of turning on autoFetch profiling for this query.
     */
    public void setAutoFetchManager(AutoFetchManager manager);

    /**
     * Return the origin point for the query.
     * 
    
     * This MUST be call prior to a query being changed via tuning. This is
     * because the queryPlanHash is used to identify the query point.
     * 
    
     */
    public ObjectGraphNode setOrigin(CallStack callStack);

    /**
     * Set the profile point of the bean or collection that is lazy loading.
     * 
    
     * This enables use to hook this back to the original 'root' query by the
     * queryPlanHash and stackPoint.
     * 
    
     */
    public void setParentNode(ObjectGraphNode node);

    /**
     * Set the property that invoked the lazy load and MUST be included in the
     * lazy loading query.
     */
    public void setLazyLoadProperty(String lazyLoadProperty);

    /**
     * Return the property that invoked lazy load.
     */
    public String getLazyLoadProperty();

    /**
     * Return the lazy load path.
     */
    public String getLazyLoadManyPath();

    /**
     * Used to hook back a lazy loading query to the original query (query
     * point).
     * 
    
     * This will return null or an "original" query.
     * 
    
     */
    public ObjectGraphNode getParentNode();

    /**
     * Return false when this is a lazy load or refresh query for a bean.
     * 
    
     * We just take/copy the data from those beans and don't collect autoFetch
     * usage profiling on those lazy load or refresh beans.
     * 
    
     */
    public boolean isUsageProfiling();

    /**
     * Set to false if this query should not be included in the autoFetch usage
     * profiling information.
     */
    public void setUsageProfiling(boolean usageProfiling);

    /**
     * Return the query name.
     */
    public String getName();

    /**
     * Calculate a hash used by AutoFetch to identify when a query has changed
     * (and hence potentially needs a new tuned query plan to be developed).
     * 
    
     * Excludes bind values and occurs prior to AutoFetch potentially
     * tuning/modifying the query.
     * 
    
     */
    public int queryAutofetchHash();

    /**
     * Identifies queries that are the same bar the bind variables.
     * 
    
     * This is used AFTER AutoFetch has potentially tuned the query. This is
     * used to identify and reused query plans (the final SQL string and
     * associated SqlTree object).
     * 
    
     * 
    
     * Excludes the actual bind values (as they don't effect the query plan).
     * 
    
     */
    public int queryPlanHash(BeanQueryRequest request);

    /**
     * Calculate a hash based on the bind values used in the query.
     * 
    
     * Combined with queryPlanHash() to return getQueryHash (a unique hash for a
     * query).
     * 
    
     */
    public int queryBindHash();

    /**
     * Identifies queries that are exactly the same including bind variables.
     */
    public int queryHash();

    /**
     * Return true if this is a query based on a SqlSelect rather than
     * generated.
     */
    public boolean isSqlSelect();

    /**
     * Return true if this is a RawSql query.
     */
    public boolean isRawSql();

    /**
     * Return the Order By clause or null if there is none defined.
     */
    public OrderBy getOrderBy();

    /**
     * Return additional where clause. This should be added to any where clause
     * that was part of the original query.
     */
    public String getAdditionalWhere();

    /**
     * Can return null if no expressions where added to the where clause.
     */
    public SpiExpressionList getWhereExpressions();

    /**
     * Can return null if no expressions where added to the having clause.
     */
    public SpiExpressionList getHavingExpressions();

    /**
     * Return additional having clause. Where raw String expressions are added
     * to having clause rather than Expression objects.
     */
    public String getAdditionalHaving();

    /**
     * Returns true if either firstRow or maxRows has been set.
     */
    public boolean hasMaxRowsOrFirstRow();

    /**
     * Return true if this query should use/check the bean cache.
     */
    public Boolean isUseBeanCache();

    /**
     * Return true if this query should use/check the query cache.
     */
    public boolean isUseQueryCache();

    /**
     * Return true if the beans from this query should be loaded into the bean
     * cache.
     */
    public boolean isLoadBeanCache();

    /**
     * Return true if the beans returned by this query should be read only.
     */
    public Boolean isReadOnly();

    /**
     * Adds this bean to the persistence context prior to executing the query.
     */
    public void contextAdd(EntityBean bean);

    /**
     * Return the type of beans queries.
     */
    public Class getBeanType();

    /**
     * Return the query timeout.
     */
    public int getTimeout();

    /**
     * Return the objects that should be added to the persistence context prior
     * to executing the query.
     */
    public ArrayList getContextAdditions();

    /**
     * Return the bind parameters.
     */
    public BindParams getBindParams();

    /**
     * Get the orm query as a String. Only available if the query was built from
     * a string.
     */
    public String getQuery();

    /**
     * Replace the query detail. This is used by the autoFetch feature to as a
     * fast way to set the query properties and joins.
     * 
    
     * Note care must be taken to keep the where, orderBy, firstRows and maxRows
     * held in the detail attributes.
     * 
    
     */
    public void setDetail(OrmQueryDetail detail);

    /**
     * Autofetch tune the detail specifying properties to select on already defined joins
     * and adding extra joins where they are missing.
     */
    public boolean tuneFetchProperties(OrmQueryDetail detail);

    /**
     * Set to true if this query has been tuned by autoFetch.
     */
    public void setAutoFetchTuned(boolean autoFetchTuned);

    /**
     * Return the query detail.
     */
    public OrmQueryDetail getDetail();

    public TableJoin getIncludeTableJoin();

    public void setIncludeTableJoin(TableJoin includeTableJoin);

    /**
     * Return the property used to specify keys for a map.
     */
    public String getMapKey();

    /**
     * Return the number of rows after which fetching should occur in a
     * background thread.
     */
    public int getBackgroundFetchAfter();

    /**
     * Return the maximum number of rows to return in the query.
     */
    public int getMaxRows();

    /**
     * Return the index of the first row to return in the query.
     */
    public int getFirstRow();

    /**
     * return true if this query uses DISTINCT.
     */
    public boolean isDistinct();

    /**
     * Return true if this query should build and return vanilla objects.
     */
    public boolean isVanillaMode(boolean serverDefaultVanillaMode);

    /**
     * Set default select clauses where none have been explicitly defined.
     */
    public void setDefaultSelectClause();

    /**
     * Return the where clause from a parsed string query.
     */
    public String getRawWhereClause();

    /**
     * Return the Id value.
     */
    public Object getId();

    /**
     * Return the queryListener.
     */
    public QueryListener getListener();

    /**
     * Return true if this query should use its own transaction.
     * 
    
     * This is true for background fetching and when using QueryListener.
     * 
    
     */
    public boolean createOwnTransaction();

    /**
     * Set the generated sql for debug purposes.
     * 
     * @param generatedSql
     */
    public void setGeneratedSql(String generatedSql);

    /**
     * Return the hint for Statement.setFetchSize().
     */
    public int getBufferFetchSizeHint();

    /**
     * Return true if this is a query executing in the background.
     */
    public boolean isFutureFetch();

    /**
     * Set to true to indicate the query is executing in a background thread
     * asynchronously.
     */
    public void setFutureFetch(boolean futureFetch);

    /**
     * Set the underlying cancelable query (with the PreparedStatement).
     */
    public void setCancelableQuery(CancelableQuery cancelableQuery);

    /**
     * Return true if this query has been cancelled.
     */
    public boolean isCancelled();
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy