internal OleDbTransaction (OleDbConnection connection, int depth, IsolationLevel isolevel) 
		{
			this.connection = connection;

			gdaTransaction = libgda.gda_transaction_new (depth.ToString ());
			
			switch (isolevel) {
			case IsolationLevel.ReadCommitted :
				libgda.gda_transaction_set_isolation_level (gdaTransaction,
									    GdaTransactionIsolation.ReadCommitted);
				break;
			case IsolationLevel.ReadUncommitted :
				libgda.gda_transaction_set_isolation_level (gdaTransaction,
									    GdaTransactionIsolation.ReadUncommitted);
				break;
			case IsolationLevel.RepeatableRead :
				libgda.gda_transaction_set_isolation_level (gdaTransaction,
									    GdaTransactionIsolation.RepeatableRead);
				break;
			case IsolationLevel.Serializable :
				libgda.gda_transaction_set_isolation_level (gdaTransaction,
									    GdaTransactionIsolation.Serializable);
				break;
			}
			
			libgda.gda_connection_begin_transaction (connection.GdaConnection, gdaTransaction);
		}

 public SqlServerConnection(
     SqlConnection connection,
     IsolationLevel? isolationLevel,
     PersistentJobQueueProviderCollection queueProviders)
     : this(connection, isolationLevel, queueProviders, true)
 {
 }

 public static void Transaction(IsolationLevel level, Action transactional)
 {
     using (UnitOfWork.Start())
     {
         // If we are already in a transaction, don't start a new one
         if (UnitOfWork.Current.IsInActiveTransaction)
         {
             transactional();
         }
         else
         {
             IGenericTransaction tx = UnitOfWork.Current.BeginTransaction(level);
             try
             {
                 transactional();
                 tx.Commit();
             }
             catch
             {
                 tx.Rollback();
                 throw;
             }
             finally
             {
                 tx.Dispose();
             }
         }
     }
 }

 public IDbTransaction BeginTransaction(IsolationLevel il)
 {
     using (ExecuteHelper.Begin(dur => context.FireExecuteEvent(this, String.Format("BeginTransaction({0})", il), dur)))
     {
         return new DbTransactionProxy(connection.BeginTransaction(il), context);
     }
 }

        public MsmqScopeOptions(TimeSpan? requestedTimeout = null, IsolationLevel? requestedIsolationLevel = null)
        {
            var timeout = TransactionManager.DefaultTimeout;
            var isolationLevel = IsolationLevel.ReadCommitted;
            if (requestedTimeout.HasValue)
            {
                var maxTimeout = GetMaxTimeout();

                if (requestedTimeout.Value > maxTimeout)
                {
                    throw new ConfigurationErrorsException(
                        "Timeout requested is longer than the maximum value for this machine. Override using the maxTimeout setting of the system.transactions section in machine.config");
                }

                timeout = requestedTimeout.Value;
            }

            if (requestedIsolationLevel.HasValue)
            {
                isolationLevel = requestedIsolationLevel.Value;
            }

            TransactionOptions = new TransactionOptions
            {
                IsolationLevel = isolationLevel,
                Timeout = timeout
            };
        }

        public IDbTransaction BeginTransaction(IsolationLevel isolationLevel)
        {
            if (factory.AlwaysReturnTransaction != null)
                return factory.AlwaysReturnTransaction;

            return DbConnection.BeginTransaction(isolationLevel);
        }

 public static void AutoRollbackTransaction(IsolationLevel level, Proc transactional, UnitOfWorkNestingOptions nestingOptions)
 {
     using (UnitOfWork.Start(nestingOptions))
     {
         // If we are already in a transaction, don't start a new one
         if (UnitOfWork.Current.IsInActiveTransaction)
         {
             transactional();
         }
         else
         {
             RhinoTransaction tx = UnitOfWork.Current.BeginTransaction(level);
             try
             {
                 transactional();
                 tx.Rollback();
             }
             catch
             {
                 tx.Rollback();
                 throw;
             }
             finally
             {
                 tx.Dispose();
             }
         }
     }
 }

        public Int32 executeNonQuery(MySqlCommand mySqlCommand, IsolationLevel isolationLevel)
        {
            using (MySqlTransaction transaccion = conexion.BeginTransaction(isolationLevel))
            {
                Int32 safectados = 0;
                try
                {

                    mySqlCommand.Connection = conexion;
                    mySqlCommand.Transaction = transaccion;
                    safectados = mySqlCommand.ExecuteNonQuery();

                    // Commit a la transacción
                    transaccion.Commit();

                }

                catch (Exception ex)
                {
                    ex.Source += " SQL: " + mySqlCommand.CommandText.ToString();
                    Log.Write(MethodBase.GetCurrentMethod().Name, ex);
                    throw ex;
                }
                return safectados;

            }
        }

        public static ISession CreateSession(this IDatabase database, string userName, string password, IsolationLevel isolation)
        {
            if (!database.Authenticate(userName, password))
                throw new InvalidOperationException(String.Format("Unable to create a session for user '{0}': not authenticated.", userName));

            return database.CreateSession(userName, isolation);
        }

        public ServiceBusTransactionScope(string name, IsolationLevel isolationLevel, TimeSpan timeout)
        {
            this.name = name;
            log = Log.For(this);

            ignore = Transaction.Current != null;

            if (ignore)
            {
                if (log.IsVerboseEnabled)
                {
                    log.Verbose(string.Format(ESBResources.QueueTransactionScopeAmbient, name,
                                              Thread.CurrentThread.ManagedThreadId));
                }

                return;
            }

            scope = new TransactionScope(TransactionScopeOption.RequiresNew,
                                             new TransactionOptions
                                             	{
                                             		IsolationLevel = isolationLevel,
                                             		Timeout = timeout
                                             	});

            if (log.IsVerboseEnabled)
            {
                log.Verbose(string.Format(ESBResources.QueueTransactionScopeCreated, name, isolationLevel, timeout,
                                          Thread.CurrentThread.ManagedThreadId));
            }
        }

		internal SqlTransaction (SqlConnection connection, IsolationLevel isolevel)
		{
			this.connection = connection;
			this.isolationLevel = isolevel;
			isOpen = true;
			isRolledBack = false;
		}

        public void BeginTransaction(IsolationLevel level)
        {
            if (mConnection.State == ConnectionState.Closed)
                mConnection.Open();

            mTransaction = mConnection.BeginTransaction(level);
        }

        internal NpgsqlTransaction(NpgsqlConnection conn, IsolationLevel isolationLevel)
        {
            Contract.Requires(conn != null);
            Contract.Requires(isolationLevel != IsolationLevel.Chaos);

            Connection = conn;
            Connector.Transaction = this;
            Connector.TransactionStatus = TransactionStatus.Pending;

            switch (isolationLevel) {
                case IsolationLevel.RepeatableRead:
                    Connector.PrependInternalMessage(PregeneratedMessage.BeginTransRepeatableRead);
                    break;
                case IsolationLevel.Serializable:
                case IsolationLevel.Snapshot:
                    Connector.PrependInternalMessage(PregeneratedMessage.BeginTransSerializable);
                    break;
                case IsolationLevel.ReadUncommitted:
                    // PG doesn't really support ReadUncommitted, it's the same as ReadCommitted. But we still
                    // send as if.
                    Connector.PrependInternalMessage(PregeneratedMessage.BeginTransReadUncommitted);
                    break;
                case IsolationLevel.ReadCommitted:
                    Connector.PrependInternalMessage(PregeneratedMessage.BeginTransReadCommitted);
                    break;
                case IsolationLevel.Unspecified:
                    isolationLevel = DefaultIsolationLevel;
                    goto case DefaultIsolationLevel;
                default:
                    throw PGUtil.ThrowIfReached("Isolation level not supported: " + isolationLevel);
            }

            _isolationLevel = isolationLevel;
        }

		public override IUnitOfWork GetUnitOfWork(IsolationLevel isolationLevel = IsolationLevel.Unspecified)
		{
			if ((object)this.DictionaryUnitOfWorkCallback != null)
				return this.DictionaryUnitOfWorkCallback();
			else
				return null;
		}

        private TestAdapterService(IsolationLevel isolationLevelToUse, Func<IDataAccessAdapter> adapterFunc)
        {
            _AdapterFunc = adapterFunc;
            _IsolationLevel = isolationLevelToUse;

            ResetActionsOnceCalled = true;
        }

        internal NpgsqlTransaction(NpgsqlConnection conn, IsolationLevel isolation)
        {
            NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, CLASSNAME);

            _conn = conn;
            _isolation = isolation;

            StringBuilder commandText = new StringBuilder("BEGIN; SET TRANSACTION ISOLATION LEVEL ");

            if ((isolation == IsolationLevel.RepeatableRead) ||
                (isolation == IsolationLevel.Serializable) ||
                (isolation == IsolationLevel.Snapshot))
            {
                commandText.Append("SERIALIZABLE");
            }
            else
            {
                // Set isolation level default to read committed.
                _isolation = IsolationLevel.ReadCommitted;
                commandText.Append("READ COMMITTED");
            }

            commandText.Append(";");

            NpgsqlCommand command = new NpgsqlCommand(commandText.ToString(), conn.Connector);
            command.ExecuteBlind();
            _conn.Connector.Transaction = this;
        }

 public IDataContextReadOnlyScope CreateReadOnlyWithTransaction(IsolationLevel isolationLevel)
 {
     return new DataContextReadOnlyScope(
       joiningOption: DataContextScopeOption.ForceCreateNew,
       isolationLevel: isolationLevel,
       dataContextFactory: _dataContextFactory);
 }

        public static ITransaction CreateTransaction(this IDatabase database, IsolationLevel isolation)
        {
            if (!database.IsOpen)
                throw new InvalidOperationException(String.Format("Database '{0}' is not open.", database.Name));

            return database.CreateSafeTransaction(isolation);
        }

        /// <summary>
        /// Begins a new, nested, isolation scope
        /// </summary>
        /// <param name="isolationScopeName">The name of the new isolation scope</param>
        /// <param name="initialize">A delegate to an action that is performed on initialization. If an exception occurs inside this 
        /// method, then the scope is automatically destroyed, calling any cleanup actions that were added during this method</param>
        public IDisposable BeginIsolationScope(string isolationScopeName, Action<IIsolationScope> initialize)
        {
            if (initialize == null)
                initialize = Functions.EmptyAction<IIsolationScope>();

            _currentState = State.Initialize;
            var lastIsolationLevel = _currentIsolationLevel;
            _currentIsolationLevel = new IsolationLevel(isolationScopeName);

            Logger.WriteLine("***************************** Initializing " + isolationScopeName + " *****************************");
            try
            {
                initialize(this);
                Logger.WriteLine("***************************** Initializing " + isolationScopeName + " Completed succesfully *****************************");
            }
            catch
            {
                _currentIsolationLevel.Cleanup();
                _currentIsolationLevel = lastIsolationLevel;
                throw;
            }

            _isolationLevels.Push(lastIsolationLevel);

            _currentState = State.Normal;

            return new IsolationScopeDisposer(this);
        }

 /// <summary>
 /// Registers openning of a workspace
 /// </summary>
 /// <param name="workspaceId">Workspace ID</param>
 /// <param name="snapshotId">Opened snapshot ID</param>
 /// <param name="isolationLevel">Isolation level</param>
 /// <param name="timeout">Workspace timeout</param>
 public void AddWorkspace(Guid workspaceId, Guid snapshotId, IsolationLevel isolationLevel, TimeSpan timeout)
 {
     lock (workspaceStates)
     {
         workspaceStates.Add(workspaceId, new WorkspaceStateElement(snapshotId, isolationLevel, DateTime.UtcNow, timeout));
     }
 }