/// <summary>
/// Creates new instance of LightningCursor
/// </summary>
/// <param name="db">Database</param>
/// <param name="txn">Transaction</param>
internal LightningCursor(LightningDatabase db, LightningTransaction txn)
{
if (db == null)
{
throw new ArgumentNullException(nameof(db));
}
if (txn == null)
{
throw new ArgumentNullException(nameof(txn));
}
_currentWithOptimizedPair = () => _currentPair;
_currentDefault = () =>
{
if (_currentKeyStructure.size == IntPtr.Zero)
{
return(default(KeyValuePair <byte[], byte[]>));
}
return(new KeyValuePair <byte[], byte[]>(_currentKeyStructure.GetBytes(),
_currentValueStructure.GetBytes()));
};
_getCurrent = _currentDefault;
mdb_cursor_open(txn.Handle(), db.Handle(), out _handle);
Database = db;
Transaction = txn;
Transaction.Disposing += Dispose;
}
public static void Put <TKey, TValue>(this LightningTransaction txn, LightningDatabase db, TKey key, TValue value, PutOptions options = PutOptions.None)
{
var keyBytes = db.ToBytes(key);
var valueBytes = db.ToBytes(value);
txn.Put(db, keyBytes, valueBytes, options);
}
public static void Delete <TKey, TValue>(this LightningTransaction txn, LightningDatabase db, TKey key, TValue value)
{
var keyBytes = db.ToBytes(key);
var valueBytes = db.ToBytes(value);
txn.Delete(db, keyBytes, valueBytes);
}
/// <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;
}
}
public MerkleTreePruningCursor(UInt256 blockHash, LightningTransaction txn, LightningDatabase db, LightningCursor cursor)
{
this.blockHash = blockHash;
this.db = db;
this.txn = txn;
this.cursor = cursor;
}
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;
}
public static TValue Get <TKey, TValue>(this LightningTransaction txn, LightningDatabase db, TKey key)
{
var keyBytes = db.ToBytes(key);
var valueBytes = txn.Get(db, keyBytes);
return(db.FromBytes <TValue>(valueBytes));
}
/// <summary>
/// Creates a LightningDatabase instance.
/// </summary>
/// <param name="name">Database name.</param>
/// <param name="flags">Database open flags/</param>
/// <param name="tran">Active transaction.</param>
/// <param name="encoding">Default strings encoding.</param>
public LightningDatabase(string name, LightningTransaction tran, DatabaseOpenFlags?flags, Encoding encoding = null)
{
if (tran == null)
{
throw new ArgumentNullException("tran");
}
if (!flags.HasValue)
{
flags = LightningConfig.Database.DefaultOpenFlags;
}
encoding = encoding ?? LightningConfig.Database.DefaultEncoding;
UInt32 handle = default(UInt32);
NativeMethods.Execute(lib => lib.mdb_dbi_open(tran._handle, name, flags.Value, out handle));
_name = name ?? DefaultDatabaseName;
_handle = handle;
_shouldDispose = true;
this.IsOpened = true;
this.Encoding = encoding;
this.OpenFlags = flags.Value;
this.Environment = tran.Environment;
}
public LightningCursor(LightningDatabase db, LightningTransaction txn)
{
if (db == null)
throw new ArgumentNullException("db");
if (txn == null)
throw new ArgumentNullException("txn");
if (db.Environment != txn.Environment)
throw new ArgumentException("db and txn belong to different environments");
IntPtr handle = default(IntPtr);
Native.Execute(lib => lib.mdb_cursor_open(txn._handle, db._handle, out handle));
_handle = handle;
this.Database = db;
this.Transaction = txn;
_shouldDispose = true;
if (txn.IsReadOnly)
this.Environment.Closing += EnvironmentOrTransactionClosing;
else
this.Transaction.Closing += EnvironmentOrTransactionClosing;
}
internal void SetComparer(LightningTransaction tran, LightningDatabase db)
{
SetNativeCompareFunction(
tran,
db,
Compare,
(lib, func) => lib.mdb_set_compare(tran._handle, db._handle, func));
}
/// <summary>
/// Drops the database.
/// </summary>
public MDBResultCode Drop(LightningTransaction transaction)
{
var result = mdb_drop(transaction.Handle(), _handle, true);
IsOpened = false;
_handle = default;
return(result);
}
/// <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 = null, TransactionBeginFlags beginFlags = LightningTransaction.DefaultTransactionBeginFlags)
{
if (!IsOpened)
{
throw new InvalidOperationException("Environment must be opened before starting a transaction");
}
return(new LightningTransaction(this, parent, beginFlags));
}
public static bool TryGet(this LightningTransaction tx, LightningDatabase db, ReadOnlySpan <byte> key, out byte[] value)
{
var(resultCode, _, mdbValue) = tx.Get(db, key);
if (resultCode == MDBResultCode.Success)
{
value = mdbValue.CopyToNewArray();
return(true);
}
value = default;
return(false);
}
internal void ConfigureDatabase(LightningTransaction tx, LightningDatabase db)
{
if (_comparer != null)
{
mdb_set_compare(tx.Handle(), db.Handle(), Compare);
}
if (_duplicatesComparer != null)
{
mdb_set_dupsort(tx.Handle(), db.Handle(), IsDuplicate);
}
}
internal void SetDuplicatesSort(LightningTransaction tran, LightningDatabase db)
{
if (!db.OpenFlags.HasFlag(DatabaseOpenFlags.DuplicatesSort))
return;
SetNativeCompareFunction(
tran,
db,
DuplicatesSort,
(lib, func) => lib.mdb_set_dupsort(tran._handle, db._handle, func));
}
public static bool TryGet <TKey, TValue>(this LightningTransaction txn, LightningDatabase db, TKey key, out TValue value)
{
GetByOperation operation;
var result = txn.TryGetBy(db, key, out operation);
value = result
? operation.Value <TValue>()
: default(TValue);
return(result);
}
public static bool TryGetBy <TKey>(this LightningTransaction txn, LightningDatabase db, TKey key, out GetByOperation value)
{
byte[] valueBytes;
var keyBytes = db.ToBytes(key);
var result = txn.TryGet(db, keyBytes, out valueBytes);
value = result
? new GetByOperation(db, valueBytes)
: null;
return(result);
}
//TODO: tests
/// <summary>
/// Renew a cursor handle.
/// Cursors are associated with a specific transaction and database and may not span threads.
/// Cursors that are only used in read-only transactions may be re-used, to avoid unnecessary malloc/free overhead.
/// The cursor may be associated with a new read-only transaction, and referencing the same database handle as it was created with.
/// </summary>
/// <param name="txn">Transaction to renew in.</param>
public void Renew(LightningTransaction txn)
{
if (txn == null)
{
throw new ArgumentNullException(nameof(txn));
}
if (!txn.IsReadOnly)
{
throw new InvalidOperationException("Can't renew cursor on non-readonly transaction");
}
mdb_cursor_renew(txn.Handle(), _handle);
}
/// <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);
}
//TODO: tests
public void Renew(LightningTransaction txn)
{
if (txn == null)
{
throw new ArgumentNullException("txn");
}
if (!txn.IsReadOnly)
{
throw new InvalidOperationException("Can't renew cursor on non-readonly transaction");
}
NativeMethods.Execute(lib => lib.mdb_cursor_renew(txn._handle, _handle));
}
/// <summary>
/// Creates a LightningDatabase instance.
/// </summary>
/// <param name="name">Database name.</param>
/// <param name="transaction">Active transaction.</param>
/// <param name="configuration">Options for the database, like encoding, option flags, and comparison logic.</param>
internal LightningDatabase(string name, LightningTransaction transaction, DatabaseConfiguration configuration)
{
if (transaction == null)
throw new ArgumentNullException(nameof(transaction));
if (configuration == null)
throw new ArgumentNullException(nameof(configuration));
Name = name;
_configuration = configuration;
Environment = transaction.Environment;
Environment.Disposing += Dispose;
mdb_dbi_open(transaction.Handle(), name, _configuration.Flags, out _handle);
_configuration.ConfigureDatabase(transaction, this);
IsOpened = true;
}
/// <summary>
/// Creates a LightningDatabase instance.
/// </summary>
/// <param name="name">Database name.</param>
/// <param name="transaction">Active transaction.</param>
/// <param name="configuration">Options for the database, like encoding, option flags, and comparison logic.</param>
internal LightningDatabase(string name, LightningTransaction transaction, DatabaseConfiguration configuration)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
Name = name;
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
Environment = transaction.Environment;
_transaction = transaction;
Environment.Disposing += Dispose;
mdb_dbi_open(transaction.Handle(), name, _configuration.Flags, out _handle).ThrowOnError();
_pinnedConfig = _configuration.ConfigureDatabase(transaction, this);
IsOpened = true;
}
public static bool TryGet(this LightningTransaction tx, LightningDatabase db, ReadOnlySpan <byte> key, byte[] destinationValueBuffer)
{
var(resultCode, _, mdbValue) = tx.Get(db, key);
if (resultCode != MDBResultCode.Success)
{
return(false);
}
var valueSpan = mdbValue.AsSpan();
if (valueSpan.TryCopyTo(destinationValueBuffer))
{
return(true);
}
throw new LightningException("Incorrect buffer size given in destinationValueBuffer", (int)MDBResultCode.BadValSize);
}
internal IDisposable ConfigureDatabase(LightningTransaction tx, LightningDatabase db)
{
var pinnedComparer = new ComparerKeepAlive();
if (_comparer != null)
{
CompareFunction compare = Compare;
pinnedComparer.AddComparer(compare);
mdb_set_compare(tx.Handle(), db.Handle(), compare);
}
if (_duplicatesComparer != null)
{
CompareFunction dupCompare = IsDuplicate;
pinnedComparer.AddComparer(dupCompare);
mdb_set_dupsort(tx.Handle(), db.Handle(), dupCompare);
}
return pinnedComparer;
}
/// <summary>
/// Creates new instance of LightningCursor
/// </summary>
/// <param name="db">Database</param>
/// <param name="txn">Transaction</param>
internal LightningCursor(LightningDatabase db, LightningTransaction txn)
{
if (db == null)
{
throw new ArgumentNullException(nameof(db));
}
if (txn == null)
{
throw new ArgumentNullException(nameof(txn));
}
mdb_cursor_open(txn.Handle(), db.Handle(), out _handle).ThrowOnError();
Transaction = txn;
Transaction.Disposing += Dispose;
}
private static void SetNativeCompareFunction(
LightningTransaction tran,
LightningDatabase db,
Func<CompareFunctionBuilder, LightningCompareDelegate> delegateFactory,
Func<INativeLibraryFacade, CompareFunction, int> setter)
{
if (delegateFactory == null)
return;
var comparer = delegateFactory.Invoke(new CompareFunctionBuilder());
if (comparer == null)
return;
var compareFunction = CreateNativeCompareFunction(db, comparer);
NativeMethods.Execute(lib => setter.Invoke(lib, compareFunction));
tran.SubTransactionsManager.StoreCompareFunction(compareFunction);
}
/// <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)
{
Environment = environment ?? throw new ArgumentNullException(nameof(environment));
ParentTransaction = parent;
IsReadOnly = flags == 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).ThrowOnError();
_originalHandle = _handle;
}
public LightningDatabase(string name, DatabaseOpenFlags flags, LightningTransaction tran, Encoding encoding)
{
if (tran == null)
throw new ArgumentNullException("tran");
UInt32 handle = default(UInt32);
NativeMethods.Execute(lib => lib.mdb_dbi_open(tran._handle, name, flags, out handle));
_name = name ?? DefaultDatabaseName;
_handle = handle;
_shouldDispose = true;
this.IsOpened = true;
this.Encoding = encoding;
this.OpenFlags = flags;
this.Environment = tran.Environment;
}
internal IDisposable ConfigureDatabase(LightningTransaction tx, LightningDatabase db)
{
var pinnedComparer = new ComparerKeepAlive();
if (_comparer != null)
{
CompareFunction compare = Compare;
pinnedComparer.AddComparer(compare);
mdb_set_compare(tx.Handle(), db.Handle(), compare);
}
if (_duplicatesComparer != null)
{
CompareFunction dupCompare = IsDuplicate;
pinnedComparer.AddComparer(dupCompare);
mdb_set_dupsort(tx.Handle(), db.Handle(), dupCompare);
}
return(pinnedComparer);
}
/// <summary>
/// Creates a LightningDatabase instance.
/// </summary>
/// <param name="name">Database name.</param>
/// <param name="flags">Database open flags/</param>
/// <param name="tran">Active transaction.</param>
/// <param name="encoding">Default strings encoding.</param>
internal LightningDatabase(string name, LightningTransaction tran, DatabaseHandleCacheEntry entry, Encoding encoding)
{
if (name == null)
throw new ArgumentNullException("name");
if (tran == null)
throw new ArgumentNullException("tran");
if (encoding == null)
throw new ArgumentNullException("encoding");
_name = name;
_handle = entry.Handle;
_shouldDispose = true;
this.Encoding = encoding;
this.OpenFlags = entry.OpenFlags;
this.Environment = tran.Environment;
}
/// <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;
}
public LightningDatabase(string name, DatabaseOpenFlags flags, LightningTransaction tran, Encoding encoding)
{
if (tran == null)
{
throw new ArgumentNullException("tran");
}
UInt32 handle = default(UInt32);
Native.Execute(() => Native.mdb_dbi_open(tran._handle, name, flags, out handle));
_name = name ?? DefaultDatabaseName;
_handle = handle;
_shouldDispose = true;
this.IsOpened = true;
this.Encoding = encoding;
this.OpenFlags = flags;
this.Environment = tran.Environment;
}
//TODO: Upgrade db flags?
internal LightningDatabase OpenDatabase(string name, LightningTransaction tran, DatabaseOpenFlags?flags, Encoding encoding)
{
var internalName = name ?? LightningDatabase.DefaultDatabaseName;
var db = _openedDatabases.GetOrAdd(internalName, n =>
{
var ldb = new LightningDatabase(name, tran, flags, encoding);
_databasesForReuse.Add(ldb._handle);
return(ldb);
});
if (db.OpenFlags != flags.GetValueOrDefault())
{
throw new InvalidOperationException("Database " + internalName + " already opened with different flags");
}
if (db.Encoding != (encoding ?? LightningConfig.Database.DefaultEncoding))
{
throw new InvalidOperationException("Can not change encoding of already opened database");
}
return(db);
}
public LightningCursor(LightningDatabase db, LightningTransaction txn)
{
if (db == null)
{
throw new ArgumentNullException("db");
}
if (txn == null)
{
throw new ArgumentNullException("txn");
}
if (db.Environment != txn.Environment)
{
throw new ArgumentException("db and txn belong to different environments");
}
IntPtr handle = default(IntPtr);
NativeMethods.Execute(lib => lib.mdb_cursor_open(txn._handle, db._handle, out handle));
_handle = handle;
this.Database = db;
this.Transaction = txn;
_shouldDispose = true;
if (txn.IsReadOnly)
{
this.Environment.Closing += EnvironmentOrTransactionClosing;
}
else
{
this.Transaction.Closing += EnvironmentOrTransactionClosing;
}
}
public LightningDatabase(string name, DatabaseOpenFlags flags, LightningTransaction tran)
: this(name, flags, tran, Encoding.UTF8)
{
}
public static TType Get <TType>(this LightningTransaction txn, LightningDatabase db, TType key)
{
return(txn.Get <TType, TType>(db, key));
}
public LightningTransaction BeginTransaction(LightningTransaction parent, TransactionBeginFlags beginFlags)
{
this.EnsureOpened();
return new LightningTransaction(this, parent, beginFlags);
}
public LightningDatabase(string name, DatabaseOpenFlags flags, LightningTransaction tran)
: this (name, flags, tran, Encoding.UTF8)
{
}
public void BeginTransaction(bool readOnly, bool pruneOnly)
{
if (this.txn != null)
throw new InvalidOperationException();
this.txn = this.jetInstance.BeginTransaction(readOnly ? TransactionBeginFlags.ReadOnly : TransactionBeginFlags.None);
}
public void Dispose()
{
if (this.txn != null)
{
this.txn.Dispose();
this.txn = null;
}
}
public static GetByOperation GetBy <TKey>(this LightningTransaction txn, LightningDatabase db, TKey key)
{
var valueBytes = txn.GetRawValue(db, key);
return(new GetByOperation(db, valueBytes));
}
public static void Delete <TKey>(this LightningTransaction txn, LightningDatabase db, TKey key)
{
var keyBytes = db.ToBytes(key);
txn.Delete(db, keyBytes);
}
/// <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 byte[] GetRawValue <TKey>(this LightningTransaction txn, LightningDatabase db, TKey key)
{
var keyBytes = db.ToBytes(key);
return(txn.Get(db, keyBytes));
}
public void RollbackTransaction()
{
CheckTransaction();
this.txn.Abort();
this.txn.Dispose();
this.txn = null;
}
//TODO: tests
public void Renew(LightningTransaction txn)
{
if(txn == null)
throw new ArgumentNullException("txn");
if (!txn.IsReadOnly)
throw new InvalidOperationException("Can't renew cursor on non-readonly transaction");
Native.Execute(lib => lib.mdb_cursor_renew(txn._handle, _handle));
}
/// <summary>
/// Truncates all data from the database.
/// </summary>
public void Truncate(LightningTransaction transaction)
{
mdb_drop(transaction.Handle(), _handle, false);
}
public void CommitTransaction()
{
CheckTransaction();
this.txn.Commit();
this.txn.Dispose();
this.txn = null;
}
/// <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>
/// Truncates all data from the database.
/// </summary>
public MDBResultCode Truncate(LightningTransaction transaction)
{
return(mdb_drop(transaction.Handle(), _handle, false));
}
/// <summary>
/// Drops the database.
/// </summary>
public void Drop(LightningTransaction transaction)
{
mdb_drop(transaction.Handle(), _handle, true);
IsOpened = false;
_handle = default(uint);
}
/// <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);
}
//TODO: Upgrade db flags?
internal LightningDatabase OpenDatabase(string name, LightningTransaction tran, DatabaseOpenFlags? flags, Encoding encoding)
{
var internalName = name ?? LightningDatabase.DefaultDatabaseName;
var db = _openedDatabases.GetOrAdd(internalName, n =>
{
var ldb = new LightningDatabase(name, tran, flags, encoding);
_databasesForReuse.Add(ldb._handle);
return ldb;
});
if (db.OpenFlags != flags.GetValueOrDefault())
throw new InvalidOperationException("Database " + internalName + " already opened with different flags");
if (db.Encoding != (encoding ?? LightningConfig.Database.DefaultEncoding))
throw new InvalidOperationException("Can not change encoding of already opened database");
return db;
}
//TODO: Upgrade db flags?
internal LightningDatabase OpenDatabase(string name, DatabaseOpenFlags flags, LightningTransaction tran)
{
var internalName = name ?? LightningDatabase.DefaultDatabaseName;
var db = _openedDatabases.GetOrAdd(internalName, n =>
{
var ldb = new LightningDatabase(name, flags, tran);
_databasesForReuse.Add(ldb._handle);
return ldb;
});
if (db.OpenFlags != flags)
throw new InvalidOperationException("Database " + internalName + " already opened with different flags");
return db;
}
public static bool ContainsKey <TKey>(this LightningTransaction txn, LightningDatabase db, TKey key)
{
var keyBytes = db.ToBytes(key);
return(txn.ContainsKey(db, keyBytes));
}