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",
25039 ** transaction counter in bytes 24-27 of database files are updated
25041 ** occur if a file is updated without also updating the transaction
25045 unsigned char transCntrChng; /* True if the transaction counter changed */
25541 ** transaction crashes and leaves behind hot journals, then any
26573 /* Set up the transaction-counter change checking flags when
26654 ** transaction counter was updated if any part of the database
26655 ** file changed. If the transaction counter is not updated,
27853 ** transaction counter was updated if any part of the database
27854 ** file changed. If the transaction counter is not updated,
28158 ** has changed. If the transaction counter is modified, record that
28170 pFile->transCntrChng = 1; /* The transaction counter has changed */
28376 ** the directory entry for the journal was never created) and the transaction
28608 ** it hence it is OK for the transaction change counter to be
35829 ** journalled during a transaction, or which pages have the "dont-write"
35847 ** start of a transaction, and is thus usually less than a few thousand,
38335 #define WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */
38374 ** snapshot is like a read-transaction. It is the state of the database
38378 ** transaction and releases the lock.
38467 ** the transaction has been written into the rollback journal and
38470 ** (b) The page was a freelist leaf page at the start of the transaction.
38473 ** the database file at the start of the transaction.
38481 ** transaction other than the update of the transaction sequence
38487 ** transaction.
38511 ** equivalent to the database file at the beginning of the transaction.
38513 ** (8) When a transaction is rolled back, the xTruncate method of the VFS
38515 ** the beginning of the transaction. (In some VFSes, the xTruncate
38528 ** of every transaction.
38604 ** * No read or write transaction is active.
38612 ** was) in exclusive-locking mode, a user-level read transaction is
38616 ** it opens a read-transaction on the database and returns to state
38617 ** OPEN after the read-transaction is completed. However a connection
38619 ** this state even after the read-transaction is closed. The only way
38623 ** * A read transaction may be active (but a write-transaction cannot).
38626 ** transaction is not active). The dbOrigSize and dbFileSize variables
38629 ** * Even if a read-transaction is not open, it is guaranteed that
38634 ** The pager moves to this state from READER when a write-transaction
38636 ** required to start a write-transaction are held, but no actual
38639 ** In rollback mode, a RESERVED or (if the transaction was opened with
38642 ** to in this state. If the transaction is committed or rolled back while
38650 ** * A write transaction is active.
38653 ** * If the connection is open in WAL-mode, a WAL write transaction
38668 ** * A write transaction is active.
38681 transaction is active.
38693 ** state after the entire transaction has been successfully written into the
38694 ** database file. In this state the transaction may be committed simply
38697 ** layer must either commit or rollback the transaction.
38699 ** * A write transaction is active.
38703 ** commit the transaction. If an error did occur, the caller will need
38704 ** to rollback the transaction.
38731 ** when a read-transaction is next opened on the pager (transitioning
38752 ** statement executed within a transaction. In this case, if the error
38818 ** transaction in another process, causing SQLite to read from the database
38859 ** savepoint and statement transaction in the system. All such structures
38915 ** relinquished on the database file. Each time a transaction is committed,
38917 ** updating the change-counter is omitted for the current transaction.
38920 ** need only update the change-counter once, for the first transaction
38925 ** When PagerCommitPhaseOne() is called to commit a transaction, it may
38930 ** the way in which the journal file is finalized after the transaction is
38941 ** subsequently interrupted transaction that reuses the journal file.
38973 ** write-transaction is opened.
38990 ** During a write-transaction, if pages with page-numbers greater than
38997 ** variable at the start of the transaction. It is used during rollback,
39001 ** Throughout a write-transaction, dbFileSize contains the size of
39003 ** write-transaction is first opened, and updated when VFS calls are made
39007 ** unnecessary calls to xTruncate() after committing a transaction. If,
39008 ** when a transaction is committed, the dbFileSize variable indicates
39012 ** dbFileSize is not used when rolling back a transaction. In this case
39023 ** write-transaction is opened (at the same time as dbFileSize and
39067 Pgno dbOrigSize; /* dbSize before the current transaction */
39309 ** a rollback transaction that switches from journal_mode=off
39698 ** within the current transaction (i.e. if Pager.journalOff==0).
39732 /* At this point the transaction is committed but the write lock
39874 ** database before the transaction began, in pages. Also, pPager->cksumInit
39922 ** of the transaction. Return an error code if anything goes wrong.
40004 ** If zMaster is a NULL pointer (occurs for a single database transaction),
40148 ** as a hot-journal and rolled back the next time a read-transaction
40238 ** the contents of the pager-cache. If a transaction was active when
40259 ** This routine ends a transaction. A transaction is usually ended by
40263 ** database transaction.
40273 ** transaction. Nor will it be considered to be a hot-journal by this
40315 /* Do nothing if the pager does not have an open write transaction
40317 ** is no write-transaction active but a RESERVED or greater lock is
40325 ** read-transaction, this function is called with eState==PAGER_READER
40326 ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
40410 ** Execute a rollback if a transaction is active and unlock the
40546 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
40619 ** different from the page content at the start of the transaction.
40677 ** if the page is on the free-list at the start of the transaction, then
40709 ** transaction was first opened. In this case we can mark the page
40720 ** again within this transaction, it will be marked as dirty but
40757 ** file for a transaction involving two databases might be:
40879 ** file in the file-system. This only happens when committing a transaction,
40880 ** or rolling back a transaction (including rolling back a hot-journal).
41103 /* If nRec is 0 and this rollback is of a transaction created by this
41170 ** state prior to the start of the transaction, so invoke the
41172 ** assertion that the transaction counter was modified.
41182 ** before the transaction was committed, then the change-counter
41317 ** written into the log file when a WAL transaction is rolled back.
41345 /* Normally, if a transaction is rolled back, any backup processes are
41350 ** also copied into the backup databases) as part of this transaction,
41359 ** This function is called to rollback a transaction on a WAL database.
41414 /* If a WAL transaction is being committed, there is no point in writing
41448 ** Begin a read transaction on the WAL.
41463 ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
41584 ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
41587 ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
41614 ** (or transaction). No page with a page-number greater than this value
42052 ** This function may only be called when a read-transaction is open on
42112 ** the database file. If a savepoint transaction were rolled back after
42136 ** truncation will be done when the current transaction is committed.
42174 ** If a transaction was in progress when this routine is called, that
42175 ** transaction is rolled back. All outstanding pages are invalidated
42180 ** This function always succeeds. If a transaction is active an attempt
42312 ** previous connection's transaction), and a crash or power-failure
42315 ** transaction), then SQLite may become confused when doing the
42666 ** was when the transaction started, not as it was when "SAVEPOINT sp"
43213 ** and possibly used for a transaction later on. Also, write-access
43292 ** read or write transaction). Check to see if the database
43358 ** transaction and unlock the pager.
43560 ** This function is called at the start of every write transaction.
43567 ** opened to write a rollback log for a transaction. It is not used
43648 ** Begin a write-transaction on the specified pager object. If a
43649 ** write-transaction has already been opened, this function is a no-op.
43657 ** within this transaction will be opened as an in-memory file. This
43659 ** running in exclusive mode) or if the transaction does not require a
43708 ** when it has an open transaction, but never to DBMOD or FINISHED.
43726 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
43742 /* This routine is not called unless a write-transaction has already
43763 ** obtained the necessary locks to begin the write-transaction, but the
43786 /* The transaction journal now exists and we have a RESERVED or an
43788 ** the transaction journal if it is not there already.
43808 ** Otherwise, when the transaction is rolled back, the logic in
44022 ** transaction is committed.
44123 ** This function may only be called while a write-transaction is active in
44150 ** journal (a single database transaction).
44160 ** The only thing that remains to commit the transaction is to finalize
44223 ** was enabled at compile time, and if this transaction meets the
44228 ** * This commit is not part of a multi-file transaction, and
44234 ** is not applicable to this transaction, call sqlite3JournalCreate()
44242 ** created for this transaction.
44273 /* If this transaction has made the database smaller, then all pages
44279 ** that it took at the start of the transaction. Otherwise, the
44361 ** updated to reflect the changes made by the current transaction and
44364 ** be used as a hot-journal and the current transaction rolled back.
44368 ** for hot-journal rollback. Once this is done the transaction is
44389 ** this transaction, the pager is running in exclusive-mode and is
44414 ** If a write transaction is open, then all changes made within the
44415 ** transaction are reverted and the current write-transaction is closed.
44425 ** in-memory cache pages to the state they were in when the transaction
44435 ** current transaction are either expelled from the cache or reverted to
44436 ** their pre-transaction state by re-reading data from the database or
44437 ** WAL files. The WAL transaction is then closed.
44645 ** transaction is rolled back. This is different to calling
44647 ** the transaction or unlock the database, it just restores the
44779 ** A transaction must be active when this routine is called. It used to be
44780 ** required that a statement transaction was not active, but this restriction
44782 ** transaction is active).
44785 ** moved as part of a database reorganization just before the transaction
44787 ** pPg refers to will not be written to again within this transaction.
44878 ** to exist, in case the transaction needs to roll back. Use pPgOld
44898 ** this transaction, it may be written to the database file before
45444 ** To start a read transaction, the reader records the index of the last
45599 ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
45636 u32 iChange; /* Counter incremented each transaction */
45756 u8 writeLock; /* True if in a write transaction */
45762 WalIndexHdr hdr; /* Wal-index header for current transaction */
46331 ** must have exited unexpectedly in the middle of a transaction (after
46333 ** Remove the remnants of that writers uncommitted transaction from
47356 ** Attempt to start a read transaction. This might fail due to a race or
47395 ** When the read transaction is completed, the caller must release the
47581 ** Begin a read transaction on the database.
47590 ** transaction, then *pChanged is set to 1 before returning. The
47609 ** Finish with a read transaction. All this does is release the
47622 ** current read transaction is configured to use the WAL.
47639 /* This routine is only be called from within a read transaction. */
47661 ** current read transaction was opened. Values added after the
47662 ** read transaction was opened may have been written incorrectly -
47664 ** that any slots written before the current read transaction was
47676 ** table after the current read-transaction had started.
47753 ** This function starts a write transaction on the WAL.
47755 ** A read transaction must have already been started by a prior call
47759 ** the read transaction was started, then it is not possible for this
47761 ** returns SQLITE_BUSY in that case and no write transaction is started.
47768 /* Cannot start a write transaction without first holding a read
47769 ** transaction. */
47786 ** time the read transaction on this connection was started, then
47799 ** End a write transaction. The commit has already been done. This
47813 ** function moves the write-pointer back to the start of the transaction.
47816 ** to the WAL since the start of the transaction. If the callback returns
47846 ** page 1 is never written to the log until the transaction is
47885 /* This savepoint was opened immediately after the write-transaction
47936 ** to handle if this transaction is rolled back.
48061 /* If this frame set completes a transaction, then nTruncate>0. If
48062 ** nTruncate==0 then this frame set does not complete the transaction. */
48145 /* If this is the end of a transaction, then we might need to pad
48146 ** the transaction and/or sync the WAL file.
48149 ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL
48174 /* If this frame set completes the first transaction in the WAL and
48746 ** from this list when a transaction is committed or rolled back, or when
48800 ** of the Btree structure. At most one of these may open a write transaction,
48834 ** 1) The current writer (BtShared.pWriter) concludes its transaction, OR
48838 ** transaction.
48852 u8 inTransaction; /* Transaction state */
48866 Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */
48871 Btree *pWriter; /* Btree with currently open write transaction */
49046 /* A bunch of assert() statements to check the transaction state variables
49596 ** transaction on this file. And, obviously, for this to be so there
49597 ** must be an open write transaction on the file itself.
49719 ** transaction. If it does not, then the BTS_PENDING flag
49751 ** transaction. If there currently exists a writer, and p is not
49874 ** transaction, a problem comes up. If the page is not journalled when
49885 ** at the end of every transaction.
49916 ** invoked at the conclusion of each write-transaction.
51008 ** the transaction, for each page restored this routine is called.
51404 /* Rollback any active transaction and free the handle structure.
51812 ** of a transaction but there is a read lock on the database, then
51816 ** If there is a transaction in progress, this routine is a no-op.
51875 ** Attempt to start a new transaction. A write-transaction
51877 ** transaction. If the second argument is 2 or more and exclusive
51878 ** transaction is started, meaning that no other process is allowed
51879 ** to access the database. A preexisting transaction may not be
51881 ** exclusivity flag only works for a new transaction.
51883 ** A write-transaction must be started before attempting any
51885 ** will work unless a transaction is started first:
51917 /* If the btree is already in a write-transaction, or it
51918 ** is already in a read-transaction and a read-transaction
51932 /* If another database handle has already opened a write transaction
51933 ** on this shared-btree structure and a second write transaction is
51956 /* Any read-only or read-write transaction implies a read-lock on
51958 ** on page 1, the transaction cannot be opened. */
52019 ** re-read the database size from page 1 if a savepoint or transaction
52020 ** rollback occurs within the transaction.
52359 ** A write-transaction must be opened before calling this function.
52387 ** This routine is called prior to sqlite3PagerCommit when a transaction
52465 ** disk and we are still holding all locks, so the transaction has not
52469 ** This call is a no-op if no write-transaction is currently active on pBt.
52474 ** (single database transaction).
52480 ** the write-transaction for this database file is to delete the journal.
52504 ** at the conclusion of a transaction.
52513 ** handle, downgrade to a read-only transaction. The other statements
52518 /* If the handle had any kind of transaction open, decrement the
52519 ** transaction count of the shared btree. If the transaction count
52530 /* Set the current transaction state to TRANS_NONE and unlock the
52531 ** pager if this call closed the only read or write transaction. */
52540 ** Commit the transaction currently in progress.
52548 ** the rollback journal (which causes the transaction to commit) and
52554 ** is non-zero then this b-tree transaction is part of a multi-file
52555 ** transaction. In this case, the transaction has already been committed
52559 ** transaction has been closed. This is quite safe, as the pager will have
52571 /* If the handle has a write-transaction open, commit the shared-btrees
52572 ** transaction and set the shared state to TRANS_READ.
52662 ** Rollback the transaction in progress. All cursors will be
52717 ** back independently of the main transaction. You must start a transaction
52719 ** if the main transaction commits or rolls back.
52724 ** can be rolled back without having to rollback the entire transaction.
52726 ** A statement sub-transaction is implemented as an anonymous savepoint. The
52742 /* At the pager level, a statement transaction is a savepoint with
52745 ** such savepoints while the statement transaction savepoint is active.
52760 ** contents of the entire transaction are rolled back. This is different
52761 ** from a normal transaction rollback, as no locks are released and the
52762 ** transaction remains open.
52780 ** when the transaction started, so we know that the value at offset
52792 ** the caller already has at least a read-only transaction open
52794 ** the caller is assumed to have an open write transaction.
52812 ** 4: There must be an active transaction.
52840 /* Assert that the caller has opened the required transaction. */
53329 ** 4) there is no open write-transaction, and
56745 ** has a read or write transaction open on the database.
57278 ** A read-only or read-write transaction must be opened before calling
57417 ** Return non-zero if a transaction is active.
57429 ** transaction on the shared-cache the argument Btree is connected to.
57450 ** Return non-zero if a read (or write) transaction is active.
57564 ** (b) there is a read/write transaction open,
57665 int bDestLocked; /* True once a write-transaction is open on pDest */
57980 /* If the source pager is currently in a write-transaction, return
57997 /* If there is no open read-transaction on the source database, open
57998 ** one now. If a transaction is opened here, then it will be closed
58141 /* Finish committing the transaction to the destination database. */
58150 /* If bCloseTrans is true, then this function opened a read transaction
58151 ** on the source database. Close the read transaction here. There is
58153 ** "committing" a read-only transaction cannot fail.
58204 /* If a transaction is still open on the Btree, roll it back. */
58260 ** has been modified by a transaction on the source pager. Copy
58297 ** Copy the complete content of pBtFrom into pBtTo. A transaction
58301 ** goes wrong, the transaction on pTo is rolled back. If successful, the
58302 ** transaction is committed before returning.
59858 ** throw an ABORT exception (causing the statement, but not entire transaction
60598 ** and reset(). Inserts are grouped into a transaction.
61246 ** A read or write transaction may or may not be active on database handle
61247 ** db. If a transaction is active, commit it. If there is a
61248 ** write-transaction spanning more than one database file, this routine
61253 int nTrans = 0; /* Number of databases with an active write-transaction */
61265 ** virtual module tables written in this transaction. This has to
61268 ** to the transaction.
61275 ** one database file has an open write transaction, a master journal
61299 ** TEMP database) has a transaction active. There is no need for the
61333 /* The complex case - There is a multi-file write-transaction active.
61334 ** This requires a master journal file to ensure the transaction is
61386 /* Write the name of each database file in the transaction into the new
61427 /* Sync all the db files involved in the transaction. The same call
61450 /* Delete the master journal file. This commits the transaction. After
61452 ** transaction files are deleted.
61465 ** transaction is already guaranteed, but some stray 'cold' journals
61516 ** If the Vdbe passed as the first argument opened a statement-transaction,
61519 ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
61520 ** statement transaction is commtted.
61530 ** statement transaction that should be closed here. The only exception
61569 /* If the statement transaction is being rolled back, also restore the
61571 ** the statement transaction was opened. */
61580 ** This function is called when a transaction opened by the database
61620 ** transaction will be committed or rolled back as a result of the
61631 ** state. We need to rollback the statement transaction, if there is
61632 ** one, or the complete transaction if there is no statement transaction.
61662 ** transaction must be rolled back to restore the database to a
61666 ** a statement or transaction rollback operation. If the error
61676 /* We are forced to roll back the active transaction. Before doing
61692 ** VM, then we do either a commit or rollback of the current transaction.
61712 ** key constraints to hold up the transaction. This means a commit
61742 /* If eStatementOp is non-zero, then a statement transaction needs to
61762 /* If this was an INSERT, UPDATE or DELETE and no statement transaction
63059 ** This function is called after a transaction has been committed. It
64909 ** the number of non-transaction savepoints currently in the
65667 ** whether or not to rollback the current transaction. Do not rollback
65670 ** VDBE, but do not rollback the transaction.
65971 ** transaction. It needs to be rolled back. */
65981 ** opens a statement transaction may invoke this opcode.
65983 ** In case this is such a statement, close any statement transaction
65986 ** If the open statement-transaction is not closed here, then the user
65987 ** may step another VM that opens its own statement transaction. This
65990 ** The statement transaction is never a top-level transaction. Hence
67503 ** transaction, then there cannot be any savepoints.
67522 /* This call is Ok even if this savepoint is actually a transaction
67524 ** If this is a transaction savepoint being opened, it is guaranteed
67538 /* If there is no open transaction, then mark this as a special
67539 ** "transaction savepoint". */
67578 /* Determine whether or not this is a transaction savepoint. If so,
67579 ** and this is a RELEASE command, then the current transaction
67674 ** still running, and a transaction is active, return an error indicating
67677 sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
67686 sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
67715 (!u.as.desiredAutoCommit)?"cannot start a transaction within a transaction":(
67716 (u.as.iRollback)?"cannot rollback - no transaction is active":
67717 "cannot commit - no transaction is active"));
67724 /* Opcode: Transaction P1 P2 * * *
67726 ** Begin a transaction. The transaction ends when a Commit or Rollback
67728 ** transaction might also be rolled back if an error is encountered.
67730 ** P1 is the index of the database file on which the transaction is
67735 ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is
67736 ** obtained on the database file when a write-transaction is started. No
67737 ** other process can start another write transaction while this transaction is
67738 ** underway. Starting a write transaction also creates a rollback journal. A
67739 ** write transaction must be started before any changes can be made to the
67743 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
67745 ** throw an ABORT exception), a statement transaction may also be opened.
67746 ** More specifically, a statement transaction is opened iff the database
67748 ** active statements. A statement transaction allows the changes made by this
67750 ** entire transaction. If no error is encountered, the statement transaction
67791 ** counter. If the statement transaction needs to be rolled back,
67807 transaction
67838 ** A transaction must be started before executing this opcode.
67885 ** Either a transaction needs to have been started or an OP_Open needs
70477 "cannot change %s wal mode from within a transaction",
70499 /* Open a transaction on the database file. Regardless of the journal
70500 ** mode, this transaction always uses a rollback journal.
70530 ** a transaction.
71296 ** vdbe program will take advantage of the various transaction,
71306 ** transaction.
71309 {OP_Transaction, 0, 0, 0}, /* 0: Start a transaction */
78903 /* Begin a transaction and code the VerifyCookie for database iDb.
78905 ** schema). Open a statement transaction if the table is a virtual
79247 /* Begin a transaction and increment the schema cookie. */
80476 ** * Transaction currently open
80486 zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");
80666 "cannot DETACH database within transaction");
81218 ** BEGIN TRANSACTION
81343 ** transaction on each used database and to verify the schema cookie
81596 ** if there were schema changes during the transaction or if a
84604 ** Begin a transaction
84630 ** Commit a transaction
84647 ** Rollback a transaction
84718 ** a read-transaction for all named database files.
84784 ** This routine starts a new transaction if we are not already within
84785 ** a transaction. If we are already within a transaction, then a checkpoint
84789 ** rollback the whole transaction. For operations where all constraints
84816 ** sure that the statement is protected by a statement transaction.
84836 ** and/or current transaction is rolled back.
87766 ** is returned and the current statement transaction rolled back. If a
87769 ** transaction before fixing the constraint violation, the attempt fails.
87773 ** database transaction is opened. Each time a statement is executed
87776 ** the database, the counter is decremented. When the transaction is
87785 ** transaction is opened, this may cause the mechanism to malfunction.
87831 ** and the statement transaction is rolled back. An exception is an INSERT
87835 ** an INSERT does not open a statement transaction.
88166 ** generated for will not open a statement transaction. */
90063 ** any ROLLBACK The current transaction is rolled back and
90074 ** transaction is not rolled back and any
92179 "from within a transaction");
92936 "Safety level may not be changed inside a transaction");
93855 /* If there is not already a read-only (or read-write) transaction opened
93856 ** on the b-tree database, open one now. If a transaction is opened, it
94094 int openedTransaction = 0; /* True if a transaction is opened */
94098 /* If there is not already a read-only (or read-write) transaction opened
94099 ** on the b-tree database, open one now. If a transaction is opened, it
94120 /* Close the transaction, if one was opened. */
101224 sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
101249 ** (possibly synchronous) transaction opened on the main database before
101275 ** locked (as there was more than one active statement when the transaction
101296 /* Begin a transaction and take an exclusive lock on the main database
101384 /* At this point, there is a write transaction open on both the
101387 ** transaction by sqlite3BtreeCopyFile() and the other by an explicit
101439 /* Currently there is an SQL level transaction open on the vacuum
101441 ** was committed at the btree level). So it safe to end the transaction
102286 ** If the virtual table pVtab supports the transaction interface
102287 ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
102335 ** virtual tables that currently have an open transaction. Pass iSavepoint
102341 ** an open transaction is invoked.
108571 0, /* TRANSACTION => nothing */
108711 "PLAN", "BEGIN", "TRANSACTION", "DEFERRED",
108791 /* 11 */ "trans_opt ::= TRANSACTION",
108792 /* 12 */ "trans_opt ::= TRANSACTION nm",
110972 /* (11) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==11);
110973 /* (12) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==12);
111494 testcase( i==26 ); /* TRANSACTION */
113177 /* If a transaction is open, the ResetInternalSchema() call above
113752 ** Register a function to be invoked when a transaction commits.
113789 ** Register a callback to be invoked each time a transaction is rolled
113830 ** a database after committing a transaction if there are nFrame or
113854 ** Register a callback to be invoked each time a transaction is written
113934 ** If a transaction is open on the database being checkpointed, this
115655 /* The blocking transaction has been concluded. Or there never was a
115656 ** blocking transaction. In either case, invoke the notify callback
115686 ** until connection pBlocker concludes its current transaction.
115699 ** the transaction opened by database db has just finished. Locks held
115764 ** is returned the transaction on connection db will still be
116447 ** populated as documents are inserted/updated/deleted in a transaction
116448 ** and used to create a new segment when the transaction is committed.
116449 ** However if this limit is reached midway through a transaction, a new
116633 /* State variables used for validating that the transaction control
120006 ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction
120007 ** always opens a savepoint transaction. And the xSavepoint() method
125469 ** a transaction, the whole transaction will be rolled back. And this is
132984 0, /* xBegin - begin transaction */
132985 0, /* xSync - sync transaction */
132986 0, /* xCommit - commit transaction */
132987 0, /* xRollback - rollback transaction */
