/// <summary> /// Test with NO conversation and "connection.release_mode" /// "auto"(<see cref="ConnectionReleaseMode.AfterTransaction"/>). /// </summary> private void connection_release_mode_auto_no_conversation() { //with NO conversation and "connection.release_mode" "auto"(AfterTransaction) //forcing "auto" by reflection. Settings settings = ((SessionFactoryImpl)this.SessionFactory).Settings; ConnectionReleaseMode connReleaseModeOriginal = settings.ConnectionReleaseMode; this.setConnectionReleaseModeByReflection(settings, ConnectionReleaseMode.AfterTransaction); //with no conversation SessionScopeSettings sessionScopeSettings = new SessionScopeSettings(this.sessionFactory); ConnectionCreationTrackingDbProvider.Count = 0; using (new SessionScope(sessionScopeSettings, true)) { ISession sessionNoConv = this.SessionFactory.GetCurrentSession(); SPCMasterEnt masterEnt2 = sessionNoConv.Get <SPCMasterEnt>(2); Assert.AreEqual(1, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); Assert.AreEqual(1, masterEnt2.SPCDetailEntList.Count, "masterEnt2.SPCDetailEntList.Count"); Assert.AreEqual(2, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); SPCMasterEnt masterEnt3 = sessionNoConv.Get <SPCMasterEnt>(3); Assert.AreEqual(3, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); Assert.AreEqual(1, masterEnt3.SPCDetailEntList.Count, "masterEnt3.SPCDetailEntList.Count"); Assert.AreEqual(4, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); } this.setConnectionReleaseModeByReflection(settings, connReleaseModeOriginal); }
private Settings BuildSettings(SessionElement sessionElement) { Settings settings = new Settings(); IConnectionProvider connectionProvider = ConnectionProviderFactory.NewConnectionProvider(sessionElement); ITransactionFactory transactionFactory = CreateTransactionFactory(sessionElement); string releaseModeName = sessionElement.ConnectionReleaseMode; ConnectionReleaseMode releaseMode = "auto".Equals(releaseModeName) ? ConnectionReleaseMode.AfterTransaction : ParseConnectionReleaseMode(releaseModeName); settings.SessionFactoryName = sessionElement.Name; settings.ConnectionReleaseMode = releaseMode; // settings.DefaultBatchFetchSize = sessionElement.DefaultBatchFetchSize; settings.BatchSize = sessionElement.BatchSize; settings.BatcherFactory = new BatcherFactory();// CreateBatcherFactory(sessionElement, settings.BatchSize, connectionProvider); string isolationString = sessionElement.IsolationString; IsolationLevel isolation = IsolationLevel.Unspecified; if (isolationString.Length > 0) { try { isolation = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), isolationString); } catch { throw new Exception("The isolation level of " + isolationString + " is not a valid IsolationLevel. Please use one of the Member Names from the IsolationLevel."); } } settings.IsolationLevel = isolation; settings.ConnectionProvider = connectionProvider; settings.TransactionFactory = transactionFactory; return(settings); }
public ConnectionManager( ISessionImplementor session, DbConnection suppliedConnection, ConnectionReleaseMode connectionReleaseMode, IInterceptor interceptor, bool shouldAutoJoinTransaction) : this(session, suppliedConnection, connectionReleaseMode, interceptor, shouldAutoJoinTransaction, new NonContextualConnectionAccess(session.Factory)) { }
ISession ISessionFactoryImplementor.OpenSession( IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { throw new NotSupportedException(); }
private ConnectionManager(SerializationInfo info, StreamingContext context) { ownConnection = info.GetBoolean("ownConnection"); session = (ISessionImplementor) info.GetValue("session", typeof(ISessionImplementor)); connectionReleaseMode = (ConnectionReleaseMode) info.GetValue("connectionReleaseMode", typeof(ConnectionReleaseMode)); interceptor = (IInterceptor)info.GetValue("interceptor", typeof(IInterceptor)); }
private ConnectionManager(SerializationInfo info, StreamingContext context) { _ownConnection = info.GetBoolean("ownConnection"); Session = (ISessionImplementor)info.GetValue("session", typeof(ISessionImplementor)); _connectionReleaseMode = (ConnectionReleaseMode)info.GetValue("connectionReleaseMode", typeof(ConnectionReleaseMode)); _interceptor = (IInterceptor)info.GetValue("interceptor", typeof(IInterceptor)); }
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { return (new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor, settings.DefaultEntityMode, flushBeforeCompletionEnabled, autoCloseSessionEnabled, connectionReleaseMode)); }
public ISession OpenSession(DbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { #pragma warning disable 618 var isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled = settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled; #pragma warning restore 618 return (new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor, flushBeforeCompletionEnabled, autoCloseSessionEnabled, isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled, connectionReleaseMode, settings.DefaultFlushMode)); }
public ConnectionManager(ISessionImplementor session, string connectionString, ConnectionReleaseMode connectionReleaseMode, IInterceptor interceptor) { this.session = session; ConnectionString = connectionString; this.connectionReleaseMode = connectionReleaseMode; this.interceptor = interceptor; batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor); ownConnection = true; }
ISession ISessionFactoryImplementor.OpenSession( DbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { var s = ActualFactory.OpenSession(connection, flushBeforeCompletionEnabled, autoCloseSessionEnabled, connectionReleaseMode); _openedSessions.Add(s.GetSessionImplementation()); return(s); }
ISession ISessionFactoryImplementor.OpenSession( DbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { #pragma warning disable CS0618 // Type or member is obsolete var s = ActualFactory.OpenSession(connection, flushBeforeCompletionEnabled, autoCloseSessionEnabled, connectionReleaseMode); #pragma warning restore CS0618 // Type or member is obsolete _openedSessions.Add(s.GetSessionImplementation()); return(s); }
/// <summary> /// Sets the <see cref="Settings.ConnectionReleaseMode"/> by reflection. /// </summary> /// <param name="settings">The settings.</param> /// <param name="mode">The mode.</param> private void setConnectionReleaseModeByReflection(Settings settings, ConnectionReleaseMode mode) { PropertyInfo pInfoConnectionReleaseMode = settings.GetType().GetProperty( "ConnectionReleaseMode", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetProperty | BindingFlags.Instance); pInfoConnectionReleaseMode.SetValue(settings, mode, null); }
/// <summary> /// Test with conversation and "connection.release_mode" /// "auto"(<see cref="ConnectionReleaseMode.AfterTransaction"/>). /// </summary> /// <remarks> /// Here we can see that every statement causes a closing of the IDbConnection. /// </remarks> private void connection_release_mode_auto() { //with conversation and "connection.release_mode" "auto"(AfterTransaction) //forcing "auto" by reflection. Settings settings = ((SessionFactoryImpl)this.SessionFactory).Settings; ConnectionReleaseMode connReleaseModeOriginal = settings.ConnectionReleaseMode; this.setConnectionReleaseModeByReflection(settings, ConnectionReleaseMode.AfterTransaction); //((SessionFactoryImpl)this.sessionFactory).Settings.ConnectionReleaseMode = ConnectionReleaseMode.AfterTransaction; ConnectionCreationTrackingDbProvider.Count = 0; this.Conversation.StartResumeConversation(); ISession sessionA = this.SessionFactory.GetCurrentSession(); SPCDetailEnt detailEnt = sessionA.Get <SPCDetailEnt>(1); Assert.AreEqual(1, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); SessionScopeSettings sessionScopeSettings = new SessionScopeSettings(this.sessionFactory); sessionScopeSettings.SingleSession = true; SPCMasterEnt masterEnt; using (new SessionScope(sessionScopeSettings, false)) { ISession sessionB = this.SessionFactory.GetCurrentSession(); masterEnt = sessionB.Get <SPCMasterEnt>(1); Assert.AreEqual(2, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); Assert.AreSame(sessionA, sessionB, "sessionA, sessionB"); } SPCMasterEnt masterEnt2 = sessionA.Get <SPCMasterEnt>(2); Assert.AreEqual(3, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); Assert.AreEqual(1, masterEnt2.SPCDetailEntList.Count, "masterEnt2.SPCDetailEntList.Count"); Assert.AreEqual(4, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); SPCMasterEnt masterEnt3 = sessionA.Get <SPCMasterEnt>(3); Assert.AreEqual(5, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); Assert.AreEqual(1, masterEnt3.SPCDetailEntList.Count, "masterEnt3.SPCDetailEntList.Count"); Assert.AreEqual(6, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count"); //Renew the conversation. this.Conversation.EndConversation(); this.Conversation.ConversationManager.FreeEnded(); this.Conversation = (IConversationState)this.applicationContext.GetObject("convConnectionReleaseModeIssue"); this.setConnectionReleaseModeByReflection(settings, connReleaseModeOriginal); }
/// <summary> /// Manejador de conexiones contra la BBDD /// </summary> /// <param name="p_ses">Session que contiene este Connection Manager</param> /// <param name="p_connectionReleaseMode">Pues eso...</param> internal CnnManager(ISessionTX p_ses, ConnectionReleaseMode p_connectionReleaseMode) { IDbConnection suppliedConnection = null; TraceLog.LogEntry("CnnManager(p_ses= {0} p_connectionReleaseMode= {1})", p_ses.SessionId, p_connectionReleaseMode); this.m_session = p_ses; this.m_connection = suppliedConnection; this.connectionReleaseMode = p_connectionReleaseMode; ownConnection = (suppliedConnection == null); // De esta forma, siempre será True. //SharpLogger.CallerOut(); }
/// <summary> /// Test with NO conversation and "connection.release_mode" /// "auto"(<see cref="ConnectionReleaseMode.AfterTransaction"/>) /// on block within the scope of "transaction boundary". /// </summary> /// <remarks> /// Here we can see that only a IDbConnection is open, even /// with the execution of various statements. This is because /// the statements are made within a "transaction boundary". /// </remarks> private void connection_release_mode_auto_transaction_boundary() { //with conversation and "connection.release_mode" "auto"(AfterTransaction) //forcing "auto" by reflection. Settings settings = ((SessionFactoryImpl)this.SessionFactory).Settings; ConnectionReleaseMode connReleaseModeOriginal = settings.ConnectionReleaseMode; this.setConnectionReleaseModeByReflection(settings, ConnectionReleaseMode.AfterTransaction); ConnectionCreationTrackingDbProvider.Count = 0; this.ConnectionReleaseModeIssueBsn.Test(); this.setConnectionReleaseModeByReflection(settings, connReleaseModeOriginal); }
public static string ToString(ConnectionReleaseMode value) { switch (value) { case ConnectionReleaseMode.AfterStatement: return "after_statement"; case ConnectionReleaseMode.AfterTransaction: return "after_transaction" ; case ConnectionReleaseMode.OnClose: return "on_close"; default: throw new ArgumentOutOfRangeException("value"); } }
/// <summary> /// Constructor used for OpenSession(...) processing, as well as construction /// of sessions for GetCurrentSession(). /// </summary> /// <param name="connection">The user-supplied connection to use for this session.</param> /// <param name="factory">The factory from which this session was obtained</param> /// <param name="timestamp">The timestamp for this session</param> /// <param name="autoCloseSessionEnabled">Should we auto close after completion of transaction</param> /// <param name="connectionReleaseMode">The mode by which we should release JDBC connections.</param> internal SessionImpl(IDbConnection connection, ISessionFactoryImplementor factory, long timestamp, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) : base(factory) { using (new SessionIdLoggingContext(SessionId)) { //if (interceptor == null) throw new AssertionFailure("The interceptor can not be null."); rootSession = null; this.timestamp = timestamp; this.autoCloseSessionEnabled = autoCloseSessionEnabled; this.connectionReleaseMode = connectionReleaseMode; connectionManager = new ConnectionManager(this, connection, connectionReleaseMode);// new ConnectionManager(this, connection, connectionReleaseMode, interceptor); CheckAndUpdateSessionStatus(); } }
public ConnectionManager( ISessionImplementor session, IDbConnection suppliedConnection, ConnectionReleaseMode connectionReleaseMode, IInterceptor interceptor) { this.session = session; connection = suppliedConnection; this.connectionReleaseMode = connectionReleaseMode; this.interceptor = interceptor; batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor); ownConnection = suppliedConnection == null; }
public ConnectionManager( ISessionImplementor session, DbConnection suppliedConnection, ConnectionReleaseMode connectionReleaseMode, IInterceptor interceptor) { this.session = session; connection = suppliedConnection; this.connectionReleaseMode = connectionReleaseMode; this.interceptor = interceptor; batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor); ownConnection = suppliedConnection == null; }
public ConnectionManager( ISessionImplementor session, DbConnection suppliedConnection, ConnectionReleaseMode connectionReleaseMode, IInterceptor interceptor, bool shouldAutoJoinTransaction) { Session = session; _connection = suppliedConnection; _connectionReleaseMode = connectionReleaseMode; _interceptor = interceptor; _batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor); _ownConnection = suppliedConnection == null; ShouldAutoJoinTransaction = shouldAutoJoinTransaction; }
public static string ToString(ConnectionReleaseMode value) { switch (value) { case ConnectionReleaseMode.AfterStatement: return("after_statement"); case ConnectionReleaseMode.AfterTransaction: return("after_transaction"); case ConnectionReleaseMode.OnClose: return("on_close"); default: throw new ArgumentOutOfRangeException("value"); } }
public ConnectionManager( ISessionImplementor session, DbConnection suppliedConnection, ConnectionReleaseMode connectionReleaseMode, IInterceptor interceptor, bool shouldAutoJoinTransaction, IConnectionAccess connectionAccess) { Session = session; _connection = suppliedConnection; _connectionReleaseMode = connectionReleaseMode; _interceptor = interceptor; _batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor); _ownConnection = suppliedConnection == null; ShouldAutoJoinTransaction = shouldAutoJoinTransaction; _connectionAccess = connectionAccess ?? throw new ArgumentNullException(nameof(connectionAccess)); }
public ISession OpenSession(IDbConnection connection, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { return new SessionImpl(connection, this, 0, autoCloseSessionEnabled, connectionReleaseMode); }
/// <summary> /// Not supported /// </summary> public ISession OpenSession(IDbConnection connection, ConnectionReleaseMode connectionReleaseMode) { throw new NotSupportedException(); }
/// <summary> /// Builds a session from the factory, when initialized... /// </summary> /// <returns></returns> public ISession OpenSession(bool p_autoCloseSessionEnabled,ConnectionReleaseMode p_connectionReleaseMode) { TraceLog.LogEntry("OpenSession(): p_autoCloseSessionEnabled {0} p_connectionReleaseMode {1}", p_autoCloseSessionEnabled, p_connectionReleaseMode); ISessionTX res = null; if (this.m_cnnStr == String.Empty) throw new Exception("Session Factory without connection string, can't get it from configuration!"); else if (this.m_closed) throw new Exception("Session Factory is closed!"); else { if (SharpCore.Data.CurrentSessionContext.HasBind(this)) { res = this.GetCurrentSession(); TraceLog.LogEntry("Existe una Sesión ya ligada, GetCurrentSession() Id {0}", res.SessionId); } else SharpCore.Data.CurrentSessionContext.Bind(res = new SessionExt(this, p_autoCloseSessionEnabled, p_connectionReleaseMode)); } // SharpLogger.CallerOut(); return res; }
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { #pragma warning disable 618 var isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled = settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled; #pragma warning restore 618 return new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor, settings.DefaultEntityMode, flushBeforeCompletionEnabled, autoCloseSessionEnabled, isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled, connectionReleaseMode, settings.DefaultFlushMode); }
public IConnectionConfiguration Releasing(ConnectionReleaseMode releaseMode) { dbc.Configuration.SetProperty(Environment.ReleaseConnections, ConnectionReleaseModeParser.ToString(releaseMode)); return(this); }
/// <inheritdoc /> ISharedSessionBuilder ISessionBuilder <ISharedSessionBuilder> .ConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode) { return(ConnectionReleaseMode(connectionReleaseMode)); }
public ISession OpenSession(IDbConnection connection, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { return(new SessionImpl(connection, this, 0, autoCloseSessionEnabled, connectionReleaseMode)); }
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { throw new NotImplementedException(); }
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode) { return new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor, settings.DefaultEntityMode, flushBeforeCompletionEnabled, autoCloseSessionEnabled, connectionReleaseMode); }
private ISession OpenSession(IDbConnection connection, long timestamp, IInterceptor interceptor, ConnectionReleaseMode connectionReleaseMode) { SessionImpl sessionImpl = new SessionImpl(connection, this, timestamp, interceptor, connectionReleaseMode); bool isSessionScopedInterceptor = this.interceptor!=interceptor; if(isSessionScopedInterceptor) interceptor.SetSession(sessionImpl); return sessionImpl; }
public TShardedBuilder ConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode) { ApplyActionToShards(b => b.ConnectionReleaseMode(connectionReleaseMode)); return((TShardedBuilder)this); }
public ISession OpenSession(IDbConnection connection, ConnectionReleaseMode connectionReleaseMode) { return OpenSession(connection, Timestamper.Next(), interceptor, connectionReleaseMode); }
ISessionBuilder ISessionBuilder <ISessionBuilder> .ConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode) { _actualBuilder.ConnectionReleaseMode(connectionReleaseMode); return(this); }
IConnectionConfiguration IConnectionConfiguration.Releasing(ConnectionReleaseMode releaseMode) { return(Releasing(releaseMode)); }