Lines Matching refs:single
4 ** single large file, the entire code can be compiled as a single translation
7 ** of 5% or more are commonly seen when SQLite is compiled as a single
1472 ** a single attached database that occur due to other database connections,
1649 ** consist of a single "-" character followed by no more than
1899 ** single thread. All open [database connections] must be closed and all
1994 ** [sqlite3_config()] except that the changes apply to a single
2101 ** by a single thread. ^If SQLite is compiled with
2139 ** <dd> ^(The SQLITE_CONFIG_MALLOC option takes a single argument which is
2148 ** <dd> ^(The SQLITE_CONFIG_GETMALLOC option takes a single argument which
2157 ** <dd> ^The SQLITE_CONFIG_SMALL_MALLOC option takes single argument of
2167 ** <dd> ^The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int,
2238 ** <dd> ^(The SQLITE_CONFIG_MUTEX option takes a single argument which is a
2250 ** <dd> ^(The SQLITE_CONFIG_GETMUTEX option takes a single argument which
2273 ** <dd> ^(The SQLITE_CONFIG_PCACHE2 option takes a single argument which is
2279 ** <dd> ^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which
2304 ** <dd>^(The SQLITE_CONFIG_URI option takes a single argument of type int.
2318 ** <dd>^The SQLITE_CONFIG_COVERING_INDEX_SCAN option takes a single integer
2376 ** <dd>^The SQLITE_CONFIG_PCACHE_HDRSZ option takes a single parameter which
2384 ** <dd>^The SQLITE_CONFIG_PMASZ option takes a single parameter which
2395 ** <dd>^The SQLITE_CONFIG_STMTJRNL_SPILL option takes a single parameter which
2409 ** <dd>The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter
2425 ** <dd>The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter
2605 ** a single SQL query statement will always use the same algorithm regardless
3074 ** ^(There can only be a single busy handler defined for each
3104 ** ^(There can only be a single busy handler for a particular
3440 ** ^(Only a single authorizer can be in place on a database connection
3615 ** statement generates a single row of result.
3683 ** ^Only a single progress handler may be defined at one time per
3958 ** hexadecimal escape sequences replaced by a single byte containing the
4235 ** An instance of this object represents a single SQL statement that
4330 ** in a single prepared statement, an SQLITE_NOMEM error is returned.</dd>)^
4351 ** <dd>The maximum number of auxiliary worker threads that a single
4701 ** sqlite3_value object. If SQLite is compiled to be single-threaded
4853 ** destructor D with a single argument of P when it is finished using
5267 ** ^These routines return information about a single column of the current
5569 ** the same inputs within a single SQL statement. Most SQL functions are
5619 ** invoked, it is passed a single argument which is a copy of the application
5834 ** except that these routines take a single [protected sqlite3_value] object
6419 ** can be used, a single callback function may be registered with the
7068 ** by all database connections within a single process.
7597 ** operand is only available if it appears as a single constant literal
7683 ** to strings where the array is terminated by a single NULL pointer.
8027 ** single default VFS that is appropriate for the host computer.
8075 ** a single-threaded application. The SQLITE_MUTEX_PTHREADS and
8289 ** The [sqlite3_mutex_alloc()] interface takes a single argument
8569 ** single-byte character C onto the end of [sqlite3_str] object X.
8737 ** about a single [database connection]. ^The first argument is the
8952 ** been run. A single "run" for the purposes of this counter is one
9001 ** The sqlite3_pcache_page object represents a single page in the
9105 ** single database page. The pExtra element of sqlite3_pcache_page will be
9143 ** The cache must not perform any reference counting. A single
9480 ** single void* pointer that is passed to the callback when it is invoked.
9644 ** A single database handle may have at most a single write-ahead log callback
10038 ** are adjacent.)^ ^(Furthermore, only a single row for each particular
10095 ** only sees a single value from the right-hand side of the IN operator
10406 ** ^At most one preupdate hook may be registered at a time on a single
11008 ** It is possible to create multiple session objects attached to a single
11118 ** If a single row is affected by more than one operation within a session,
11151 ** KEY may consist of a single column, or may be a composite key.
11228 ** each representing a change to a single row of an attached table. An INSERT
11253 ** single table are grouped together. In other words, when iterating through
11255 ** to a single table are processed before moving on to the next table. Tables
11258 ** a single table are stored is undefined.
11312 ** This may appear to have some counter-intuitive effects if a single row
11434 ** a single table are grouped together, tables appear in the order in which
11495 ** that apply to a single table are grouped together. This means that when
11497 ** this function, all changes that relate to a single table are visited
11811 ** single changeset. The result is a changeset equivalent to applying
11856 ** (or patchsets) into a single changeset (or patchset). A single changegroup
11909 ** contain changes that apply to a single row, the final contents of the
11977 ** sqlite3session_patchset() functions, all changes related to a single
12204 ** a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The
12376 ** simultaneously. If a single key is modified by multiple remote
12391 ** case of multiple remote UPDATE operations, some fields of a single
12488 ** require that the entire changeset be stored in a single buffer in memory.
12490 ** a pointer to a single large buffer allocated using sqlite3_malloc().
12495 ** In order to avoid this problem, instead of a single large buffer, input
12531 ** pointer to a single large buffer. In this case, a pair of parameters such
12859 ** Each extension function is allocated a single auxiliary data slot for
12861 ** more than once for a single FTS query, then all invocations share a
12862 ** single auxiliary data context.
12897 ** method, to iterate through all instances of a single query phrase within
13096 ** <ol><li> By mapping all synonyms to a single token. In this case, using
13107 ** tokenizer may provide multiple synonyms for a single term
13123 ** being treated as a single phrase.
13125 ** <li> By adding multiple synonyms for a single term to the FTS index.
13154 ** xToken() is called. Multiple synonyms may be specified for a single token
13157 ** single token.
13338 ** The maximum length of a single SQL statement in bytes.
13917 ** All elements of the hash table are on a single doubly-linked list.
13941 ** structure. All elements are stored on a single doubly-linked list.
15023 ** RESERVED: A single process may hold a RESERVED lock on a file at
15025 ** PENDING: A single process may hold a PENDING lock on a file at
15049 ** A SHARED_LOCK is obtained by locking a single randomly-chosen
15055 ** a single byte of the file that is designated as the reserved lock byte.
15064 ** But a single Win95 reader will lock out all WinNT readers and a single
15083 ** that all locks will fit on a single page even at the minimum page size.
15693 /* An instance of the BtreePayload object describes the content of a single
15864 ** A single VDBE is an opaque structure named "Vdbe". Only routines
15878 ** A single instruction of the virtual machine has an opcode
16580 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */
16705 ** SQLITE_MUTEX_NOOP For single-threaded applications. No
16801 ** In shared cache mode, a single Schema object can be shared by multiple
17327 ** a single object of this type is allocated. FuncDestructor.nRef is set to
17372 ** single query - might change over time */
17428 ** a single query. The iArg is ignored. The user-data is always set
17569 ** a single allocation. Each string is 0x00 terminated. The datatype
17658 ** for a numeric type is a single comparison. And the BLOB type is first.
17706 ** All VTable objects that correspond to a single table in a shared
18294 ** two or more Expr objects will be stored in a single memory allocation,
18572 ** The SrcItem object represents a single term in the FROM clause of a query.
18644 ** content for an SQL statement. For example, a single SrcList object
18771 ** An instance of the following object describes a single ON CONFLICT
18808 ** needed to generate code for a single SELECT statement.
18908 ** SRT_Mem Only valid if the result is a single column.
18913 ** SRT_Set The result must be a single column. Store each
18978 #define SRT_Coroutine 13 /* Generate a single row of result */
19301 ** 2. All triggers associated with a single table form a linked list, using the
19335 ** An instance of struct TriggerStep is used to store a single SQL statement
19580 SrcItem *pSrcItem; /* A single FROM clause item */
19632 ** A single common table expression
19697 ** (1) A single instance of this structure is attached to the
19702 ** (2) All window functions in a single SELECT form a linked-list
20230 #define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */
20450 ** The common case is for a varint to be a single byte. They following
20922 ** a single bit set.
21230 ** option requires a separate macro because legal values contain a single
22421 ** VDBE. This information used to all be at the top of the single
22481 ** * A one-row "pseudotable" stored in a single register
22753 ** of this structure. All such structures associated with a single VM
22796 /* The ScanStatus object holds a single value for the
22955 ** single-byte varint.
23302 ** Query status information for a single database connection
23567 ** A structure for holding a single date and time.
25837 ** into a single structure named "mem". This is to keep the
26386 ** into a single structure named "mem3". This is to keep the
27011 ** then the two blocks are coalesced into the single larger block.
27068 ** into a single structure named "mem5". This is to keep the
27948 ** that use SQLite in a single thread. The routines defined
28180 ** home-grown mutexes. Encapsulate these conditions into a single #define.
29315 ** Maximum size of any single memory allocation.
31385 ** Generate a single line of output for the tree, with a prefix that contains
31413 ** Shorthand for starting a new tree item that consists of a single label
32645 /* All threads share a single random number generator.
32807 ** single threaded systems. Nothing in SQLite requires multiple threads.
32810 ** single-threaded if desired.
32822 #define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */
32845 /* This routine is never used in single-threaded mode */
32894 #define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */
33170 ** Translate a single UTF-8 character. Return the unicode value.
33188 ** byte of a character are interpreted as single-byte characters
33295 ** A single byte is required for the output string
34761 ** single-byte case. All code should use the MACRO version as
34762 ** this function assumes the single-byte case has already been handled.
34934 ** Translate a single byte of Hex into an integer.
35496 /* Remove a single entry from the hash table given a pointer to that
35839 /* A single open file. There are only two files represented by this
36234 ** by a single space, then the encoding of the journal. The space
37958 ** A single inode can have multiple file descriptors, so each unixFile
38211 ** we always increase the file size to 1 by writing a single byte
38494 ** byte', each single bytes at well known offsets, and the 'shared byte
38502 ** single randomly selected by from the 'shared byte range' is locked.
39035 ** (1) There is zero concurrency. A single reader blocks all other
39217 ** a single exclusive lock. In other words, SHARED, RESERVED, and
39220 ** only a single process can be reading the database at a time.
39424 ** supports EXCLUSIVE locking. Only a single process can read or write
40702 ** writes a single byte into that file in order to work around a bug
40760 ** single byte to the last byte in each block that falls entirely
40761 ** within the extended region. Then, if required, a single byte
41144 ** has its own unixShm object, but they all point to a single instance
41148 ** Each unixShmNode object is connected to a single unixInodeInfo object.
41683 ** writing a single byte to the end of each (OS) page being
43770 ** single host at a time and moving file locks off of the database file
43811 ** * conch file to limit access to the database file to a single host
43830 ** The proxy file - a single-byte file used for all advisory file locks
44931 ** single thread. The memory allocation and mutex subsystems have not
48777 ** Object used to represent a single file opened and mmapped to provide
48780 ** point to a single instance of this object. In other words, each
51310 ** connected to a single database connection and do not require additional
52627 ** entry in the cache holds a single page of the database file. The
52670 ** When sqlite3PcacheTrace is 1, single line trace messages are issued.
53605 ** If N is positive, then N pages worth of memory are allocated using a single
53680 ** (2) There is a single global PGroup that all PCaches are a member
53688 ** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single
53703 ** temporary or transient database) has a single page cache which
54239 ** private PGroup (mode-1). pcache1.separateCache is false if the single
54244 ** * Use a unified cache in single-threaded applications that have
55146 ** tree with depth of iDepth. A depth of 1 means the tree contains a single
55229 /* Merge the forest into a single sorted list on first call */
55537 ** number consists of a single page change.
56267 ** size as a single disk sector. See also setSectorSize().
57188 ** If zSuper is a NULL pointer (occurs for a single database transaction),
57740 ** Read a single page from either the journal file (if isMainJrnl==1) or
58005 ** Parameter zSuper is the name of a super-journal file. A single journal
58042 ** TODO: This function allocates a single block of memory to load
58159 ** currently is, so detect this case and write a single zero byte to
58230 ** might change if a crash occurs while writing to a single byte in
59093 ** single disk sector is atomic, then this mode provides
60154 /* Write a single frame for this page to the log. */
60917 ** single unnecessary sqlite3OsRead() call at the start-up.
61549 ** Mark a single data page as writeable. The page is written into the
61735 ** fit on a single disk sector. In this case all co-resident pages
61950 ** super-journal (a single database transaction).
62221 ** The start of the journal file currently contains a single journal
63062 ** including all ATTACHed databases. This seems expensive for a single
63380 ** Each frame records the revised content of a single page from the
63383 ** contains a commit marker. A single WAL can and usually does record
63388 ** A single WAL file can be used multiple times. In other words, the
63476 ** of the database from a single point in time. This technique allows
64171 ** This function encodes a single frame header and writes it to a buffer
64982 ** This function merges two sorted lists into a single sorted list.
66647 ** There can only be a single writer active at a time.
66896 ** Write out a single frame of the WAL
66994 int szFrame; /* The size of a single frame */
67601 ** In this implementation, a single file can hold one or more separate
67657 ** space in a page that can be consumed by a single cell for standard
67790 /* The maximum number of cells on a single page of the database. This
67828 ** An instance of this object stores information about each a single database
67957 ** An instance of this object represents a single database file.
67959 ** A single database file can be in use at the same time by two
68024 u8 *pTmpSpace; /* Temp space sufficient to hold a single cell */
68072 ** A single database file can be shared by two more database connections,
68196 ** entry consists of a single byte 'type' and a 4 byte parent page number.
68551 ** in single threaded applications that use shared cache. Except for
68745 ** Implementation of the SQLITE_CORRUPT_PAGE() macro. Takes a single
68943 ** only be a single writer).
69728 ** on a single B-tree page. Make necessary adjustments to the CellInfo
70755 /* To many cells for a single page. The page must be corrupt */
72080 ** consisting of a single page and no schema objects). Return SQLITE_OK
72494 ** Perform a single step of an incremental-vacuum. If successful, return
72631 ** It performs a single unit of work towards an incremental vacuum.
72777 ** (single database transaction).
73967 ** single child page. This can only happen with the table rooted at page 1.
74375 ** single byte varint and the record fits entirely on the main
74544 ** single byte varint and the record fits entirely on the main
76253 ** pParent is its parent. pPage must have a single overflow entry
76462 ** same amount of free space. Usually a single sibling on either side of the
77442 ** single call to balance_quick() is made for each call to this
77886 ** multiple records into an intkey b-tree using a single cursor (as can
78049 ** associated with a single table entry and its indexes. Only one of those
78479 ** Delete all information from a single table in the database. iTable is
78512 ** Delete all information from the single table that pCur is open on.
79014 ** Do various sanity checks on a single page of a tree. Return
79299 ** happens when performing an integrity check on a single table. The
79524 ** a single shared-btree. The memory is used by client code for its own
79660 ** Set both the "read version" (single byte at byte offset 18) and
79661 ** "write version" (single byte at byte offset 19) fields in the database
79792 ** Once it has been created using backup_init(), a single sqlite3_backup
80526 ** within a single call (unless an error occurs). The assert() statement
80562 ** stores a single value in the VDBE. Mem is an opaque structure visible
80685 ** A single int or real value always converts to the same strings. But
82140 /* Handle negative integers in a single step. This is needed in the
82332 ** A single call to this function populates zero or more fields of the
82334 ** right starting with 0). A single field is populated if:
83554 ** Generate code (a single OP_Abortable opcode) that will
84478 ** Print a single opcode. This routine is used for debugging only.
84569 ** with no indexes using a single prepared INSERT statement, bind()
87284 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
87383 ** at the start of (pKey1/nKey1) fits in a single byte.
87458 ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
88848 ** is requested more than once within the same run of a single prepared
88914 ** single prepared statement. The iArg values must match.
90007 ** Return status data for a single loop within query pStmt.
91914 ** The registers P1 through P1+P2-1 contain a single row of
93835 /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint
94821 ** Open a new cursor that points to a fake table that contains a single
94826 ** A pseudo-table created by this opcode is used to hold a single
97486 ** disabled. In some cases a single trigger may generate more than one
97489 ** single trigger all have the same value for the SubProgram.token
98167 ** Perform a single step of the incremental vacuum procedure on
98932 ** Programs contain a single instance of this opcode as the very first
99802 ** sqlite3VdbeSorterWrite() Add a single new row to the VdbeSorter
99867 ** If the sorter is running in single-threaded mode, then all PMAs generated
99868 ** are appended to a single temporary file. Or, if the sorter is running in
99886 ** sorter is running in single-threaded mode, then these PMAs are merged
99893 ** merged T bytes of data into a single sorted PMA, the main thread
99911 ** thread to merge the output of each of the others to a single PMA for
100040 ** This object represents a single thread of control in a sort operation.
100045 ** single-threaded operation, there is exactly one instance of this object
100085 ** Main sorter structure. A single instance of this is allocated for each
100146 ** There are two types of IncrMerger object - single (bUseThread==0) and
100164 ** A single-threaded IncrMerger does not open any temporary files of its
100167 ** background thread to prepare data for the PmaReader, with a single
100201 ** This object is the header on a single record while that record is being
100209 ** Or, if using the single large allocation method (VdbeSorter.list.aMemory!=0),
100235 /* Maximum number of PMAs that a single MergeEngine can merge */
100498 ** contains a single PMA, and that that PMA omits the initial length varint.
100699 ** The sorter can guarantee a stable sort when running in single-threaded
101120 ** Merge the two sorted lists p1 and p2 into a single list.
101571 ** If using the single large allocation mode (pSorter->aMemory!=0), then
101720 ** For single-threaded objects, this is accomplished by literally reading
101857 ** Only INCRINIT_NORMAL is valid in single-threaded builds (when
101903 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
101906 /* Verify that the MergeEngine is assigned to a single thread */
101972 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
101978 ** requires two temp files to itself, whereas a single-threaded object
102051 ** Or, if the IncrMerger is single threaded, the same function is called
102270 ** up either VdbeSorter.pMerger (for single threaded sorters) or pReader
102320 ** in single-threaded mode. This is important, as the
102381 ** creates a new list consisting of a single key immediately afterwards.
102896 ** We must have a single stmt=? constraint that will be passed through
105014 ** pE is a pointer to an expression which is a single term in the
105685 ** list rather than a single expression.
105760 ** Resolve names in expressions that can only reference a single table
105835 ** Return the affinity character for a single column of a table.
106260 ** that return a single column!) then return pVector unmodified.
106635 ** for this node and for the pToken argument is a single allocation
106948 ** Wildcards consisting of a single "?" are assigned the next sequential
106983 i = z[1]-'0'; /* The common case of ?N for a single digit N */
108082 ** is considered a variable but a single-quoted string (ex: 'abc') is
108108 ** for any single row of the table with cursor iCur. In other words, the
108229 ** is considered a variable but a single-quoted string (ex: 'abc') is
108518 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
109395 ** into a single opcode. */
109402 /* Combine Step 3 and Step 5 into a single opcode */
112238 ** Allocate a single new register for use to hold some intermediate result.
112412 ** database zDb with their single-quoted equivalents. If argument bTemp is
113548 ** with the new column name, or with single-quoted versions of themselves.
113570 ** using single quotes. If the character immediately following the
113571 ** original token within the input SQL was a single quote ('), then
113572 ** add another space after the new, single-quoted version of the
114174 ** double-quotes use single quotes instead.
114665 ** must be separated from the last integer by a single space. If the
114670 ** column contains a single integer which is the (estimated) number of
114745 ** all contain just a single integer which is the same as the first
115574 ** a single table.
115778 /* For a single-column UNIQUE index, once we have found a non-NULL
115913 /* Create a single sqlite_stat1 entry containing NULL as the index
115971 ** Generate code that will do an analysis of a single table in
115972 ** a database. If pOnlyIdx is not NULL then it is a single index
116003 ** Form 2 analyzes all indices the single database named.
116907 ** This procedure generates VDBE code for a single invocation of either the
117206 ** All of the code in this file may be omitted by defining a single
117588 ** This routine is called after a single SQL statement has been
118119 ** "main" and "temp") for a single database connection.
118652 ** Insert a single OP_JournalMode query opcode in order to force the
118907 ** of the DML statement. That TEMP trigger contains a single SELECT
119295 ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
121447 /* Because the parser constructs pTblName from a single identifier,
121936 ** point at most a single index (the newly added index) will be out of
122910 Db *pDb; /* A single database */
123717 ** the name of a single table, as one might find in an INSERT, DELETE,
124266 nKey = 1; /* OP_DeferredSeek always uses a single rowid */
124390 ** This routine generates VDBE code that causes a single row of a
124391 ** single table to be deleted. Both the original table entry and
124407 ** single memory location iPk.
124566 ** index entries associated with a single row of a single table, pTab
125392 ** "[a-z]" matches any single lower-case letter. To match a '-', make
125424 ** single character of the input string for each "?" skipped */
125440 assert( matchOther<0x80 ); /* '[' is a single-byte character */
125622 /* The escape character string must consist of a single UTF-8 character.
125629 "ESCAPE expression must be a single character", -1);
125837 ** Strings are surrounded by single-quotes with escapes on interior quotes
126586 /* If removing single accumulated string, harmlessly over-do. */
127217 ** statement that inserts a single row only (no triggers). In this case,
127277 ** If the parent key consists of a single column (the foreign key constraint
127324 /* If this is a non-composite (single column) foreign key, check if it
127845 ** to this function contains a single entry guaranteed to resolve to
128153 /* Inserting a single row into a parent table cannot cause (or fix)
129207 ** insert with data coming from a single-row VALUES clause, the code executes
129221 ** in other words if the SELECT pulls all columns from a single table
129340 ** single row (the common case) then keep that one row of values
129508 ** produces a single row of the SELECT on each invocation. The
129577 ** single-row VALUES clause
130415 ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single
130486 ** OE_Update guarantees that only a single row will change, so it
130515 /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
130520 /* A single ON CONFLICT DO UPDATE. Make all resolutions OE_Update */
133632 ** or that return single-column results where the name of the
134425 ** Generate code to return a single integer value.
134433 ** Generate code to return a single text value.
134591 ** Generate code to output a single-column result row with a value of the
135409 ** Return a single row for each column of the named table. The columns of
135473 ** Return a single row for each table, virtual table, or view in the
135897 ** All schemas are checked by default. To check just a single
137335 ** data structures for a single database file. The index of the
137749 ** common cleanups, we save a single NULL-pointer comparison in
138778 ** JOINs. If only a single table on the left side of this join
139585 ** then there should be a single item on the stack. Write this
139767 ** can only be changed if this is just a single reference to the object.
139829 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
140221 ** origin info for the single column in the result set of the SELECT
140781 ** one. Each row extracted from Queue is output to pDest. Then the single
140924 /* Output the single row in Current */
140935 /* Execute the recursive SELECT taking the single row in Current as
142321 ** a single flat select, like this:
142363 ** table sqlite_once that consists of a single row containing a
142364 ** single NULL.
142786 /* The subquery uses a single slot of the FROM clause of the outer
144632 ** Add a single OP_Explain instruction to the VDBE to explain a simple
144762 ** Deallocate a single AggInfo object
145284 /* Implement a co-routine that will return a single row of the result
145393 ** The second form is preferred as a single index (or temp-table) may be
145767 ** it might be a single loop that uses an index to extract information
145923 /* Generate a subroutine that outputs a single row of the result
146056 ** processing is much simpler since there is only a single row
146207 char *z; /* A single column of result */
147389 ** Generate VDBE code for the statements inside the body of a single
148568 ** Do not consider a single-pass strategy for a multi-row update if
148572 ** or index, causing a single-pass approach to malfunction. */
148954 /* Nothing to do at end-of-loop for a single-pass */
149022 ** makes a single invocation of VUpdate.
149330 ** single column of an index. The sCol[0] node will be the TK_COLLATE
150270 ** structure is associated with a single sqlite3* user of the schema.
150797 ** or else must have a single-column PRIMARY KEY */
151365 ** This object contains information needed to implement a single nested
151373 ** The WhereInfo object contains a single instance of this object for
151528 ** All WhereTerms are collected into a single WhereClause structure.
151558 ** but they do so indirectly. A single WhereMaskSet structure translates
152041 ** defined at compile-time. If it is not a no-op, a single OP_Explain opcode
152153 ** Add a single OP_Explain opcode that describes a Bloom filter.
152437 ** single value. Since the parser never creates such a vector, some
152471 ** Generate code for a single equality term of the WHERE clause. An equality
152699 WhereTerm *pTerm; /* A single constraint term */
152987 ** Say there is a single row in t2 that matches (t1.a=t2.b), but its
153462 /* Case 2: We can directly reference a single row using an
153821 ** of expensive seek operations by replacing a single seek with
154187 WhereInfo *pSubWInfo; /* Info for single OR-term scan */
154351 /* Tables marked isRecursive have only a single row that is stored in
154739 ** Add a single new WhereTerm entry to the WhereClause object pWC.
154924 ** a single escape character. The second condition is necessary so
155264 ** A single subterm might be a set of AND-connected sub-subterms.
155276 ** If all subterms are of the form T.C=expr for some single column of C and
155277 ** a single table T (as shown in example B above) then create a new virtual
155299 ** If all subterms are indexable by a single table T, then set
155461 ** something other than == on a column in the single table. The 1-bit
155463 ** "table.column=expr" for some single table. The one bit that is set
156299 ** single virtual table in the FROM clause of the SELECT.
156705 ** a single row is to be changed. Return ONEPASS_MULTI (2) if the one-pass
157378 WhereTerm *pTerm; /* A single term of the WHERE clause */
158008 ** to pRec. If pRec contains a single field, the set of samples to search
158190 ** Return the affinity for a single column of an index.
158347 ** used, a single range inequality reduces the search space by a factor of 4.
158606 tRowcnt nEst; /* Number of rows for a single term */
159889 ** Add all WhereLoop objects for a single table of the join where the table
160334 ** (2) Multiple outputs from a single IN value will not merge
160928 WhereTerm *pTerm; /* A single term of the WHERE clause */
161395 /* Seed the search with a single WherePath containing zero WhereLoops.
161718 ** Most queries use only a single table (they are not joins) and have
161875 ** at most a single row.
162094 ** same as a SELECT with only a single table in the FROM clause.) For
162189 WhereLevel *pLevel; /* A single level in pWInfo->a[] */
162190 WhereLoop *pLoop; /* Pointer to a single WhereLoop object */
162230 ** return value. A single allocation is used to store the WhereInfo
162705 ** loop below generates code for a single nested loop of the VM
163180 ** the same window declaration (the OVER bit), then a single scan may
164478 ** or not. Identical window objects can be processed in a single scan.
164550 /* The inline versions of min() and max() require a single ephemeral
164667 ** A single instance of this structure is allocated on the stack by
165029 ** aggregate window functions that use the standard API, a single
165348 ** generates VM code for a single RETURN_ROW, AGGSTEP or AGGINVERSE
165791 ** 2. Instead of processing a single row, each RETURN_ROW, AGGSTEP or
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
166797 ** The action table is constructed as a single large table named yy_action[].
166813 ** yy_action[] A single table containing all actions.
167642 /* The following structure represents a single element of the
171510 /* Check that the stack is large enough to grow by a single entry
172887 ** Insert a single space character into pStr if the current string
173086 ** (2) NORMAL We are in the middle of statement which ends with a single
173208 case '"': /* single- and double-quoted strings */
173894 ** single argument which is a pointer to an instance of the
173903 ** single argument which is a pointer to an instance of the
173912 ** single argument of type int, interpreted as a boolean, which enables
173933 ** a single parameter which is a pointer to an integer and writes into
173955 ** single argument which is a pointer to an sqlite3_pcache_methods2
173963 ** single argument which is a pointer to an sqlite3_pcache_methods2
174045 /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
174055 ** option takes a single integer argument which is interpreted as a
174567 ** copies of a single function are created when create_function() is called
174683 ** Return the transaction state for a single databse, or the maximum
177805 ** run a single CREATE TABLE statement to construct the imposter table in
178339 /* Since nOpt is normally in single digits, a linear search is
178765 ** A docid is the unique integer identifier for a single document.
178810 ** a single docid. A "column-list" is the set of positions for a single
178821 ** iterate through a single leaf node's data) and LeavesReader (to
178850 ** node (a leaf node with a single term and doclist). The goal of
178940 ** level 0 segments are merged into a single level 1 segment. Level 1
178942 ** segments are merged to a single level 2 segment (representing
179251 ** structure. All elements are stored on a single doubly-linked list.
179337 ** FTS3_MERGE_COUNT segments of level N, they are merged into a single
179526 ** statements is run and reset within a single virtual table API call.
179550 ** A single FTS4 table may have multiple full-text indexes. For each index
179675 ** sequence. A single token is the base case and the most common case.
179843 int bLookup; /* True if a lookup of a single entry. */
180130 ** Read a single varint from the doclist at *pp and advance *pp to point
180730 ** and its contents are allocated using a single allocation. It
181514 ** This function is used to process a single interior node when searching
181706 ** varints. Each call to this function appends a single varint to a list.
181724 ** a single document record of a doclist. So, in other words, this
181737 ** varint. A single POS_END (0) byte. Except, if the 0 byte is preceded by
181767 ** A column-list is list of delta-encoded positions for a single column
181768 ** within a single document within a doclist.
182135 ** This function is used to read a single varint from a buffer. Parameter
182140 ** If *pp does not point to or past pEnd, then a single varint is read
182167 ** This function is used to write a single varint to a buffer. The varint
182447 ** Merge all doclists in the TermSelect.aaOutput[] array into a single
182461 ** into a single doclist.
182527 ** as a single-byte delta, whereas in the second it must be stored as a
182679 ** single level therein.
182931 ** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry
183020 ** full-text query or docid lookup, the statement retrieves a single
183413 ** function merges all segments in the database to a single segment.
183794 ** entries within a single segment b-tree. An Fts3MultiSegReader uses multiple
183798 ** If the allocated Fts3MultiSegReader just seeks to a single entry in a
184572 ** of data that will fit on a single leaf page of an intkey table in
184917 ** where "*" may match any single token. The position list in this case
186361 ** be tested using a single build of testfixture.
186487 ** single token and set *ppExpr to point to it. If the end of the buffer is
186611 ** Fts3PhraseToken structures token buffers are all stored as a single
186612 ** allocation so that the expression can be freed with a single call to
186837 ** with a quoted phrase, only with a single token. Not sure if this was
187385 ** Free a single node of an expression tree.
187750 ** single parameter "keyClass". The return value of ftsHashFunction()
187860 /* Remove a single entry from the hash table given a pointer to that
189525 ** single block of memory. It then dequotes any of the strings that appear
190245 ** Read a single entry from the %_segdir table. The entry from absolute
190257 ** Return a single row if the segment with end_block=? is appendable. Or
190439 ** separate component values into the single 64-bit integer value that
190520 ** Append a single varint to a PendingList buffer. SQLITE_OK is returned
191007 ** level, they are merged into a single level (iLevel+1) segment and the
191041 ** full, merge all segments in level iLevel into a single iLevel+1
191062 ** This function reads data from a single row of the %_segments table. The
192437 ** This function is used after merging multiple segments into a single large
192650 ** unnecessary merge/sort operations for the case where single segment
192861 ** and a single term returned with the merged doclist.
193096 ** Merge all level iLevel segments in the database into a single
193098 ** single segment with a level equal to the numerically largest level
193137 /* This call is to merge all segments in the database to a single
193152 ** a single iLevel+2 segment if necessary. */
193611 ** An object of the following type is used to read data from a single
193827 ** A node header is a single 0x00 byte for a leaf node, or a height varint
193994 ** root node. If the segment fits entirely on a single leaf node, iRoot
194009 /* The entire output segment fits on a single node. Normally, this means
194018 ** pointer to the single content node. So that the segment consists of a
194019 ** single leaf and a single interior (root) node.
195275 ** a single checksum for the entire index.
195377 ** included, except that it only contains entries for a single row of the
195682 ** there was any data to flush) into a single segment.
196539 ** delta-encoded list of term offsets within a single column of a single
196566 ** This function gathers 'y' or 'b' data for a single phrase.
196625 ** for a single query.
196784 ** hits for a single phrase on a single row in order to calculate the
197157 ** below attempts to locate a single fragment of text nToken tokens in
198353 /* A single node of parsed JSON
198480 /* Append a single character
198740 ** Translate a single byte of Hex into an integer.
199002 ** Parse a single JSON value which begins at pParse->zJson[i]. Return the
199794 /* With a single PATH argument */
200966 ** The data structure for a single virtual r-tree table is stored in three
200996 ** consists of a single 8-byte integer followed by an even number
201248 ** coordinates within a single R-Tree are always of the same time.
201318 ** A single cell from a node, deserialized
202973 ** a single row.
204581 ** that returns a single integer value. The statement is compiled and executed
204612 ** This ensures that each node is stored on a single database page. If the
204614 ** would fit in a single node, use a smaller node-size.
206245 ** Add a single segment and its associated events.
207578 /* The escape character string must consist of a single UTF-8 character.
207588 "ESCAPE expression must be a single character", -1);
208222 ** as a regular database checkpoint, except that a single frame is
208289 ** single leaf that is modified more than once as part of the transaction
208297 ** pattern that resembles a single linear scan through the index b-tree,
208306 ** guarantee that a single update process will run for long enough to apply
208403 ** update, the corresponding data_% table should contain a single record
208413 ** update, the corresponding data_% table should contain a single record
208420 ** update, the corresponding data_% table should contain a single record
208494 ** the new handle. Each call to sqlite3rbu_step() performs a single
209139 ** A single step of an incremental checkpoint - frame iWalFrame of the wal
211936 ** a single frame of data from the wal file into the database file, as
212146 ** RBU_IDX_DELETE. This function performs the work of a single
212550 /* At one point the following block copied a single frame from the
212552 ** checkpointed a single frame.
212683 ** This user-defined SQL function is invoked with a single argument - the
213746 ** Obtain a pointer to a mapping of a single 32KiB page of the *-shm file.
214275 /* Size information for a single cell within a btree page */
214285 /* Size information for a single btree page */
214548 ** For a single cell on a btree page, compute the number of bytes of
215586 ** input data. Input data may be supplied either as a single large buffer
215656 ** single byte describing its type, as follows:
215667 ** only of the single type byte. For other types of values, the type byte
215691 ** one or more tables. Operations on a single table are grouped together,
215748 ** single record: (PK fields for DELETE, PK and modified fields for UPDATE,
215751 ** As in the changeset format, each field of the single record that is part
215778 ** changesets. All entries related to a single table are grouped together.
215798 ** If the change that caused the conflict was a DELETE, then the single
215800 ** was an INSERT, then the single record is a copy of the new.* record. If
215801 ** the conflicting change was an UPDATE, then the single record is a copy
215807 ** For each row modified during a session, there exists a single instance of
216195 ** a single records which is written to the buffer at *paOut. *paOut is
216504 ** All returned buffers are part of the same single allocation, which must
217572 ** called. Otherwise, append a single byte to the buffer.
217585 ** called. Otherwise, append a single varint to the buffer.
218498 ** Deserialize a single record from a buffer in memory. See "RECORD FORMAT"
218764 ** it, or for the two single byte values otherwise. */
221021 ** old.* and new.* records for the change. The rebase buffer (a single
221520 ** Each extension function is allocated a single auxiliary data slot for
221522 ** more than once for a single FTS query, then all invocations share a
221523 ** single auxiliary data context.
221558 ** method, to iterate through all instances of a single query phrase within
221757 ** <ol><li> By mapping all synonyms to a single token. In this case, using
221768 ** tokenizer may provide multiple synonyms for a single term
221784 ** being treated as a single phrase.
221786 ** <li> By adding multiple synonyms for a single term to the FTS index.
221815 ** xToken() is called. Multiple synonyms may be specified for a single token
221818 ** single token.
221999 ** Maximum number of prefix indexes on single FTS5 table. This must be
222006 ** Maximum segments permitted in a single index
222183 /* Set the value of a single config attribute */
223013 ** The action table is constructed as a single large table named fts5yy_action[].
223029 ** fts5yy_action[] A single table containing all actions.
223111 /* The following structure represents a single element of the
224116 /* Check that the stack is large enough to grow by a single entry
224302 ** a single column of the current row. If the phrase instances in the
224305 ** common), each set of overlapping instances is treated as a single
225567 ** the input cursor past both and copy a single quote character
226459 ** An instance of the following structure represents a single search term
227540 /* As this "NEAR" object is actually a single phrase that consists
227541 ** of a single term only, grab pointers into the poslist managed by the
229114 ** single integer as an argument. If the integer is an alpha-numeric
229484 ** its current data are stored in a single memory allocation. The
229836 ** single list and returns a pointer to its first element.
230035 ** (e.g. 1000 bytes). A single doclist may span multiple pages. Care is
230076 ** recorded in a single record within the %_data table. The record consists
230077 ** of a single 32-bit configuration cookie value followed by a list of
230100 ** A single record within the %_data table. The data is a list of varints.
230162 ** The page footer consists of a single varint for each term located
230170 ** term/doclist data fits on a single leaf page. If this is not the case,
230187 ** a single leaf record only. The format of each doclist index leaf page
230388 ** Object for iterating through a single segment, visiting each term/rowid
233340 ** single-byte varints.
234240 ** a single page has been assigned to more than one segment. In
235967 ** is because the hash table only supports a single scan query at
236902 ** A single object of this type is allocated when the FTS5 module is
238435 ** A delete specifies a single argument - the rowid of the row to remove.
243140 ** Except, this version does handle the single byte case that the core