internal Provider(Application parent) { _id = Guid.NewGuid(); _parent = parent; _dbLib = _parent.DbLib; _parent = parent; }
/// <summary> /// Renew a read-only transaction. /// This acquires a new reader lock for a transaction handle that had been released by mdb_txn_reset(). /// It must be called before a reset transaction may be used again. /// </summary> public void Renew() { var handle = CheckDisposed(); var ret = DbLib.mdb_txn_renew(handle); ErrorUtil.CheckRetCode(ret); }
/// <summary> /// Commit all the operations of a transaction into the database. /// The transaction handle is freed. It and its cursors must not be used again after this call, except with mdb_cursor_renew(). /// Note: Earlier documentation incorrectly said all cursors would be freed. Only write-transactions free cursors. /// </summary> public void Commit() { var ret = DbRetCode.SUCCESS; // we check here, as we dont want to throw an exception in the CER, but won't use this handle. var handle = CheckDisposed(); var txnId = IntPtr.Zero; RuntimeHelpers.PrepareConstrainedRegions(); try { /* */ } finally { // now we use atomic access to the handle handle = Interlocked.CompareExchange(ref txn, IntPtr.Zero, txn); // if the txn handle was valid before we cleared it, lets close the handle if (handle != IntPtr.Zero) { txnId = DbLib.mdb_txn_id(handle); ret = DbLib.mdb_txn_commit(handle); } } if (handle != IntPtr.Zero) { // weather the call succeeded or not, the transaction cannot be re-used. ReleaseManagedResources(true); disposed?.Invoke(txnId); ErrorUtil.CheckRetCode(ret); Committed(); } }
/// <summary> /// Set the size of the memory map to use for this environment. /// The size should be a multiple of the OS page size. The default is 10485760 bytes. The size of the memory map /// is also the maximum size of the database. The value should be chosen as large as possible, to accommodate /// future growth of the database. This function should be called after mdb_env_create() and before mdb_env_open(). /// It may be called at later times if no transactions are active in this process. /// Note that the library does not check for this condition, the caller must ensure it explicitly. /// </summary> /// <remarks> /// The new size takes effect immediately for the current process but will not be persisted to any others /// until a write transaction has been committed by the current process. Also, only mapsize increases are persisted /// into the environment. /// If the mapsize is increased by another process, and data has grown beyond the range of the current mapsize, /// mdb_txn_begin() will return MDB_MAP_RESIZED. This function may be called with a size of zero to adopt the new size. /// Any attempt to set a size smaller than the space already consumed by the environment will be silently changed /// to the current size of the used space. /// Note: the current MapSize can be obtained by calling GetEnvInfo(). /// </remarks> /// <param name="newValue"></param> public void SetMapSize(long newValue) { if (autoReduceMapSizeIn32BitProcess && (IntPtr.Size == 4) && (newValue > int.MaxValue)) { newValue = int.MaxValue; } RunChecked((handle) => DbLib.mdb_env_set_mapsize(handle, (IntPtr)newValue)); }
internal void Load() { DbLib dbLib = new DbLib(); DataTable dataTable = dbLib.SessionGet(_id); Load(dataTable.Rows[0]); }
internal Appointment(Application parent, Patient patient, Referrer referrer, Provider provider, ClinicType clinicType) { _parent = parent; _dbLib = _parent.DbLib; _ubrn = _parent.GetMaxUBRN(); _patient = patient; _referrer = referrer; _provider = provider; _clinicType = clinicType; _createdDateTime = DateTime.Now; _status = AppointmentStatus.Pending; }
/// <summary> /// Implementation of Dispose() pattern. See <see cref="Dispose()"/>. /// </summary> /// <param name="disposing"><c>true</c> if explicity disposing (finalizer not run), <c>false</c> if disposed from finalizer.</param> protected virtual void Dispose(bool disposing) { var handle = Interlocked.Exchange(ref txn, IntPtr.Zero); // if the txn handle was valid before we cleared it, lets close the handle if (handle != IntPtr.Zero) { var txnId = DbLib.mdb_txn_id(handle); DbLib.mdb_txn_abort(handle); ReleaseManagedResources(); disposed?.Invoke(txnId); } }
public static void CheckRetCode(DbRetCode ret) { if (ret != DbRetCode.SUCCESS) { string errStr; if (ret > MdbLowError && ret <= DbRetCode.LAST_ERRCODE) { errStr = DbLib.mdb_strerror(ret); } else { errStr = DotNetStr(ret); } throw new LmdbException(ret, errStr); } }
/// <summary>Constructor.</summary> /// <param name="config">Configuration to use.</param> public LmdbEnvironment(LmdbEnvironmentConfiguration config = null) { // so that we can refer back to the Environment instance instanceHandle = GCHandle.Alloc(this, GCHandleType.WeakTrackResurrection); DbRetCode ret; RuntimeHelpers.PrepareConstrainedRegions(); try { /* */ } finally { IntPtr envHandle; ret = DbLib.mdb_env_create(out envHandle); if (ret == DbRetCode.SUCCESS) { var ret2 = DbLib.mdb_env_set_userctx(envHandle, (IntPtr)instanceHandle); if (ret2 == DbRetCode.SUCCESS) { this.env = envHandle; } else { ret = ret2; DbLib.mdb_env_close(envHandle); } } } ErrorUtil.CheckRetCode(ret); if (config != null) { this.autoReduceMapSizeIn32BitProcess = config.AutoReduceMapSizeIn32BitProcess; if (config.MapSize.HasValue) { this.SetMapSize(config.MapSize.Value); } if (config.MaxDatabases.HasValue) { this.MaxDatabases = config.MaxDatabases.Value; } if (config.MaxReaders.HasValue) { this.MaxReaders = config.MaxReaders.Value; } } }
/// <summary> /// Commit all the operations of a transaction into the database. /// The transaction handle is freed. It and its cursors must not be used again after this call, except with mdb_cursor_renew(). /// Note: Earlier documentation incorrectly said all cursors would be freed. Only write-transactions free cursors. /// </summary> public void Commit() { // we check here, as we dont want to throw an exception later, but won't use this handle. var currentHandle = CheckDisposed(); // now we use atomic access to the handle var handle = Interlocked.Exchange(ref txn, IntPtr.Zero); // if the txn handle was valid before we cleared it, lets close the handle if (handle != IntPtr.Zero) { var txnId = DbLib.mdb_txn_id(handle); var ret = DbLib.mdb_txn_commit(handle); // whether the call succeeded or not, the transaction cannot be re-used. ReleaseManagedResources(true); disposed?.Invoke(txnId); ErrorUtil.CheckRetCode(ret); Committed(); } }
/// <summary> /// Implementation of Dispose() pattern. See <see cref="Dispose()"/>. /// </summary> /// <param name="disposing"><c>true</c> if explicity disposing (finalizer not run), <c>false</c> if disposed from finalizer.</param> protected virtual void Dispose(bool disposing) { IntPtr handle = IntPtr.Zero; IntPtr txnId = IntPtr.Zero; RuntimeHelpers.PrepareConstrainedRegions(); try { /* */ } finally { handle = Interlocked.CompareExchange(ref txn, IntPtr.Zero, txn); // if the txn handle was valid before we cleared it, lets close the handle if (handle != IntPtr.Zero) { txnId = DbLib.mdb_txn_id(handle); DbLib.mdb_txn_abort(handle); } } if (handle != IntPtr.Zero) { ReleaseManagedResources(); disposed?.Invoke(txnId); } }
/// <summary> /// Reset a read-only transaction. /// Abort the transaction like mdb_txn_abort(), but keep the transaction handle. mdb_txn_renew() may reuse the handle. /// This saves allocation overhead if the process will start a new read-only transaction soon, and also locking overhead /// if MDB_NOTLS is in use.The reader table lock is released, but the table slot stays tied to its thread or MDB_txn. /// Use mdb_txn_abort() to discard a reset handle, and to free its lock table slot if MDB_NOTLS is in use. /// Cursors opened within the transaction must not be used again after this call, except with mdb_cursor_renew(). /// Reader locks generally don't interfere with writers, but they keep old versions of database pages allocated. /// Thus they prevent the old pages from being reused when writers commit new data, and so under heavy load /// the database size may grow much more rapidly than otherwise. /// </summary> public void Reset() { var handle = CheckDisposed(); DbLib.mdb_txn_reset(handle); }
private Application() { _dbLib = new DbLib(); }
internal Appointment(Application parent, DataRow dataRow) { _parent = parent; _dbLib = _parent.DbLib; Load(dataRow); }
private Application(Session session) { _dbLib = new DbLib(); _session = session; }
internal Provider(Application parent, DataRow dataRow) { _parent = parent; _dbLib = _parent.DbLib; this.Load(dataRow); }
internal Referrer(Application parent) { _id = Guid.NewGuid(); _parent = parent; _dbLib = _parent.DbLib; }
/// <summary> /// Retrieve the multi-value options for the database. /// </summary> public MultiValueDatabaseOptions GetMultiValueOptions(Transaction transaction) { uint opts = GetChecked((uint handle, out uint value) => DbLib.mdb_dbi_flags(transaction.Handle, handle, out value)); return(unchecked ((MultiValueDatabaseOptions)opts)); }
internal Referrer(Application parent, DataRow dataRow) { _parent = parent; _dbLib = _parent.DbLib; Load(dataRow); }
internal Slot(Application parent) { _id = Guid.NewGuid(); _parent = parent; _dbLib = _parent.DbLib; }