Lines Matching defs:terms
4697 ** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
5140 ** The terms "protected" and "unprotected" refer to whether or not
8070 ** ^The optimizer automatically inverts terms of the form "expr OP column"
8072 ** get as many WHERE clause terms into the form shown above as possible.
8073 ** ^The aConstraint[] array only reports WHERE clause terms that are
8160 int nOrderBy; /* Number of terms in the ORDER BY clause */
14499 ** extra data to the FTS index or require FTS5 to query for multiple terms,
14500 ** so it is efficient in terms of disk space and query speed. However, it
14731 ** * Terms in the SET clause of an UPDATE statement
14732 ** * Terms in the result set of a SELECT statement
14733 ** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
14734 ** * Terms in the VALUES clause of an INSERT statement
14825 ** The maximum number of terms in a compound SELECT statement.
14828 ** if the number of terms is too large. In practice, most SQL
14829 ** never has more than 3 or 4 terms. Use a value of 0 to disable
14830 ** any limit on the number of terms in a compound SELECT.
16193 ** 0x00000100 Move HAVING terms into WHERE
16244 ** 0x00004000 Show all WHERE terms at key points
16247 ** 0x00010000 Show more detail when printing WHERE terms
16248 ** 0x00020000 Show WHERE terms returned from whereScanNext()
20581 ** pUpsertSet is the list of column=expr terms of the UPDATE statement.
21567 ** (3) The terms of the WINDOW clause of a SELECT are instances of this
22156 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
42032 ** lock transitions in terms of the POSIX advisory shared and exclusive
67508 ** terms of the sequence whereas s0 omits the final term.
86280 ** The second and third terms in the following conditional enforces
101485 ** where the IN operator is on the later terms of the index by avoiding
101654 ** The seekHit integer represents the maximum of terms in an index for which
101656 ** than the total number of equality terms in an index lookup, then the
101779 ** contains any NULL value, jump immediately to P2. If all terms of the
102055 /* The next rowid or record number (different terms for the same
105567 ** satisfy the Expr in P4. TK_REGISTER terms in the P4 expression refer
105568 ** to values currently held in registers. TK_COLUMN terms in the P4
110676 ** parenthesized subset of the FROM clause terms. Example:
110804 ** words non-VIEW candidate terms take precedence over VIEWs.
111787 ** to the AS-name of one of the terms of the expression list. If it is,
111902 ** ORDER BY terms that are already an integer between 1 and N are
111903 ** unmodified. ORDER BY terms that are integers outside the range of
111904 ** 1 through N generate an error. ORDER BY terms that are expressions
111926 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
112036 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
112111 int nResult; /* Number of terms in the result set */
112168 int nCompound; /* Number of compound terms processed so far */
112400 ** the WHERE clause, go through and verify that none of the terms
112413 /* Resolve the ORDER BY on a compound SELECT after all terms of
112562 ** terms.
113736 ** Each of the vector values in pEList must contain exactly nElem terms.
113737 ** If a list element that is not a vector or does not contain nElem terms,
113894 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
115007 ** terms that are always true or false. Return the simplified expression.
115315 ** contain any terms from outer contexts.
115462 ** if the expression consists entirely of constants or copies of terms
116048 ** and the RHS is not constant or has two or fewer terms,
116216 ** Generate code that will construct an ephemeral table containing all terms
118311 int nExpr; /* 2x number of WHEN terms */
118313 ExprList *pEList; /* List of WHEN terms */
118314 struct ExprList_item *aListelem; /* Array of WHEN terms */
119185 ** terms in pA with bindings in pParse->pReprepare can be matched against
119519 ** evaluating terms in the ON clause of an inner join.
119647 ** Terms of p that are marked with EP_OuterON (and hence that come from
119983 sqlite3ErrorMsg(pParse, "more than %d aggregate terms", mxTerm);
120116 sqlite3ErrorMsg(pParse, "more than %d aggregate terms", mxTerm);
125112 i64 nSum100 = 0; /* Number of terms contributing to sumEq */
130510 /* Analyze the list of expressions that form the terms of the index and
131124 sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
131541 /* All terms to the left of a RIGHT JOIN should be tagged with the
133141 ** The "rcauth==SQLITE_OK" terms is the
137769 /* If the child table is the same as the parent table, then add terms
137771 ** The added WHERE clause terms are like this:
148810 int nOBSat; /* Number of ORDER BY terms satisfied by indices */
148959 ** in terms of the following bit values:
149171 ** Set the EP_OuterON property on all terms of the given expression.
149175 ** The EP_OuterON property is used on terms of an expression to tell
149178 ** of the more general WHERE clause. These terms are moved over to the
149261 ** * ON and USING clauses result in extra terms being added to the
149263 ** WHERE clause terms will be tagged with EP_OuterON or
149266 ** The terms of a FROM clause are contained in the Select.pSrc structure.
149323 /* Create extra terms on the WHERE clause for each column named
149500 int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */
149504 int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */
150468 "USE TEMP B-TREE FOR LAST %d TERMS OF ORDER BY", nKey
151604 ** (2) All terms are UNION ALL
151646 ** part of a recursive CTE still has its anchor terms attached. If the
151647 ** anchor terms have already been removed, then return false.
151823 ** Error message for when two or more terms of a compound select have different
151828 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
152188 int nOrderBy; /* Number of terms in the ORDER BY clause */
152189 u32 *aPermute; /* Mapping from ORDER BY terms to result set columns */
152210 ** terms to the ORDER BY clause as necessary.
152232 ** ORDER BY clause terms so that when selectA and selectB are
152957 ** (17b) no terms within the subquery compound may be aggregate
152984 ** (18) If the sub-query is a compound select, then all terms of the
152993 ** somewhat by saying that the terms of the ORDER BY clause must
153336 nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */
153361 /* Transfer the FROM clause terms from the subquery into the
153482 int nConst; /* Number for COLUMN=CONSTANT terms */
153542 ** Find all terms
153544 ** is part of the AND-connected terms of the expression. For each term
153656 ** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
153657 ** CONSTANT=COLUMN that are top-level AND-connected terms that are not
153777 ** Make copies of relevant WHERE clause terms of the outer query into
153787 ** The hope is that the terms added to the inner query will make it more
153797 ** clause terms that can be evaluated using only the index and without
153807 ** it is allowed by putting the extra terms on the HAVING clause.
153882 ** terms are duplicated into the subquery.
153941 ** sure no other terms are marked SF_Recursive in case something changes
154270 ** there are COLLATE terms in the ORDER BY.
154707 ** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword
155205 ** * VDBE Cursor numbers are assigned to all FROM-clause terms.
155783 ** Transfer eligible terms from the HAVING clause of a query, which is
155794 ** entirely of constants and expressions that are also GROUP BY terms that
155806 TREETRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
155878 ** * The subquery is a UNION ALL of two or more terms
156157 ** The xExpr callback for the search of invalid ON clause terms.
156212 ** The xSelect callback for the search of invalid ON clause terms.
156267 ** If p2 exists and p1 and p2 have the same number of terms, then change
156483 ** If terms of the i-th table are used in the WHERE clause in such a
156691 /* Loop over all terms in the FROM clause and do two things for each term:
156759 /* Make copies of constant WHERE-clause terms in the outer query down
157390 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
157392 ** Then compare the current GROUP BY terms against the GROUP BY terms
157434 ** This code copies current group by terms in b0,b1,b2,...
158815 ** list is of the form "*". Raise an error if the terms if of the
158832 /* The input list pList is the list of result set terms from a RETURNING
163144 ** prevent a query solution - which is an error) and many terms of the
163180 u16 omitMask; /* Terms that may be omitted */
163182 u32 mHandleIn; /* Terms to handle as IN(...) instead of == */
163244 i8 isOrdered; /* No. of ORDER BY terms satisfied. -1 for unknown */
163268 ** quickly for terms that match any of several different operators.
163295 ** The number of terms in a join is limited by the number of bits
163306 u8 eMatchOp; /* Op for vtab MATCH/LIKE/GLOB/REGEXP terms */
163335 #define TERM_LIKEOPT 0x0100 /* Virtual terms from the LIKE optimization */
163350 ** terms in the WHERE clause that are useful to the query planner.
163383 int nTerm; /* Number of terms */
163385 int nBase; /* Number of terms through the last non-Virtual */
163449 WhereClause *pWC; /* WHERE clause terms */
163513 i8 nOBSat; /* Number of ORDER BY terms satisfied by indices */
163517 unsigned untestedTerms :1; /* Not all WHERE terms resolved by outer loop */
163530 Bitmask revMask; /* Mask of ORDER BY terms that need reversing */
163649 #define WO_OR 0x0200 /* Two or more OR-connected terms */
163650 #define WO_AND 0x0400 /* Two or more AND-connected terms */
163687 #define WHERE_SELFCULL 0x00800000 /* nOut reduced by extra WHERE terms */
163715 ** Terms are separated by AND so add the "AND" text for second and subsequent
163716 ** terms only.
163721 int nTerm, /* Number of terms */
164068 ** of the join. Disabling is an optimization. When terms are satisfied
164076 ** automatically disabled. In this way, terms get disabled if derived
164077 ** virtual terms are tested first. For example:
164084 ** and child2 terms were added by the LIKE optimization. If both of
164085 ** the virtual child terms are valid, then testing of the parent can be
164222 ** RHS. But not all terms in the vector are indexable and the terms might
164227 ** the vector contains only index terms and those terms are in the correct
164250 int iEq, /* Look at loop terms starting here */
164854 /* Any terms specified as part of the ON(...) clause for any LEFT
164858 ** If this table is the rhs of a LEFT JOIN, "IS" or "IS NULL" terms
164870 ** For the same reason, WHERE terms such as:
164890 /* All terms in pWLoop->aLTerm[] except pEndRange are used to initialize
164891 ** the cursor. These terms are not needed as hints for a pure range
164892 ** scan (that has no == terms) so omit them. */
165026 ** WHERE clause terms on the query, and if any of those terms must be
165027 ** true because pTruth is true, then mark those WHERE clause terms as
165187 sqlite3DebugPrintf("All WHERE-clause terms before coding:\n");
165499 ** terms ("==" or "IN" or "IS" operators) that refer to the N
165543 u16 nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */
165552 int nConstraint; /* Number of constraint terms */
165568 /* Find any inequality constraint terms for the start and end
165632 ** start and end terms (pRangeStart and pRangeEnd).
165646 /* Generate code to evaluate all constraint terms using == or IN
165647 ** and store the values of those terms in an array of registers
165865 ** terms from the query that must be true due to the WHERE clause of
165905 /* Case 5: Two or more separately indexed terms connected by OR
165916 ** In the example, there are three indexed terms connected by OR.
165958 int untestedTerms = 0; /* Some terms not completely tested */
166020 ** That way, terms in y that are factored into the disjunction will
166024 ** the "interesting" terms of z - terms that did not originate in the
166025 ** ON or USING clause of a LEFT JOIN, and terms that are usable as
166170 ** terms from the notReady table could not be tested and will
166175 /* If all of the OR-connected terms are optimized using the same
166183 ** terms, set pCov to the candidate covering index. Otherwise, set
166493 sqlite3DebugPrintf("All WHERE-clause terms after coding level %d:\n",
166506 ** Generate the code for the loop that finds all non-matched terms
167163 ** If these two terms are both of the form: "A op B" with the same
167232 ** This routine analyzes terms such as the middle term in the above example.
167241 ** Examples of terms under analysis:
167302 ** Terms that satisfy case 3 are candidates for lookup by using
167436 ** IN operator because one or more terms in the OR clause contain
167441 ** sure the same column is used on all terms. The 2-bit case is when
167442 ** the all terms are of the form "table1.column=table2.column". It
167447 ** Note that terms of the form "table.column1=table.column2" (the
167453 int iCursor = -1; /* Table cursor common to all terms */
167815 extraRight = x-1; /* ON clause terms may not be used with an index
167899 /* If a term is the BETWEEN operator, create two new virtual terms
167908 ** The two new terms are added onto the end of the WhereClause object.
167909 ** The new terms are "dynamic" and are children of the original BETWEEN
168081 ** new terms for each component comparison - "a = ?" and "b = ?". The
168082 ** new terms completely replace the original vector comparison, which is
168189 /* Prevent ON clause terms of a LEFT JOIN from being used to drive
168217 ** all terms of the WHERE clause.
168277 ** Possibly add terms corresponding to the LIMIT and OFFSET clauses of the
168278 ** SELECT statement passed as the second argument. These terms are only
168285 ** 4. There are no terms in the WHERE clause that will not be passed
168290 ** LIMIT and OFFSET terms are ignored by most of the planner code. They
168308 ** other, subsequent terms. It can be ignored. See tag-20220128a */
168314 /* If this term has child terms, then they are also part of the
168316 ** will only be added if each of the child terms passes the
168348 /* All conditions are met. Add the terms to the where-clause object. */
168498 ** Call exprAnalyze on all terms in a WHERE clause.
168500 ** Note that exprAnalyze() might add new virtual terms onto the
168502 ** virtual terms, so start analyzing at the end and work forward
168503 ** so that the added virtual terms are never processed.
168517 ** new WHERE clause terms.
168606 u32 mIn; /* Mask of terms that are <col> IN (...) */
168607 u32 mHandleIn; /* Terms that vtab will handle as <col> IN (...) */
168637 ** Return the number of ORDER BY terms that are satisfied by the
168640 ** terms means that no sorting is needed at all. A return that
168641 ** is positive but less than the number of ORDER BY terms means that
169041 ** for terms of the form "X <op> <expr>" where X is column iColumn of table
169047 ** If the search is for X and the WHERE clause contains terms of the
169048 ** form X=Y then this routine might also return terms of the form
169101 ** Search for terms matching the iColumn-th column of pIdx
169112 ** If there are multiple terms in the WHERE clause of the form "X <op> <expr>"
169115 ** the form "X <op> Y" where Y is a column in another table if no terms of
169116 ** the form "X <op> <const-expr>" exist. If no terms with a constant RHS
169608 /* Make the automatic index a partial index if there are terms in the
169852 const WhereTerm *pTerm; /* For looping over WHERE clause terms */
169965 ** Return term iTerm of the WhereClause passed as the first argument. Terms
169966 ** are numbered from 0 upwards, starting with the terms in pWC->a[], then
169986 Bitmask mUnusable, /* Ignore terms with these prereqs */
169988 u16 *pmNoOmit /* Mask of terms not to omit */
170013 ** terms found.
170052 /* Skip over constant terms in the ORDER BY clause */
170625 ** bound, a lower bound, or both. The WHERE clause terms that set the upper
171214 ** (1b) X has fewer == terms than Y
171222 ** (2b) X uses fewer WHERE clause terms than Y
171270 ** WHERE clause terms than Y and that every WHERE clause term used by X is
171572 ** Adjust the WhereLoop.nOut value downward to account for terms of the
171591 ** Heuristic 2: If there exists one or more WHERE clause terms of the
171632 /* If there are extra terms in the WHERE clause not used by an index
171637 ** 2022-03-24: Self-culling only applies if either the extra terms
171778 ** We have so far matched pBuilder->pNew->u.btree.nEq terms of the
171783 ** terms only. If it is modified, this value is restored before this
171801 WhereScan scan; /* Iterator for WHERE terms */
171939 ** M = the number of rows in the table that match terms to the
172036 ** "x IN(...)" terms are replaced with "x = ?". This block updates
172076 /* TUNING: Mark terms as "low selectivity" if they seem likely
172183 ** available for the left-most terms of the index, and if the average
172184 ** number of repeats in the left-most terms is at least 18.
172380 ** expressions terms. Hence, we cannot determine whether or not it is
172562 ** WHERE clause includes "x IN (....)" terms used in place of "x=?". Or when
172563 ** implicit "x IN (SELECT x FROM tbl)" terms are added for skip-scans.
172823 ** lookups. Take into account WHERE clause terms that can be
172925 ** uses one or more WO_IN terms, or false otherwise.
172931 u16 mExclude, /* Exclude terms using these operators */
173037 ** consume the ORDER BY clause because (1) the order of IN terms
173038 ** is not necessarily related to the order of output terms and
173047 ** terms. And if there are any, they should follow all other terms. */
173056 ** if there is a LIMIT/OFFSET and there are other unused terms,
173245 ** table. So any terms for which all prerequisites are satisfied by
173248 ** virtual table, so any terms for which the prerequisites overlap with
173301 /* If the call to xBestIndex() with all terms enabled produced a plan
173313 ** xBestIndex again, this time with IN(...) terms disabled. */
173327 ** in the set of terms that apply to the current virtual table. */
173377 ** Add WhereLoop entries to handle OR terms. This works for either
173540 /* Add prerequisites to prevent reordering of FROM clause terms
173545 ** The hasRightCrossJoin flag prevent FROM-clause terms from moving
173611 ** a subquery or CTE that has an ORDER BY clause. See if any of the terms
173613 ** query. Mark off all satisfied terms (by setting bits in *pOBSat) and
173636 ** (2) The subquery ORDER BY terms must exactly match subquery result
173638 ** on iOrderByCol to do matching between order by terms and result
173654 Bitmask *pOBSat /* Which terms of pOrderBy are satisfied so far */
173704 ** N>0: N terms of the ORDER BY clause are satisfied
173705 ** N==0: No terms of the ORDER BY clause are satisfied
173706 ** N<0: Unknown yet how many terms of ORDER BY might be satisfied.
173713 ** the pOrderBy terms can be matched in any order. With ORDER BY, the
173714 ** pOrderBy terms must be matched in strict left-to-right order.
173734 u16 nOrderBy; /* Number terms in the ORDER BY clause */
173745 Bitmask obSat = 0; /* Mask of ORDER BY terms satisfied so far */
173746 Bitmask obDone; /* Mask of all ORDER BY terms */
173798 /* No further ORDER BY terms may be matched. So this call should
173821 /* IN terms are only valid for sorting in the ORDER BY LIMIT
173864 /* All relevant terms of the index must also be non-NULL in order
173886 /* Skip over == and IS and ISNULL terms. (Also skip IN terms when
173888 ** terms imply that the index is not UNIQUE NOT NULL in which case
174023 /* Mark off any other ORDER BY terms that reference pLoop */
174100 int nOrderBy, /* Number of ORDER BY clause terms */
174101 int nSorted /* Number of initial ORDER BY terms naturally in order */
174108 ** Or, if the order-by clause has X terms but only the last Y
174109 ** terms are out of order, then block-sorting will reduce the
174159 terms in the FROM clause. Queries with
174160 ** two or fewer FROM clause terms are handled by the caller.
174175 ** optimization. If there are fewer than four terms in the FROM
174222 int nLoop = pWInfo->nLevel; /* Number of terms in the join */
174242 SrcItem *aFromTabs; /* All terms of the FROM clause */
174406 int nLoop; /* Number of terms in the join */
174408 int iLoop; /* Loop counter over the terms of the join */
174411 int nOrderBy; /* Number of ORDER BY clause terms */
174476 ** cost of sorting nRowEst rows of data where the first X terms of
174494 /* If nLoop is zero, then there are no FROM terms in the query. Since
175077 ** 6) The ORDER BY clause has 63 or fewer terms
175354 ** the tables have indices and there are terms in the WHERE clause that
175359 ** Terms of the WHERE clause are also used to limit which rows actually
175361 ** terms of the WHERE clause that use only terms in that loop and outer
175436 /* An ORDER/GROUP BY clause of more than 63 terms cannot be optimized */
175567 ** If there are WHERE terms that are false, then no rows will be output,
175642 if( sqlite3WhereTrace & 0x4000 ){ /* Display all WHERE clause terms */
175761 if( sqlite3WhereTrace & 0x4000 ){ /* Display all terms of the WHERE clause */
179740 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
184172 /* When doing a nested parse, one can include terms in an expression
184173 ** that look like this: #1 #2 ... These terms refer to registers
192670 ** structures called segments which map terms to doclists. The
192760 ** Segment leaf nodes store terms and doclists, ordered by term. Leaf
192772 ** (further terms are delta-encoded)
192794 ** assumption is that large doclists represent terms which are more
192804 ** Segment interior nodes store blockids for subtree nodes and terms
192818 ** (further terms are delta-encoded)
192828 ** An interior node encodes n terms separating n+1 subtrees. The
192830 ** is encoded. The subtree at iBlockid will contain all terms less
192831 ** than the first term encoded (or all terms if no term is encoded).
192832 ** Otherwise, for terms greater than or equal to pTerm[i] but less
192841 ** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing
192911 ** frequent terms (which are somewhat dominated by segment merge
192912 ** costs), and infrequent and non-existent terms still seem to be fast
193327 ** FTS4 virtual tables may maintain multiple indexes - one index of all terms
193339 ** (FTS3_MERGE_COUNT^1024) separate flushes of the pending-terms tables.
193519 ** terms that appear in the document set. Each subsequent index in aIndex[]
193530 int nPrefix; /* Prefix length (0 for main terms index) */
193531 Fts3Hash hPending; /* Pending terms table for this index */
194635 ** always maintain the main "terms" index, but may also maintain one or
195517 char *zBuffer = 0; /* Buffer to load terms into */
195581 ** to the term from the interior node, then all terms on the sub-tree
195616 ** or terms for which the specified term is a prefix.
195625 ** the specified term or any terms for which it is a prefix. However, if the
195626 ** segment does contain any such terms, they are stored within the identified
196606 ** for the pending-terms. If this is a scan, then this call must be being
196710 ** if isPrefix is true, to scan the doclist for all terms for which
197137 ** Implementation of xSync() method. Flush the contents of the pending-terms
197230 ** the pending-terms hash-table have already been flushed into the database
197245 ** Implementation of xRollback(). Discard the contents of the pending-terms
197503 /* As it happens, the pending terms table is always empty here. This is
197506 ** flushes the pending terms table. But leave the (no-op) call to
197551 ** Flush the contents of the pending-terms table to disk.
197598 ** Discard the contents of the pending terms table.
198152 ** pending-terms lists when writing to databases with "order=desc".
199879 ** Schema of the terms table.
204101 ** An instance of this structure is used to iterate through the terms on
204105 ** terms when querying the full-text index. See functions:
204190 ** or the pending-terms table being flushed), leaves are written into the
204201 int nEntry; /* Number of terms written to node so far */
204543 ** document terms, and each configured prefix size (configured the FTS
204554 ** 64-bit integer level values ("absolute levels"). The main terms index
204746 ** Add an entry to one of the pending-terms hash tables.
204752 terms hash table to add entry to */
204785 ** pending-terms hash-table. The docid used is that currently stored in
204842 /* Add the term to the terms index */
204880 ** buffer was half empty, that would let the less frequent terms
204898 ** Discard the contents of the pending-terms hash tables.
205029 ** pending terms.
205034 /* Discard the contents of the pending-terms hash table. */
205063 ** (an integer) of a row about to be deleted. Remove all terms from the
205488 /* A pending-terms seg-reader for an FTS4 table that uses order=desc.
205489 ** Pending-terms doclists are always built up in ascending order, so
205666 ** an array of pending terms by term. This occurs as part of flushing
205667 ** the contents of the pending-terms hash table to the database.
205688 ** a subset of the terms stored in the Fts3Table.pendingTerms array.
205691 ** through each term in the pending-terms table. Or, if isPrefixIter is
205693 ** the pending terms hash table contains the terms "sqlite", "mysql" and
205694 ** "firebird", then the iterator visits the following 'terms' (in the order
205701 ** Whereas if isPrefixIter is zero, the terms visited are:
205711 Fts3SegReader **ppReader /* OUT: SegReader for pending-terms */
205748 ** callback as is used when flushing terms to disk.
205796 ** 2) The current terms (if any) are compared using memcmp(). If one
205827 ** a doclist for identical terms. Comparison is made as follows:
205865 ** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are
206061 ** the database contain two terms that share a prefix of almost 2KB,
206383 ** database. This function must be called after all terms have been added
207944 ** stored in blob *pNode. The node need not contain any terms, but the
208618 ** all terms that are greater than or equal to zTerm/nTerm (for leaf nodes)
208625 const char *zTerm, /* Omit all terms smaller than this */
208671 ** Remove all terms smaller than zTerm/nTerm from segment iIdx in absolute
208683 const char *zTerm, /* Remove terms smaller than this */
209815 ** Flush any data in the pending-terms hash table to disk. If successful,
209919 u64 hlmask; /* Mask of snippet terms to highlight */
210262 u64 *pmHighlight /* OUT: Bitmask of terms to highlight */
210485 ** non-highlighted terms to the right of the final highlighted term as there
210493 ** actually contains terms that follow the final highlighted term.
210605 int isHighlight = 0; /* True for highlighted terms */
211405 int iTerm; /* For looping through nTerm phrase terms */
211467 /* Count the number of terms in the query */
211533 int i; /* Used to loop through terms */
241187 ** extra data to the FTS index or require FTS5 to query for multiple terms,
241188 ** so it is efficient in terms of disk space and query speed. However, it
241749 /* Bucket of terms object used by the integrity-check in offsets=0 mode. */
246319 ** A phrase. One or more terms that must appear in a contiguous sequence
246326 Fts5ExprTerm aTerm[FLEXARRAY]; /* Terms that make up this phrase */
246329 /* Size (in bytes) of an Fts5ExprPhrase object that holds up to N terms */
247303 int bMatch; /* True if all terms are at the same rowid */
247930 ** Callback for tokenizing terms used by ParseTerm().
248145 int i; /* Used to iterate through phrase terms */
249147 ** Return the number of terms in the iPhrase'th phrase in pExpr.
250548 u8 bTermEq; /* True if the terms are equal */
250691 ** page. This macro evaluates to true if the leaf contains no terms, or
254376 ** is larger than all terms written to earlier leaves, and equal to or
254396 ** terms at all to disk.
254522 /* The new leaf holds no terms or rowids */
255245 /* The page contains no terms or rowids. Replace it with an empty
256383 ** all entries for terms that have pToken/nToken as a prefix. If bPrefix
256389 ** all index terms corresponding to pToken/nToken are collapsed into a single
256504 Fts5Buffer terms;
256641 fts5BufferFree(&pSet->terms);
256656 int iTermOff; /* Offset of current term in terms.p[] */
256679 pSetup->iTermOff = pSetup->pT->terms.n;
256680 fts5BufferAppendBlob(&p->rc, &pSetup->pT->terms, nNew-1, pNew+1);
257060 /* Add the entry to the main terms index. */
257418 ** not point to any terms that match the query. So delete it and break
257498 ** satisfied by scanning multiple terms in the main index.
257534 /* Scan multiple terms in the main index for a prefix query. */
257735 *ppOut = (const char*)&pT->terms.p[p->iIter];
257783 fts5TokendataIterAppendMap(p, pT, pT->terms.n, nToken, iRowid, iPos);
257784 fts5BufferAppendBlob(&p->rc, &pT->terms, nToken, (const u8*)pToken);
258463 ** contain zero terms.
258477 ** (a) exist and (b) contain no terms. */
258589 ** entry even if all the terms are removed from it by secure-delete
258618 ** (a) exist and (b) contain no terms. */
259780 int nTerm; /* Size of phrase in terms */
260235 ** more complex queries that use multiple terms the number of rows might
261764 ** the pending-terms hash-table have already been flushed into the database
261774 ** Implementation of xRollback(). Discard the contents of the pending-terms
262784 ** Flush the contents of the pending-terms table to disk.
262819 ** Discard the contents of the pending terms table.
Indexes created Wed Jun 24 00:24:50 UTC 2026