Lines Matching full:transaction
227 ** the aborted transaction. This could lead to database corruption.
830 ** ^If [sqlite3_close()] is invoked while a transaction is open,
831 ** the transaction is automatically rolled back.
1274 ** current transaction. This hint is not guaranteed to be accurate but it
1325 ** write ahead log and shared memory files used for transaction control
1349 ** a write transaction to indicate that, unless it is rolled back for some
1351 ** transaction. This is used by VACUUM operations.
1427 ** of the sqlite3_vfs object changes in the transaction between
2346 ** that is inside an explicit transaction, then the entire transaction
2439 ** when SQLite is in the middle of a large transaction where all the
3565 ** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK],
3591 ** statements that are holding a transaction open.
3965 ** or occurs outside of an explicit transaction, then you can retry the
3967 ** explicit transaction then you should rollback the transaction before
5012 ** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR],
5014 ** transaction might be rolled back automatically. The only way to
5015 ** find out whether SQLite automatically rolled back the transaction after
5080 ** function to be invoked whenever a transaction is [COMMIT | committed].
5084 ** function to be invoked whenever a transaction is [ROLLBACK | rolled back].
5114 ** ^For the purposes of this API, a transaction is said to have been
5117 ** ^The rollback callback is not invoked if a transaction is
5806 ** commit if the transaction continues to completion.)^
5860 ** ^Closing a BLOB shall cause the current transaction to commit
6878 ** ^SQLite holds a write transaction open on the destination database file
6990 ** active write-transaction on the destination database is rolled back.
7077 ** its current transaction, either by committing it or rolling it back.
7086 ** when the blocking connections current transaction is concluded. ^The
7088 ** call that concludes the blocking connections transaction.
7092 ** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
7126 ** When a blocking connections transaction is concluded, there may be
7141 ** connection Y's transaction to be concluded, and similarly connection
7142 ** Y is waiting on connection X's transaction, then neither connection
7150 ** callback on the conclusion of connection B's transaction, and connection
7152 ** A's transaction is concluded. ^Indirect deadlock is also detected, so
7155 ** C's transaction, where connection C is waiting on connection A. ^Any
7222 ** [write-ahead log] (i.e. whenever a transaction is committed in
7264 ** after committing a transaction if there are N or
7432 ** is able to roll back a statement or database transaction, and abandon
9600 u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
9797 int nSavepoint; /* Number of non-transaction savepoints */
9799 i64 nDeferredCons; /* Net deferred constraints this transaction. */
10107 ** transaction, these accesses need to be made via the same database
10266 ** causes the operation in process to fail and for the current transaction
10269 ** but the transaction is not rolled back. FAIL processing means that
10289 #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
10290 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
11116 yDbMask writeMask; /* Start a write transaction on these databases */
22552 /* 35 */ "Transaction",
25046 ** transaction counter in bytes 24-27 of database files are updated
25048 ** occur if a file is updated without also updating the transaction
25052 unsigned char transCntrChng; /* True if the transaction counter changed */
25559 ** transaction crashes and leaves behind hot journals, then any
26591 /* Set up the transaction-counter change checking flags when
26672 ** transaction counter was updated if any part of the database
26673 ** file changed. If the transaction counter is not updated,
27871 ** transaction counter was updated if any part of the database
27872 ** file changed. If the transaction counter is not updated,
28176 ** has changed. If the transaction counter is modified, record that
28188 pFile->transCntrChng = 1; /* The transaction counter has changed */
28394 ** the directory entry for the journal was never created) and the transaction
28628 ** it hence it is OK for the transaction change counter to be
35857 ** journalled during a transaction, or which pages have the "dont-write"
35875 ** start of a transaction, and is thus usually less than a few thousand,
38363 #define WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */
38402 ** snapshot is like a read-transaction. It is the state of the database
38406 ** transaction and releases the lock.
38495 ** the transaction has been written into the rollback journal and
38498 ** (b) The page was a freelist leaf page at the start of the transaction.
38501 ** the database file at the start of the transaction.
38509 ** transaction other than the update of the transaction sequence
38515 ** transaction.
38539 ** equivalent to the database file at the beginning of the transaction.
38541 ** (8) When a transaction is rolled back, the xTruncate method of the VFS
38543 ** the beginning of the transaction. (In some VFSes, the xTruncate
38556 ** of every transaction.
38632 ** * No read or write transaction is active.
38640 ** was) in exclusive-locking mode, a user-level read transaction is
38644 ** it opens a read-transaction on the database and returns to state
38645 ** OPEN after the read-transaction is completed. However a connection
38647 ** this state even after the read-transaction is closed. The only way
38651 ** * A read transaction may be active (but a write-transaction cannot).
38654 ** transaction is not active). The dbOrigSize and dbFileSize variables
38657 ** * Even if a read-transaction is not open, it is guaranteed that
38662 ** The pager moves to this state from READER when a write-transaction
38664 ** required to start a write-transaction are held, but no actual
38667 ** In rollback mode, a RESERVED or (if the transaction was opened with
38670 ** to in this state. If the transaction is committed or rolled back while
38678 ** * A write transaction is active.
38681 ** * If the connection is open in WAL-mode, a WAL write transaction
38696 ** * A write transaction is active.
38709 ** * A write transaction is active.
38721 ** state after the entire transaction has been successfully written into the
38722 ** database file. In this state the transaction may be committed simply
38725 ** layer must either commit or rollback the transaction.
38727 ** * A write transaction is active.
38731 ** commit the transaction. If an error did occur, the caller will need
38732 ** to rollback the transaction.
38759 ** when a read-transaction is next opened on the pager (transitioning
38780 ** statement executed within a transaction. In this case, if the error
38846 ** transaction in another process, causing SQLite to read from the database
38887 ** savepoint and statement transaction in the system. All such structures
38943 ** relinquished on the database file. Each time a transaction is committed,
38945 ** updating the change-counter is omitted for the current transaction.
38948 ** need only update the change-counter once, for the first transaction
38953 ** When PagerCommitPhaseOne() is called to commit a transaction, it may
38958 ** the way in which the journal file is finalized after the transaction is
38969 ** subsequently interrupted transaction that reuses the journal file.
39001 ** write-transaction is opened.
39018 ** During a write-transaction, if pages with page-numbers greater than
39025 ** variable at the start of the transaction. It is used during rollback,
39029 ** Throughout a write-transaction, dbFileSize contains the size of
39031 ** write-transaction is first opened, and updated when VFS calls are made
39035 ** unnecessary calls to xTruncate() after committing a transaction. If,
39036 ** when a transaction is committed, the dbFileSize variable indicates
39040 ** dbFileSize is not used when rolling back a transaction. In this case
39051 ** write-transaction is opened (at the same time as dbFileSize and
39095 Pgno dbOrigSize; /* dbSize before the current transaction */
39337 ** a rollback transaction that switches from journal_mode=off
39726 ** within the current transaction (i.e. if Pager.journalOff==0).
39760 /* At this point the transaction is committed but the write lock
39902 ** database before the transaction began, in pages. Also, pPager->cksumInit
39950 ** of the transaction. Return an error code if anything goes wrong.
40032 ** If zMaster is a NULL pointer (occurs for a single database transaction),
40176 ** as a hot-journal and rolled back the next time a read-transaction
40266 ** the contents of the pager-cache. If a transaction was active when
40287 ** This routine ends a transaction. A transaction is usually ended by
40291 ** database transaction.
40301 ** transaction. Nor will it be considered to be a hot-journal by this
40343 /* Do nothing if the pager does not have an open write transaction
40345 ** is no write-transaction active but a RESERVED or greater lock is
40353 ** read-transaction, this function is called with eState==PAGER_READER
40354 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
40438 ** Execute a rollback if a transaction is active and unlock the
40574 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
40647 ** different from the page content at the start of the transaction.
40705 ** if the page is on the free-list at the start of the transaction, then
40737 ** transaction was first opened. In this case we can mark the page
40748 ** again within this transaction, it will be marked as dirty but
40785 ** file for a transaction involving two databases might be:
40907 ** file in the file-system. This only happens when committing a transaction,
40908 ** or rolling back a transaction (including rolling back a hot-journal).
41131 /* If nRec is 0 and this rollback is of a transaction created by this
41198 ** state prior to the start of the transaction, so invoke the
41200 ** assertion that the transaction counter was modified.
41210 ** before the transaction was committed, then the change-counter
41345 ** written into the log file when a WAL transaction is rolled back.
41373 /* Normally, if a transaction is rolled back, any backup processes are
41378 ** also copied into the backup databases) as part of this transaction,
41387 ** This function is called to rollback a transaction on a WAL database.
41442 /* If a WAL transaction is being committed, there is no point in writing
41476 ** Begin a read transaction on the WAL.
41491 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
41612 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
41615 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
41642 ** (or transaction). No page with a page-number greater than this value
42080 ** This function may only be called when a read-transaction is open on
42140 ** the database file. If a savepoint transaction were rolled back after
42164 ** truncation will be done when the current transaction is committed.
42202 ** If a transaction was in progress when this routine is called, that
42203 ** transaction is rolled back. All outstanding pages are invalidated
42208 ** This function always succeeds. If a transaction is active an attempt
42340 ** previous connection's transaction), and a crash or power-failure
42343 ** transaction), then SQLite may become confused when doing the
42694 ** was when the transaction started, not as it was when "SAVEPOINT sp"
43241 ** and possibly used for a transaction later on. Also, write-access
43320 ** read or write transaction). Check to see if the database
43386 ** transaction and unlock the pager.
43588 ** This function is called at the start of every write transaction.
43595 ** opened to write a rollback log for a transaction. It is not used
43676 ** Begin a write-transaction on the specified pager object. If a
43677 ** write-transaction has already been opened, this function is a no-op.
43685 ** within this transaction will be opened as an in-memory file. This
43687 ** running in exclusive mode) or if the transaction does not require a
43736 ** when it has an open transaction, but never to DBMOD or FINISHED.
43754 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
43770 /* This routine is not called unless a write-transaction has already
43791 ** obtained the necessary locks to begin the write-transaction, but the
43814 /* The transaction journal now exists and we have a RESERVED or an
43816 ** the transaction journal if it is not there already.
43836 ** Otherwise, when the transaction is rolled back, the logic in
44050 ** transaction is committed.
44151 ** This function may only be called while a write-transaction is active in
44178 ** journal (a single database transaction).
44188 ** The only thing that remains to commit the transaction is to finalize
44251 ** was enabled at compile time, and if this transaction meets the
44256 ** * This commit is not part of a multi-file transaction, and
44262 ** is not applicable to this transaction, call sqlite3JournalCreate()
44270 ** created for this transaction.
44301 /* If this transaction has made the database smaller, then all pages
44307 ** that it took at the start of the transaction. Otherwise, the
44389 ** updated to reflect the changes made by the current transaction and
44392 ** be used as a hot-journal and the current transaction rolled back.
44396 ** for hot-journal rollback. Once this is done the transaction is
44417 ** this transaction, the pager is running in exclusive-mode and is
44442 ** If a write transaction is open, then all changes made within the
44443 ** transaction are reverted and the current write-transaction is closed.
44453 ** in-memory cache pages to the state they were in when the transaction
44463 ** current transaction are either expelled from the cache or reverted to
44464 ** their pre-transaction state by re-reading data from the database or
44465 ** WAL files. The WAL transaction is then closed.
44673 ** transaction is rolled back. This is different to calling
44675 ** the transaction or unlock the database, it just restores the
44807 ** A transaction must be active when this routine is called. It used to be
44808 ** required that a statement transaction was not active, but this restriction
44810 ** transaction is active).
44813 ** moved as part of a database reorganization just before the transaction
44815 ** pPg refers to will not be written to again within this transaction.
44906 ** to exist, in case the transaction needs to roll back. Use pPgOld
44926 ** this transaction, it may be written to the database file before
45472 ** To start a read transaction, the reader records the index of the last
45627 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
45664 u32 iChange; /* Counter incremented each transaction */
45784 u8 writeLock; /* True if in a write transaction */
45790 WalIndexHdr hdr; /* Wal-index header for current transaction */
46359 ** must have exited unexpectedly in the middle of a transaction (after
46361 ** Remove the remnants of that writers uncommitted transaction from
47384 ** Attempt to start a read transaction. This might fail due to a race or
47423 ** When the read transaction is completed, the caller must release the
47609 ** Begin a read transaction on the database.
47618 ** transaction, then *pChanged is set to 1 before returning. The
47637 ** Finish with a read transaction. All this does is release the
47650 ** current read transaction is configured to use the WAL.
47667 /* This routine is only be called from within a read transaction. */
47689 ** current read transaction was opened. Values added after the
47690 ** read transaction was opened may have been written incorrectly -
47692 ** that any slots written before the current read transaction was
47704 ** table after the current read-transaction had started.
47781 ** This function starts a write transaction on the WAL.
47783 ** A read transaction must have already been started by a prior call
47787 ** the read transaction was started, then it is not possible for this
47789 ** returns SQLITE_BUSY in that case and no write transaction is started.
47796 /* Cannot start a write transaction without first holding a read
47797 ** transaction. */
47814 ** time the read transaction on this connection was started, then
47827 ** End a write transaction. The commit has already been done. This
47841 ** function moves the write-pointer back to the start of the transaction.
47844 ** to the WAL since the start of the transaction. If the callback returns
47874 ** page 1 is never written to the log until the transaction is
47913 /* This savepoint was opened immediately after the write-transaction
47964 ** to handle if this transaction is rolled back.
48089 /* If this frame set completes a transaction, then nTruncate>0. If
48090 ** nTruncate==0 then this frame set does not complete the transaction. */
48173 /* If this is the end of a transaction, then we might need to pad
48174 ** the transaction and/or sync the WAL file.
48177 ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL
48202 /* If this frame set completes the first transaction in the WAL and
48774 ** from this list when a transaction is committed or rolled back, or when
48828 ** of the Btree structure. At most one of these may open a write transaction,
48862 ** 1) The current writer (BtShared.pWriter) concludes its transaction, OR
48866 ** transaction.
48880 u8 inTransaction; /* Transaction state */
48894 Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */
48899 Btree *pWriter; /* Btree with currently open write transaction */
49074 /* A bunch of assert() statements to check the transaction state variables
49624 ** transaction on this file. And, obviously, for this to be so there
49625 ** must be an open write transaction on the file itself.
49747 ** transaction. If it does not, then the BTS_PENDING flag
49779 ** transaction. If there currently exists a writer, and p is not
49902 ** transaction, a problem comes up. If the page is not journalled when
49913 ** at the end of every transaction.
49944 ** invoked at the conclusion of each write-transaction.
51036 ** the transaction, for each page restored this routine is called.
51432 /* Rollback any active transaction and free the handle structure.
51840 ** of a transaction but there is a read lock on the database, then
51844 ** If there is a transaction in progress, this routine is a no-op.
51903 ** Attempt to start a new transaction. A write-transaction
51905 ** transaction. If the second argument is 2 or more and exclusive
51906 ** transaction is started, meaning that no other process is allowed
51907 ** to access the database. A preexisting transaction may not be
51909 ** exclusivity flag only works for a new transaction.
51911 ** A write-transaction must be started before attempting any
51913 ** will work unless a transaction is started first:
51945 /* If the btree is already in a write-transaction, or it
51946 ** is already in a read-transaction and a read-transaction
51960 /* If another database handle has already opened a write transaction
51961 ** on this shared-btree structure and a second write transaction is
51984 /* Any read-only or read-write transaction implies a read-lock on
51986 ** on page 1, the transaction cannot be opened. */
52047 ** re-read the database size from page 1 if a savepoint or transaction
52048 ** rollback occurs within the transaction.
52387 ** A write-transaction must be opened before calling this function.
52415 ** This routine is called prior to sqlite3PagerCommit when a transaction
52493 ** disk and we are still holding all locks, so the transaction has not
52497 ** This call is a no-op if no write-transaction is currently active on pBt.
52502 ** (single database transaction).
52508 ** the write-transaction for this database file is to delete the journal.
52532 ** at the conclusion of a transaction.
52541 ** handle, downgrade to a read-only transaction. The other statements
52546 /* If the handle had any kind of transaction open, decrement the
52547 ** transaction count of the shared btree. If the transaction count
52558 /* Set the current transaction state to TRANS_NONE and unlock the
52559 ** pager if this call closed the only read or write transaction. */
52568 ** Commit the transaction currently in progress.
52576 ** the rollback journal (which causes the transaction to commit) and
52582 ** is non-zero then this b-tree transaction is part of a multi-file
52583 ** transaction. In this case, the transaction has already been committed
52587 ** transaction has been closed. This is quite safe, as the pager will have
52599 /* If the handle has a write-transaction open, commit the shared-btrees
52600 ** transaction and set the shared state to TRANS_READ.
52690 ** Rollback the transaction in progress. All cursors will be
52745 ** back independently of the main transaction. You must start a transaction
52747 ** if the main transaction commits or rolls back.
52752 ** can be rolled back without having to rollback the entire transaction.
52754 ** A statement sub-transaction is implemented as an anonymous savepoint. The
52770 /* At the pager level, a statement transaction is a savepoint with
52773 ** such savepoints while the statement transaction savepoint is active.
52788 ** contents of the entire transaction are rolled back. This is different
52789 ** from a normal transaction rollback, as no locks are released and the
52790 ** transaction remains open.
52808 ** when the transaction started, so we know that the value at offset
52820 ** the caller already has at least a read-only transaction open
52822 ** the caller is assumed to have an open write transaction.
52840 ** 4: There must be an active transaction.
52868 /* Assert that the caller has opened the required transaction. */
53357 ** 4) there is no open write-transaction, and
56773 ** has a read or write transaction open on the database.
57306 ** A read-only or read-write transaction must be opened before calling
57445 ** Return non-zero if a transaction is active.
57457 ** transaction on the shared-cache the argument Btree is connected to.
57478 ** Return non-zero if a read (or write) transaction is active.
57592 ** (b) there is a read/write transaction open,
57693 int bDestLocked; /* True once a write-transaction is open on pDest */
58008 /* If the source pager is currently in a write-transaction, return
58025 /* If there is no open read-transaction on the source database, open
58026 ** one now. If a transaction is opened here, then it will be closed
58169 /* Finish committing the transaction to the destination database. */
58178 /* If bCloseTrans is true, then this function opened a read transaction
58179 ** on the source database. Close the read transaction here. There is
58181 ** "committing" a read-only transaction cannot fail.
58232 /* If a transaction is still open on the Btree, roll it back. */
58288 ** has been modified by a transaction on the source pager. Copy
58325 ** Copy the complete content of pBtFrom into pBtTo. A transaction
58329 ** goes wrong, the transaction on pTo is rolled back. If successful, the
58330 ** transaction is committed before returning.
59886 ** throw an ABORT exception (causing the statement, but not entire transaction
60626 ** and reset(). Inserts are grouped into a transaction.
61274 ** A read or write transaction may or may not be active on database handle
61275 ** db. If a transaction is active, commit it. If there is a
61276 ** write-transaction spanning more than one database file, this routine
61281 int nTrans = 0; /* Number of databases with an active write-transaction */
61293 ** virtual module tables written in this transaction. This has to
61296 ** to the transaction.
61303 ** one database file has an open write transaction, a master journal
61327 ** TEMP database) has a transaction active. There is no need for the
61361 /* The complex case - There is a multi-file write-transaction active.
61362 ** This requires a master journal file to ensure the transaction is
61414 /* Write the name of each database file in the transaction into the new
61455 /* Sync all the db files involved in the transaction. The same call
61478 /* Delete the master journal file. This commits the transaction. After
61480 ** transaction files are deleted.
61493 ** transaction is already guaranteed, but some stray 'cold' journals
61544 ** If the Vdbe passed as the first argument opened a statement-transaction,
61547 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
61548 ** statement transaction is commtted.
61558 ** statement transaction that should be closed here. The only exception
61597 /* If the statement transaction is being rolled back, also restore the
61599 ** the statement transaction was opened. */
61608 ** This function is called when a transaction opened by the database
61648 ** transaction will be committed or rolled back as a result of the
61659 ** state. We need to rollback the statement transaction, if there is
61660 ** one, or the complete transaction if there is no statement transaction.
61690 ** transaction must be rolled back to restore the database to a
61694 ** a statement or transaction rollback operation. If the error
61704 /* We are forced to roll back the active transaction. Before doing
61720 ** VM, then we do either a commit or rollback of the current transaction.
61740 ** key constraints to hold up the transaction. This means a commit
61770 /* If eStatementOp is non-zero, then a statement transaction needs to
61790 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
63087 ** This function is called after a transaction has been committed. It
64937 ** the number of non-transaction savepoints currently in the
65695 ** whether or not to rollback the current transaction. Do not rollback
65698 ** VDBE, but do not rollback the transaction.
65999 ** transaction. It needs to be rolled back. */
66009 ** opens a statement transaction may invoke this opcode.
66011 ** In case this is such a statement, close any statement transaction
66014 ** If the open statement-transaction is not closed here, then the user
66015 ** may step another VM that opens its own statement transaction. This
66018 ** The statement transaction is never a top-level transaction. Hence
67531 ** transaction, then there cannot be any savepoints.
67550 /* This call is Ok even if this savepoint is actually a transaction
67552 ** If this is a transaction savepoint being opened, it is guaranteed
67566 /* If there is no open transaction, then mark this as a special
67567 ** "transaction savepoint". */
67606 /* Determine whether or not this is a transaction savepoint. If so,
67607 ** and this is a RELEASE command, then the current transaction
67702 ** still running, and a transaction is active, return an error indicating
67705 sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
67714 sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
67743 (!u.as.desiredAutoCommit)?"cannot start a transaction within a transaction":(
67744 (u.as.iRollback)?"cannot rollback - no transaction is active":
67745 "cannot commit - no transaction is active"));
67752 /* Opcode: Transaction P1 P2 * * *
67754 ** Begin a transaction. The transaction ends when a Commit or Rollback
67756 ** transaction might also be rolled back if an error is encountered.
67758 ** P1 is the index of the database file on which the transaction is
67763 ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is
67764 ** obtained on the database file when a write-transaction is started. No
67765 ** other process can start another write transaction while this transaction is
67766 ** underway. Starting a write transaction also creates a rollback journal. A
67767 ** write transaction must be started before any changes can be made to the
67771 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
67773 ** throw an ABORT exception), a statement transaction may also be opened.
67774 ** More specifically, a statement transaction is opened iff the database
67776 ** active statements. A statement transaction allows the changes made by this
67778 ** entire transaction. If no error is encountered, the statement transaction
67819 ** counter. If the statement transaction needs to be rolled back,
67835 ** There must be a read-lock on the database (either a transaction
67866 ** A transaction must be started before executing this opcode.
67913 ** Either a transaction needs to have been started or an OP_Open needs
70505 "cannot change %s wal mode from within a transaction",
70527 /* Open a transaction on the database file. Regardless of the journal
70528 ** mode, this transaction always uses a rollback journal.
70558 ** a transaction.
71324 ** vdbe program will take advantage of the various transaction,
71334 ** transaction.
71337 {OP_Transaction, 0, 0, 0}, /* 0: Start a transaction */
78939 /* Begin a transaction and code the VerifyCookie for database iDb.
78941 ** schema). Open a statement transaction if the table is a virtual
79283 /* Begin a transaction and increment the schema cookie. */
80512 ** * Transaction currently open
80522 zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");
80702 "cannot DETACH database within transaction");
81254 ** BEGIN TRANSACTION
81379 ** transaction on each used database and to verify the schema cookie
81632 ** if there were schema changes during the transaction or if a
84640 ** Begin a transaction
84666 ** Commit a transaction
84683 ** Rollback a transaction
84754 ** a read-transaction for all named database files.
84820 ** This routine starts a new transaction if we are not already within
84821 ** a transaction. If we are already within a transaction, then a checkpoint
84825 ** rollback the whole transaction. For operations where all constraints
84852 ** sure that the statement is protected by a statement transaction.
84872 ** and/or current transaction is rolled back.
87802 ** is returned and the current statement transaction rolled back. If a
87805 ** transaction before fixing the constraint violation, the attempt fails.
87809 ** database transaction is opened. Each time a statement is executed
87812 ** the database, the counter is decremented. When the transaction is
87821 ** transaction is opened, this may cause the mechanism to malfunction.
87867 ** and the statement transaction is rolled back. An exception is an INSERT
87871 ** an INSERT does not open a statement transaction.
88202 ** generated for will not open a statement transaction. */
90099 ** any ROLLBACK The current transaction is rolled back and
90110 ** transaction is not rolled back and any
92215 "from within a transaction");
92972 "Safety level may not be changed inside a transaction");
93891 /* If there is not already a read-only (or read-write) transaction opened
93892 ** on the b-tree database, open one now. If a transaction is opened, it
94130 int openedTransaction = 0; /* True if a transaction is opened */
94134 /* If there is not already a read-only (or read-write) transaction opened
94135 ** on the b-tree database, open one now. If a transaction is opened, it
94156 /* Close the transaction, if one was opened. */
101260 sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
101285 ** (possibly synchronous) transaction opened on the main database before
101311 ** locked (as there was more than one active statement when the transaction
101332 /* Begin a transaction and take an exclusive lock on the main database
101420 /* At this point, there is a write transaction open on both the
101423 ** transaction by sqlite3BtreeCopyFile() and the other by an explicit
101475 /* Currently there is an SQL level transaction open on the vacuum
101477 ** was committed at the btree level). So it safe to end the transaction
102322 ** If the virtual table pVtab supports the transaction interface
102323 ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
102371 ** virtual tables that currently have an open transaction. Pass iSavepoint
102377 ** an open transaction is invoked.
108607 0, /* TRANSACTION => nothing */
108747 "PLAN", "BEGIN", "TRANSACTION", "DEFERRED",
108827 /* 11 */ "trans_opt ::= TRANSACTION",
108828 /* 12 */ "trans_opt ::= TRANSACTION nm",
111008 /* (11) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==11);
111009 /* (12) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==12);
111530 testcase( i==26 ); /* TRANSACTION */
113213 /* If a transaction is open, the ResetInternalSchema() call above
113788 ** Register a function to be invoked when a transaction commits.
113825 ** Register a callback to be invoked each time a transaction is rolled
113866 ** a database after committing a transaction if there are nFrame or
113890 ** Register a callback to be invoked each time a transaction is written
113970 ** If a transaction is open on the database being checkpointed, this
115691 /* The blocking transaction has been concluded. Or there never was a
115692 ** blocking transaction. In either case, invoke the notify callback
115722 ** until connection pBlocker concludes its current transaction.
115735 ** the transaction opened by database db has just finished. Locks held
115800 ** is returned the transaction on connection db will still be
116483 ** populated as documents are inserted/updated/deleted in a transaction
116484 ** and used to create a new segment when the transaction is committed.
116485 ** However if this limit is reached midway through a transaction, a new
116669 /* State variables used for validating that the transaction control
120042 ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction
120043 ** always opens a savepoint transaction. And the xSavepoint() method
125517 ** a transaction, the whole transaction will be rolled back. And this is
133032 0, /* xBegin - begin transaction */
133033 0, /* xSync - sync transaction */
133034 0, /* xCommit - commit transaction */
133035 0, /* xRollback - rollback transaction */
