/// <summary> /// Translate the given <see cref="System.SystemException"/> into a generic data access exception. /// </summary> /// <param name="task">A readable string describing the task being attempted.</param> /// <param name="sql">The SQL query or update that caused the problem. May be null.</param> /// <param name="exception"> /// The <see cref="System.Exception"/> encountered by the ADO.NET implementation. /// </param> /// <returns> /// A <see cref="Spring.Dao.DataAccessException"/> appropriate for the supplied /// <paramref name="exception"/>. /// </returns> public virtual DataAccessException Translate(string task, string sql, Exception exception) { if (task == null) { task = ""; } if (sql == null) { sql = ""; } string errorCode = ExtractErrorCode(exception); DataAccessException dex = DoTranslate(task, sql, errorCode, exception); if (dex != null) { // Specific exception match found. return(dex); } // Looking for a fallback... if (log.IsDebugEnabled) { log.Debug("Unable to translate exception with errorCode '" + errorCode + "', will use the fallback translator"); } IAdoExceptionTranslator fallback = FallbackTranslator; if (fallback != null) { return(FallbackTranslator.Translate(task, sql, exception)); } // We couldn't identify it more precisely. return(new UncategorizedAdoException(task, sql, errorCode, exception)); }
/// <summary> /// Initializes a new instance of the <see cref="SpringSessionSynchronization"/> class. /// </summary> public SpringSessionSynchronization(SessionHolder sessionHolder, ISessionFactory sessionFactory, IAdoExceptionTranslator adoExceptionTranslator, bool newSession) { this.sessionHolder = sessionHolder; this.sessionFactory = sessionFactory; this.adoExceptionTranslator = adoExceptionTranslator; this.newSession = newSession; }
private void CheckTranslation(IAdoExceptionTranslator translator, string errorCode, Type exType) { TestSqlException sex = new TestSqlException("", errorCode); DataAccessException ex = translator.Translate("", "", sex); Assert.IsTrue(exType.IsAssignableFrom(ex.GetType())); Assert.IsTrue(ex.InnerException == sex); }
public void ExceptionTranslator() { ISessionFactory sessionFactory = ctx["SessionFactory"] as ISessionFactory; HibernateTemplate template = new HibernateTemplate(sessionFactory); IAdoExceptionTranslator translator = template.AdoExceptionTranslator; Assert.IsNotNull(translator, "ADO.NET exception translator should not be null"); Assert.That(translator, Is.InstanceOf(typeof(ErrorCodeExceptionTranslator))); }
private static ISession GetSession( ISessionFactory sessionFactory, IInterceptor entityInterceptor, IAdoExceptionTranslator adoExceptionTranslator, bool allowCreate) { try { return(DoGetSession(sessionFactory, entityInterceptor, adoExceptionTranslator, allowCreate)); } catch (HibernateException ex) { throw new DataAccessResourceFailureException("Could not open Hibernate Session", ex); } }
/// <summary> /// Converts a Hibernate ADOException to a Spring DataAccessExcption, extracting the underlying error code from /// ADO.NET. Will extract the ADOException Message and SqlString properties and pass them to the translate method /// of the provided IAdoExceptionTranslator. /// </summary> /// <param name="translator">The IAdoExceptionTranslator, may be a user provided implementation as configured on /// HibernateTemplate. /// </param> /// <param name="ex">The ADOException throw</param> /// <returns>The translated DataAccessException or UncategorizedAdoException in case of an error in translation /// itself.</returns> public static DataAccessException ConvertAdoAccessException(IAdoExceptionTranslator translator, ADOException ex) { try { string sqlString = (ex.SqlString != null) ? ex.SqlString.ToString() : string.Empty; return(translator.Translate( "Hibernate operation: " + ex.Message, sqlString, ex.InnerException)); } catch (Exception e) { log.Error("Exception thrown during exception translation. Message = [" + e.Message + "]", e); log.Error("Exception that was attempted to be translated was [" + ex.Message + "]", ex); if (ex.InnerException != null) { log.Error(" Inner Exception was [" + ex.InnerException.Message + "]", ex.InnerException); } throw new UncategorizedAdoException(e.Message, "", "", e); } }
/// <summary> /// Convert the given ADOException to an appropriate exception from the /// the Spring.Dao hierarchy. Can be overridden in subclasses. /// </summary> /// <param name="ex">The ADOException that occured, wrapping the underlying /// ADO.NET thrown exception.</param> /// <param name="translator">The translator to convert hibernate ADOExceptions.</param> /// <returns> /// The corresponding DataAccessException instance /// </returns> protected virtual DataAccessException ConvertAdoAccessException(ADOException ex, IAdoExceptionTranslator translator) { return(translator.Translate("Hibernate flushing: " + ex.Message, null, ex.InnerException)); }
/// <summary> /// Converts a Hibernate ADOException to a Spring DataAccessExcption, extracting the underlying error code from /// ADO.NET. Will extract the ADOException Message and SqlString properties and pass them to the translate method /// of the provided IAdoExceptionTranslator. /// </summary> /// <param name="translator">The IAdoExceptionTranslator, may be a user provided implementation as configured on /// HibernateTemplate. /// </param> /// <param name="ex">The ADOException throw</param> /// <returns>The translated DataAccessException or UncategorizedAdoException in case of an error in translation /// itself.</returns> public static DataAccessException ConvertAdoAccessException(IAdoExceptionTranslator translator, ADOException ex) { try { string sqlString = (ex.SqlString != null) ? ex.SqlString.ToString() : string.Empty; return translator.Translate( "Hibernate operation: " + ex.Message, sqlString, ex.InnerException); } catch (Exception e) { log.Error("Exception thrown during exception translation. Message = [" + e.Message + "]", e); log.Error("Exception that was attempted to be translated was [" + ex.Message + "]", ex); if (ex.InnerException != null) { log.Error(" Inner Exception was [" + ex.InnerException.Message + "]", ex.InnerException); } throw new UncategorizedAdoException(e.Message, "", "", e); } }
private static ISession DoGetSession( ISessionFactory sessionFactory, IInterceptor entityInterceptor, IAdoExceptionTranslator adoExceptionTranslator, bool allowCreate) { AssertUtils.ArgumentNotNull(sessionFactory, "sessionFactory", "SessionFactory can not be null"); SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.GetResource(sessionFactory); if (sessionHolder != null && !sessionHolder.IsEmpty) { // pre-bound Hibernate Session ISession session = null; if (TransactionSynchronizationManager.SynchronizationActive && sessionHolder.DoesNotHoldNonDefaultSession) { // Spring transaction management is active -> // register pre-bound Session with it for transactional flushing. session = sessionHolder.ValidatedSession; if (session != null && !sessionHolder.SynchronizedWithTransaction) { log.Debug("Registering Spring transaction synchronization for existing Hibernate Session"); TransactionSynchronizationManager.RegisterSynchronization( new SpringSessionSynchronization(sessionHolder, sessionFactory, adoExceptionTranslator, false)); sessionHolder.SynchronizedWithTransaction = true; // Switch to FlushMode.AUTO if we're not within a read-only transaction. FlushMode flushMode = session.FlushMode; if (FlushMode.Never == flushMode && !TransactionSynchronizationManager.CurrentTransactionReadOnly) { session.FlushMode = FlushMode.Auto; sessionHolder.PreviousFlushMode = flushMode; } } } else { // No Spring transaction management active -> simply return default thread-bound Session, if any // (possibly from OpenSessionInViewModule) session = sessionHolder.ValidatedSession; } if (session != null) { return session; } } ISession sess = OpenSession(sessionFactory, entityInterceptor); // Set Session to FlushMode.Never if we're within a read-only transaction. // Use same Session for further Hibernate actions within the transaction. // Thread object will get removed by synchronization at transaction completion. if (TransactionSynchronizationManager.SynchronizationActive) { log.Debug("Registering Spring transaction synchronization for new Hibernate Session"); SessionHolder holderToUse = sessionHolder; if (holderToUse == null) { holderToUse = new SessionHolder(sess); } else { holderToUse.AddSession(sess); } if (TransactionSynchronizationManager.CurrentTransactionReadOnly) { sess.FlushMode = FlushMode.Never; } TransactionSynchronizationManager.RegisterSynchronization( new SpringSessionSynchronization(holderToUse, sessionFactory, adoExceptionTranslator, true)); holderToUse.SynchronizedWithTransaction = true; if (holderToUse != sessionHolder) { TransactionSynchronizationManager.BindResource(sessionFactory, holderToUse); } } // Check whether we are allowed to return the Session. if (!allowCreate && !IsSessionTransactional(sess, sessionFactory)) { CloseSession(sess); throw new InvalidOperationException ("No Hibernate Session bound to thread, " + "and configuration does not allow creation of non-transactional one here"); } return sess; }
private static ISession GetSession( ISessionFactory sessionFactory, IInterceptor entityInterceptor, IAdoExceptionTranslator adoExceptionTranslator, bool allowCreate) { try { return DoGetSession(sessionFactory, entityInterceptor, adoExceptionTranslator, allowCreate); } catch (HibernateException ex) { throw new DataAccessResourceFailureException("Could not open Hibernate Session", ex); } }
/// <summary> /// Convert the given ADOException to an appropriate exception from the /// the Spring.Dao hierarchy. Can be overridden in subclasses. /// </summary> /// <param name="ex">The ADOException that occured, wrapping the underlying /// ADO.NET thrown exception.</param> /// <param name="translator">The translator to convert hibernate ADOExceptions.</param> /// <returns> /// The corresponding DataAccessException instance /// </returns> protected virtual DataAccessException ConvertAdoAccessException(ADOException ex, IAdoExceptionTranslator translator) { return translator.Translate("Hibernate flusing: " + ex.Message, null, ex.InnerException); }
protected virtual void InitExceptionTranslator() { if (exceptionTranslator == null) { IDbProvider provider = DbProvider; if (provider != null) { exceptionTranslator = new ErrorCodeExceptionTranslator(provider); } else { exceptionTranslator = new FallbackExceptionTranslator(); } } }
private static ISession DoGetSession( ISessionFactory sessionFactory, IInterceptor entityInterceptor, IAdoExceptionTranslator adoExceptionTranslator, bool allowCreate) { AssertUtils.ArgumentNotNull(sessionFactory, "sessionFactory", "SessionFactory can not be null"); SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(sessionFactory); if (sessionHolder != null && !sessionHolder.IsEmpty) { // pre-bound Hibernate Session ISession session = null; if (TransactionSynchronizationManager.SynchronizationActive && sessionHolder.DoesNotHoldNonDefaultSession) { // Spring transaction management is active -> // register pre-bound Session with it for transactional flushing. session = sessionHolder.ValidatedSession; if (!sessionHolder.SynchronizedWithTransaction) { log.Debug("Registering Spring transaction synchronization for existing Hibernate Session"); TransactionSynchronizationManager.RegisterSynchronization( new SpringSessionSynchronization(sessionHolder, sessionFactory, adoExceptionTranslator, false)); sessionHolder.SynchronizedWithTransaction = true; // Switch to FlushMode.AUTO if we're not within a read-only transaction. FlushMode flushMode = session.FlushMode; if (FlushMode.Never == flushMode && !TransactionSynchronizationManager.CurrentTransactionReadOnly) { session.FlushMode = FlushMode.Auto; sessionHolder.PreviousFlushMode = flushMode; } } } else { // No Spring transaction management active -> simply return default thread-bound Session, if any // (possibly from OpenSessionInViewModule) session = sessionHolder.ValidatedSession; } if (session != null) { return(session); } } ISession sess = OpenSession(sessionFactory, entityInterceptor); // Set Session to FlushMode.Never if we're within a read-only transaction. // Use same Session for further Hibernate actions within the transaction. // Thread object will get removed by synchronization at transaction completion. if (TransactionSynchronizationManager.SynchronizationActive) { log.Debug("Registering Spring transaction synchronization for new Hibernate Session"); SessionHolder holderToUse = sessionHolder; if (holderToUse == null) { holderToUse = new SessionHolder(sess); } else { holderToUse.AddSession(sess); } if (TransactionSynchronizationManager.CurrentTransactionReadOnly) { sess.FlushMode = FlushMode.Never; } TransactionSynchronizationManager.RegisterSynchronization( new SpringSessionSynchronization(holderToUse, sessionFactory, adoExceptionTranslator, true)); holderToUse.SynchronizedWithTransaction = true; if (holderToUse != sessionHolder) { TransactionSynchronizationManager.BindResource(sessionFactory, holderToUse); } } // Check whether we are allowed to return the Session. if (!allowCreate && !IsSessionTransactional(sess, sessionFactory)) { CloseSession(sess); throw new InvalidOperationException("No Hibernate Session bound to thread, " + "and configuration does not allow creation of non-transactional one here"); } return(sess); }