public LightningTransaction(LightningEnvironment environment, LightningTransaction parent, TransactionBeginFlags flags)
{
if (environment == null)
throw new ArgumentNullException("environment");
this.Environment = environment;
this.ParentTransaction = parent;
this.IsReadOnly = flags == TransactionBeginFlags.ReadOnly;
var parentHandle = parent != null
? parent._handle
: IntPtr.Zero;
IntPtr handle = default(IntPtr);
Native.Execute(() => Native.mdb_txn_begin(environment._handle, parentHandle, flags, out handle));
_handle = handle;
this.State = LightningTransacrionState.Active;
if (parent == null)
this.Environment.Closing += EnvironmentOrParentTransactionClosing;
else
parent.Closing += EnvironmentOrParentTransactionClosing;
}
/// <summary>
/// Create a transaction for use with the environment.
/// The transaction handle may be discarded using Abort() or Commit().
/// Note:
/// Transactions may not span threads; a transaction must only be used by a single thread. Also, a thread may only have a single transaction.
/// Cursors may not span transactions; each cursor must be opened and closed within a single transaction.
/// </summary>
/// <param name="parent">
/// If this parameter is non-NULL, the new transaction will be a nested transaction, with the transaction indicated by parent as its parent.
/// Transactions may be nested to any level.
/// A parent transaction may not issue any other operations besides BeginTransaction, Abort, or Commit while it has active child transactions.
/// </param>
/// <param name="beginFlags">
/// Special options for this transaction.
/// </param>
/// <returns>
/// New LightningTransaction
/// </returns>
public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
{
if (!IsOpened)
{
throw new InvalidOperationException("Environment must be opened before starting a transaction");
}
return(new LightningTransaction(this, parent, beginFlags));
}
public Transaction BeginTransaction(TransactionBeginFlags flags = TransactionBeginFlags.ReadWrite)
{
if (((int)flags & (int)TransactionBeginFlags.ReadOnly) != 0)
{
ThrowShouldUseReadOnlyTxn();
}
var impl = TransactionImpl.Create(this, flags);
var txn = new Transaction(impl);
return(txn);
}
public LightningTransaction Create(TransactionBeginFlags beginFlags)
{
EnsureEnvironmentOpened();
IntPtr handle = default(IntPtr);
NativeMethods.Execute(lib => lib.mdb_txn_begin(_environment._handle, _parentHandle, beginFlags, out handle));
var tran = new LightningTransaction(_environment, handle, _parentTransaction, beginFlags);
_transactions.TryAdd(tran, true);
return tran;
}
/// <summary>
/// Created new instance of LightningTransaction
/// </summary>
/// <param name="environment">Environment.</param>
/// <param name="parent">Parent transaction or null.</param>
/// <param name="flags">Transaction open options.</param>
internal LightningTransaction(LightningEnvironment environment, IntPtr handle, LightningTransaction parent, TransactionBeginFlags flags)
{
if (environment == null)
throw new ArgumentNullException("environment");
this.Environment = environment;
this.ParentTransaction = parent;
this.IsReadOnly = flags == TransactionBeginFlags.ReadOnly;
this.State = LightningTransactionState.Active;
_handle = handle;
_subTransactionsManager = new TransactionManager(environment, this);
_cursorManager = new CursorManager(this);
}
/// <summary>
/// Created new instance of LightningTransaction
/// </summary>
/// <param name="environment">Environment.</param>
/// <param name="parent">Parent transaction or null.</param>
/// <param name="flags">Transaction open options.</param>
internal LightningTransaction(LightningEnvironment environment, LightningTransaction parent, TransactionBeginFlags flags)
{
if (environment == null)
throw new ArgumentNullException(nameof(environment));
Environment = environment;
ParentTransaction = parent;
IsReadOnly = (flags & TransactionBeginFlags.ReadOnly) == TransactionBeginFlags.ReadOnly;
State = LightningTransactionState.Active;
Environment.Disposing += Dispose;
if (parent != null)
{
parent.Disposing += Dispose;
parent.StateChanging += OnParentStateChanging;
}
var parentHandle = parent?.Handle() ?? IntPtr.Zero;
mdb_txn_begin(environment.Handle(), parentHandle, flags, out _handle);
_originalHandle = _handle;
}
/// <summary>
/// Create a transaction for use with the environment.
/// The transaction handle may be discarded using Abort() or Commit().
/// Note:
/// Transactions may not span threads; a transaction must only be used by a single thread. Also, a thread may only have a single transaction.
/// Cursors may not span transactions; each cursor must be opened and closed within a single transaction.
/// </summary>
/// <param name="parent">
/// If this parameter is non-NULL, the new transaction will be a nested transaction, with the transaction indicated by parent as its parent.
/// Transactions may be nested to any level.
/// A parent transaction may not issue any other operations besides BeginTransaction, Abort, or Commit while it has active child transactions.
/// </param>
/// <param name="beginFlags">
/// Special options for this transaction.
/// </param>
/// <returns>
/// New LightningTransaction
/// </returns>
public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
{
this.EnsureOpened();
return(new LightningTransaction(this, parent, beginFlags));
}
/// <summary>
/// Begin a child transaction.
/// </summary>
/// <param name="beginFlags">Options for a new transaction.</param>
/// <returns>New child transaction.</returns>
public LightningTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return new LightningTransaction(Environment, this, beginFlags);
}
/// <summary>
/// Create a transaction for use with the environment.
/// The transaction handle may be discarded usingAbort() or Commit().
/// Note:
/// Transactions may not span threads; a transaction must only be used by a single thread. Also, a thread may only have a single transaction.
/// Cursors may not span transactions; each cursor must be opened and closed within a single transaction.
/// </summary>
/// <param name="beginFlags">
/// Special options for this transaction.
/// </param>
/// <returns>
/// New LMDBTransaction
/// </returns>
public LMDBTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return(BeginTransaction(null, beginFlags));
}
int INativeLibraryFacade.mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn)
{
return FallbackLibraryFacade.mdb_txn_begin(env, parent, flags, out txn);
}
public LightningTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return this.BeginTransaction(null, beginFlags);
}
internal static TransactionImpl Create(LMDBEnvironment lmdbEnvironment, TransactionBeginFlags beginFlags)
{
lmdbEnvironment.EnsureOpen();
TransactionImpl tx;
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
var isReadOnly = (beginFlags & TransactionBeginFlags.ReadOnly) == TransactionBeginFlags.ReadOnly;
if (isReadOnly)
{
if ((tx = lmdbEnvironment.ReadTxnPool.Rent()) == null)
{
tx = TxPool.Rent();
tx._isReadOnly = true;
if (tx._state != TransactionState.Disposed)
{
ThrowShoudBeDisposed();
}
}
else
{
Debug.Assert(tx._isReadOnly);
Debug.Assert(tx._state == TransactionState.Reset);
}
if (tx.IsInvalid)
{
// create new handle
NativeMethods.AssertExecute(NativeMethods.mdb_txn_begin(
lmdbEnvironment._handle.Handle,
IntPtr.Zero, beginFlags, out var handle));
tx.SetNewHandle(handle);
}
else
{
tx.Renew();
}
}
else
{
tx = TxPool.Rent();
tx._isReadOnly = false;
NativeMethods.AssertExecute(NativeMethods.mdb_txn_begin(
lmdbEnvironment._handle.Handle,
IntPtr.Zero, beginFlags, out IntPtr handle));
tx._handle = handle;
if (tx._state != TransactionState.Disposed)
{
ThrowShoudBeDisposed();
}
}
tx._lmdbEnvironment = lmdbEnvironment;
tx._state = TransactionState.Active;
#if DEBUG
tx.StackTrace = Environment.StackTrace;
#endif
return(tx);
}
/// <summary>
/// Create a transaction for use with the environment.
/// The transaction handle may be discarded using Abort() or Commit().
/// Note:
/// Transactions may not span threads; a transaction must only be used by a single thread. Also, a thread may only have a single transaction.
/// Cursors may not span transactions; each cursor must be opened and closed within a single transaction.
/// </summary>
/// <param name="parent">
/// If this parameter is non-NULL, the new transaction will be a nested transaction, with the transaction indicated by parent as its parent.
/// Transactions may be nested to any level.
/// A parent transaction may not issue any other operations besides BeginTransaction, Abort, or Commit while it has active child transactions.
/// </param>
/// <param name="beginFlags">
/// Special options for this transaction.
/// </param>
/// <returns>
/// New LightningTransaction
/// </returns>
public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
{
if (!IsOpened)
throw new InvalidOperationException("Environment must be opened before starting a transaction");
return new LightningTransaction(this, parent, beginFlags);
}
/// <summary>
/// Create a transaction for use with the environment.
/// The transaction handle may be discarded usingAbort() or Commit().
/// Note:
/// Transactions may not span threads; a transaction must only be used by a single thread. Also, a thread may only have a single transaction.
/// Cursors may not span transactions; each cursor must be opened and closed within a single transaction.
/// </summary>
/// <param name="beginFlags">
/// Special options for this transaction.
/// </param>
/// <returns>
/// New LightningTransaction
/// </returns>
public LightningTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return(this.BeginTransaction(null, beginFlags));
}
/// <summary>
/// Begin a child transaction.
/// </summary>
/// <param name="beginFlags">Options for a new transaction.</param>
/// <returns>New child transaction.</returns>
public LightningTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return(new LightningTransaction(Environment, this, beginFlags));
}
int INativeLibraryFacade.mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn)
{
return(FallbackLibraryFacade.mdb_txn_begin(env, parent, flags, out txn));
}
public static MDBResultCode mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn)
{
return(LmdbMethods.mdb_txn_begin(env, parent, flags, out txn));
}
/// <summary>
/// Begin a child transaction.
/// </summary>
/// <param name="beginFlags">Options for a new transaction.</param>
/// <returns>New child transaction.</returns>
public LMDBTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return(new LMDBTransaction(Environment, this, beginFlags));
}
/// <summary>
/// Begin a child transaction.
/// </summary>
/// <param name="beginFlags">Options for a new transaction.</param>
/// <returns>New child transaction.</returns>
public LightningTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return(this.Environment.BeginTransaction(this, beginFlags));
}
/// <summary>
/// Created new instance of LightningTransaction
/// </summary>
/// <param name="environment">Environment.</param>
/// <param name="parent">Parent transaction or null.</param>
/// <param name="flags">Transaction open options.</param>
public LightningTransaction(LightningEnvironment environment, LightningTransaction parent, TransactionBeginFlags flags)
{
if (environment == null)
{
throw new ArgumentNullException("environment");
}
this.Environment = environment;
this.ParentTransaction = parent;
this.IsReadOnly = flags == TransactionBeginFlags.ReadOnly;
var parentHandle = parent != null
? parent._handle
: IntPtr.Zero;
IntPtr handle = default(IntPtr);
NativeMethods.Execute(lib => lib.mdb_txn_begin(environment._handle, parentHandle, flags, out handle));
_handle = handle;
this.State = LightningTransactionState.Active;
if (parent == null)
{
this.Environment.Closing += EnvironmentOrParentTransactionClosing;
}
else
{
parent.Closing += EnvironmentOrParentTransactionClosing;
}
}
/// <summary>
/// Created new instance of LightningTransaction
/// </summary>
/// <param name="environment">Environment.</param>
/// <param name="parent">Parent transaction or null.</param>
/// <param name="flags">Transaction open options.</param>
internal LightningTransaction(LightningEnvironment environment, LightningTransaction parent, TransactionBeginFlags flags)
{
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
Environment = environment;
ParentTransaction = parent;
IsReadOnly = (flags & TransactionBeginFlags.ReadOnly) == TransactionBeginFlags.ReadOnly;
State = LightningTransactionState.Active;
Environment.Disposing += Dispose;
if (parent != null)
{
parent.Disposing += Dispose;
parent.StateChanging += OnParentStateChanging;
}
var parentHandle = parent?.Handle() ?? IntPtr.Zero;
Lmdb.mdb_txn_begin(environment.Handle(), parentHandle, flags, out _handle);
_originalHandle = _handle;
}
/// <summary>
/// Create a transaction for use with the environment.
/// The transaction handle may be discarded using Abort() or Commit().
/// Note:
/// Transactions may not span threads; a transaction must only be used by a single thread. Also, a thread may only have a single transaction.
/// Cursors may not span transactions; each cursor must be opened and closed within a single transaction.
/// </summary>
/// <param name="parent">
/// If this parameter is non-NULL, the new transaction will be a nested transaction, with the transaction indicated by parent as its parent.
/// Transactions may be nested to any level.
/// A parent transaction may not issue any other operations besides BeginTransaction, Abort, or Commit while it has active child transactions.
/// </param>
/// <param name="beginFlags">
/// Special options for this transaction.
/// </param>
/// <returns>
/// New LightningTransaction
/// </returns>
public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
{
return(new LightningTransaction(this, parent, beginFlags));
}
public static void RunTransactionScenario(this LightningEnvironment env,
Action <LightningTransaction, LightningDatabase> scenario,
DatabaseOpenFlags flags = DatabaseOpenFlags.Create, TransactionBeginFlags transactionFlags = TransactionBeginFlags.None)
{
using var tx = env.BeginTransaction(transactionFlags);
using var db = tx.OpenDatabase(configuration: new DatabaseConfiguration { Flags = flags });
scenario(tx, db);
}
public LightningTransaction BeginTransaction(TransactionBeginFlags beginFlags)
{
return this.Environment.BeginTransaction(this, beginFlags);
}
public static extern int mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn);
private ITransaction BeginTransactionInternal(ITransaction parentTransaction, TransactionBeginFlags flags)
{
if (parentTransaction == null || parentTransaction.InnerObject == null)
{
return(new LMDBTransaction(_environment.BeginTransaction(flags), flags == TransactionBeginFlags.ReadOnly ? true : false));
}
else
{
ValidateTransaction(parentTransaction);
LightningTransaction lmdbTransaction = (LightningTransaction)parentTransaction.InnerObject;
return(new LMDBTransaction(lmdbTransaction.BeginTransaction(flags), flags == TransactionBeginFlags.ReadOnly ? true : false));
}
}
private static extern int mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn);
public static extern MDBResultCode mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn);
public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
{
this.EnsureOpened();
return new LightningTransaction(this, parent, beginFlags);
}
public static int mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn)
{
return check(LmdbMethods.mdb_txn_begin(env, parent, flags, out txn));
}
public static int mdb_txn_begin(IntPtr env, IntPtr parent, TransactionBeginFlags flags, out IntPtr txn)
{
return(check(LmdbMethods.mdb_txn_begin(env, parent, flags, out txn)));
}
/// <summary>
/// Create a transaction for use with the environment.
/// The transaction handle may be discarded using Abort() or Commit().
/// Note:
/// Transactions may not span threads; a transaction must only be used by a single thread. Also, a thread may only have a single transaction.
/// Cursors may not span transactions; each cursor must be opened and closed within a single transaction.
/// </summary>
/// <param name="parent">
/// If this parameter is non-NULL, the new transaction will be a nested transaction, with the transaction indicated by parent as its parent.
/// Transactions may be nested to any level.
/// A parent transaction may not issue any other operations besides BeginTransaction, Abort, or Commit while it has active child transactions.
/// </param>
/// <param name="beginFlags">
/// Special options for this transaction.
/// </param>
/// <returns>
/// New LightningTransaction
/// </returns>
public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
{
return new LightningTransaction(this, parent, beginFlags);
}