public static ITransaction CreateTransaction(this IDatabase database, TransactionIsolation isolation) { if (!database.IsOpen) throw new InvalidOperationException(String.Format("Database '{0}' is not open.", database.Name())); return database.CreateSafeTransaction(isolation); }
public SessionInfo(int commitId, User user, TransactionIsolation isolation, ConnectionEndPoint endPoint) { if (user == null) throw new ArgumentNullException("user"); if (endPoint == null) throw new ArgumentNullException("endPoint"); CommitId = commitId; User = user; EndPoint = endPoint; Isolation = isolation; StartedOn = DateTimeOffset.UtcNow; }
private static IsolationLevel GetIsolationLevel(TransactionIsolation level) { switch (level) { case TransactionIsolation.ReadUncommitted: return IsolationLevel.ReadUncommitted; case TransactionIsolation.RepeatableRead: return IsolationLevel.RepeatableRead; case TransactionIsolation.Serializable: return IsolationLevel.Serializable; case TransactionIsolation.Snapshot: return IsolationLevel.Snapshot; default: return IsolationLevel.ReadCommitted; } }
/// <summary> /// Initializes a new instance of the <see cref="TransactionsImpl" /> class. /// </summary> /// <param name="target">Target.</param> /// <param name="marsh">Marshaller.</param> /// <param name="localNodeId">Local node id.</param> public TransactionsImpl(IUnmanagedTarget target, Marshaller marsh, Guid localNodeId) : base(target, marsh) { _localNodeId = localNodeId; TransactionConcurrency concurrency = default(TransactionConcurrency); TransactionIsolation isolation = default(TransactionIsolation); TimeSpan timeout = default(TimeSpan); DoInOp(OpCacheConfigParameters, stream => { var reader = marsh.StartUnmarshal(stream).GetRawReader(); concurrency = (TransactionConcurrency) reader.ReadInt(); isolation = (TransactionIsolation) reader.ReadInt(); timeout = TimeSpan.FromMilliseconds(reader.ReadLong()); }); _dfltConcurrency = concurrency; _dfltIsolation = isolation; _dfltTimeout = timeout; }
internal Transaction(Database database, int commitId, TransactionIsolation isolation, IEnumerable<TableSource> committedTables, IEnumerable<IIndexSet> indexSets) { CommitId = commitId; Database = database; Isolation = isolation; InitManagers(); Registry = new TransactionRegistry(this); tableManager.AddVisibleTables(committedTables, indexSets); AddInternalTables(); OldNewTableState = new OldNewTableState(); IsClosed = false; Database.TransactionFactory.OpenTransactions.AddTransaction(this); currentSchema = database.DatabaseContext.DefaultSchema(); readOnly = dbReadOnly = database.DatabaseContext.ReadOnly(); autoCommit = database.DatabaseContext.AutoCommit(); ignoreCase = database.DatabaseContext.IgnoreIdentifiersCase(); }
internal Transaction(Database database, int commitId, TransactionIsolation isolation) : this(database, commitId, isolation, new TableSource[0], new IIndexSet[0]) { }
public int BeginTransaction(TransactionIsolation isolationLevel) { var response = SendMessage(new BeginRequest(isolationLevel)) as BeginResponse; if (response == null) throw new InvalidOperationException(); return response.CommitId; }
public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation, TimeSpan timeout, int txSize) { var id = DoOutInOp(OpStart, w => { w.WriteInt((int) concurrency); w.WriteInt((int) isolation); w.WriteTimeSpanAsLong(timeout); w.WriteInt(txSize); }, s => s.ReadLong()); var innerTx = new TransactionImpl(id, this, concurrency, isolation, timeout, _localNodeId); return new Transaction(innerTx); }
internal ITransaction CreateTransaction(TransactionIsolation isolation) { var thisCommittedTables = new List<TableSource>(); // Don't let a commit happen while we are looking at this. lock (commitLock) { int thisCommitId = CurrentCommitId; var committedTableList = StateStore.GetVisibleList(); thisCommittedTables.AddRange(committedTableList.Select(resource => GetTableSource(resource.TableId))); // Create a set of IIndexSet for all the tables in this transaction. var indexInfo = (thisCommittedTables.Select(mtable => mtable.CreateIndexSet())).ToList(); // Create the transaction and record it in the open transactions list. return new Transaction(Database, thisCommitId, isolation, thisCommittedTables, indexInfo); } }
/** <inheritDoc /> */ public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation) { return(TxStart(concurrency, isolation, _dfltTimeout, 0)); }
/** <inheritDoc /> */ public ITransactionClient TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation) { return(TxStart(concurrency, isolation, DefaultTimeout)); }
public SessionInfo(int commitId, User user, TransactionIsolation isolation) : this(commitId, user, isolation, ConnectionEndPoint.Embedded) { }
/// <inheritdoc /> public void Start(TransactionScopeOption transactionScopeOption, TransactionIsolation transactionIsolation, int transactionTimespan) { // Do Nothing }
/** <inheritDoc /> */ public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation) { return TxStart(concurrency, isolation, _dfltTimeout, 0); }
public static IUserSession CreateSystemSession(this IDatabase database, TransactionIsolation isolation) { var transaction = database.CreateTransaction(isolation); return new SystemUserSession(database, transaction); }
internal static ITransaction CreateSafeTransaction(this IDatabase database, TransactionIsolation isolation) { return database.TransactionFactory.CreateTransaction(isolation); }
public BeginRequest(TransactionIsolation isolationLevel) { IsolationLevel = isolationLevel; }
public static ITransaction BeginTransaction(this ISession session, TransactionIsolation level) { return session.BeginTransaction(GetIsolationLevel(level)); }
public SessionInfo(User user, TransactionIsolation isolation, ConnectionEndPoint endPoint) : this(-1, user, isolation, endPoint) { }
/** <inheritDoc /> */ public ITransactionClient TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation, TimeSpan timeout) { return(TxStart(concurrency, isolation, timeout, null)); }
public ITransaction CreateTransaction(TransactionIsolation isolation) { lock (this) { ITransaction transaction; try { transaction = database.TableComposite.CreateTransaction(isolation); } catch (DatabaseSystemException) { throw; } catch (Exception ex) { throw new DatabaseSystemException("Unable to create a transaction.", ex); } return transaction; } }
public SessionInfo(User user, TransactionIsolation isolation) : this(-1, user, isolation) { }
/** <inheritDoc /> */ public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation, TimeSpan timeout, int txSize) { var id = UU.TransactionsStart(Target, (int)concurrency, (int)isolation, (long)timeout.TotalMilliseconds, txSize); var innerTx = new TransactionImpl(id, this, concurrency, isolation, timeout, _localNodeId); return new Transaction(innerTx); }
public ITransaction StartTransaction(TransactionConcurrency concurrency, TransactionIsolation isolation) { return((ignite ?? DIContext.Obtain <ITRexGridFactory>().Grid(Mutability)) .GetTransactions() .TxStart(concurrency, isolation)); }