Lines Matching refs:Transaction
516 ** ^If an [sqlite3] object is destroyed while a transaction is open,
517 ** the transaction is automatically rolled back.
993 ** current transaction. This hint is not guaranteed to be accurate but it
1032 ** and sent to the VFS after a transaction has been committed immediately
1058 ** write ahead log and shared memory files used for transaction control
1082 ** a write transaction to indicate that, unless it is rolled back for some
1084 ** transaction. This is used by VACUUM operations.
1246 ** of the sqlite3_vfs object changes in the transaction between
2266 ** that is inside an explicit transaction, then the entire transaction
3576 ** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK],
3604 ** statements that are holding a transaction open.
4012 ** or occurs outside of an explicit transaction, then you can retry the
4014 ** explicit transaction then you should rollback the transaction before
5228 ** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR],
5230 ** transaction might be rolled back automatically. The only way to
5231 ** find out whether SQLite automatically rolled back the transaction after
5301 ** function to be invoked whenever a transaction is [COMMIT | committed].
5305 ** function to be invoked whenever a transaction is [ROLLBACK | rolled back].
5335 ** ^For the purposes of this API, a transaction is said to have been
5338 ** ^The rollback callback is not invoked if a transaction is
6126 ** commit if the transaction continues to completion.)^
6185 ** blob handles or active write statements, the current transaction is
6186 ** committed. ^If an error occurs while committing the transaction, an error
6187 ** code is returned and the transaction rolled back.
6908 ** transaction rollback or database recovery operations are not included.
7251 ** ^SQLite holds a write transaction open on the destination database file
7287 ** there is already a read or read-write transaction open on the
7367 ** active write-transaction on the destination database is rolled back.
7455 ** its current transaction, either by committing it or rolling it back.
7464 ** when the blocking connections current transaction is concluded. ^The
7466 ** call that concludes the blocking connections transaction.
7470 ** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
7504 ** When a blocking connections transaction is concluded, there may be
7519 ** connection Y's transaction to be concluded, and similarly connection
7520 ** Y is waiting on connection X's transaction, then neither connection
7528 ** callback on the conclusion of connection B's transaction, and connection
7530 ** A's transaction is concluded. ^Indirect deadlock is also detected, so
7533 ** C's transaction, where connection C is waiting on connection A. ^Any
7657 ** after committing a transaction if there are N or
7856 ** is able to roll back a statement or database transaction, and abandon
8818 ** the aborted transaction. This could lead to database corruption.
11770 int nSavepoint; /* Number of non-transaction savepoints */
11772 i64 nDeferredCons; /* Net deferred constraints this transaction. */
12143 ** transaction, these accesses need to be made via the same database
12301 ** causes the operation in process to fail and for the current transaction
12304 ** but the transaction is not rolled back. FAIL processing means that
12324 #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
12325 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
13244 yDbMask writeMask; /* Start a write transaction on these databases */
17339 ** transaction has been committed. Injecting a fault at this point
17341 ** but the transaction is committed anyway.
26260 /* 3 */ "Transaction" OpHelp(""),
26651 ** transaction counter in bytes 24-27 of database files are updated
26653 ** occur if a file is updated without also updating the transaction
26657 unsigned char transCntrChng; /* True if the transaction counter changed */
27216 ** transaction crashes and leaves behind hot journals, then any
28332 /* Set up the transaction-counter change checking flags when
28413 ** transaction counter was updated if any part of the database
28414 ** file changed. If the transaction counter is not updated,
29629 ** transaction counter was updated if any part of the database
29630 ** file changed. If the transaction counter is not updated,
29971 ** has changed. If the transaction counter is modified, record that
29983 pFile->transCntrChng = 1; /* The transaction counter has changed */
30203 ** the directory entry for the journal was never created) and the transaction
30503 ** it hence it is OK for the transaction change counter to be
40065 ** journalled during a transaction, or which pages have the "dont-write"
40083 ** start of a transaction, and is thus usually less than a few thousand,
42934 #define WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */
42973 ** snapshot is like a read-transaction. It is the state of the database
42977 ** transaction and releases the lock.
43067 ** the transaction has been written into the rollback journal and
43070 ** (b) The page was a freelist leaf page at the start of the transaction.
43073 ** the database file at the start of the transaction.
43081 ** transaction other than the update of the transaction sequence
43087 ** transaction.
43111 ** equivalent to the database file at the beginning of the transaction.
43113 ** (8) When a transaction is rolled back, the xTruncate method of the VFS
43115 ** the beginning of the transaction. (In some VFSes, the xTruncate
43128 ** of every transaction.
43204 ** * No read or write transaction is active.
43212 ** was) in exclusive-locking mode, a user-level read transaction is
43216 ** it opens a read-transaction on the database and returns to state
43217 ** OPEN after the read-transaction is completed. However a connection
43219 ** this state even after the read-transaction is closed. The only way
43223 ** * A read transaction may be active (but a write-transaction cannot).
43226 ** transaction is not active). The dbOrigSize and dbFileSize variables
43229 ** * Even if a read-transaction is not open, it is guaranteed that
43234 ** The pager moves to this state from READER when a write-transaction
43236 ** required to start a write-transaction are held, but no actual
43239 ** In rollback mode, a RESERVED or (if the transaction was opened with
43242 ** to in this state. If the transaction is committed or rolled back while
43250 ** * A write transaction is active.
43253 ** * If the connection is open in WAL-mode, a WAL write transaction
43268 ** * A write transaction is active.
43281 ** * A write transaction is active.
43293 ** state after the entire transaction has been successfully written into the
43294 ** database file. In this state the transaction may be committed simply
43297 ** layer must either commit or rollback the transaction.
43299 ** * A write transaction is active.
43303 ** commit the transaction. If an error did occur, the caller will need
43304 ** to rollback the transaction.
43331 ** when a read-transaction is next opened on the pager (transitioning
43352 ** statement executed within a transaction. In this case, if the error
43418 ** transaction in another process, causing SQLite to read from the database
43459 ** savepoint and statement transaction in the system. All such structures
43522 ** relinquished on the database file. Each time a transaction is committed,
43524 ** updating the change-counter is omitted for the current transaction.
43527 ** need only update the change-counter once, for the first transaction
43532 ** When PagerCommitPhaseOne() is called to commit a transaction, it may
43537 ** the way in which the journal file is finalized after the transaction is
43548 ** subsequently interrupted transaction that reuses the journal file.
43582 ** write-transaction is opened.
43599 ** During a write-transaction, if pages with page-numbers greater than
43606 ** variable at the start of the transaction. It is used during rollback,
43610 ** Throughout a write-transaction, dbFileSize contains the size of
43612 ** write-transaction is first opened, and updated when VFS calls are made
43616 ** unnecessary calls to xTruncate() after committing a transaction. If,
43617 ** when a transaction is committed, the dbFileSize variable indicates
43621 ** dbFileSize is not used when rolling back a transaction. In this case
43632 ** write-transaction is opened (at the same time as dbFileSize and
43678 Pgno dbOrigSize; /* dbSize before the current transaction */
43944 ** a rollback transaction that switches from journal_mode=off
44337 ** within the current transaction (i.e. if Pager.journalOff==0).
44371 /* At this point the transaction is committed but the write lock
44513 ** database before the transaction began, in pages. Also, pPager->cksumInit
44561 ** of the transaction. Return an error code if anything goes wrong.
44643 ** If zMaster is a NULL pointer (occurs for a single database transaction),
44781 ** as a hot-journal and rolled back the next time a read-transaction
44872 ** the contents of the pager-cache. If a transaction was active when
44895 ** This routine ends a transaction. A transaction is usually ended by
44899 ** database transaction.
44909 ** transaction. Nor will it be considered to be a hot-journal by this
44951 /* Do nothing if the pager does not have an open write transaction
44953 ** is no write-transaction active but a RESERVED or greater lock is
44961 ** read-transaction, this function is called with eState==PAGER_READER
44962 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
44987 ** cause the last transaction to roll back. See
45042 /* This branch is taken when committing a transaction in rollback-journal
45044 ** At this point the journal has been finalized and the transaction
45070 ** Execute a rollback if a transaction is active and unlock the
45220 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
45293 ** different from the page content at the start of the transaction.
45351 ** if the page is on the free-list at the start of the transaction, then
45383 ** transaction was first opened. In this case we can mark the page
45394 ** again within this transaction, it will be marked as dirty but
45431 ** file for a transaction involving two databases might be:
45553 ** file in the file-system. This only happens when committing a transaction,
45554 ** or rolling back a transaction (including rolling back a hot-journal).
45786 /* If nRec is 0 and this rollback is of a transaction created by this
45855 ** state prior to the start of the transaction, so invoke the
45857 ** assertion that the transaction counter was modified.
45867 ** before the transaction was committed, then the change-counter
46001 ** written into the log file when a WAL transaction is rolled back.
46034 /* Normally, if a transaction is rolled back, any backup processes are
46039 ** also copied into the backup databases) as part of this transaction,
46048 ** This function is called to rollback a transaction on a WAL database.
46103 /* If a WAL transaction is being committed, there is no point in writing
46142 ** Begin a read transaction on the WAL.
46157 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
46279 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
46282 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
46309 ** (or transaction). No page with a page-number greater than this value
46789 ** This function may only be called when a read-transaction is open on
46849 ** the database file. If a savepoint transaction were rolled back after
46873 ** truncation will be done when the current transaction is committed.
46875 ** This function is only called right before committing a transaction.
46876 ** Once this function has been called, the transaction must either be
46890 ** called right before committing a transaction. So although the
47000 ** If a transaction was in progress when this routine is called, that
47001 ** transaction is rolled back. All outstanding pages are invalidated
47006 ** This function always succeeds. If a transaction is active an attempt
47139 ** previous connection's transaction), and a crash or power-failure
47142 ** transaction), then SQLite may become confused when doing the
47923 ** transaction that populates a new database is being rolled back.
48066 ** and possibly used for a transaction later on. Also, write-access
48220 ** transaction and unlock the pager.
48294 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
48499 ** This function is called at the start of every write transaction.
48506 ** opened to write a rollback log for a transaction. It is not used
48593 ** Begin a write-transaction on the specified pager object. If a
48594 ** write-transaction has already been opened, this function is a no-op.
48602 ** within this transaction will be opened as an in-memory file. This
48604 ** running in exclusive mode) or if the transaction does not require a
48653 ** when it has an open transaction, but never to DBMOD or FINISHED.
48671 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
48696 ** Otherwise, when the transaction is rolled back, the logic in
48739 /* This routine is not called unless a write-transaction has already
48753 ** obtained the necessary locks to begin the write-transaction, but the
48987 ** transaction is committed.
49054 ** next time a read transaction is opened the cache will be
49094 ** This function may only be called while a write-transaction is active in
49121 ** journal (a single database transaction).
49131 ** The only thing that remains to commit the transaction is to finalize
49194 ** was enabled at compile time, and if this transaction meets the
49199 ** * This commit is not part of a multi-file transaction, and
49205 ** is not applicable to this transaction, call sqlite3JournalCreate()
49213 ** created for this transaction.
49274 ** image was extended as part of the current transaction and then the
49303 ** updated to reflect the changes made by the current transaction and
49306 ** be used as a hot-journal and the current transaction rolled back.
49310 ** for hot-journal rollback. Once this is done the transaction is
49331 ** this transaction, the pager is running in exclusive-mode and is
49357 ** If a write transaction is open, then all changes made within the
49358 ** transaction are reverted and the current write-transaction is closed.
49368 ** in-memory cache pages to the state they were in when the transaction
49378 ** current transaction are either expelled from the cache or reverted to
49379 ** their pre-transaction state by re-reading data from the database or
49380 ** WAL files. The WAL transaction is then closed.
49599 ** transaction is rolled back. This is different to calling
49601 ** the transaction or unlock the database, it just restores the
49760 ** A transaction must be active when this routine is called. It used to be
49761 ** required that a statement transaction was not active, but this restriction
49763 ** transaction is active).
49766 ** moved as part of a database reorganization just before the transaction
49768 ** pPg refers to will not be written to again within this transaction.
49859 ** to exist, in case the transaction needs to roll back. Use pPgOld
49879 ** this transaction, it may be written to the database file before
50428 ** To start a read transaction, the reader records the index of the last
50585 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
50622 u32 iChange; /* Counter incremented each transaction */
50742 u8 writeLock; /* True if in a write transaction */
50748 WalIndexHdr hdr; /* Wal-index header for current transaction */
51319 ** must have exited unexpectedly in the middle of a transaction (after
51321 ** Remove the remnants of that writers uncommitted transaction from
52414 ** Attempt to start a read transaction. This might fail due to a race or
52453 ** When the read transaction is completed, the caller must release the
52654 ** Begin a read transaction on the database.
52663 ** transaction, then *pChanged is set to 1 before returning. The
52682 ** Finish with a read transaction. All this does is release the
52711 /* This routine is only be called from within a read transaction. */
52733 ** current read transaction was opened. Values added after the
52734 ** read transaction was opened may have been written incorrectly -
52736 ** that any slots written before the current read transaction was
52748 ** table after the current read-transaction had started.
52832 ** This function starts a write transaction on the WAL.
52834 ** A read transaction must have already been started by a prior call
52838 ** the read transaction was started, then it is not possible for this
52840 ** returns SQLITE_BUSY in that case and no write transaction is started.
52847 /* Cannot start a write transaction without first holding a read
52848 ** transaction. */
52865 ** time the read transaction on this connection was started, then
52878 ** End a write transaction. The commit has already been done. This
52892 ** function moves the write-pointer back to the start of the transaction.
52895 ** to the WAL since the start of the transaction. If the callback returns
52925 ** page 1 is never written to the log until the transaction is
52963 /* This savepoint was opened immediately after the write-transaction
53013 ** to handle if this transaction is rolled back. */
53127 /* If this frame set completes a transaction, then nTruncate>0. If
53128 ** nTruncate==0 then this frame set does not complete the transaction. */
53211 /* If this is the end of a transaction, then we might need to pad
53212 ** the transaction and/or sync the WAL file.
53215 ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL
53240 /* If this frame set completes the first transaction in the WAL and
53837 ** from this list when a transaction is committed or rolled back, or when
53893 ** of the Btree structure. At most one of these may open a write transaction,
53927 ** 1) The current writer (BtShared.pWriter) concludes its transaction, OR
53931 ** transaction.
53946 u8 inTransaction; /* Transaction state */
53963 Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */
53968 Btree *pWriter; /* Btree with currently open write transaction */
54162 /* A bunch of assert() statements to check the transaction state variables
54778 ** transaction on this file. And, obviously, for this to be so there
54779 ** must be an open write transaction on the file itself.
54901 ** transaction. If it does not, then the BTS_PENDING flag
54933 ** transaction. If there currently exists a writer, and p is not
55054 ** transaction, a problem comes up. If the page is not journalled when
55065 ** at the end of every transaction.
55096 ** invoked at the conclusion of each write-transaction.
56581 ** the transaction, for each page restored this routine is called.
57016 /* Rollback any active transaction and free the handle structure.
57506 ** of a transaction but there is a read lock on the database, then
57510 ** If there is a transaction in progress, this routine is a no-op.
57583 ** Attempt to start a new transaction. A write-transaction
57585 ** transaction. If the second argument is 2 or more and exclusive
57586 ** transaction is started, meaning that no other process is allowed
57587 ** to access the database. A preexisting transaction may not be
57589 ** exclusivity flag only works for a new transaction.
57591 ** A write-transaction must be started before attempting any
57593 ** will work unless a transaction is started first:
57625 /* If the btree is already in a write-transaction, or it
57626 ** is already in a read-transaction and a read-transaction
57641 /* If another database handle has already opened a write transaction
57642 ** on this shared-btree structure and a second write transaction is
57665 /* Any read-only or read-write transaction implies a read-lock on
57667 ** on page 1, the transaction cannot be opened. */
57728 ** re-read the database size from page 1 if a savepoint or transaction
57729 ** rollback occurs within the transaction.
58082 ** A write-transaction must be opened before calling this function.
58123 ** This routine is called prior to sqlite3PagerCommit when a transaction
58193 ** disk and we are still holding all locks, so the transaction has not
58197 ** This call is a no-op if no write-transaction is currently active on pBt.
58202 ** (single database transaction).
58208 ** the write-transaction for this database file is to delete the journal.
58235 ** at the conclusion of a transaction.
58247 ** handle, downgrade to a read-only transaction. The other statements
58252 /* If the handle had any kind of transaction open, decrement the
58253 ** transaction count of the shared btree. If the transaction count
58264 /* Set the current transaction state to TRANS_NONE and unlock the
58265 ** pager if this call closed the only read or write transaction. */
58274 ** Commit the transaction currently in progress.
58282 ** the rollback journal (which causes the transaction to commit) and
58288 ** is non-zero then this b-tree transaction is part of a multi-file
58289 ** transaction. In this case, the transaction has already been committed
58293 ** transaction has been closed. This is quite safe, as the pager will have
58305 /* If the handle has a write-transaction open, commit the shared-btrees
58306 ** transaction and set the shared state to TRANS_READ.
58356 ** tripped. In general, writeOnly is false if the transaction being
58401 ** Rollback the transaction in progress.
58464 ** back independently of the main transaction. You must start a transaction
58466 ** if the main transaction commits or rolls back.
58471 ** can be rolled back without having to rollback the entire transaction.
58473 ** A statement sub-transaction
58489 /* At the pager level, a statement transaction is a savepoint with
58492 ** such savepoints while the statement transaction savepoint is active.
58507 ** contents of the entire transaction are rolled back. This is different
58508 ** from a normal transaction rollback, as no locks are released and the
58509 ** transaction remains open.
58527 ** when the transaction started, so we know that the value at offset
58539 ** the caller already has at least a read-only transaction open
58541 ** the caller is assumed to have an open write transaction.
58559 ** 4: There must be an active transaction.
58588 /* Assert that the caller has opened the required transaction. */
59064 ** 4) there is no open write-transaction, and
60248 ** current transaction has already run one or more incremental-vacuum
63130 ** has a read or write transaction open on the database.
63782 ** A read-only or read-write transaction must be opened before calling
63926 ** Return non-zero if a transaction is active.
63938 ** transaction on the shared-cache the argument Btree is connected to.
63959 ** Return non-zero if a read (or write) transaction is active.
64084 ** (b) there is a read/write transaction open,
64202 int bDestLocked; /* True once a write-transaction is open on pDest */
64303 ** Check that there is no open read-transaction on the b-tree passed as the
64305 ** is an open read-transaction, return SQLITE_ERROR and leave an error
64380 ** error was hit. Or there is a transaction open on the destination
64555 /* If the source pager is currently in a write-transaction, return
64572 /* If there is no open read-transaction on the source database, open
64573 ** one now. If a transaction is opened here, then it will be closed
64740 /* Finish committing the transaction to the destination database. */
64749 /* If bCloseTrans is true, then this function opened a read transaction
64750 ** on the source database. Close the read transaction here. There is
64752 ** "committing" a read-only transaction cannot fail.
64803 /* If a transaction is still open on the Btree, roll it back. */
64875 ** has been modified by a transaction on the source pager. Copy
64915 ** Copy the complete content of pBtFrom into pBtTo. A transaction
64919 ** goes wrong, the transaction on pTo is rolled back. If successful, the
64920 ** transaction is committed before returning.
67147 ** throw an ABORT exception (causing the statement, but not entire transaction
68042 ** and reset(). Inserts are grouped into a transaction.
68703 ** A read or write transaction may or may not be active on database handle
68704 ** db. If a transaction is active, commit it. If there is a
68705 ** write-transaction spanning more than one database file, this routine
68710 int nTrans = 0; /* Number of databases with an active write-transaction */
68722 ** virtual module tables written in this transaction. This has to
68725 ** to the transaction.
68732 ** one database file has an open write transaction, a master journal
68758 ** TEMP database) has a transaction active. There is no need for the
68792 /* The complex case - There is a multi-file write-transaction active.
68793 ** This requires a master journal file to ensure the transaction is
68845 /* Write the name of each database file in the transaction into the new
68886 /* Sync all the db files involved in the transaction. The same call
68909 /* Delete the master journal file. This commits the transaction. After
68911 ** transaction files are deleted.
68924 ** transaction is already guaranteed, but some stray 'cold' journals
68978 ** If the Vdbe passed as the first argument opened a statement-transaction,
68981 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
68982 ** statement transaction is committed.
68992 ** statement transaction that should be closed here. The only exception
69031 /* If the statement transaction is being rolled back, also restore the
69033 ** the statement transaction was opened. */
69043 ** This function is called when a transaction opened by the database
69085 ** transaction will be committed or rolled back as a result of the
69096 ** state. We need to rollback the statement transaction, if there is
69097 ** one, or the complete transaction if there is no statement transaction.
69127 ** transaction must be rolled back to restore the database to a
69131 ** a statement or transaction rollback operation. If the error
69141 /* We are forced to roll back the active transaction. Before doing
69158 ** VM, then we do either a commit or rollback of the current transaction.
69178 ** key constraints to hold up the transaction. This means a commit
69213 /* If eStatementOp is non-zero, then a statement transaction needs to
69234 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
71443 ** This function is called after a transaction has been committed. It
73419 ** the number of non-transaction savepoints currently in the
73815 ** whether or not to rollback the current transaction. Do not rollback
73818 ** VDBE, but do not rollback the transaction.
74215 ** transaction. It needs to be rolled back. */
74225 ** opens a statement transaction may invoke this opcode.
74227 ** In case this is such a statement, close any statement transaction
74230 ** If the open statement-transaction is not closed here, then the user
74231 ** may step another VM that opens its own statement transaction. This
74234 ** The statement transaction is never a top-level transaction. Hence
75735 ** transaction, then there cannot be any savepoints.
75754 /* This call is Ok even if this savepoint is actually a transaction
75756 ** If this is a transaction savepoint being opened, it is guaranteed
75770 /* If there is no open transaction, then mark this as a special
75771 ** "transaction savepoint". */
75810 /* Determine whether or not this is a transaction savepoint. If so,
75811 ** and this is a RELEASE command, then the current transaction
75916 sqlite3VdbeError(p, "cannot commit transaction - "
75945 (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
75946 (iRollback)?"cannot rollback - no transaction is active":
75947 transaction is active"));
75954 /* Opcode: Transaction P1 P2 P3 P4 P5
75956 ** Begin a transaction on database P1 if a transaction is not already
75958 ** If P2 is non-zero, then a write-transaction is started, or if a
75959 ** read-transaction is already active, it is upgraded to a write-transaction.
75960 ** If P2 is zero, then a read-transaction is started.
75962 ** P1 is the index of the database file on which the transaction is
75967 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
75969 ** throw an ABORT exception), a statement transaction may also be opened.
75970 ** More specifically, a statement transaction is opened iff the database
75972 ** active statements. A statement transaction allows the changes made by this
75974 ** entire transaction. If no error is encountered, the statement transaction
76032 ** counter. If the statement transaction needs to be rolled back,
76083 ** There must be a read-lock on the database (either a transaction
76114 ** A transaction must be started before executing this opcode.
78903 "cannot change %s wal mode from within a transaction",
78925 /* Open a transaction on the database file. Regardless of the journal
78926 ** mode, this transaction always uses a rollback journal.
78955 ** a transaction.
79739 ** vdbe program will take advantage of the various transaction,
79749 ** transaction.
89677 /* Begin a transaction for database iDb.
89679 ** schema). Open a statement transaction if the table is a virtual
90025 /* Begin a transaction and increment the schema cookie. */
92018 ** * Transaction currently open
92028 zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");
92222 "cannot DETACH database within transaction");
92803 ** BEGIN TRANSACTION
92957 ** transaction on each used database and to verify the schema cookie
96697 ** Begin a transaction
96723 ** Commit a transaction
96740 ** Rollback a transaction
96851 ** This routine starts a new transaction if we are not already within
96852 ** a transaction. If we are already within a transaction, then a checkpoint
96856 ** rollback the whole transaction. For operations where all constraints
96883 ** sure that the statement is protected by a statement transaction.
96903 ** and/or current transaction is rolled back.
100415 ** statement transaction rolled back. If a
100418 ** transaction before fixing the constraint violation, the attempt fails.
100422 ** database transaction is opened. Each time a statement is executed
100425 ** the database, the counter is decremented. When the transaction is
100434 ** transaction is opened, this may cause the mechanism to malfunction.
100481 ** and the statement transaction is rolled back. An exception is an INSERT
100485 ** an INSERT does not open a statement transaction.
100826 ** generated for will not open a statement transaction. */
101126 ** the statement transaction will not be rolled back even if FK
102910 ** any ROLLBACK The current transaction is rolled back and
102921 ** transaction is not rolled back and any
105964 "from within a transaction");
106775 "Safety level may not be changed inside a transaction");
107979 /* If there is not already a read-only (or read-write) transaction opened
107980 ** on the b-tree database, open one now. If a transaction is opened, it
108224 int openedTransaction = 0; /* True if a transaction is opened */
108228 /* If there is not already a read-only (or read-write) transaction opened
108229 ** on the b-tree database, open one now. If a transaction is opened, it
108250 /* Close the transaction, if one was opened. */
116540 sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
116565 ** (possibly synchronous) transaction opened on the main database before
116591 ** locked (as there was more than one active statement when the transaction
116612 /* Begin a transaction and take an exclusive lock on the main database
116704 /* At this point, there is a write transaction open on both the
116707 ** transaction by sqlite3BtreeCopyFile() and the other by an explicit
116760 /* Currently there is an SQL level transaction open on the vacuum
116762 ** was committed at the btree level). So it safe to end the transaction
117685 ** If the virtual table pVtab supports the transaction interface
117686 ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
117736 ** virtual tables that currently have an open transaction. Pass iSavepoint
117742 ** an open transaction is invoked.
126809 0, /* TRANSACTION => nothing */
126956 "PLAN", "BEGIN", "TRANSACTION", "DEFERRED",
127037 /* 11 */ "trans_opt ::= TRANSACTION",
127038 /* 12 */ "trans_opt ::= TRANSACTION nm",
129337 /* (11) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==11);
129338 /* (12) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==12);
129864 testcase( i==26 ); /* TRANSACTION */
131821 /* If a transaction is open, the disconnectAllVtab() call above
131894 /* If a transaction is open, roll it back. This also ensures that if
131895 ** any database schemas have been modified by an uncommitted transaction
132007 ** This is important in case the transaction being rolled back has
132635 ** Register a function to be invoked when a transaction commits.
132686 ** Register a callback to be invoked each time a transaction is rolled
132734 ** a database after committing a transaction if there are nFrame or
132761 ** Register a callback to be invoked each time a transaction is written
132857 ** If a transaction is open on the database being checkpointed, this
134805 /* The blocking transaction has been concluded. Or there never was a
134806 ** blocking transaction. In either case, invoke the notify callback
134836 ** until connection pBlocker concludes its current transaction.
134849 ** the transaction opened by database db has just finished. Locks held
134914 ** is returned the transaction on connection db will still be
135612 ** populated as documents are inserted/updated/deleted in a transaction
135613 ** and used to create a new segment when the transaction is committed.
135614 ** However if this limit is reached midway through a transaction, a new
135818 /* State variables used for validating that the transaction control
139594 ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction
139595 ** always opens a savepoint transaction. And the xSavepoint() method
146429 ** a transaction, causing SQLite to return SQLITE_LOCKED or
146433 ** committing a transaction, the whole transaction will be rolled back.
157077 0, /* xBegin - begin transaction */
157078 0, /* xSync - sync transaction */
157079 0, /* xCommit - commit transaction */
157080 0, /* xRollback - rollback transaction */
158466 ** Writing a transaction containing a large number of operations on
158473 ** single leaf that is modified more than once as part of the transaction
158488 ** large transaction to be broken down into sub-transactions performed
158498 ** transmitted via a wireless network to a mobile device. A transaction
158504 ** An "RBU update" transaction is subject to the following limitations:
158506 ** * The transaction must consist of INSERT, UPDATE and DELETE operations
161070 ** other client appends a transaction to the wal file in the middle of
161502 ** is already a transaction open, so the prepared statement cannot
161911 ** transaction is committed in rollback mode) currently stored on
162010 /* Commit the transaction to the *-oal file. */
162085 ** that the values are always trustworthy within an open transaction.
178279 ** xBegin(): Start of a new transaction.
178282 ** xRollback(): Rollback the transaction.
178294 ** During a write-transaction the fts5_index.c module may cache some data
178300 ** structure is used to record the current transaction state. This information
179649 /* A transaction must be open when this is called. */
