Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
* indicated by the @author tags or express copyright attribution
* statements applied by the authors. All third-party contributions are
* distributed under license by Red Hat Middleware LLC.
*
* This copyrighted material is made available to anyone wishing to use, modify,
* copy, or redistribute it subject to the terms and conditions of the GNU
* Lesser General Public License, as published by the Free Software Foundation.
*
* This program 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 this distribution; if not, write to:
* Free Software Foundation, Inc.
* 51 Franklin Street, Fifth Floor
* Boston, MA 02110-1301 USA
*
*/
package org.hibernate.engine;
import java.io.Serializable;
import java.sql.Connection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.CacheMode;
import org.hibernate.EntityMode;
import org.hibernate.FlushMode;
import org.hibernate.HibernateException;
import org.hibernate.Interceptor;
import org.hibernate.Query;
import org.hibernate.ScrollMode;
import org.hibernate.ScrollableResults;
import org.hibernate.Transaction;
import org.hibernate.engine.query.sql.NativeSQLQuerySpecification;
import org.hibernate.collection.PersistentCollection;
import org.hibernate.event.EventListeners;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.jdbc.Batcher;
import org.hibernate.jdbc.JDBCContext;
import org.hibernate.loader.custom.CustomQuery;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.type.Type;
/**
* Defines the internal contract between the Session and other parts of
* Hibernate such as implementors of Type or EntityPersister.
*
* @see org.hibernate.Session the interface to the application
* @see org.hibernate.impl.SessionImpl the actual implementation
* @author Gavin King
*/
public interface SessionImplementor extends Serializable {
/**
* Retrieves the interceptor currently in use by this event source.
*
* @return The interceptor.
*/
public Interceptor getInterceptor();
/**
* Enable/disable automatic cache clearing from after transaction
* completion (for EJB3)
*/
public void setAutoClear(boolean enabled);
/**
* Does this Session have an active Hibernate transaction
* or is there a JTA transaction in progress?
*/
public boolean isTransactionInProgress();
/**
* Initialize the collection (if not already initialized)
*/
public void initializeCollection(PersistentCollection collection, boolean writing)
throws HibernateException;
/**
* Load an instance without checking if it was deleted.
*
* When nullable is disabled this method may create a new proxy or
* return an existing proxy; if it does not exist, throw an exception.
*
* When nullable is enabled, the method does not create new proxies
* (but might return an existing proxy); if it does not exist, return
* null.
*
* When eager is enabled, the object is eagerly fetched
*/
public Object internalLoad(String entityName, Serializable id, boolean eager, boolean nullable)
throws HibernateException;
/**
* Load an instance immediately. This method is only called when lazily initializing a proxy.
* Do not return the proxy.
*/
public Object immediateLoad(String entityName, Serializable id) throws HibernateException;
/**
* System time before the start of the transaction
*/
public long getTimestamp();
/**
* Get the creating SessionFactoryImplementor
*/
public SessionFactoryImplementor getFactory();
/**
* Get the prepared statement Batcher for this session
*/
public Batcher getBatcher();
/**
* Execute a find() query
*/
public List list(String query, QueryParameters queryParameters) throws HibernateException;
/**
* Execute an iterate() query
*/
public Iterator iterate(String query, QueryParameters queryParameters) throws HibernateException;
/**
* Execute a scroll() query
*/
public ScrollableResults scroll(String query, QueryParameters queryParameters) throws HibernateException;
/**
* Execute a criteria query
*/
public ScrollableResults scroll(CriteriaImpl criteria, ScrollMode scrollMode);
/**
* Execute a criteria query
*/
public List list(CriteriaImpl criteria);
/**
* Execute a filter
*/
public List listFilter(Object collection, String filter, QueryParameters queryParameters) throws HibernateException;
/**
* Iterate a filter
*/
public Iterator iterateFilter(Object collection, String filter, QueryParameters queryParameters) throws HibernateException;
/**
* Get the EntityPersister for any instance
* @param entityName optional entity name
* @param object the entity instance
*/
public EntityPersister getEntityPersister(String entityName, Object object) throws HibernateException;
/**
* Get the entity instance associated with the given Key,
* calling the Interceptor if necessary
*/
public Object getEntityUsingInterceptor(EntityKey key) throws HibernateException;
/**
* Notify the session that the transaction completed, so we no longer
* own the old locks. (Also we should release cache softlocks.) May
* be called multiple times during the transaction completion process.
* Also called after an autocommit, in which case the second argument
* is null.
*/
public void afterTransactionCompletion(boolean successful, Transaction tx);
/**
* Notify the session that the transaction is about to complete
*/
public void beforeTransactionCompletion(Transaction tx);
/**
* Return the identifier of the persistent object, or null if
* not associated with the session
*/
public Serializable getContextEntityIdentifier(Object object);
/**
* The best guess entity name for an entity not in an association
*/
public String bestGuessEntityName(Object object);
/**
* The guessed entity name for an entity not in an association
*/
public String guessEntityName(Object entity) throws HibernateException;
/**
* Instantiate the entity class, initializing with the given identifier
*/
public Object instantiate(String entityName, Serializable id) throws HibernateException;
/**
* Execute an SQL Query
*/
public List listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)
throws HibernateException;
/**
* Execute an SQL Query
*/
public ScrollableResults scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters)
throws HibernateException;
/**
* Execute a native SQL query, and return the results as a fully built list.
*
* @param spec The specification of the native SQL query to execute.
* @param queryParameters The parameters by which to perform the execution.
* @return The result list.
* @throws HibernateException
*/
public List list(NativeSQLQuerySpecification spec, QueryParameters queryParameters)
throws HibernateException;
/**
* Execute a native SQL query, and return the results as a scrollable result.
*
* @param spec The specification of the native SQL query to execute.
* @param queryParameters The parameters by which to perform the execution.
* @return The resulting scrollable result.
* @throws HibernateException
*/
public ScrollableResults scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters)
throws HibernateException;
/**
* Retreive the currently set value for a filter parameter.
*
* @param filterParameterName The filter parameter name in the format
* {FILTER_NAME.PARAMETER_NAME}.
* @return The filter parameter value.
* @deprecated use #getLoadQueryInfluencers instead
*/
public Object getFilterParameterValue(String filterParameterName);
/**
* Retreive the type for a given filter parrameter.
*
* @param filterParameterName The filter parameter name in the format
* {FILTER_NAME.PARAMETER_NAME}.
* @return The filter param type
* @deprecated use #getLoadQueryInfluencers instead
*/
public Type getFilterParameterType(String filterParameterName);
/**
* Return the currently enabled filters. The filter map is keyed by filter
* name, with values corresponding to the {@link org.hibernate.impl.FilterImpl}
* instance.
* @return The currently enabled filters.
* @deprecated use #getLoadQueryInfluencers instead
*/
public Map getEnabledFilters();
public int getDontFlushFromFind();
/**
* Retrieves the configured event listeners from this event source.
*
* @return The configured event listeners.
*/
public EventListeners getListeners();
//TODO: temporary
/**
* Get the persistence context for this session
*/
public PersistenceContext getPersistenceContext();
/**
* Execute a HQL update or delete query
*/
int executeUpdate(String query, QueryParameters queryParameters) throws HibernateException;
/**
* Execute a native SQL update or delete query
*/
int executeNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters) throws HibernateException;
/**
* Return changes to this session that have not been flushed yet.
*
* @return The non-flushed changes.
*/
public NonFlushedChanges getNonFlushedChanges() throws HibernateException;
/**
* Apply non-flushed changes from a different session to this session. It is assumed
* that this SessionImpl is "clean" (e.g., has no non-flushed changes, no cached entities,
* no cached collections, no queued actions). The specified NonFlushedChanges object cannot
* be bound to any session.
*
* @param nonFlushedChanges the non-flushed changes
*/
public void applyNonFlushedChanges(NonFlushedChanges nonFlushedChanges) throws HibernateException;
// copied from Session:
public EntityMode getEntityMode();
public CacheMode getCacheMode();
public void setCacheMode(CacheMode cm);
public boolean isOpen();
public boolean isConnected();
public FlushMode getFlushMode();
public void setFlushMode(FlushMode fm);
public Connection connection();
public void flush();
/**
* Get a Query instance for a named query or named native SQL query
*/
public Query getNamedQuery(String name);
/**
* Get a Query instance for a named native SQL query
*/
public Query getNamedSQLQuery(String name);
public boolean isEventSource();
public void afterScrollOperation();
/**
* Get the internal fetch profile currently associated with this session.
*
* @return The current internal fetch profile, or null if none currently associated.
* @deprecated use #getLoadQueryInfluencers instead
*/
public String getFetchProfile();
/**
* Set the current internal fetch profile for this session.
*
* @param name The internal fetch profile name to use
* @deprecated use #getLoadQueryInfluencers instead
*/
public void setFetchProfile(String name);
public JDBCContext getJDBCContext();
/**
* Determine whether the session is closed. Provided seperately from
* {@link #isOpen()} as this method does not attempt any JTA synch
* registration, where as {@link #isOpen()} does; which makes this one
* nicer to use for most internal purposes.
*
* @return True if the session is closed; false otherwise.
*/
public boolean isClosed();
/**
* Get the load query influencers associated with this session.
*
* @return the load query influencers associated with this session;
* should never be null.
*/
public LoadQueryInfluencers getLoadQueryInfluencers();
}
