#region License
/*
* Copyright � 2002-2005 the original author or authors.
*
* Licensed 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.
*/
#endregion
#region Imports
using System;
using System.Diagnostics;
using System.Reflection;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Type;
using Spring.Objects.Factory;
using log4net;
using System.Collections;
using System.Collections.Specialized;
#endregion
namespace Spring.Orm.Hibernate
{
/// <summary>
/// Helper class that simplifies Hibernate data access code.
///
/// <p>Typically used to implement data access or business logic services that
/// use Hibernate within their implementation but are Hibernate-agnostic in their
/// interface. The latter or code calling the latter only have to deal with
/// domain objects, query objects.</p>
///
/// <p>The central method is "Execute", supporting Hibernate code implementing
/// the IHibernateCallback interface. It provides Hibernate Session handling
/// such that neither the IHibernateCallback implementation nor the calling
/// code needs to explicitly care about retrieving/closing Hibernate Sessions,
/// or handling Session lifecycle exceptions. For typical single step actions,
/// there are various convenience methods (find, load, saveOrUpdate, delete).</p>
///
/// <p>Can be used within a service implementation via direct instantiation
/// with a SessionFactory reference, or get prepared in an application context
/// and given to services as bean reference. Note: The SessionFactory should
/// always be configured as bean in the application context, in the first case
/// given to the service directly, in the second case to the prepared template.</p>
///
///
/// <p>Note that even if HibernateTransactionManager is used for transaction
/// demarcation in higher-level services, all those services above the data
/// access layer don't need need to be Hibernate-aware. Setting such a special
/// PlatformTransactionManager is a configuration issue.</p>
///
/// <p>LocalSessionFactoryBean is the preferred way of obtaining a reference
/// to a specific Hibernate SessionFactory.</p>
///
///
///
/// <author> Juergen Hoeller </author>
/// <author> Moim Hossain (.NET) </author>
/// </summary>
public class HibernateTemplate : HibernateAccessor , IHibernateOperations
{
/// <summary>
/// Alow Create a new Session
/// </summary>
private bool allowCreate = true;
/// <summary>
/// If Always create a new Session
/// </summary>
private bool alwaysUseNewSession = false;
/// <summary>
/// Expose the Native Session
/// </summary>
private bool exposeNativeSession = false;
/// <summary>
/// Allow Write Operation
/// </summary>
private bool checkWriteOperations = true;
/// <summary>
/// Cache Query ?
/// </summary>
private bool cacheQueries = false;
/// <summary>
/// The Region
/// </summary>
private String queryCacheRegion;
/// <summary>
/// No Args Constructor
/// </summary>
public HibernateTemplate()
{
}
/// <summary>
/// The Constructor
/// </summary>
/// <param name="sessionFactory">The <see cref="NHibernate.ISessionFactory"/> Instance</param>
public HibernateTemplate(ISessionFactory sessionFactory)
{
this.SessionFactory = sessionFactory;
AfterPropertiesSet();
}
/// <summary>
/// Create a new HibernateTemplate instance.
/// <params> sessionFactory SessionFactory to create Sessions </params>
/// <params> allowCreate if a new Session should be created if no thread-bound found </params>
/// </summary>
public HibernateTemplate(ISessionFactory sessionFactory, bool allowCreate)
{
this.SessionFactory = sessionFactory;
SetAllowCreate( allowCreate );
AfterPropertiesSet();
}
/// <summary>
/// Set if a new Session should be created if no thread-bound found.
/// <p>HibernateTemplate is aware of a respective Session bound to the
/// current thread, for example when using HibernateTransactionManager.</p>
/// If allowCreate is true, a new Session will be created if none found.
/// If false, an IllegalStateException will get thrown in this case.
/// </summary>
public void SetAllowCreate(bool allowCreate)
{
this.allowCreate = allowCreate;
}
/// <summary>
/// Return if a new Session should be created if no thread-bound found.
/// </summary>
public bool IsAllowCreate()
{
return allowCreate;
}
/// <summary>
/// Set whether to always use a new Hibernate Session for this template.
/// Default is false; if activated, all operations on this template will
/// work on a new Hibernate Session even in case of a pre-bound Session
/// (for example, within a transaction or OpenSessionInViewFilter).
/// <p>Within a transaction, a new Hibernate Session used by this template
/// will participate in the transaction through using the same
/// Connection. In such a scenario, multiple Sessions will participate
/// in the same database transaction. </p>
/// <p>Turn this on for operations that are supposed to always execute
/// independently, without side effects caused by a shared Hibernate
/// Session.</p>
/// </summary>
public void SetAlwaysUseNewSession(bool alwaysUseNewSession)
{
this.alwaysUseNewSession = alwaysUseNewSession;
}
/// <summary>
/// Return whether to always use a new Hibernate Session for this template.
/// </summary>
public bool IsAlwaysUseNewSession()
{
return alwaysUseNewSession;
}
/// <summary>
/// Set whether to expose the native Hibernate Session to IHibernateCallback
/// code. Default is false; instead, a Session proxy will be returned,
/// suppressing <code>close</code> calls and automatically applying
/// query cache settings and transaction timeouts.
/// </summary>
public void SetExposeNativeSession(bool exposeNativeSession)
{
this.exposeNativeSession = exposeNativeSession;
}
/// <summary>
/// Return whether to expose the native Hibernate Session to HibernateCallback
/// code, or rather a Session proxy.
/// </summary>
public bool IsExposeNativeSession()
{
return exposeNativeSession;
}
/// <summary>
/// Set whether to check that the Hibernate Session is not in read-only mode
/// in case of write operations (save/update/delete).
/// <p>Default is true, for fail-fast behavior when attempting write operations
/// within a read-only transaction. Turn this off to allow save/update/delete
/// on a Session with flush mode NEVER.</p>
/// </summary>
public void SetCheckWriteOperations(bool checkWriteOperations)
{
this.checkWriteOperations = checkWriteOperations;
}
/// <summary>
/// Return whether to check that the Hibernate Session is not in read-only
/// mode in case of write operations (save/update/delete).
/// </summary>
public bool IsCheckWriteOperations()
{
return checkWriteOperations;
}
/// <summary>
/// Set whether to cache all queries executed by this template.
/// If this is true, all Query and Criteria objects created by
/// this template will be marked as cacheable (including all
/// queries through find methods).
/// <p>To specify the query region to be used for queries cached
/// by this template, set the "queryCacheRegion" property.
/// <param name="cacheQueries"></param>
/// </summary>
public void SetCacheQueries(bool cacheQueries)
{
this.cacheQueries = cacheQueries;
}
/// <summary>
/// Return whether to cache all queries executed by this template.
/// </summary>
public bool IsCacheQueries()
{
return cacheQueries;
}
/// <summary>
/// Set the name of the cache region for queries executed by this template.
/// If this is specified, it will be applied to all Query and Criteria objects
/// created by this template (including all queries through find methods).
/// <p>The cache region will not take effect unless queries created by this
/// template are configured to be cached via the "cacheQueries" property.</p>
///
/// </summary>
public void SetQueryCacheRegion(String queryCacheRegion)
{
this.queryCacheRegion = queryCacheRegion;
}
/// <summary>
/// Return the name of the cache region for queries executed by this template.
/// </summary>
public String GetQueryCacheRegion()
{
return queryCacheRegion;
}
/// <summary>
/// Prepare the given Criteria object, applying cache settings and/or
/// a transaction timeout.
/// <param name="criteria"> criteria the Criteria object to prepare</params>
/// </summary>
public void PrepareCriteria(ICriteria criteria)
{
if (IsCacheQueries())
{
criteria.SetCacheable(true);
if (GetQueryCacheRegion() != null)
{
criteria.SetCacheRegion(GetQueryCacheRegion());
}
}
}
/// <summary>
/// Prepare the given Query object, applying cache settings and/or
/// a transaction timeout.
/// <param name="queryObject">the Query object to prepare </param>
/// </summary>
public void PrepareQuery(IQuery queryObject)
{
if (IsCacheQueries())
{
queryObject.SetCacheable(true);
if (GetQueryCacheRegion() != null)
{
queryObject.SetCacheRegion(GetQueryCacheRegion());
}
}
}
/// <summary>
/// Execute the action specified by the given action object within a Session.
/// <param name="action">callback object that specifies the Hibernate action</param>
/// <param name="exposeNativeSession">whether to expose the native Hibernate Session</param>
/// <returns>a result object returned by the action, or null</returns>
/// </summary>
public Object Execute(IHibernateCallback action, bool exposeNativeSession)
{
ISession session = GetSession();
try
{
ISession sessionToExpose = (exposeNativeSession ? session : CreateSessionProxy(session));
Object result = action.DoInHibernate(sessionToExpose);
FlushIfNecessary(session, true);// Is it true or false
return result;
}
catch (HibernateException ex)
{
throw new ApplicationException( "Hibernate Error." , ex );
}
catch (Exception ex)
{
throw ex;
}
finally
{
SessionFactoryUtils.CloseSessionIfNecessary(session, SessionFactory );
}
}
/// <summary>
/// Return a Session for use by this template.
/// <p>Returns a new Session in case of "AlwaysUseNewSession" ,
/// if applicable), a pre-bound
/// Session in case of "allowCreate" turned off, and a pre-bound or new Session
/// else (new only if no transactional or otherwise pre-bound Session exists). </p>
/// </summary>
protected ISession GetSession()
{
if (IsAlwaysUseNewSession())
{
return SessionFactoryUtils.GetNewSession( SessionFactory , EntityInterceptor );
}
else if (!IsAllowCreate())
{
return SessionFactoryUtils.GetSession( SessionFactory , false );
}
else
{
return SessionFactoryUtils.GetSession(SessionFactory , EntityInterceptor );
}
}
/// <summary>
/// Create a close-suppressing proxy for the given Hibernate Session.
/// The proxy also prepares returned Query and Criteria objects.
/// <param name="session">the Hibernate Session to create a proxy for</param>
/// <returns>the Session proxy</returns>
/// </summary>
protected ISession CreateSessionProxy(ISession session)
{
// return (ISession) Proxy.newProxyInstance(
// getClass().getClassLoader(),
// new Class[] {Session.class},
// new CloseSuppressingInvocationHandler(session));
return session;
}
/// <summary>
/// Check whether write operations are allowed on the given Session.
/// <p>Default implementation throws an InvalidDataAccessApiUsageException
/// in case of FlushMode.NEVER. Can be overridden in subclasses.</p>
/// <param name="session">current Hibernate Session</param>
/// </summary>
public void CheckWriteOperationAllowed(ISession session)
{
if (IsCheckWriteOperations() && FlushMode != FLUSH_EAGER &&
NHibernate.FlushMode.Never.Equals(session.FlushMode) )
{
throw new ApplicationException(
"Write operations are not allowed in read-only mode (FlushMode.NEVER) - turn your Session " +
"into FlushMode.AUTO or remove 'readOnly' marker from transaction definition");
}
}
#region IHibernateOperations Members
/// <summary>
/// The Execute Method
/// </summary>
/// <param name="action">The Callback Reference</param>
/// <returns>The Result Object</returns>
public Object Execute(IHibernateCallback action)
{
return Execute( action , IsExposeNativeSession() );
}
/// <summary>
/// Execute the Find Operation
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public IList ExecuteFind(IHibernateCallback action)
{
return (IList) Execute( action, IsExposeNativeSession());
}
/// <summary>
/// Retrive the Entity By ID
/// </summary>
/// <param name="entityClass">The <see cref="System.Type"/> instance</param>
/// <param name="id">The ID of the Instance</param>
/// <returns>The Result Object</returns>
public Object Get(Type entityClass, Object id)
{
return Get(entityClass, id, null);
}
/// <summary>
/// Retrive the Entity
/// </summary>
/// <param name="entityClass">The <see cref="System.Type"/> instance </param>
/// <param name="id">The ID of the Instance</param>
/// <param name="lockMode">The Lock Mode</param>
/// <returns>The Result Object</returns>
public Object Get(Type entityClass, Object id, LockMode lockMode)
{
return Execute( new GetHibernetCallBack(entityClass,id,lockMode) , true );
}
/// <summary>
/// Load a Entity
/// </summary>
/// <param name="entityClass">The <see cref="System.Type"/> instance</param>
/// <param name="id">The Entity ID</param>
/// <returns>The Result Object</returns>
public Object Load(Type entityClass, Object id)
{
return Load(entityClass, id, null);
}
/// <summary>
/// Load an Entity
/// </summary>
/// <param name="entityClass">The <see cref="System.Type"/> instance</param>
/// <param name="id">The Entity ID</param>
/// <param name="lockMode">The Lock Mode</param>
/// <returns>The Result Object</returns>
public Object Load(Type entityClass, Object id, LockMode lockMode)
{
return Execute( new LoadHibernetCallBack( entityClass , id , lockMode ) , true );
}
/// <summary>
/// Load All Entity
/// </summary>
/// <param name="entityClass">The <see cref="System.Type"/> instance</param>
/// <returns>The <see cref="System.Collection.IList"/> instance</returns>
public IList LoadAll(Type entityClass)
{
return Execute( new LoadAllHibernetCallBack( entityClass , this ) , true ) as IList;
}
/// <summary>
/// Load Entity By ID into the entity
/// </summary>
/// <param name="entity">The Entity Object that will be filled with the retrive Data</param>
/// <param name="id">The Enetity ID</param>
public void Load(Object entity, Object id)
{
Execute( new LoadObjectHibernetCallBack( entity , id ), true );
}
/// <summary>
/// Refresh the Entity for the Session
/// </summary>
/// <param name="entity"></param>
public void Refresh(Object entity)
{
Refresh(entity, null);
}
/// <summary>
/// Refresh Entity by Locking
/// </summary>
/// <param name="entity">The Entity to Refersh</param>
/// <param name="lockMode">The Lock Mode</param>
public void Refresh(Object entity, LockMode lockMode)
{
Execute( new RefreshHibernetCallBack( entity , lockMode ), true );
}
/// <summary>
/// Check it the Entity Contains into the Session
/// </summary>
/// <param name="entity">The Entity</param>
/// <returns>true if exists, false other wise</returns>
public bool Contains(Object entity)
{
return (bool)Execute( new ContainsObjectHibernetCallBack( entity ) , true );
}
/// <summary>
/// Evict the Entity from the session
/// </summary>
/// <param name="entity">The Entity</param>
public void Evict(Object entity)
{
Execute( new EvictObjectHibernetCallBack( entity ) , true );
}
/// <summary>
/// Initialize.
/// </summary>
/// <param name="proxy">The Proxy Instance</param>
public void Initialize(Object proxy)
{
try
{
NHibernateUtil.Initialize( proxy );
}
catch (HibernateException ex)
{
throw new ApplicationException("Error initializing...",ex);
}
}
//-------------------------------------------------------------------------
// Convenience methods for storing individual objects
//-------------------------------------------------------------------------
/// <summary>
/// Lock the Entity
/// </summary>
/// <param name="entity">The Entity</param>
/// <param name="lockMode">The Lock Mode</param>
public void Lock(Object entity, LockMode lockMode)
{
Execute( new LockHibernetCallBack( entity , lockMode ),true);
}
/// <summary>
/// Save a entity
/// </summary>
/// <param name="entity">The Entity</param>
/// <returns>The ID of the Entity</returns>
public Object Save(Object entity)
{
return Execute( new SaveHibernetCallBack( entity , this ), true );
}
/// <summary>
/// Save the Entity with the ID
/// </summary>
/// <param name="entity">The Entity</param>
/// <param name="id">The ID</param>
public void Save(Object entity, Object id)
{
Execute( new SaveWithIDHibernetCallBack( entity , id , this ) , true );
}
/// <summary>
/// Update
/// </summary>
/// <param name="entity">The Entity</param>
public void Update(Object entity)
{
Update(entity, null);
}
/// <summary>
/// Update
/// </summary>
/// <param name="entity"></param>
/// <param name="lockMode"></param>
public void Update(Object entity, LockMode lockMode)
{
Execute( new UpdateHibernetCallBack( entity , lockMode , this ), true );
}
/// <summary>
/// Save or Update
/// </summary>
/// <param name="entity"></param>
public void SaveOrUpdate(Object entity)
{
Execute( new SaveOrUpdateHibernetCallBack( entity , this ) , true );
}
/// <summary>
/// Save or Update All Entities into the collection
/// </summary>
/// <param name="entities"></param>
public void SaveOrUpdateAll(ICollection entities)
{
// NOT IMPLEMENTING NOW
}
/// <summary>
/// Save or Update the Copy
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public Object SaveOrUpdateCopy(Object entity)
{
return Execute( new SaveOrUpdateCopyHibernetCallBack( entity , this ), true );
}
/// <summary>
/// Delete the Entity
/// </summary>
/// <param name="entity"></param>
public void Delete(Object entity)
{
Delete(entity, null);
}
/// <summary>
/// Delete with Locking
/// </summary>
/// <param name="entity"></param>
/// <param name="lockMode"></param>
public void Delete(Object entity, LockMode lockMode)
{
Execute( new DeleteHibernetCallBack( entity , lockMode , this ), true );
}
/// <summary>
/// Delete All
/// </summary>
/// <param name="entities"></param>
public void DeleteAll(ICollection entities)
{
for( IEnumerator enumerator = entities.GetEnumerator(); enumerator.MoveNext(); )
{ // Iterate over the collection and delete each item from the collection
Delete( enumerator.Current );
}
}
/// <summary>
/// Flush the Session
/// </summary>
public void Flush()
{
Execute( new FlushHibernetCallBack( ) , true );
}
/// <summary>
/// Clear
/// </summary>
public void Clear()
{
Execute( new ClearHibernetCallBack() , true );
}
/// <summary>
/// Finds and returns the <see cref="System.Collection.IList"/> instance
/// </summary>
/// <param name="queryString">The Query String</param>
/// <returns> The <see cref="System.Collection.IList"/> instance </returns>
public IList Find(String queryString)
{
return Find( queryString , (Object[])null , (IType[])null );
}
/// <summary>
/// Find
/// </summary>
/// <param name="queryString"></param>
/// <param name="value"></param>
/// <returns></returns>
public IList Find(String queryString, Object value)
{
return Find( queryString , new object[]{value} , (IType[])null );
}
/// <summary>
/// Find
/// </summary>
/// <param name="queryString"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns></returns>
public IList Find(String queryString, Object value, IType type)
{
return Find( queryString , new object[]{value} , new IType[]{type} );
}
/// <summary>
/// Find
/// </summary>
/// <param name="queryString"></param>
/// <param name="values"></param>
/// <returns></returns>
public IList Find(String queryString, Object[] values)
{
return Find( queryString , values , (IType[])null );
}
/// <summary>
/// Find
/// </summary>
/// <param name="queryString"></param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns></returns>
public IList Find(String queryString, Object[] values, IType[] types)
{
if( null != values && null != types && values.Length != types.Length )
{
throw new ArgumentException("Values and types length must be equal.","Values and Types");
}
return Execute( new FindAllHibernetCallBack( queryString , values , types , this ) , true ) as IList;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="paramName"></param>
/// <param name="value"></param>
/// <returns></returns>
public IList FindByNamedParam(String queryName, String paramName, Object value)
{
// TODO: Add HibernateTemplate.FindByNamedParam implementation
return null;
}
/// <summary>
/// Find By Name
/// </summary>
/// <param name="queryName"></param>
/// <param name="paramName"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns></returns>
public IList FindByNamedParam(String queryName, String paramName, Object value, IType type)
{
// TODO: Add HibernateTemplate.FindByNamedParam implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="paramNames"></param>
/// <param name="values"></param>
/// <returns></returns>
public IList FindByNamedParam(String queryString, String[] paramNames, Object[] values)
{
// TODO: Add HibernateTemplate.FindByNamedParam implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="paramNames"></param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns></returns>
public IList FindByNamedParam(String queryString, String[] paramNames, Object[] values, IType[] types)
{
// TODO: Add HibernateTemplate.FindByNamedParam implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="valueBean"></param>
/// <returns></returns>
public IList FindByValueObject(String queryString, Object valueBean)
{
// TODO: Add HibernateTemplate.FindByValueBean implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <returns></returns>
public IList FindByNamedQuery(String queryName)
{
// TODO: Add HibernateTemplate.FindByNamedQuery implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="value"></param>
/// <returns></returns>
public IList FindByNamedQuery(String queryName, Object value)
{
// TODO: Add HibernateTemplate.FindByNamedQuery implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns></returns>
public IList FindByNamedQuery(String queryName, Object value, IType type)
{
// TODO: Add HibernateTemplate.FindByNamedQuery implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="values"></param>
/// <returns></returns>
public IList FindByNamedQuery(String queryName, Object[] values)
{
// TODO: Add HibernateTemplate.FindByNamedQuery implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns></returns>
public IList FindByNamedQuery(String queryName, Object[] values, IType[] types)
{
// TODO: Add HibernateTemplate.FindByNamedQuery implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="paramName"></param>
/// <param name="value"></param>
/// <returns></returns>
public IList FindByNamedQueryAndNamedParam(String queryName, String paramName, Object value)
{
// TODO: Add HibernateTemplate.FindByNamedQueryAndNamedParam implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="paramName"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns></returns>
public IList FindByNamedQueryAndNamedParam(String queryName, String paramName, Object value, IType type)
{
// TODO: Add HibernateTemplate.FindByNamedQueryAndNamedParam implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="paramNames"></param>
/// <param name="values"></param>
/// <returns></returns>
public IList FindByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)
{
// TODO: Add HibernateTemplate.FindByNamedQueryAndNamedParam implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="paramNames"></param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns></returns>
public IList FindByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values, IType[] types)
{
// TODO: Add HibernateTemplate.FindByNamedQueryAndNamedParam implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryName"></param>
/// <param name="valueBean"></param>
/// <returns></returns>
public IList FindByNamedQueryAndValueBean(String queryName, Object valueBean)
{
// TODO: Add HibernateTemplate.FindByNamedQueryAndValueBean implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <returns></returns>
public IEnumerator Enumerate(String queryString)
{
// TODO: Add HibernateTemplate.Enumerate implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="value"></param>
/// <returns></returns>
public IEnumerator Enumerate(String queryString, Object value)
{
// TODO: Add HibernateTemplate.Enumerate implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns></returns>
public IEnumerator Enumerate(String queryString, Object value, IType type)
{
// TODO: Add HibernateTemplate.Enumerate implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="values"></param>
/// <returns></returns>
public IEnumerator Enumerate(String queryString, Object[] values)
{
// TODO: Add HibernateTemplate.Enumerate implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns></returns>
public IEnumerator Enumerate(String queryString, Object[] values, IType[] types)
{
// TODO: Add HibernateTemplate.Enumerate implementation
return null;
}
/// <summary>
///
/// </summary>
/// <param name="enumerator"></param>
public void CloseEnumerator(IEnumerator enumerator)
{
// TODO: Add HibernateTemplate.CloseEnumerator implementation
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <returns></returns>
public int Delete(String queryString)
{
// TODO: Add HibernateTemplate.Delete implementation
return 0;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <returns></returns>
public int Delete(String queryString, Object value, IType type)
{
// TODO: Add HibernateTemplate.Delete implementation
return 0;
}
/// <summary>
///
/// </summary>
/// <param name="queryString"></param>
/// <param name="values"></param>
/// <param name="types"></param>
/// <returns></returns>
public int Delete(String queryString, Object[] values, IType[] types)
{
// TODO: Add HibernateTemplate.Delete implementation
return 0;
}
#endregion
#region Inner Classes Implementations
/// <summary>
/// Call back for GET
/// </summary>
public class GetHibernetCallBack : IHibernateCallback
{
public GetHibernetCallBack( Type entityClass, Object id, LockMode lockMode )
{
m_entityClass = entityClass;
m_id = id;
m_lockMode = lockMode;
}
private Type m_entityClass;
private Object m_id;
private LockMode m_lockMode;
#region IHibernateCallback Members
public Object DoInHibernate(ISession session)
{
if ( m_lockMode != null )
{
return session.Get( m_entityClass, m_id, m_lockMode);
}
else
{
return session.Get( m_entityClass, m_id);
}
}
#endregion
}
/// <summary>
/// Call back for REFRESH
/// </summary>
public class RefreshHibernetCallBack : IHibernateCallback
{
public RefreshHibernetCallBack( Object entity, LockMode lockMode )
{
m_entity = entity;
m_lockMode = lockMode;
}
private Object m_entity;
private LockMode m_lockMode;
#region IHibernateCallback Members
public Object DoInHibernate(ISession session)
{
if ( m_lockMode != null )
{
session.Refresh( m_entity, m_lockMode);
}
else
{
session.Refresh( m_entity, m_lockMode);
}
return null;
}
#endregion
}
/// <summary>
/// Call back for LOAD
/// </summary>
public class LoadHibernetCallBack : IHibernateCallback
{
public LoadHibernetCallBack( Type entityClass, Object id, LockMode lockMode )
{
m_entityClass = entityClass;
m_id = id;
m_lockMode = lockMode;
}
private Type m_entityClass;
private Object m_id;
private LockMode m_lockMode;
#region IHibernateCallback Members
public Object DoInHibernate(ISession session)
{
if ( m_lockMode != null )
{
return session.Load( m_entityClass, m_id, m_lockMode);
}
else
{
return session.Load( m_entityClass, m_id);
}
}
#endregion
}
/// <summary>
/// Call back for LOAD
/// </summary>
public class LoadObjectHibernetCallBack : IHibernateCallback
{
public LoadObjectHibernetCallBack( Object entity , Object id )
{
m_entity = entity;
m_id = id;
}
private Object m_entity;
private Object m_id;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
session.Load( m_entity, m_id );
return null;
}
#endregion
}
/// <summary>
/// Call back for LOAD
/// </summary>
public class LoadAllHibernetCallBack : IHibernateCallback
{
public LoadAllHibernetCallBack( Type entityClass , HibernateTemplate Template )
{
m_entityClass = entityClass;
m_HibernateTemplate = Template;
}
private Type m_entityClass;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
ICriteria criteria = session.CreateCriteria(m_entityClass);
m_HibernateTemplate. PrepareCriteria(criteria);
return criteria.List();
}
#endregion
}
/// <summary>
/// Call back for CONTAINS
/// </summary>
public class ContainsObjectHibernetCallBack : IHibernateCallback
{
public ContainsObjectHibernetCallBack( Object entity )
{
m_entity = entity;
}
private Object m_entity;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
return session.Contains( m_entity );
}
#endregion
}
/// <summary>
/// Call back for EVICT
/// </summary>
public class EvictObjectHibernetCallBack : IHibernateCallback
{
public EvictObjectHibernetCallBack( Object entity )
{
m_entity = entity;
}
private Object m_entity;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
session.Evict( m_entity );
return null;
}
#endregion
}
/// <summary>
/// Call back for LOCK
/// </summary>
public class LockHibernetCallBack : IHibernateCallback
{
public LockHibernetCallBack( Object entity, LockMode lockMode )
{
m_entity = entity;
m_lockMode = lockMode;
}
private Object m_entity;
private LockMode m_lockMode;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
session.Lock( m_entity , m_lockMode );
return null;
}
#endregion
}
/// <summary>
/// Call back for SAVEWithID
/// </summary>
public class SaveWithIDHibernetCallBack : IHibernateCallback
{
public SaveWithIDHibernetCallBack( Object entity , Object id , HibernateTemplate template)
{
m_entity = entity;
m_HibernateTemplate = template;
m_id = id;
}
private Object m_entity;
private Object m_id;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
m_HibernateTemplate.CheckWriteOperationAllowed( session );
session.Save( m_entity , m_id );
return null;
}
#endregion
}
/// <summary>
/// Call back for SAVE
/// </summary>
public class SaveHibernetCallBack : IHibernateCallback
{
public SaveHibernetCallBack( Object entity , HibernateTemplate template)
{
m_entity = entity;
m_HibernateTemplate = template;
}
private Object m_entity;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
m_HibernateTemplate.CheckWriteOperationAllowed( session );
return session.Save( m_entity );
}
#endregion
}
/// <summary>
/// Call back for UPDATE
/// </summary>
public class UpdateHibernetCallBack : IHibernateCallback
{
public UpdateHibernetCallBack( Object entity , LockMode lockMode , HibernateTemplate template)
{
m_entity = entity;
m_LockMode = lockMode;
m_HibernateTemplate = template;
}
private Object m_entity;
private LockMode m_LockMode;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
m_HibernateTemplate.CheckWriteOperationAllowed( session );
session.Update( m_entity );
if( null != m_LockMode )
{
session.Lock( m_entity , m_LockMode );
}
return null;
}
#endregion
}
/// <summary>
/// Call back for SAVEorUpdate
/// </summary>
public class SaveOrUpdateHibernetCallBack : IHibernateCallback
{
public SaveOrUpdateHibernetCallBack( Object entity , HibernateTemplate template)
{
m_entity = entity;
m_HibernateTemplate = template;
}
private Object m_entity;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
m_HibernateTemplate.CheckWriteOperationAllowed( session );
session.SaveOrUpdate( m_entity );
return null;
}
#endregion
}
/// <summary>
/// Call back for SAVEorUpdate Copy
/// </summary>
public class SaveOrUpdateCopyHibernetCallBack : IHibernateCallback
{
public SaveOrUpdateCopyHibernetCallBack( Object entity , HibernateTemplate template)
{
m_entity = entity;
m_HibernateTemplate = template;
}
private Object m_entity;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
m_HibernateTemplate.CheckWriteOperationAllowed( session );
return session.SaveOrUpdateCopy( m_entity );
}
#endregion
}
/// <summary>
/// Call back for DELETE
/// </summary>
public class DeleteHibernetCallBack : IHibernateCallback
{
public DeleteHibernetCallBack( Object entity , LockMode lockMode , HibernateTemplate template)
{
m_entity = entity;
m_LockMode = lockMode;
m_HibernateTemplate = template;
}
private Object m_entity;
private LockMode m_LockMode;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
m_HibernateTemplate.CheckWriteOperationAllowed( session );
if( null != m_LockMode )
{
session.Lock( m_entity , m_LockMode );
}
session.Delete( m_entity );
return null;
}
#endregion
}
/// <summary>
/// Call back for FLUSH
/// </summary>
public class FlushHibernetCallBack : IHibernateCallback
{
public FlushHibernetCallBack( )
{
}
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
session.Flush();
return null;
}
#endregion
}
/// <summary>
/// Call back for CLEAR
/// </summary>
public class ClearHibernetCallBack : IHibernateCallback
{
public ClearHibernetCallBack( )
{
}
#region IHibernateCallback Members
/// <summary>
///
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
session.Clear();
return null;
}
#endregion
}
/// <summary>
/// Call back for Find
/// </summary>
public class FindAllHibernetCallBack : IHibernateCallback
{
public FindAllHibernetCallBack( string QueryString , object[]Values , IType[]Types , HibernateTemplate Template )
{
m_queryString = QueryString;
m_values = Values;
m_types = Types;
m_HibernateTemplate = Template;
}
private string m_queryString;
private object[]m_values;
private IType[]m_types;
private HibernateTemplate m_HibernateTemplate;
#region IHibernateCallback Members
/// <summary>
/// CallBack for Find Method
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public Object DoInHibernate(ISession session)
{
IQuery queryObject = session.CreateQuery( m_queryString );
m_HibernateTemplate.PrepareQuery( queryObject );
if ( m_values != null )
{
for (int i = 0; i < m_values.Length; i++)
{
if ( m_types != null && m_types[i] != null)
{
queryObject.SetParameter( i, m_values[i], m_types[i]);
}
else
{
queryObject.SetParameter( i, m_values[i]);
}
}
}
return queryObject.List();
}
#endregion
}
#endregion
}
}
Submit an article or tip