Lines Matching +refs:log +refs:view +refs:mode
114 ** * Columns in a view
194 ** The default number of frames to accumulate in the log file before
195 ** checkpointing the database in WAL mode.
763 ** See the [threading mode] documentation for additional information.
1316 ** write ahead log and shared memory files used for transaction control
1318 ** closes. Setting persistent WAL mode causes those files to persist after
1324 ** That integer is 0 to disable persistent WAL mode or 1 to enable persistent
1325 ** WAL mode. If the integer is -1, then it is overwritten with the current
1833 ** [threading mode] to Single-thread. In other words, it disables
1834 ** all mutexing and puts SQLite into a mode where it can only be used
1837 ** it is not possible to change the [threading mode] from its default
1844 ** [threading mode] to Multi-thread. In other words, it disables
1852 ** it is not possible to set the Multi-thread [threading mode] and
1858 ** [threading mode] to Serialized. In other words, this option enables
1861 ** In this mode (which is the default when SQLite is compiled with
1868 ** it is not possible to set the Serialized [threading mode] and
2016 ** log message after formatting via [sqlite3_snprintf()].
2187 ** ^Changes to a view that are simulated by an [INSTEAD OF trigger]
2833 ** is the name of the inner-most trigger or view that is responsible for
2967 ** <dd>The database is opened in read-only mode. If the database does not
2987 ** opens in the multi-thread [threading mode] as long as the single-thread
2988 ** mode has not been set at compile-time or start-time. ^If the
2990 ** in the serialized [threading mode] unless single-thread was
2993 ** eligible to use [shared cache mode], regardless of whether or not shared
2996 ** participate in [shared cache mode] even if it is enabled.
3056 ** <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw" or
3060 ** third argument to sqlite3_prepare_v2(). ^If the mode option is set to
3065 ** used, it is an error to specify a value for the mode parameter that is
3102 ** <tr><td> file:data.db?mode=ro&cache=private <td>
3104 ** Regardless of whether or not shared-cache mode is enabled by
3108 ** <tr><td> file:data.db?mode=readonly <td>
3109 ** An error. "readonly" is not a valid option for the "mode" parameter.
3181 ** When the serialized [threading mode] is in use, it might be the
4870 ** KEYWORDS: {autocommit mode}
4873 ** zero if the given database connection is or is not in autocommit mode,
4874 ** respectively. ^Autocommit mode is on by default.
4875 ** ^Autocommit mode is disabled by a [BEGIN] statement.
4876 ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
5030 ** ^(The cache sharing mode set by this interface effects all subsequent
5032 ** Existing database connections continue use the sharing mode
5161 ** ^If the specified table is actually a view, an [error code] is returned.
5408 ** cost of approximately log(N).
5686 ** database connection is in [autocommit mode].
6075 ** when the [threading mode] is Serialized.
6076 ** ^If the [threading mode] is Single-thread or Multi-thread then this
6362 ** [shared cache mode] being enabled.
6705 ** <li> the destination database is using write-ahead-log journaling
6799 ** If running in [shared cache mode], the application must
6827 ** ^When running in shared-cache mode, a database operation may fail with
6958 ** ^The [sqlite3_log()] interface writes a message into the error log
6971 ** will not use dynamically allocated memory. The log message is stored in
6972 ** a fixed-length buffer on the stack. If the log message is longer than
6983 ** [write-ahead log] (i.e. whenever a transaction is committed in
6984 ** [journal_mode | journal_mode=WAL mode]).
6995 ** is the number of pages currently in the write-ahead log file,
7006 ** A single database handle may have at most a single write-ahead log callback
7008 ** previously registered write-ahead log callback. ^Note that the
7026 ** more frames in the [write-ahead log] file. ^Passing zero or
7053 ** [WAL | write-ahead log mode] then this interface is a harmless no-op.
7074 ** readers or writers to finish. Sync the db file if all frames in the log
7075 ** are checkpointed. This mode is the same as calling
7079 ** This mode blocks (calls the busy-handler callback) until there is no
7081 ** snapshot. It then checkpoints all frames in the log file and syncs the
7086 ** This mode works the same way as SQLITE_CHECKPOINT_FULL, except after
7087 ** checkpointing the log file it blocks (calls the busy-handler callback)
7089 ** that the next client to write to the database file restarts the log file
7095 ** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
7130 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
7138 int *pnLog, /* OUT: Size of WAL log in frames */
7187 ** ON CONFLICT mode specified.
7192 ** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite
7195 ** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns
7196 ** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode
7217 ** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode
7227 ** inform a [virtual table] implementation what the [ON CONFLICT] mode
9321 ** In shared cache mode, a single Schema object can be shared by multiple
9364 ** changes and so the view will need to be reset.
9391 ** be stored in lookaside because in shared cache mode the schema information
9458 u8 dfltLockMode; /* Default locking-mode for attached dbs */
9579 #define SQLITE_ReadUncommitted 0x0080000 /* For shared-cache mode */
9921 char *zName; /* Name of the table or view */
9928 Select *pSelect; /* NULL for tables. Points to definition if a view. */
10180 u8 directMode; /* Direct rendering mode means take data directly
10182 u8 useSortingIdx; /* In direct mode, reference the sorting index rather
10362 ** routine is implemented as a macro that only works when in debugging mode,
10868 TableLock *aTableLock; /* Required table locks for shared-cache mode */
10960 char *table; /* The table or view to which the trigger applies */
11099 int sharedCacheEnabled; /* true if shared-cache mode enabled */
15442 ** Open the file indicated and write a log of all unfreed memory
15443 ** allocations into that log.
15452 fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
16085 ** Open the file indicated and write a log of all unfreed memory
16086 ** allocations into that log.
16098 fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
16709 ** Open the file indicated and write a log of all unfreed memory
16710 ** allocations into that log.
16722 fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
19853 char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */
19863 ** Format and write a message to the log if logging is enabled.
20675 ** point precision mode other than /fp:precise. From the MSDN
23188 ** Object used to represent a the shared memory area for a single log file.
23189 ** When multiple threads all reference the same log-summary, each thread has
23191 ** object. In other words, each log-summary is opened only once per process.
23284 ULONG mode, timeout;
23289 mode = 1; /* shared lock */
23298 mode = 0; /* exclusive lock */
23301 NULL, &area, timeout, mode);
23909 int flags, /* Open mode flags */
23986 /* Open in random access mode for possibly better speed. Allow full
24614 /* In test mode, increase the size of this structure a bit so that
24626 #define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
24881 static int posixOpen(const char *zFile, int flags, int mode){
24882 return open(zFile, flags, mode);
25637 ** If it does fail, simply leak the file descriptor, but do log the
25642 ** So we don't even try to recover from an EINTR. Just log the error
26403 ** This locking mode is appropriate for use on read-only databases
26408 ** corruption if this locking mode is used in situations where multiple
26450 ** Nevertheless, a dotlock is an appropriate locking mode for use if no
32406 /* The following blocks should probably assert in debug mode, but they
32919 /* No need to log a failure to lock */
33247 ** Windows will only let you create file view mappings
33282 ** log-summary, each thread has its own winFile object, but they all
33284 ** log-summary is opened only once per process.
34011 int flags, /* Open mode flags */
35819 ** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single
35948 PGroup grp; /* The global PGroup for mode (2) */
36572 ** PGroup. In other words, separateCache is true for mode (1) where no
36575 ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
36580 ** use separate caches (mode-1)
37449 ** the implementation of each function in log.c for further details.
37478 /* Connection to a write-ahead log (WAL) file.
37483 /* Open and close a connection to a write-ahead log. */
37500 /* Read a page from the write-ahead log, if it is present. */
37510 /* Undo any frames written (but not committed) to the log */
37521 /* Write a frame or frames to the log. */
37524 /* Copy pages from the log to the database file */
37526 Wal *pWal, /* Write-ahead log connection */
37721 ** rollback (non-WAL) mode are met. Unless the pager is (or recently
37722 ** was) in exclusive-locking mode, a user-level read transaction is
37749 ** In rollback mode, a RESERVED or (if the transaction was opened with
37756 ** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
37761 ** * If the connection is open in rollback-mode, a RESERVED or greater
37763 ** * If the connection is open in WAL-mode, a WAL write transaction
37774 ** first modified by the upper layer. In rollback mode the journal file
37789 ** just the log file).
37802 ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
37877 ** connection is open in WAL mode. A WAL connection is always in one
37880 ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
37881 ** state. There are two exceptions: immediately after exclusive-mode has
38029 ** This mechanism means that when running in exclusive mode, a connection
38041 ** committed or rolled back when running in "journal_mode=PERSIST" mode.
38046 ** running in "journal_mode=truncate" mode.
38164 ** significant mode change (such as changing the page_size, locking_mode,
38165 ** or the journal_mode). From another view, these class members describe
38223 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
38224 char *zWal; /* File name for write-ahead log */
38315 ** Return true if this pager uses a write-ahead log instead of the usual
38359 /* If the useJournal flag is clear, the journal-mode must be "OFF".
38360 ** And if the journal-mode is "OFF", the journal file must not be open.
38484 "Locking mode: locking_mode=%s\n"
38485 "Journal mode: journal_mode=%s\n"
38813 ** if the pager is not in no-sync mode, sync the journal file immediately
38866 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
38903 ** if in full-sync mode), the zero is overwritten with the true number
38913 ** * When the pager is in no-sync mode. Corruption can follow a
39101 ** thing written to a journal file. If the pager is in full-sync mode, the
39142 /* If in full-sync mode, advance to the next disk sector before writing
39164 /* If the pager is in peristent-journal mode, then the physical
39208 ** if it is open and the pager is not in exclusive mode.
39245 ** This function is a no-op if the pager is in exclusive mode and not
39249 ** If the pager is not in exclusive-access mode, the database file is
39256 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
39319 ** normal and exclusive-locking mode.
39385 ** depends on whether or not the pager is running in exclusive mode and
39386 ** the current journal-mode (Pager.journalMode value), as follows:
39403 ** If the pager is running in exclusive mode, this method of finalizing
39405 ** DELETE and the pager is in exclusive mode, the method described under
39409 ** If running in non-exclusive rollback mode, the lock on the file is
39416 ** tries to unlock the database file if not in exclusive mode. If the
39501 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
39715 ** An exception to the above rule: If the database is in no-sync mode
39786 ** obscure. When running in synchronous mode, this can only happen
40192 ** working in no-sync mode. This means that the rest of the journal
40282 ** mode, then subsequent transactions performed by the connection will not
40335 int isInWal = 0; /* True if page is in log file */
40348 /* Try to pull the page from the write-ahead log. */
40415 ** written into the log file when a WAL transaction is rolled back.
40446 ** rollback involves simply truncating the log file. Therefore, if one
40447 ** or more frames have already been written to the log (and therefore
40464 ** been written (but not committed) to the log file, do one of the
40493 PgHdr *pList, /* List of frames to log */
40591 ** available from the WAL sub-system if the log file is empty or
40638 ** in WAL mode. If the database is empty or if no *-wal file exists and
40852 ** single disk sector is atomic, then this mode provides
40856 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
40861 ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
41127 ** to WAL mode yet.
41349 ** Otherwise, the actions required depend on the journal-mode and the
41359 ** mode, then the journal file is synced before this field is updated.
41368 ** if( <full-sync mode> ) xSync(<journal file>);
41399 ** mode, then the journal file may at this point actually be larger
41437 ** full-synchronous mode, sync the journal first. This ensures that
41479 /* Unless the pager is in noSync mode, the journal file was just
41721 /* Write a single frame for this page to the log. */
42229 ** 2) If the pager is running in exclusive-mode, and there are currently
42245 ** exclusive access mode.
42288 ** Unless the pager is in locking_mode=exclusive mode, the lock is
42298 ** in exclusive-access mode the file descriptor will be kept open
42301 ** mode (and also for journal_mode=truncate on some systems).
42414 ** mode. Otherwise, the following function call is a no-op.
42653 ** opened to write a rollback log for a transaction. It is not used
42656 ** If the journal file is already open (as it may be in exclusive mode),
42745 ** running in exclusive mode) or if the transaction does not require a
42772 /* Grab the write lock on the log file. If successful, upgrade to
42793 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
42798 ** WAL mode.
43152 ** operating in direct-mode, make page 1 writable. When not in
43153 ** direct mode, page 1 is always held in cache and hence the PagerGet()
43164 /* If running in direct mode, write the contents of page 1 to the file. */
43207 ** rollback. If the connection is in WAL mode, this call is a no-op.
43212 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
43318 ** counter in 'indirect-mode'. If the optimization is compiled in but
43322 ** mode.
43326 ** in 'direct' mode. In this case the journal file will never be
43360 ** file. This can only happen in auto-vacuum mode.
43474 ** this transaction, the pager is running in exclusive-mode and is
43481 ** header. Since the pager is in exclusive mode, there is no need
43507 ** Otherwise, in rollback mode, this function performs two functions:
43519 ** In WAL mode, all cache-entries containing data modified within the
43996 ** Get/set the locking-mode for this pager. Parameter eMode must be one
43999 ** the locking-mode is set to the value specified.
44003 ** locking-mode.
44019 ** Set the journal-mode for this pager. Parameter eMode must be one of:
44036 ** The returned indicate the current (possibly updated) journal-mode.
44058 ** to WAL mode.
44074 /* Change the journal mode. */
44079 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
44127 /* Return the new journal mode */
44132 ** Return the current journal mode.
44227 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
44237 /* If the pager is already in exclusive-mode, the WAL module will use
44246 /* Open the connection to the log file. If this operation fails,
44306 ** This function is called to close the connection to the log file prior
44307 ** to switching from WAL to rollback mode.
44309 ** Before closing the log file, this function attempts to take an
44311 ** error (SQLITE_BUSY) is returned and the log connection is not closed.
44319 /* If the log file is not already open, but does exist in the file-system,
44321 ** rollback mode. Open it now so this can happen.
44336 /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
44337 ** the database file, the log and log-summary files will be deleted.
44353 ** into the log file.
44383 ** This file contains the implementation of a write-ahead log (WAL) used in
44384 ** "journal_mode=WAL" mode.
44486 ** multiple concurrent readers to view different versions of the database
44539 ** the log, and so on.
44678 u32 aFrameCksum[2]; /* Checksum of last frame in log */
44751 /* Size of write ahead log header, including checksum. */
44767 ** Return the offset of frame iFrame in the write-ahead log file,
44769 ** is to the start of the write-ahead log frame-header.
44776 ** An open write-ahead log file is represented by an instance of the
44783 u32 iCallback; /* Value to pass to log callback (or 0) */
44789 u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
45033 Wal *pWal, /* The write-ahead log */
45060 Wal *pWal, /* The write-ahead log */
45195 ** (*piZero+N) in the log.
45414 ** Recover the wal-index by reading the write-ahead log file.
45425 i64 nSize; /* Size of log file */
45461 i64 iOffset; /* Next offset to read from log file */
45462 int szPage; /* Page size according to the log */
45518 /* Read all frames from the log file. */
45525 /* Read and decode the next log frame. */
45565 /* If more than one frame was recovered from the log file, report an
45568 ** checkpointing the log file.
45609 ** If the log file is successfully opened, SQLITE_OK is returned and
45617 int bNoShm, /* True to run in heap-memory mode */
45655 /* Open file handle on the write-ahead log file. */
45878 u32 iLast; /* Last frame in log */
45885 ** it only runs if there is actually content in the log (mxFrame>0).
45988 ** SQLite is in WAL-mode in synchronous=NORMAL. That means that if
46154 ** Close a connection to a log file.
46167 ** ordinary, rollback-mode locking methods, this guarantees that the
46168 ** connection associated with this log file is the only connection to
46471 ** may have been appended to the log before READ_LOCK(0) was obtained.
46472 ** When holding READ_LOCK(0), the reader ignores the entire log file,
46477 ** However, if frames have been appended to the log (or if the log
46541 ** that the log file may have been wrapped by a writer, or that frames
46542 ** that occur later in the log than pWal->hdr.mxFrame may have been
46551 ** log-wrap (either of which would require an exclusive lock on
46708 /* If iRead is non-zero, then it is the log frame number that contains the
46709 ** required page. Read and return data from the log file.
46799 ** If any data has been written (but not committed) to the log file, this
46833 ** page 1 is never written to the log until the transaction is
46874 ** to the start of the log. Update the savepoint values to match.
46891 ** This function is called just before writing a set of frames to the log
46893 ** to the current log file, it is possible to overwrite the start of the
46894 ** existing log file with the new frames (i.e. "reset" the log). If so,
46916 ** frames will overwrite the start of the existing log. Update the
46973 ** Write a set of frames to the log. The caller must hold the write-lock
46974 ** on the log file (obtained using sqlite3WalBeginWriteTransaction()).
47002 ** log file, instead of appending to it at pWal->hdr.mxFrame.
47008 /* If this is the first frame written into the log, write the WAL
47040 /* Write the log file. */
47043 i64 iOffset; /* Write offset in log file */
47070 /* Sync the log file if the 'isSync' flag was specified. */
47204 /* Copy data from the log to the database file. */
47259 ** transition out of exclusive-mode is successful, return 1. This
47266 ** WAL is already in exclusive-locking mode - meaning that this
47282 ** happen if the connection is actually in exclusive mode (as no xShmLock
47284 ** upgrade to exclusive-mode following such an error.
47375 ** Finding a particular key requires reading O(log(M)) pages from the
47421 ** 64 4 Incremental vacuum mode
47760 u8 doNotUseWAL; /* If true, do not open write-ahead-log file */
48564 ** by a connection in read-uncommitted mode is on the sqlite_master
49955 ** and we are in shared cache mode, then the open will fail with an
50064 /* In debug mode, we mark all persistent databases as sharable
50116 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
50418 ** and autovacuum mode can no longer be changed.
50501 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
50602 ** in WAL mode. If the log is not already open, open it now. Then
50606 ** may not be the latest version - there may be a newer one in the log
52087 ** mode, the following events may invalidate an overflow page-list cache.
52090 ** * A commit in auto_vacuum="full" mode,
53475 ** freePage2() may zero the page contents if secure-delete mode is
54223 ** Unless SQLite is compiled in secure-delete mode. In this case,
55455 ** database. This is because in auto-vacuum mode the backend may
56773 int destMode; /* Destination journal mode */
56817 /* Do not allow backup if the destination database is in WAL mode
59285 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
59291 ** If SQLite is not threadsafe but does support shared-cache mode, then
59296 ** If SQLite is not threadsafe and does not support shared-cache mode, this
60400 ** has made changes and is in autocommit mode, then commit those
64031 Btree *pBt; /* Btree to change journal mode of */
64033 int eNew; /* New journal mode */
64034 int eOld; /* The old journal mode */
66397 ** connection is currently not in autocommit mode, or if there are other
66626 ** in read/write mode. For a given table, there can be one or more read-only
67454 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
69026 ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL
69062 ** Change the journal mode of database P1 to P3. P3 must be one of the
69067 ** If changing into or out of WAL mode the procedure is more complicated.
69069 ** Write a string containing the final journal-mode to register P2.
69073 Btree *pBt; /* Btree to change journal mode of */
69075 int eNew; /* New journal mode */
69076 int eOld; /* The old journal mode */
69116 "cannot change %s wal mode from within a transaction",
69123 /* If leaving WAL mode, close the log file. If successful, the call
69124 ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
69133 /* Cannot transition directly from MEMORY to WAL. Use mode OFF
69139 ** mode, this transaction always uses a rollback journal.
69991 sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
74383 if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
74386 assert( pTab->pSelect==0 ); /* FROM clause is not a view */
77225 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
77547 /* Make sure this is not an attempt to ALTER a view. */
77549 sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
78753 const char *zType, /* "view", "trigger", or "index" */
78754 const Token *pName /* Name of the view, trigger, or index */
78775 ** view in one database does not refer to objects in a different database.
79447 const char *zMsg = isView ? "no such view" : "no such table";
79614 ** Delete memory allocated for the column names of a table or view (the
79778 /* The table or view or trigger name is passed to this routine via tokens
79826 ** unqualified name for a new schema object (table, index, view or
79859 Token *pName1, /* First part of the name of the table or view */
79860 Token *pName2, /* Second part of the name of the table or view */
79873 /* The table or view name to create is passed to this routine via tokens
79887 ** set to the index of the database that the table or view is to be
80652 char *zType; /* "view" or "table" */
80662 ** Initialize zType for the new view or table.
80670 /* A view */
80671 zType = "view";
80802 Token *pName1, /* The token that holds the name of the view */
80803 Token *pName2, /* The token that holds the name of the view */
80804 Select *pSelect, /* A SELECT statement that will become the new view */
80805 int isTemp, /* TRUE for a TEMPORARY view */
80830 if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName)
80837 /* Make a copy of the entire SELECT statement that defines the view.
80865 /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
80874 ** the columns of the view in the pTable structure. Return the number
80879 Select *pSel; /* Copy of the SELECT that implements the view */
80895 /* A positive nCol means the columns names for this view are
80916 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
80923 ** "*" elements in the results set of the view and will assign cursors
80926 ** statement that defines the view.
81216 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
81224 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
81261 ** move as a result of the drop (can happen in auto-vacuum mode).
83473 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
83483 ** Evaluate a view and store its result in an ephemeral table. The
83485 ** set of rows in the view that are to be added to the ephemeral table.
83642 int isView; /* True if attempting to delete from a view */
83662 ** deleted from is a view
83676 /* If pTab is really a view, make sure it has been initialized.
83703 /* Start the view context
83718 /* If we are trying to delete from a view, realize that view into
83788 /* Unless this is a view, open cursors for the table we are
83789 ** deleting from and all its indices. If this is a view, then the
83943 ** a view (in which case the only effect of the DELETE statement is to
87354 int isView; /* True if attempting to insert into a view */
87383 ** inserted into is a view
87399 /* If pTab is really a view, make sure it has been initialized.
87400 ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
87409 * (b) that if it is a view then ON INSERT triggers exist
87633 /* If this is not a view, open the table and and all indices */
87739 /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
88583 return 0; /* tab2 may not be a view */
89098 void (*log)(int,const char*,...);
89301 #define sqlite3_log sqlite3_api->log
90018 ** Interpret the given string as a locking mode value.
90030 ** Interpret the given string as an auto-vacuum mode value.
90179 ** in auto-commit mode. */
90226 ** journal-mode name.
90449 ** the current default locking mode (which may be different to
90450 ** the locking-mode of the main database).
90457 ** of the PRAGMA command. In this case the locking-mode must be
90462 ** locking mode.
90506 ** current mode */
90515 /* If the "=MODE" part does not match any known journal mode,
90587 /* When setting the auto_vacuum mode to either "full" or
91369 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "log", SQLITE_STATIC);
91381 ** after accumulating N frames in the log. Or query for the current value
91535 ** argv[1] = root page number for table or index. 0 for trigger or view.
91561 ** structures that describe the table, index, or view.
91724 ** meta[3] Largest rootpage (auto/incr_vacuum mode)
91727 ** meta[6] Incremental vacuum mode
92951 /* In this mode, write each query result to the key of the temporary
93406 /* The "table" is actually a sub-select or a view in the FROM clause
93412 ** rowid of the sub-select or view. This expression is legal (see
95452 ** where table is a database table, not a sub-select or view. If the query
95515 ** that implements the view. A copy is made of the view's SELECT
95518 ** of the view.
95553 ** an entry of the FROM clause is a subquery instead of a table or view,
95582 /* An ordinary table or view name in the FROM clause */
95590 /* We reach here if the named table is a really a view */
97221 SrcList *pTableName,/* The name of the table/view the trigger applies to */
97339 sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
98378 int isView; /* True when updating a view (INSTEAD OF trigger) */
98406 ** updated is a view.
98549 /* Start the view context. */
98554 /* If we are trying to update a view, realize that view into
99191 " WHERE type='view' OR type='trigger'"
100293 ** Return the ON CONFLICT resolution mode in effect for the virtual
101173 ** From another point of view, "indexable" means that the subterm could
102256 double logN; /* log(nTableRow) */
111472 ** Invoke sqlite3_wal_checkpoint if the number of frames in the log file
111494 ** more frames in the log file. Passing zero or a negative value as the
111518 ** into the write-ahead-log by this database connection.
111545 int *pnLog, /* OUT: Size of WAL log in frames */
111595 ** not currently open in WAL mode.
111958 ** "cache=xxx" or "mode=xxx" query parameters.
112093 int mode;
112111 if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
112127 int mode = 0;
112131 mode = aMode[i].mode;
112135 if( mode==0 ){
112136 *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
112140 if( mode>limit ){
112141 *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
112146 flags = (flags & ~mask) | mode;
112407 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
112408 ** mode. Doing nothing at all also makes NORMAL the default.
112609 ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
112734 ** 2. The table is not a view and the column name identified an
119889 unsigned char parenOnly; /* Only valid in paren mode */
120112 Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */
120598 ** Hash and comparison functions when the mode is FTS3_HASH_STRING
120616 ** Hash and comparison functions when the mode is FTS3_HASH_BINARY
121304 stem(&z, "igol", "log", m_gt_0);
125423 ** If the on-conflict mode is REPLACE, this means that the existing row
125425 ** if the on-conflict mode is other than REPLACE, then this method must
125443 ** rowid column. So if the conflict mode is REPLACE, then delete any
125446 ** Or, if the conflict mode is not REPLACE, insert the new record into
129764 ** In the first case, if the conflict-handling mode is REPLACE, then
129767 ** conflict-handling mode specified by the user.