Lines Matching defs:new
329 ** "experimental". Experimental interfaces are normally new
1201 ** pointed to is set to the new limit.
1207 ** point to an integer (type int) containing the new chunk-size to use
1259 ** integers where the first integer is the new retry count and the second
1611 ** The VFS interface is sometimes extended by adding new methods onto
2332 ** <dd> These options are obsolete and should not be used by new code.
2410 ** of type (int) - the new value of the sorter-reference size threshold.
2559 ** which case the new setting is not reported back. </dd>
2576 ** be a NULL pointer, in which case the new setting is not reported back.
2582 ** which will become the new schema name in place of "main". ^SQLite
2583 ** does not make a copy of the new main schema name string, so the application
2737 ** ability to generate new database files that are compatible with version
2833 ** If a separate thread performs a new [INSERT] on the same
2837 ** unpredictable and might not equal either the old or the new
2981 ** SQL statements on [database connection] D complete. ^Any new SQL statements
3075 ** [database connection]. Setting a new busy handler clears any
3353 ** select random [ROWID | ROWIDs] when inserting new records into a table that
3684 ** [database connection]; setting a new progress handler cancels the
3728 ** over the new database connection. ^(The flags parameter to
3762 ** <dd>The new database connection will use the "multi-thread"
3768 ** <dd>The new database connection will use the "serialized"
3814 ** the new database connection should use. ^If the fourth parameter is
4002 ** <li> A new filename constructed using [sqlite3_create_filename()].
4266 ** new limit for that construct.)^
4268 ** ^If the new limit is a negative number, the limit is unchanged.
4463 ** and sqlite3_prepare16_v3() interfaces are recommended for all new programs.
4695 ** [sqlite3_value_dup()] interface can be used to construct a new
5115 ** new "vX" interface is recommended for new applications but the legacy
5136 ** is returned each time a new row of data is ready for processing by the
5605 ** C-language callbacks that implement the new function. xStep and xFinal
5608 ** non-NULL, in which case the new function may be used as either an aggregate
5635 ** ^Built-in functions may be overloaded by new application-defined functions.
5709 ** The SQLITE_DETERMINISTIC flag means that the new function always gives
5775 ** to be supported. However, new applications should avoid
5984 ** to the new memory. ^On second and subsequent calls to
6097 ** Future enhancements may make use of negative N values to define new
6480 const void *pKey, int nKey /* The new key */
6485 const void *pKey, int nKey /* The new key */
6534 ** be avoided in new projects.
7137 ** only. All new applications should use the
7306 ** each new [database connection] that is created. The idea here is that
7308 ** that is to be automatically loaded into all new database connections.
7634 ** ^These routines are used to register a new [virtual table module] name.
7636 ** creating a new [virtual table] using the module and before using a
7645 ** when a new virtual table is be being created or reinitialized.
7657 ** NULL then no new module is created and any existing modules with the
7707 ** prior to assigning a new string to zErrMsg. ^After the error message
7761 ** before this API is called, a new function is created.)^ ^The implementation
7762 ** of the new function always causes an exception to be thrown. So
7763 ** the new function is not good for anything by itself. Its only
7816 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored
7891 ** to a different row of the same database table. ^The new row is identified
7894 ** remain the same. Moving an existing [BLOB handle] to a new row is
7895 ** faster than closing the existing handle and opening a new one.
7897 ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
7899 ** the nominated column.)^ ^If the new row is not present in the table, or if
8038 ** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
8048 ** the default. The choice for the new VFS is arbitrary.)^
8087 ** ^The sqlite3_mutex_alloc() routine allocates a new
8112 ** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
8463 ** creates a new table named "BEGIN" with three columns named
8481 ** new keywords may be added to future releases of SQLite.
8510 ** a new [sqlite3_str] object. To avoid memory leaks, the object returned by
8517 ** silently reject new text, always return SQLITE_NOMEM from
9066 ** ^SQLite invokes the xCreate() method to construct a new cache instance.
9121 ** <tr><td> 0 <td> Do not allocate a new page. Return NULL.
9122 ** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
9124 ** <tr><td> 2 <td> Make every effort to allocate a new page. Only return
9125 ** NULL if allocating a new page is effectively impossible.
9464 ** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is
9681 ** ^Every new [database connection] defaults to having the auto-checkpoint
9734 ** database file. ^This mode blocks new database writers while it is pending,
9735 ** but new database readers are allowed to continue unimpeded.
9743 ** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new
10479 ** in this case the new values are not available. In this case, when a
10535 ** by the reader until a new read transaction is started.
10538 ** version of the database file so that it is possible to later open a new read
10551 ** new [sqlite3_snapshot] object that records the current state of
10599 ** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read
10694 ** calling [sqlite3_close()]) and a new connection is subsequently opened
11003 ** Create a new session object attached to database handle db. If successful,
11004 ** a pointer to the new object is written to *ppSession and SQLITE_OK is
11146 ** the new tables are also recorded.
11229 ** change contains the values of each field of a new database row. A DELETE
11267 ** records the primary key values of all new rows inserted into the table.
11279 ** a new record) and those that consist of the primary key values and the
11664 ** CAPI3REF: Obtain new.* Values From A Changeset Iterator
11681 ** new row values stored as part of the UPDATE or INSERT change and
11683 ** a new value for the requested column, *ppValue is set to NULL and
11685 ** this is similar to the "new.*" columns available to update or delete
11784 ** <li> For each UPDATE change, the old.* and new.* values are exchanged.
11861 ** a pointer to a new sqlite3_changegroup object before returning. The caller
11881 ** new() and delete(), and in any order.
11908 ** simply copied into it. Or, if both the new changeset and the changegroup
11917 ** The new change is ignored. This case does not occur if the new
11923 ** existing change and then updated according to the new change.
11928 ** The new change is ignored. This case does not occur if the new
11934 ** by the existing change and then again by the new change.
11936 ** The existing UPDATE is replaced by the new DELETE within the
11940 ** new change differ from those in the row deleted by the existing
11945 ** The new change is ignored. This case does not occur if the new
11949 ** The new change is ignored. This case does not occur if the new
11954 ** If the new changeset contains changes to a table that is already present
12090 ** For each INSERT change, an attempt is made to insert the new row into
12357 ** to reflect the new.* values in the UPDATE.
12362 ** is changed into an INSERT. Any undefined values in the new.* record
12368 ** the old.* values are rebased using the new.* values in the remote
12402 ** <li> The new object is configured with the rebase buffer obtained from
12419 ** Allocate a new changeset rebaser object. If successful, set (*ppNew) to
12420 ** point to the new object and return SQLITE_OK. Otherwise, if an error
12448 ** is set to point to the new buffer containing the rebased changeset and
12450 ** responsibility of the caller to eventually free the new buffer using
12667 ** If this value is greater than 0, it is used as the new streaming data
12865 ** invoked, then it is replaced by the new pointer. If an xDelete callback
13021 ** should be set to point to the new tokenizer handle and SQLITE_OK
13232 /* Create a new tokenizer */
13249 /* Create a new auxiliary function */
14228 ** the default file format for new databases and the maximum file format
15024 ** any time. Other processes may hold and obtain new SHARED locks.
15026 ** any one time. Existing SHARED locks may persist, but no new
15704 ** pData,nData hold the content of the new entry. nZero extra zero bytes
16549 /* Create a new pager cache.
16878 ** disables lookaside without adding a new test for the bDisable flag
17180 #define SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */
17330 ** member of each of the new FuncDef objects is set to point to the allocated
17773 int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
17929 ** a UNIQUE constraint violation are removed so that the new insert or
18342 ** TK_TRIGGER: 1 -> new, 0 -> old
18717 ** Each subquery gets a new NameContext. The pNext field points to the
18924 ** SRT_Coroutine Generate a co-routine that returns a new row of
19028 ** a mask of new.* columns used by the program.
19035 u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
19142 int regRoot; /* Register holding root page number for new objects */
19160 u32 newmask; /* Mask of new.* columns referenced */
22495 Bool useRandomRowid:1; /* Generate new record numbers semi-randomly */
22516 /* When a new VdbeCursor is allocated, only the fields above are zeroed.
22850 /* When allocating a new Vdbe object, all of the fields below should be
22926 UnpackedRecord *pNewUnpacked; /* Unpacked version of new.* record */
22927 int iNewReg; /* Register for new.* values */
22931 Mem *aNew; /* Array of new.* values */
24261 DateTime new;
24262 memset(&new, 0, sizeof(new));
24264 new.iJD = iGuess;
24265 new.validJD = 1;
24266 rc = toLocaltime(&new, pCtx);
24268 computeJD(&new);
24269 iErr = new.iJD - iOrigJD;
25268 ** VFS multiple times. The new VFS becomes the default if makeDflt is
25855 ** The number of levels of backtrace to save in new allocations.
25975 ** the content of a new memory allocation to unpredictable values and
26097 ** allocation into a new place in memory. In this way, if the
26414 ** iKeyBlk is the index of the key chunk. Most new allocations
26557 ** Return a pointer to the new allocation. Or, if the key chunk
26598 ** the current mem3.iKeyBlk with the new larger chunk. In order for
27226 ** two in order to create a new free block of size iLogsize.
27847 ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
28037 ** The sqlite3_mutex_alloc() routine allocates a new
28256 ** The sqlite3_mutex_alloc() routine allocates a new
28280 ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
28804 ** The sqlite3_mutex_alloc() routine allocates a new
28828 ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
30709 ** a new one. */
30971 ** The StrAccum "p" is not large enough to accept N new bytes of z[].
31059 ** sqlite3_str object accepts no new text and always returns
31133 /* Allocate and initialize a new dynamic string object */
31355 ** Add a new subitem to the tree. The moreToFollow flag indicates that this
31413 ** Shorthand for starting a new tree item that consists of a single label
32101 ** to a column in the new.* or old.* pseudo-tables available to
32103 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
32834 /* Create a new thread */
32929 /* Create a new thread */
32997 ** This implementation does not actually create a new thread. It does the
33009 /* Create a new thread */
33832 ** The input string must be zero-terminated. A new zero-terminator
35214 ** Add a new name/number pair to a VList. This might require that the
35215 ** VList object be reallocated, so return the new VList. If an OOM
35261 assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */
35420 ** if the new size is the same as the prior size.
35424 struct _ht *new_ht; /* The new hash table */
35543 ** If no element exists with a matching key, then a new
35547 ** new data replaces the old data and the old data is returned.
35549 ** the new data is returned and the hash table is unchanged.
36933 ** Default permissions when creating a new file
37028 ** counter. This test is made to avoid new problems similar to the
37390 sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
37745 ** Changes are made in-place. Return the new name length.
37779 ** the object is returned. A new vxworksFileId object is created
37785 struct vxworksFileId *pNew; /* search key and new file ID */
37813 /* No match was found. We will make a new file ID */
37872 ** on its own. Whenever a new database is opened, we have to find the
38172 ** describes that file descriptor. Create a new one if necessary. The
38513 ** on the 'pending byte'. This ensures that no new SHARED locks can be
41469 ** When opening a new shared-memory file, if no other instances of that
41487 /* Allocate space for the new unixShm object. */
41494 ** one if present. Create a new one if necessary.
41507 ** a new *-shm file is created, an attempt will be made to create it
41572 /* Make the new connection a child of the unixShmNode */
41583 ** new (struct unixShm) object to the pShmNode has been set. All that is
41584 ** left to do is to link the new object into the linked list starting
41685 ** last page in order to extend the file. But writing to all new
42053 u8 *pNew = 0; /* Location of new mapping */
42102 /* If pNew is still NULL, try to create an entirely new mapping. */
42123 ** is already mapped, the existing mapping is replaced by the new). Or, if
42830 ** ignored and -1 is returned. The caller will try to open a new file
42884 ** to create new files with. If no error occurs, then SQLITE_OK is returned
42979 ** file handle closed. To achieve the same effect using this new
43809 ** Proxy file locking relies primarily on two new supporting files:
43984 ** Create a new VFS file descriptor (stored in memory obtained from
43991 const char *path, /* path for the new unixFile */
44123 ** Takes an open conch file, copies the contents to a new path and then moves
44141 /* create a new path by replace the trailing '-conch' with '-break' */
44269 ** host IDs match, or a new lock path will be generated automatically
44316 /* a short read or version format mismatch means we need to create a new
44323 ** retry with a new auto-generated path
44363 /* either the conch didn't match or we need to create a new one */
44402 /* If we created a new conch file (not just updated the contents of a
44519 ** Make *pConchPath point to the new name. Return SQLITE_OK on success
46242 sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
47666 LONG upperBits; /* Most sig. 32 bits of new offset */
47667 LONG lowerBits; /* Least sig. 32 bits of new offset */
47677 ** containing the lower 32-bits of the new file-offset. Or, if it fails,
47679 ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine
47701 LARGE_INTEGER x; /* The new offset */
48990 ** When opening a new shared-memory file, if no other instances of that
49003 /* Allocate space for the new sqlite3_shm object. Also speculatively
49004 ** allocate space for a new winShmNode and filename.
49019 ** If no matching winShmNode currently exists, create a new one.
49067 /* Make the new connection a child of the winShmNode */
49078 ** new (struct winShm) object to the pShmNode has been set. All that is
49079 ** left to do is to link the new object into the linked list starting
49474 ** is already mapped, the existing mapping is replaced by the new). Or, if
50213 /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
50218 /* Creates a new file, only if it does not already exist. */
52176 ** Register the new VFS.
52306 ** Create a new bitmap object able to handle bits between 0 and iSize,
52307 ** inclusive. Return a pointer to the new object. Return NULL if
52918 ** Create a new PCache object. Storage space to hold the object
52979 ** such an object is already in cache, or if a new one is created.
52984 ** be 3 (not 1, but 3) to try to create a new page.
52987 ** is not already in the cache. If createFlag is 1, then a new page
53013 ** 0 Do not allocate a new page. (createFlag==0)
53014 ** 1 Allocate a new page if doing so is inexpensive.
53016 ** 2 Allocate a new page even it doing so is difficult.
53031 ** If the sqlite3PcacheFetch() routine is unable to allocate a new
53036 ** allocate the new page and will only fail to allocate a new page on
53759 int separateCache; /* Use a new PGroup for each PCache */
53964 ** Allocate a new page object initially associated with cache pCache.
54039 ** Return true if it desirable to avoid allocating a new page cache
54044 ** it is desirable to avoid allocating a new page cache entry because
54051 ** allocating a new page cache entry in order to avoid stressing
54296 ** Allocate a new cache.
54300 PGroup *pGroup; /* The group the new page cache will belong to */
54301 int sz; /* Bytes of memory required to allocate the new cache */
54453 ** attempt to allocate a new one.
54482 ** Whether or not a new page may be allocated by this function depends on
54483 ** the value of the createFlag argument. 0 means do not allocate a new
54484 ** page. 1 means allocate a new page if space is easily available. 2
54485 ** means to try really hard to allocate a new page.
54502 ** return NULL (do not allocate a new page) if any of the following
54529 ** 5. Otherwise, allocate and return a new page buffer.
54839 ** process has started, no new elements may be inserted.
54850 ** obviously. The INSERT primitive adds a new element to the RowSet.
54870 ** The cost of an INSERT is roughly constant. (Sometimes new memory
54871 ** has to be allocated on an INSERT.) The cost of a TEST with a new
54930 struct RowSetEntry *pFresh; /* Source of new entry objects */
54995 ** Allocate a new RowSetEntry object that is associated with the
54996 ** given RowSet. Return a pointer to the new and completely uninitialized
55022 ** Insert a new value into a RowSet.
55028 struct RowSetEntry *pEntry; /* The new entry */
55120 ** and return pointers to the first and last elements of the new list.
55161 struct RowSetEntry *p; /* Root of the new tree */
55255 ** If this is the first test of a new batch and if there exist entries
55265 /* Sort entries into the forest on the first test of a new batch.
56022 ** to allocate a new page to prevent the journal file from being written
56038 ** This variable is updated by the upper layer each time a new
56244 ** The sanity checking information for the new journal format consists
56637 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
56664 ** Pager.eLock variable to the new locking state.
56667 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
57559 /* Make sure the new file size is written into the inode right away.
58160 ** the end of the new file instead.
59237 ** Change the page size used by the Pager object. The new page size
59246 ** * the new page size (value of *pPageSize) is valid (a power
59257 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
59389 ** function is used to read database headers, and a new transient or
59561 ** The new object will use the pointer pData, obtained from xFetch().
59562 ** If successful, set *ppPage to point to the new page reference
59923 ** in Pager.dbFileVers[] is updated to match the new value stored in
60125 ** journal (and adding a new header) is not allowed. This occurs
60212 ** Allocate and initialize a new Pager object and put a pointer to it
60225 ** via the sqlite3PagerGetExtra() API. When a new page is allocated, the
60238 ** the new pager object. If an error occurs, *ppPager is set to NULL
60695 ** transaction that populates a new database is being rolled back.
61013 ** Otherwise, a new page object is allocated and populated with data
61015 ** choose not to allocate a new page object and may reuse an existing
61035 ** a new page into the cache to be filled with the data read
61098 /* The pager cache has created a new page. Its content needs to
61592 ** to change is in the rollback journal, or if the page is a new page off
62430 ** if the allocation fails. Otherwise, zero the new portion in case a
62982 /* Return the new journal mode */
63389 ** WAL can fill up with frames and then be checkpointed and then new
63457 ** value is randomized. This prevents old and new frames in the WAL from
63608 ** that correspond to frames greater than the new K value are removed
63740 ** in the WAL has been backfilled into the database) then new readers
63745 ** Writers normally append new frames to the end of the WAL. However,
63750 ** writing new content beginning at frame 1.
63932 ** walIteratorInit() - Create a new iterator,
64256 ** and the new database size.
64524 ** the hash-table before writing any new entries.
64831 ** *ppWal is set to point to a new WAL handle. If an error occurs,
64991 ** This routine overwrites aRight[] with a new (probably longer) sequence
65346 ** new wal-index header. It should be passed a pseudo-random value (i.e.
65381 ** into the database. This ensures that if the new content is persistent
65386 ** it safe to delete the WAL since the new content will persist in the
65678 ** pWal->hdr, then pWal->hdr is updated to the content of the new header
66372 ** Other threads might append new content to the WAL and wal-index but
66802 ** existing log file with the new frames (i.e. "reset" the log). If so,
67238 int isChanged = 0; /* True if a new wal-index header is loaded */
67320 /* If a new wal-index header was loaded before the checkpoint was
67712 ** to keep free space after the last cell pointer so that new cells can
67844 /* Only the first 8 bytes (above) are zeroed by pager.c when a new page
67986 ** while in the 'pending-lock' state, no connection may start a new
68202 ** new location. The pointer map is used to locate the parent page quickly.
70283 ** for the portion used by the new allocation. */
70316 ** allocation is being made in order to insert a new cell, so we will
70317 ** also end up needing a new cell pointer.
70406 ** The first byte of the new free block is pPage->aData[iStart]
70492 /* The new freeblock is at the beginning of the cell content area,
70500 /* Insert the new freeblock into the freelist */
71074 Btree **ppBtree, /* Pointer to new Btree object written here */
71276 /* Add the new BtShared object to the linked list sharable BtShareds.
71298 /* If the new Btree uses a sharable pBtShared, then link the new
72036 ** into a new empty database by initializing the first page of
72093 ** Attempt to start a new transaction. A write-transaction
72099 ** exclusivity flag only works for a new transaction.
73054 ** including the new anonymous savepoint, open on the B-Tree. i.e. if there
73120 ** Create a new cursor for the BTree whose root is on the page
73166 BtCursor *pCur /* Space for new cursor */
73233 BtCursor *pCur /* Space for new cursor */
73246 BtCursor *pCur /* Write new cursor here */
73885 ** Move the cursor down to a new child page. The newPgno argument is the
73889 ** the new child page does not match the flags field of the parent (i.e.
74858 ** Allocate a new page from the database file.
74860 ** The new page is marked as dirty. (In other words, sqlite3PagerWrite()
74861 ** has already been called on the new page.) The new page has also
74863 ** sqlite3PagerUnref() on the new page when it is done.
75121 /* There are no pages on the freelist, so append a new page to the
75124 ** Normally, new pages allocated by this block can be requested from the
75148 /* If *pPgno refers to a pointer-map page, allocate two new pages
75150 ** becomes a new pointer-map page, the second is used by the caller.
75252 ** new free-list trunk page. Otherwise, it will become a leaf of the
75254 ** is possible to add the page as a new free-list leaf.
75277 ** being freed as a new leaf.
75313 ** will become the new first trunk page in the free-list.
75325 TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
75674 ** Insert a new cell on pPage at cell index "i". pCell points to the
75679 ** pTemp is not null. Regardless of pTemp, allocate a new entry
75682 ** Allocating a new entry in pPage->aCell[] implies that
75690 u8 *pCell, /* Content of the new cell */
75696 int idx = 0; /* Where to write new cell content in data[] */
76000 ** *ppData is updated to point to the new start of the content area
76136 int iNew, /* Index of new first cell on page */
76241 ** a new entry is being inserted on the extreme right-end of the
76242 ** tree, in other words, when the new entry will become the largest
76246 ** a new page to the right-hand side and put the one new entry in
76248 ** unbalanced. But odds are that we will be inserting new entries
76276 /* Allocate a new page. This page will become the right-sibling of
76277 ** pPage. Make the parent page writable, so that the new divider cell
76307 ** with entries for the new page, and any pointer from the
76341 /* Insert the new divider cell into pParent. */
76347 /* Set the right-child pointer of pParent to point to the new page. */
76350 /* Release the reference to the new page. */
76438 ** match the new data. The initialization of pTo can actually fail under
76529 u8 abDone[NB+2]; /* True after i'th new page is populated */
76530 Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */
76913 ** Allocate k new pages. Reuse old pages where possible.
76938 /* Set the pointer-map entry for the new sibling page. */
76949 ** Reassign page numbers so that the new pages are in ascending order.
76990 TRACE(("BALANCE: new: %d(%d nc=%d) %d(%d nc=%d) %d(%d nc=%d) "
77009 ** of the right-most new sibling page is set to the value that was
77053 /* Cell pCell is destined for new sibling page pNew. Originally, it
77074 /* Insert new divider cells into pParent. */
77236 TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
77239 /* Free any old pages that were not reused as new pages.
77276 ** A new child page is allocated and the contents of the current root
77279 ** pointer pointing to the new page.
77282 ** that the new child-page now contains pointers to are updated. The
77283 ** entry corresponding to the new right-child pointer of the root
77293 MemPage *pChild = 0; /* Pointer to a new child page */
77294 Pgno pgnoChild = 0; /* Page number of the new child page */
77300 /* Make pRoot, the root page of the b-tree, writable. Allocate a new
77301 ** page that will become the new right-child of pPage. Copy the contents
77302 ** of the node stored on pRoot into the new child page.
77394 ** balance_deeper() function to create a new child for the root-page
77433 /* Call balance_quick() to create a new sibling of pPage on which
77434 ** to store the overflow cell. balance_quick() inserts a new cell
77466 ** copied either into the body of a database page or into the new
77476 ** new pSpace buffer, so it may be safely freed here. */
77599 ** Insert a new record into the BTree. The content of the new record
77703 ** to a row with the same key as the new entry being inserted.
77741 ** to a row with the same key as the new entry being inserted.
77746 ** overwritten, or if a new cell is being inserted, if the cursor is
77767 ** and the new content is the same as as the old, then use the
77799 loc==0 ? "overwrite" : "new entry"));
77842 /* Overwrite the old cell with the new if they are the same size.
77849 ** new entry uses overflow pages, as the insertCell() call below is
77933 ** This function does not actually write the new value to cursor pDest.
77935 ** writes the data for the new cell into the BtShared.pTmpSpace buffer
78256 ** Create a new BTree table. Write into *piTable the page
78257 ** number for the root page of the new table.
78271 int ptfFlags; /* Page-type flage for the root page of new table */
78287 /* Creating a new table may probably require moving an existing database
78288 ** to make room for the new tables root page. In case this page turns
78295 ** root page of the new table should go. meta[3] is the largest root-page
78296 ** created so far, so the new root-page is (meta[3]+1).
78304 /* The new root-page may not be allocated on a pointer-map page, or the
78324 ** the new table (assuming an error did not occur). But we were
78376 /* Update the pointer-map and meta-data with the new root-page number. */
78383 /* When the new root page was allocated, page 1 was made writable in
78605 /* Set the new 'max-root-page' value in the database header. This
79881 ** a pointer to the new sqlite3_backup object.
79918 /* Allocate space for a new sqlite3_backup object...
79928 /* If the allocation succeeded, populate the new object. */
80428 ** to be updated with the new data before the backup operation is
80446 ** the new data into the backup.
80782 ** pMem->z into the new allocation. pMem must be either a string or
81105 ** prior to inserting new content into the Mem.
81411 ** Use this routine to reset the Mem prior to insert a new value.
81738 /* The following block sets the new values of Mem.z and Mem.xDel. It
81909 ** Create a new sqlite3_value object.
81932 ** Allocate and return a pointer to a new sqlite3_value object. If
82009 sqlite3_value **ppVal, /* Write the new value here */
82107 sqlite3_value **ppVal, /* Write the new value here */
82248 ** Create a new sqlite3_value object, containing the value of pExpr.
82262 sqlite3_value **ppVal /* Write the new value here */
82272 ** pAlloc if one does not exist and the new value is added to the
82354 ** is NULL and a value can be successfully extracted, a new UnpackedRecord
82400 ** If successful, set *ppVal to point to a new value object and return
82417 ** the column value into *ppVal. If *ppVal is initially NULL then a new
82489 const void *z, /* Text of the new string */
82557 ** Create a new virtual database engine.
82616 ** Add a new element to the Vdbe->pDblStr list.
82656 ** This routine transfers the new bytecode in pA over to pB
82754 ** Add a new instruction to the list of instructions current in the
82755 ** VDBE. Return the address of the new instruction.
82873 int op, /* The new opcode */
82935 int op, /* The new opcode */
82971 ** Add a new OP_Explain opcode.
83031 int op, /* The new opcode */
83062 ** Create a new symbolic label for an instruction that has yet to be
83983 ** The P4 operand must not have been previously defined. And the new
84019 ** insert a No-op and add the comment to that new instruction. This
84648 ** so far. The nRow value will increase as new trigger subprograms are
84691 ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
85453 /* Write the name of each database file in the transaction into the new
87702 ** Configure SQL variable iVar so that binding a new value to it signals
87804 int iReg, /* Register for new.* record */
87886 ** that sqlite3_prepare() generates. For example, if new functions or
88870 ** Create a new aggregate context for p and return a pointer to
88891 ** Allocate or return the aggregate context for a user function. A new
88992 ** This function is deprecated. Do not use it for new code. It is
89363 ** binding a new value to this variable invalidates the current query plan.
89808 ** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure
90382 ** If it does, record the new maximum blob size.
90512 int iCur, /* Index of the new VdbeCursor */
90514 u8 eCurType /* Type of the new cursor */
92419 ** This opcode saves the result of comparison for use by the new
92457 ** This opcode saves the result of comparison for use by the new
93356 /* If after trying to extract new entries from the header, nHdrParsed is
93637 Mem *pRec; /* The new record */
93715 ** out how much space is required for the new record. After this loop,
93853 ** the new record. The output register (pOp->p3) is not allowed to
93976 ** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
94004 /* A new savepoint cannot be created if there are active write
94023 /* Create a new savepoint structure. */
94038 /* Link the new savepoint into the database handle's list. */
94420 /* When the schema cookie changes, record the new cookie internally */
94445 ** database. Give the new cursor an identifier of P1. The P1
94631 ** Open a new cursor P1 that points to the same ephemeral table as
94639 VdbeCursor *pCx; /* The new cursor */
94669 ** Open a new cursor P1 to a transient table.
94725 ** empty again, rather than creating a new table. */
94821 ** Open a new cursor that points to a fake table that contains a single
95726 ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
95728 ** table that cursor P1 points to. The new record number is written
95732 ** the largest previously generated record number. No new record numbers are
95739 i64 v; /* The new rowid */
95740 VdbeCursor *pC; /* Cursor of table to get the new rowid */
95768 ** succeeded. If the random rowid does exist, we select a new one
95863 ** Write an entry into the table of cursor P1. A new entry is
95985 ** tables, register P3 contains the rowid to use with the new record in
96372 ** appending a new entry onto the btree.
97116 ** Allocate a new b-tree in the main database file if P1==0 or in the
97120 ** The root page number of the new b-tree is stored in register P2.
97160 ** This opcode invokes the parser to create a new virtual machine,
97161 ** then runs the new virtual machine. It is thus a re-entrant opcode.
97471 Mem *pEnd; /* Last memory cell in new array */
97603 ** address space. This is used by trigger programs to access the new.*
97782 ** and jump to P2 if the new value is exactly zero.
98632 ** deletion occurs. The argv[1] element is the rowid of the new
98633 ** row. This can be NULL to have the virtual table select the new
98635 ** the values of columns in the new row.
99674 ** incorrect, but is convenient because at this point the new.* values
99800 ** sqlite3VdbeSorterInit() Create a new VdbeSorter object.
99802 ** sqlite3VdbeSorterWrite() Add a single new row to the VdbeSorter
99898 ** by Write() above to determine when to create a new PMA.
100019 ** The contents of aTree[] are updated first by comparing the new PmaReader
100160 ** sets the PmaReader fields to read from the new aFile[0] and kicks off
100161 ** another background thread to populate the new aFile[1]. And so on, until
100382 ** new mapping and return SQLITE_OK. If the mapping is not attempted
100707 VdbeCursor *pCsr /* Cursor that holds the new sorter */
100711 VdbeSorter *pSorter; /* The new sorter */
100947 ** Allocate a new MergeEngine object capable of handling up to
101470 ** Flush the current contents of VdbeSorter.list to a new PMA, possibly
101480 SortSubtask *pTask = 0; /* Thread context used to create new PMA */
101572 ** flush the contents of memory to a new PMA if (a) at least one value is
101573 ** already in memory and (b) the new value will not fit in memory.
101726 ** been exhausted, this function also launches a new background thread
101727 ** to populate the new aFile[1].
101765 ** Allocate and return a new IncrMerger object to read data from pMerger.
101771 SortSubtask *pTask, /* The thread that will be using the new IncrMerger */
101773 IncrMerger **ppOut /* Write the new IncrMerger here */
102073 ** Allocate a new MergeEngine object to merge the contents of nPMA level-0
102075 ** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut
102381 ** creates a new list consisting of a single key immediately afterwards.
102593 ** Create a new bytecode() table-valued function.
102653 ** Constructor for a new bytecodevtab_cursor object.
103169 /* If the file should be created now, create it and write the new data
103858 ** Create a new expression term for the column specified by pMatch and
103859 ** iColumn. Append this new expression term to the FULL JOIN Match set
103860 ** in *ppList. Create a new *ppList if this is the first term in the
104105 ** it is a new.* or old.* trigger argument reference. Or
104122 }else if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){
105613 ** one of the special names "old" or "new".
105904 ** sequence named by pToken. Return a pointer to a new Expr node that
106285 ** Compute and return a new Expr object which when passed to
106634 ** Construct a new expression node and return a pointer to it. Memory
106696 ** Allocate a new expression node from a zero-terminated token that has
106753 ** One or both of the subtrees can be NULL. Return a pointer to the new
106877 ** Construct a new expression node for a function with multiple
107238 /* Figure out where to write the new Expr structure. */
107589 ** Add a new element to the end of an expression list. If pList is
107590 ** initially NULL, then create a new expression list.
107601 ** that the new entry was successfully appended.
107670 ** For each term of the vector assignment, append new entries to the
107985 ** when processing a new CREATE TABLE statement. A bound parameter raises
107986 ** an error for new statements, but is silently converted
108219 ** processing a new CREATE TABLE statement. When isInit is true, parameters
108588 ** satisfy the query. This is preferable to generating a new
109121 ** preexisting limit is discarded in place of the new LIMIT 1.
109141 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
109490 assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
110470 ** to a column in the new.* or old.* pseudo-tables available to
110472 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
110479 ** i is the index of the column. For a new.rowid reference, p1 is
110481 ** For a reference to any other column in the new.* pseudo-table, p1
110490 ** p1==0 -> old.rowid p1==3 -> new.rowid
110491 ** p1==1 -> old.a p1==4 -> new.a
110492 ** p1==2 -> old.b p1==5 -> new.b
110511 (pExpr->iTable ? "new" : "old"),
110969 ** it into the Parse.pConstExpr list. We should use a new bit for this,
111336 ** to re-prepare each time a new value is bound to variable pVar.
111860 ** When entering a new subquery on the pExpr argument, add all FROM clause
112027 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
112028 ** the new element. Return a negative number if malloc fails.
112043 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
112044 ** the new element. Return a negative number if malloc fails.
112165 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
112238 ** Allocate a single new register for use to hold some intermediate result.
112453 Token *pName /* The new table name. */
112474 /* Get a NULL terminated version of the new table name. */
112541 ** the schema to use the new table name. */
112570 ** it with the new table name.
112633 ** has been parsed. Argument pColDef contains the text of the new
112637 ** the new column during parsing.
112646 Column *pCol; /* The new column */
112647 Expr *pDflt; /* Default value for the new column */
112676 /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
112690 /* If the default value for the new column was specified with a
112797 ** is parsed (i.e. sqlite3AddColumn()) add the new Column data to
112930 int bQuote; /* True to quote the new name */
112969 ** uses the sqlite_rename_column() SQL function to compute the new
113014 ** Each new object is created by sqlite3RenameTokenMap().
113087 ** In other words, construct a new RenameToken object and add it
113528 ** quoted version of the new column name. */
113548 ** with the new column name, or with single-quoted versions of themselves.
113572 ** add another space after the new, single-quoted version of the
113775 ** 7. bQuote: Non-zero if the new column name should be quoted.
114004 ** 5: The new name of the table being renamed.
114007 ** It returns the new schema statement. For example:
114071 /* Modify any FK definitions to point to the new table. */
114808 /* Create new statistic tables if they do not exist, or clear them
114819 ** of the new table in register pParse->regRoot. This is important
115203 /* If necessary, remove sample iMin to make room for the new sample. */
115225 /* Insert the new sample */
116173 ** the old data with the new instead of allocating a new array. */
116499 /* Load new statistics out of the sqlite_stat1 table */
116617 ** new database, close the database on db->init.iDb and reopen it as an
116684 /* Allocate the new entry in the db->aDb[] array and initialize the schema
116783 /* If the file was opened successfully, read the schema for the new database.
117971 ** names into the new preferred names, as appropriate.
118157 Column *pCol, /* The column to receive the new DEFAULT expression */
118158 Expr *pExpr /* The new default expression */
118506 ** unqualified name for a new schema object (table, index, view or
118669 ** Begin constructing a new table representation in memory. This is
118678 ** The new table record is initialized and put in pParse->pNewTable.
118682 ** is called to complete the construction of the new table record.
118694 char *zName = 0; /* The name of the new table */
118748 /* Make sure the new table name does not collide with an existing
118838 ** The rowid for the new entry is left in register pParse->regRowid.
118839 ** The root page number of the new table is left in reg pParse->regRoot.
118960 ** Add a new column to the table currently being constructed.
119379 ** Add a new CHECK constraint to the table currently under construction.
119840 ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
120086 ** the new table will match the result set of the SELECT.
120095 Table *p; /* The new table */
120240 /* If not initializing, then create a record for the new table
120259 ** Initialize zType for the new view or table.
120274 ** statement to populate the new table. The root-page number for the
120275 ** new table is in register pParse->regRoot.
120279 ** by the new table.
120281 ** A shared-cache write-lock is not required to write to the new table,
120290 int regRec; /* A record to be insert into the new table */
120428 ** The parser calls this routine in order to create a new VIEW
120436 Select *pSelect, /* A SELECT statement that will become the new view */
121036 ** This routine is called to create a new foreign key on the table
121362 ** Create a new index for an SQL table. pName1.pName2 is the name of the index
121819 /* Link the new Index structure to its table and to the other
122098 ** to extend the array so that there is space for a new object at the end.
122105 ** space allocated for the new object is zeroed, *pnEntry updated to
122106 ** reflect the new size of the array and a pointer to the new allocation
122107 ** returned. *pIdx is set to the index of the new array entry in this case.
122117 int *pIdx /* Write the index of a new slot here */
122137 ** Append a new element to the given IdList. Create a new IdList if
122140 ** A new IdList is returned, or NULL if malloc() fails.
122207 ** creating nExtra new slots beginning at iStart. iStart is zero based.
122211 ** To append 3 new entries onto the end, do this:
122217 ** would have been: A, nil, nil, nil, B. To prepend the new slots,
122228 int nExtra, /* Number of new slots to add to pSrc->a[] */
122229 int iStart /* Index in pSrc->a[] of first new slot */
122280 ** Append a new table name to the given SrcList. Create a new SrcList if
122281 ** need be. A new entry is created in the SrcList even if pTable is NULL.
122286 ** a new one. If an OOM error does occurs, then the prior value of pList
122316 SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
122400 ** This routine is called by the parser to add a new term to the
122412 ** Return a new SrcList which encodes is the FROM with the new
122733 ** This routine starts a new transaction if we are not already within
123043 ** Create a new CTE object
123094 ** NULL, then a new WITH argument is created.
123252 ** true, then create a new entry. Otherwise return NULL.
123265 int create /* Create a new entry if true */
123305 ** new entry. Otherwise return NULL.
123504 ** Insert a new FuncDef into a FuncDefHash hash table.
123538 ** If the createFlag argument is true, then a new (blank) FuncDef
123556 u8 createFlag /* Create new entry if true and does not otherwise exist */
123587 ** install a new function. Whatever FuncDef structure is returned it will
123588 ** have fields overwritten with new information appropriate for the
123589 ** new function. But the FuncDefs for built-in functions are read-only.
123590 ** So we must not search for built-ins when creating a new function.
123608 ** new entry to the hash table and return it.
123675 ** a new one if necessary.
123959 /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
124651 int regOut, /* Put the new key into this register if not 0 */
127181 ** search the child table for rows that correspond to the new
127206 ** resolution is considered to delete rows before the new row is inserted.
127208 ** is thrown, even if the FK constraint would be satisfied after the new
127423 ** new row.
127648 ** once to "delete" the old row and once to "insert" the new row.
128003 ** first register of an array of (pTab->nCol+1) registers containing the new
128009 ** but before the new record is inserted using the INSERT convention.
128366 Token tNew = { "new", 3 }; /* Literal "new" token */
128395 ** WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN)
128771 ** the last opcode generated. The new OP_TypeCheck needs to be inserted
128772 ** before the OP_MakeRecord. The new OP_TypeCheck should use the same
128774 ** the first of a series of registers that will form the new record.
128783 ** by one slot and insert a new OP_TypeCheck where the current
128990 ** triggers. A new AutoincInfo structure is created if this is the
129112 ** new rowid that is about to be inserted. If that new rowid is
129350 /* Locate the table into which we will be inserting new information.
129437 ** for all columns of the new row.
129730 /* Compute data for ordinary columns of the new entry. Values
129845 /* Copy the new data already generated. */
129850 /* Compute the new value for generated columns after all other
129883 /* Compute the new rowid */
129921 /* Compute the new value for generated columns after all other
130084 ** the new row in the UPDATE statement.
130184 ** that regNewData points to) will contain the new rowid, or NULL in the
130206 ** The code generated by this routine will store new index entries into
130212 ** (2019-05-07) The generated code also creates a new record for the
130218 ** the new record is inserted.
130610 /* If rowid is changing, make sure the new rowid does not previously
130665 /* Check to see if the new rowid already exists in the table. Skip
130695 ** only. The table b-tree entry will be replaced by the new entry
130721 ** existing entry and then insert a new one. */
130883 /* Check to see if the new index entry will be unique */
130916 ** table, only conflict if the new PRIMARY KEY values are actually
130946 /* Generate code that executes if the new index entry is not unique */
131121 ** number is iCur, and register regData contains the new record for the
131130 int regData /* Data containing new record */
131953 ** WARNING: In order to maintain backwards compatibility, add new
131954 ** interfaces to the end of this structure only. If you insert new
132746 ** When adding new APIs, add them to the bottom of this structure
132893 ** a library that is new enough to support that API.
133293 /* Append the new shared library handle to the db->aExtension array. */
133395 ** loaded by every new database connection.
133437 ** set of routines that is invoked for each new database connection, if it
134831 ** flag setting and reports the new value.
136316 ** encoding that will be used for the main database file if a new file
136320 ** In all cases new databases created using the ATTACH command are
136326 ** new database files created using this database handle. It is only
136353 ** initialized. If the main database exists, the new sqlite.enc value
136355 ** already exists, it will be created to use the new encoding value.
136537 ** this pragma will perform new optimizations in future releases.
136557 ** of the optimizations listed above except Debug Mode, including new
136558 ** optimizations that have not yet been invented. If new optimizations are
136702 ** Configure the maximum number of worker threads. Return the new
136722 ** in each index that it looks at. Return the new limit.
136964 /* Create a new cursor for the pragma virtual table */
137126 ** a pointer to the Module object for the new virtual table.
137742 ** Add a new cleanup operation to a Parser. The cleanup should happen when
137867 ** is not possible for another thread to start a new schema change
138044 ** Two versions of the official API. Legacy and new use. In the legacy
138047 ** sqlite3_step(). In the new version, the original SQL text is retained
138160 ** Two versions of the official API. Legacy and new use. In the legacy
138163 ** sqlite3_step(). In the new version, the original SQL text is retained
138329 ** Allocate a new Select structure and return a pointer to that
138788 ** adding a new error so as to not break legacy applications.
138996 /* At this point the values for the new sorter entry are stored
138999 ** less than LIMIT+OFFSET items or (b) the new record is smaller than
139002 ** entry before inserting the new one. This way there are never more
139005 ** If the new record does not need to be inserted into the sorter,
139065 ** jump to VM address addrRepeat. Otherwise, insert a new record into
139073 ** is compared against previous row. If they match, the new row
139075 ** the VM program proceeds with processing the new row.
139754 ** Make a new pointer to a KeyInfo object
140145 /* At one time, code such as "SELECT new.x" within a trigger would
140418 Column **paCol /* Write the new column list here */
140615 ** Get a VDBE for the given parser context. Create a new one if necessary.
142196 ** Assign new cursor numbers to each of the items in pSrc. For each
142197 ** new cursor number assigned, set an entry in the aCsrMap[] array
142198 ** to map the old cursor number to the new:
142258 ** Assign a new cursor number to each cursor in the FROM clause (Select.pSrc)
142261 ** Except, do not assign a new cursor number to the iExcept'th element in
142263 ** to refer to the new cursor numbers.
142934 ** Add a new entry to the pConst object. Except, do not add duplicate
146200 ** is to fill in the TabResult structure appropriately, allocating new
146477 Trigger *pTrigger = 0; /* The new trigger */
146716 /* If this is a new CREATE TABLE statement, and if shadow tables
146810 ** Allocate space to hold a new trigger step. The allocated space
146843 ** to the new trigger step.
146897 ExprList *pEList, /* The SET clause: list of column and new values */
147412 ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
147509 ** Create and populate a new TriggerPrg object with a sub-program
147546 /* Allocate and populate a new Parse context to use for coding the
147623 ** TriggerPrg object exists, a new object is allocated and populated before
147646 /* If an existing TriggerPrg could not be located, create a new one. */
147704 ** that contain the values substituted for the new.* and old.* references
147779 ** Triggers may access values stored in the old.* or new.* pseudo-table.
147781 ** old.* or new.* tables actually are used by triggers. This information
147786 ** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
147791 ** It is not possible to determine if the old.rowid or new.rowid column is
147795 ** applies to the old.* table. If 1, the new.* table.
147807 int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */
148155 Expr *pRowidExpr = 0; /* Expression defining the new record number */
148185 int regNewRowid = 0; /* The new rowid */
148716 ** contain the new value. If the rowid is not being modified,
148755 /* Populate the array of registers beginning at regNew with the new
148756 ** row data. This array is used to check constants, create the new
148757 ** table and index records, and as the values for any new.* references
148762 ** this UPDATE statement and (b) not accessed by new.* references. The
148790 ** a new.* reference in a trigger program.
148926 /* Insert the new index entries and the new record. */
149244 ** Create a new Upsert object.
149590 ** (1) Create a new transient database file
149592 ** the new transient database file
149801 db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */
149972 ** If there already exists a module with zName, replace it with the new one.
150019 ** The actual function that does the work of creating a new module.
150042 ** External API function used to create a new virtual-table module.
150057 ** External API function used to create a new virtual-table module.
150291 ** Add a new module argument to pTable->u.vtab.azArg[].
150324 Token *pName1, /* Name of new table, or database name */
150325 Token *pName2, /* Name of new table or NULL */
150329 Table *pTable; /* The new virtual table */
150577 /* If everything went according to plan, link the new VTable structure
151058 ** new FuncDef structure that is marked as ephemeral using the
151109 /* Create a new ephemeral function definition for the overloaded
151965 ** at a time. This routine adds a new term to the end of the expression.
152904 ** the specified column into the new register, and
153071 ** and column number and continue with those new values, rather than seeking
154077 /* Set up a new SrcList in pOrTab containing the table being scanned
154171 ** become part of the new Expr.op. However, it does make the
154739 ** Add a single new WhereTerm entry to the WhereClause object pWC.
154740 ** The new WhereTerm object is constructed from Expr p and with wtFlags.
154741 ** The index in pWC->a[] of the new WhereTerm is returned on success.
154742 ** 0 is returned if the new WhereTerm could not be added due to a memory
154750 ** This is true even if this routine fails to allocate a new WhereTerm.
155196 ** add a new virtual AND term to pWC that is the combination of the
155277 ** a single table T (as shown in example B above) then create a new virtual
155283 ** then create a new virtual term like this:
155290 ** has x=A (for the same x and A) then add a new virtual conjunct term to the
155555 ** case 1. In that case, construct a new virtual term that is
155737 ** columns, then the original expression is unchanged and a new virtual
155740 ** and the new term is marked with TERM_DYNAMIC (because it's pExpr
155910 /* If a term is the BETWEEN operator, create two new virtual terms
155919 ** The two new terms are added onto the end of the WhereClause object.
155920 ** The new terms are "dynamic" and are children of the original BETWEEN
156086 ** new terms for each component comparison - "a = ?" and "b = ?". The
156087 ** new terms completely replace the original vector comparison, which is
156483 ** Note that exprAnalyze() might add new virtual terms onto the
156484 ** end of the WHERE clause. We do not want to analyze these new
156500 ** new WHERE clause terms.
156747 ** Try to insert a new prerequisite/cost entry into the WhereOrSet pSet.
156749 ** The new entry might overwrite an existing entry, or it might be
156755 Bitmask prereq, /* Prerequisites of the new entry */
156756 LogEst rRun, /* Run-cost of the new entry */
156757 LogEst nOut /* Number of outputs for the new entry */
156831 ** Create a new mask for cursor iCursor.
157375 WhereLevel *pLevel /* Write new index here */
158943 ** to be added to the list as a new entry, then return a pointer to the
159013 ** An existing WhereLoop entry might be overwritten if the new template
159016 ** fewer dependencies than the template. Otherwise a new WhereLoop is
159025 ** still might overwrite similar loops with the new template if the
159026 ** new template is better. Loops may be overwritten if the following
159090 ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new
159106 /* Allocate a new WhereLoop to add to the end of the list */
161517 /* If we reach this points it means that the new candidate path
163981 ** appending the new one.
164051 ** When rewriting a query, if the new subquery in the FROM clause
164300 ** Allocate and return a new Window object describing a Window Definition.
165177 int regNew, /* First in array of new values */
165410 ** if the input cursor is still finding new rows, that the end
165498 ** third argument. Set the Window.pOwner field of the new object to
165584 ** if( new partition ){
165587 ** Insert new row into eph table.
165646 ** if( new partition ){
165649 ** Insert new row into eph table.
165674 ** if( new partition ){
165677 ** Insert new row into eph table.
165718 ** if( new partition ){
165721 ** Insert new row into eph table.
165752 ** if( new partition ){
165755 ** Insert new row into eph table.
165767 ** The new "continue" statement in the above jumps to the next iteration
165774 ** added to the ephemeral table is the start of a new group. In
165778 ** if( new partition ){
165781 ** Insert new row into eph table.
165786 ** }else if( new group ){
165803 ** if( new partition ){
165806 ** Insert new row into eph table.
165839 ** if( new partition ){
165842 ** Insert new row into eph table.
165869 ** if( new partition ){
165872 ** Insert new row into eph table.
165921 int regNew; /* Array of registers holding new input row */
165923 int regNewPeer = 0; /* Peer values for new row (part of regNew) */
166029 ** VM code to check if the input row is the start of a new partition.
166049 /* Insert the new row into the ephemeral table */
166386 /* Construct a new Expr object from a single token */
166432 /* Add a single new term to an ExprList that is used to store a
168504 /* Initialize a new parser that has already been allocated.
168534 ** This function allocates a new parser.
168924 YYACTIONTYPE yyNewState, /* The new state to shift in */
171572 ** * Begin accepting and shifting new tokens. No new error
174165 ** allocating a new one so we don't have to have space for
175371 ** Worker function used by utf-8 APIs that create new functions:
175426 ** Create new user functions.
175527 ** a new one that always throws a run-time error.
176122 ** Create a new collating function for database "db". The name is zName
176259 ** new limit is negative.
176261 ** A new lower limit does not shrink existing constructs.
176262 ** It merely prevents new constructs that exceed the limit
176988 ** Open a new database handle.
177008 ** Open a new database handle.
177047 ** Register a new collation sequence with the database handle db.
177060 ** Register a new collation sequence with the database handle db.
177085 ** Register a new collation sequence with the database handle db.
177488 ** This test-control also resets the PRNG so that the new seed will
177526 ** is called immediately after installing the new callback and the return
177973 ** character after then zero terminator on the new text in p[].
178780 ** varint POS_COLUMN; (marks start of position list for new column)
178781 ** varint column; (index of new column)
178803 ** at D signals the start of a new column; the 1 at E indicates that the
178804 ** new column is column number 1. There are two positions at 12 and 45
178847 ** New data is spilled to a new leaf node when the current node
178867 ** SegmentWriter creates new leaf nodes, or when an interior node
178898 ** New data is spilled to a new interior node at the same height when
178915 ** and a new root interior node is generated (which should always fit
178986 ** we simply write the new doclist. Segment merges overwrite older
179070 ** Structures used by the tokenizer interface. When a new tokenizer
179100 ** Create a new tokenizer. The values in the argv[] array are the
179346 ** and used to create a new segment when the transaction is committed.
179347 ** However if this limit is reached midway through a transaction, a new
180716 ** of the new FTS4 table.
181841 ** the value of iCol encoded as a varint to *pp. This will start a new
182729 ** a pointer to the new Fts3MultiSegReader to *ppSegcsr. Otherwise, return
184271 ** database and populate output variable *p with the details of the new
184281 TokenDoclist *p, /* OUT: Docid and doclist for new entry */
184526 Fts3TokenAndCost **ppTC, /* Write new entries to *(*ppTC)++ */
184527 Fts3Expr ***ppOr, /* Write new OR root to *(*ppOr)++ */
186343 ** is defined, then it uses the new syntax. The differences between
186344 ** the new and the old syntaxes are:
186346 ** a) The new syntax supports parenthesis. The old does not.
186348 ** b) The new syntax supports the AND and NOT operators. The old does not.
186351 ** supported by the new syntax (it is replaced by the NOT operator).
186354 ** than an implicit AND. When using the new, both implicity and explicit
186360 ** non-zero the new syntax is activated. This is so both syntaxes can
186867 ** When using the new fts3 query syntax (when SQLITE_ENABLE_FTS3_PARENTHESIS
186898 ** of the tree changing, in which case *ppHead is set to the new root node.
187099 ** new root expression node.
187191 ** internal node of the new tree. */
187812 struct _fts3ht *new_ht; /* The new hash table */
187928 ** If no element exists with a matching key, then a new
187933 ** new data replaces the old data and the old data is returned.
187935 ** the new data is returned and the hash table is unchanged.
188058 ** Create a new tokenizer instance.
188654 ** Allocate a new porter tokenizer. Return a pointer to the new
189248 ** Create a new tokenizer instance.
189414 ** Allocate a new simple tokenizer. Return a pointer to the new
190227 /* Estimate the upper limit on the number of leaf nodes in a new segment
190524 ** For example, to create a new PendingList structure containing two
190559 /* Append the new serialized varint to the end of the list. */
190654 /* Malloc failed while inserting the new entry. This can only
190801 ** operation. It adds entries for each term in the new record to the
190805 ** fts3InsertData(). Parameter iDocid is the docid of the new row.
190901 ** new docid value.
190999 ** This function allocates a new level iLevel index in the segdir table.
191499 ** Allocate a new SegReader object.
191813 sqlite3_int64 iBlock, /* Block id for new block */
191987 ** current node. Create a new node (a right-sibling of the current node).
191990 ** Otherwise, the term is not added to the new node, it is left empty for
192116 ** be passed NULL. This function will allocate a new SegmentWriter object
192171 /* Figure out how many bytes are required by this new entry */
192193 ** b) be less than or equal to the term about to be added to the new
192215 /* Increase the total number of bytes written to account for the new entry. */
193007 sqlite3_int64 nByte /* Size of new segment at iAbsLevel */
193113 int iIdx = 0; /* Index of new segment */
193114 sqlite3_int64 iNewLevel = 0; /* Level/index to create new segment at */
193115 SegmentWriter *pWriter = 0; /* Used to write the new, merged, segment */
193138 ** segment. The level of the new segment is equal to the numerically
193140 ** index. The idx of the new segment is always 0. */
193439 ** created using the content=xxx option, then the new index is based on
193637 ** to reflect the new size of the pBlob->a[] buffer.
193660 ** variables for the new entry.
193801 ** Then allocate a new, empty sibling node. The key will be written
193840 ** enough to accommodate the new entry. The buffer associated with pPrev
193934 ** b) be less than or equal to the term about to be added to the new
194333 int iIdx, /* Index of new output segment */
194490 ** This function creates a new node image in blob object *pNew by copying
194497 Blob *pNew, /* OUT: Write new node image here */
194503 Blob prev = {0, 0, 0}; /* Previous term written to new node */
194515 /* Populate new node buffer */
195596 ** should be deleted from the database before inserting the new row. Or,
195602 /* Find the value object that holds the new rowid value. */
195612 /* The new rowid is not NULL (in this case the rowid will be
195618 ** Or, if the conflict mode is not REPLACE, insert the new record into
195647 /* If this is an INSERT or UPDATE operation, insert the new record. */
195681 ** merge all segments in the database (including the new segment, if
197674 ** Create a new tokenizer instance.
198969 ** Create a new JsonNode instance based on the arguments and append that
198971 ** new node, or -1 if a memory allocation fails.
199252 ** is no longer valid, parse the JSON again and return the new parse,
199253 ** and also register the new parse so that it will be available for
199337 ** If pApnd!=0, then try to append new nodes to complete zPath if it is
199339 ** new nodes are appended *pApnd is set to 1.
200747 /* Start a search on a new JSON string */
201608 ** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0),
201790 RtreeNode *pNode, /* Write new cell into this node */
202402 ** Push a new element onto the priority queue
202406 RtreeDValue rScore, /* Score for the new search point */
202407 u8 iLevel /* Level for the new search point */
202436 ** Allocate a new RtreeSearchPoint and return a pointer to it. Return
202441 RtreeDValue rScore, /* Score for the new search point */
202442 u8 iLevel /* Level for the new search point */
203983 ** Select a currently unused rowid for a new r-tree record.
204173 int bHaveRowid = 0; /* Set to 1 after new rowid is determined */
204267 ** (aData[2]..aData[argc-1]) contain a new record to insert into
204271 /* Insert the new record into the r-tree */
204274 /* Figure out the rowid of the new row. */
204915 ** If successful, a pointer to the new SQL statement is returned. Otherwise,
205971 ** new GeoPoly
205973 ** If pPoly is NULL but aCoord is not NULL, then compute a new GeoPoly from
206927 ** argv[2] = new value for _shape
206928 ** argv[3] = new value for first application-defined column....
206941 i64 newRowid; /* The new rowid */
207002 ** (aData[2]..aData[argc-1]) contain a new record to insert into
207006 /* Insert the new record into the r-tree */
207282 ** Register a new geometry function for use with the r-tree MATCH operator.
207286 const char *zGeom, /* Name of the new SQL function */
207290 RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */
207305 ** Register a new 2nd-generation geometry function for use with the
207310 const char *zQueryFunc, /* Name of new SQL function */
207315 RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */
207957 ** Create a new tokenizer instance.
208217 ** detect the new *-wal file and read the database in wal mode. At
208218 ** this point they see the new version of the database - including
208221 ** 3) The new *-wal file is checkpointed. This proceeds in the same way
208247 ** At present, for an UPDATE, both the new.* and old.* records are
208405 ** other columns should be set to the values that make up the new record
208424 ** the new values of all columns being update. The text value in the
208494 ** the new handle. Each call to sqlite3rbu_step() performs a single
208592 ** The vacuum can be resumed by calling this function to open a new RBU
208610 ** new RBU vacuum operation.
208624 ** the RBU handle passed as the first argument. The new limit is specified
208841 ** then the new RBU VFS uses the default system VFS to access the file-system.
208842 ** The new object is registered as a non-default VFS with SQLite before
209530 ** If successful, set *ppStmt to point to the new statement and return
209572 ** compilation is successful, *ppStmt is set to point to the new statement
210703 ** If an OOM error is encountered when allocating space for the new
210757 ** If an OOM error is encountered when allocating space for the new
211253 char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
211494 ** table into it. Return a pointer to the new object. It is the
211579 ** open on the target database. Use this handle instead of opening a new
212954 ** Open and return a new RBU handle.
213045 ** specifying the current target and state databases to start a new
213246 ** to point to the new file. A mutex protected linked list of all main
213250 ** 3. Using a new file-control "SQLITE_FCNTL_RBU", a main db rbu_file
214086 ** via existing VFS zParent. The new object is registered as a non-default
214146 /* Allocate the mutex and register the new VFS (not as the default) */
214338 ** Connect to or create a new DBSTAT virtual table.
214469 ** Open a new DBSTAT cursor.
215116 ** The data field of sqlite_dbpage table can be updated. The new
215251 ** Open a new dbpagevfs cursor.
215572 SessionHook hook; /* APIs to grab new and old data with */
215619 sqlite3_value **apValue; /* old.* and new.* values */
215707 ** new.* record: (insert and update only)
215709 ** The "old.*" and "new.*" records, if present, are N field records in the
215715 ** The new.* record that is part of each INSERT change contains the values
215716 ** that make up the new row. Similarly, the old.* record that is part of each
215726 ** change records took place. Within the new.* record, fields associated
215727 ** with table columns modified by the UPDATE change contain the new
215763 ** and fields associated with modified columns contain the new column values.
215800 ** was an INSERT, then the single record is a copy of the new.* record. If
215802 ** of the new.* record with the PK fields filled in based on the original
215994 ** hash-key value passed as the first. Return the new hash-key value.
216003 ** the hash-key value passed as the first. Return the new hash-key value.
216013 ** hash-key value passed as the first. Return the new hash-key value.
216022 ** new.* row currently available and, assuming no error occurs, writes it to
216033 int bNew, /* True to hash the new.* PK */
216291 u8 *aNewRecord1, /* new.* record for first change */
216292 u8 *aNewRecord2 /* new.* record for second change */
216328 /* Write the new.* vector */
216876 /* Create a new change object containing all the old values (if
216980 ** do not automatically add the new table. */
217319 /* Find new rows */
217359 /* Allocate and populate the new session object. */
217369 /* Add the new session object to the linked list of session objects
217480 /* Allocate new SessionTable object. */
217486 /* Populate the new SessionTable object and link it into the list.
217487 ** The new object must be linked onto the end of the list, not
217735 ** m bytes: new.* record (see RECORD FORMAT)
217740 ** at the current version of the row (the new.* values).
217742 ** If all of the old.* values are equal to their corresponding new.* value
217746 ** original values of any fields that have been modified. The new.* record
217747 ** contains the new values of only those fields that have been modified.
217752 sqlite3_stmt *pStmt, /* Statement handle pointing at new row */
217757 SessionBuffer buf2 = {0,0,0}; /* Buffer to accumulate new.* record in */
217823 /* Add a field to the new.* record. Or the only record if currently
218050 ** If no error occurs, SQLITE_OK is returned and the new changeset/patchset
218681 ** also allocated or resized according to the new value of p->nCol. The
218741 int *pbNew, /* If non-NULL, true if new table */
218825 /* If this is an INSERT or UPDATE, read the new.* record. */
218833 ** modified fields are present in the new.* record. The old.* record
218835 ** new.* to old.*, to accommodate the code that reads these arrays. */
218852 ** or (b) also present in the new.* record.
218890 int *pbNew /* If non-NULL, true if new table */
218982 ** iVal'th value in the new.* record. Or, if that particular value is not
218991 int iVal, /* Index of new.* value to retrieve */
219167 /* Write the header for the new UPDATE change. Same as the original. */
219171 /* Read the old.* and new.* records for the update change. */
219178 /* Write the new old.* record. Consists of the PK columns from the
219180 ** new.* record. */
219186 /* Write the new new.* record. Consists of a copy of all values
219649 ** transfers new.* values from the current iterator entry to statement
219707 ** new.* record to the SELECT statement. Or, if it points to a DELETE or
219839 /* Bind the new.* PRIMARY KEY values to the SELECT statement. */
219847 /* There exists another row with the new.* primary key. */
219861 /* No other row with the new.* primary key. */
220477 ** part of an sqlite3changeset_concat() operation. A new change object is
220592 /* Allocate a new SessionChange object. Ensure that the aRecord[]
220593 ** buffer of the new object is large enough to hold any record that
220714 /* The new object must be linked on to the end of the list, not
220834 ** Allocate a new, empty, sqlite3_changegroup.
221021 ** old.* and new.* records for the change. The rebase buffer (a single
221136 /* Append a table header to the output for this new table */
221235 ** Create a new rebaser object.
221526 ** invoked, then it is replaced by the new pointer. If an xDelete callback
221682 ** should be set to point to the new tokenizer handle and SQLITE_OK
221893 /* Create a new tokenizer */
221910 /* Create a new auxiliary function */
222346 ** Open a new iterator to iterate though all rowids that match the
222389 ** For an insert, it must be called once for each token in the new document.
223304 /* Initialize a new parser that has already been allocated.
223334 ** This function allocates a new parser.
223660 fts5YYACTIONTYPE fts5yyNewState, /* The new state to shift in */
224178 ** * Begin accepting and shifting new tokens. No new error
225226 ** pBuf, which must be already be large enough to hold the new data.
225541 ** the string and, if found, dequotes the string in place and adds a new
225815 ** Before returning, set pzOut to point to a new buffer containing a
225920 ** new Fts5Config object. If an error occurs, an SQLite error code is
227076 ** the phrase poslist buffer. The new poslist for the phrase (containing
227079 ** being read. This is safe as the entries for the new poslist are a
227143 ** to a value laster than *piLast, update *piLast to the new lastest value.
227543 ** a new poslist the way we have to for more complicated phrase or NEAR
227667 ** new lastest rowid seen so far. */
227953 ** If argument pNear is NULL, then a new Fts5ExprNearset object is allocated
228190 ** Create a new FTS5 expression by cloning phrase iPhrase of the
228326 ** a new colset object containing the contents of (p) with new value column
228639 ** Allocate and return a new expression object. If anything goes wrong (i.e.
229527 ** Allocate a new hash table.
229713 /* If an existing hash entry cannot be found, create a new one. */
229727 /* Allocate new Fts5HashEntry and add it to the hash table. */
229756 ** space to append the largest possible new entry. Worst case scenario
229759 ** + 9 bytes for a new rowid,
229761 ** + 1 byte for a "new column" byte,
229762 ** + 3 bytes for a new column number (16-bit max) as a varint,
229763 ** + 5 bytes for the new position offset (32-bit max).
229782 /* If this is a new rowid, append the 4-byte size field for the previous
229783 ** entry, and the new rowid for this entry. */
229802 /* Append a new column value, if necessary */
229816 /* Append the new position offset, if necessary */
229935 void **ppOut, /* OUT: Pointer to new object */
230118 ** varint: number of bytes of new term data (nNew)
230119 ** blob: nNew bytes of new term data
230646 ** rollback since it was last used. In this case a new blob handle
230894 ** returned. Otherwise, *ppOut is set to point to the new object and
231271 ** A new segment has just been written to level iLvl of index structure
231711 int nNew; /* Bytes of new data */
231964 int *pbNewTerm /* OUT: Set for new term */
232036 int *pbNewTerm /* OUT: Set for new term */
232316 /* Figure out how many new bytes are in this term */
232960 int *pbNewTerm /* OUT: True if *might* be new term */
233210 ** and sets pIter->base.pData/nData to point to the new position list.
233211 ** If memory is required for the new position list, use buffer pIter->poslist.
233212 ** Or, if the new position list is a contiguous subset of the input, set
233441 ** Allocate a new Fts5Iter object.
233443 ** The new object will be used to iterate through data in structure pStruct.
233469 /* Allocate space for the new multi-seg-iterator. */
233644 ** Allocate a new segment-id for the structure pStruct. The new segment
233756 ** Any new array elements are zeroed before returning.
233832 ** smaller than the first term on the new leaf.
233840 int nTerm, const u8 *pTerm /* First term on new page */
233911 /* This was the root node. Push its first rowid up to the new root. */
233977 /* The new leaf holds no terms or rowids */
234051 /* Append the number of bytes of new data, then the term data itself
234229 int iOff = pSeg->iTermLeafOffset; /* Offset on new first leaf page */
234256 /* Set up the new page-index array */
234342 /* Add the new segment to the output level */
234377 /* This is a new term. Append a term to the output segment. */
234572 ** Flush the contents of in-memory hash table iHash to a new level-0
234584 /* Obtain a reference to the index structure and allocate a new segment-id
234585 ** for the new level-0 segment. */
234785 ** the new Fts5Level object so that pLvl->aSeg[0] is the oldest
235403 ** Open a new Fts5Index handle. If the bCreate argument is true, create
235406 ** If successful, set *pp to point to the new object and return SQLITE_OK.
235517 ** For an insert, it must be called once for each token in the new document.
235555 ** Open a new iterator to iterate though all rowid that match the
235937 const char *z, int n, /* Possibly new term to test */
236284 /* If this is a new term, query for it. Update cksum3 with the results. */
236871 ** xBegin(): Start of a new transaction.
237199 /* Allocate the new vtab object and parse the configuration */
237688 ** If the new rowid is not equal to the old, set output parameter *pbSkip
237829 ** handles here, rather than preparing a new one for each query. But that
238440 ** 2. The "new" rowid.
239426 ** Register a new auxiliary function with global context pGlobal.
239430 const char *zName, /* Name of new function */
239464 ** Register a new tokenizer. This is the implementation of the
239469 const char *zName, /* Name of new function */
239525 const char *zName, /* Name of new function */
240027 ** Open a new Fts5Index handle. If the bCreate argument is true, create
240030 ** If successful, set *pp to point to the new object and return SQLITE_OK.
240424 ** Allocate a new rowid. This is used for "external content" tables when
240425 ** a NULL value is inserted into the rowid column. The new rowid is allocated
240451 ** Insert a new row into the FTS content table.
240461 /* Insert the new row into the %_content table. */
240486 ** Insert new entries into the FTS index and %_docsize table.
244326 ** The stmtConnect() method is invoked to create a new
244384 ** Constructor for a new stmt_cursor object.