Lines Matching full:term
158 ** level of recursion for each term. A stack overflow can result
4731 ** ^Each term of aOrderBy records a column of the ORDER BY clause.
8886 CollSeq *aColl[1]; /* Collating sequence for each term of the key */
9358 struct WhereTerm *pTerm; /* WHERE clause term for OR-search */
15918 ** for situations where the memory might be held long-term. This
16085 /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
18003 #define READ_UTF16LE(zIn, TERM, c){ \
18006 if( c>=0xD800 && c<0xE000 && TERM ){ \
18013 #define READ_UTF16BE(zIn, TERM, c){ \
18016 if( c>=0xD800 && c<0xE000 && TERM ){ \
33373 ** The third term of the test was added to fix ticket #2565.
43088 ** the term after the || in the following assert(). */
46737 ** values to wrap around. On x86 hardware, the third term is always
52636 CollSeq *pColl; /* Collating sequence to use on this term */
54252 CollSeq *pColl; /* Collating sequence to use on this term */
55507 ** confusion because the term "temp table", might refer either
59330 ** The reason for suppressing the TK_AS term when the expression is a simple
59909 ** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
59941 ** pE is a pointer to an expression which is a single term in the
59946 ** ORDER BY term is not an integer index into the result set. That
59961 Expr *pE /* The specific ORDER BY term */
59973 /* Resolve all names in the ORDER BY term expression
60003 ** Generate an ORDER BY or GROUP BY term out-of-range error.
60008 int i, /* The index (1-based) of the term out of range */
60012 "%r %s BY term out of range - should be "
60018 ** each term of the ORDER BY clause is a constant integer between 1
60103 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
60112 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
60113 ** the SELECT statement pSelect. If any term is reference to a
60115 ** then convert that term into a copy of the corresponding result set
60158 ** This routine resolves each term of the clause into an expression.
60159 ** If the order-by term is an integer I between 1 and N (where N is the
60162 ** the order-by term is an identify that corresponds to the AS-name of
60163 ** a result-set expression, then the term resolves to a copy of the
60179 struct ExprList_item *pItem; /* A term of the ORDER BY clause */
60198 /* The ORDER BY term is an integer constant. Again, set the column
60200 ** order-by term to a copy of the result-set expression */
60209 /* Otherwise, treat the ORDER BY term as an ordinary expression */
60372 /* Advance to the next term of the compound
60422 ** The "x" term of the order by is replaced by "a+b" to render:
61609 /* If pWalker->u.i is 3 then any term of the expression that comes from
61858 if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */
63117 ** for function overloading. But we use the B term in "glob(B,A)".
63272 ** ELSE clause and no other term matches, then the result of the
63277 ** or if there is no matching Ei, the ELSE term Y, or if there is
63278 ** no ELSE term, NULL.
63617 Expr compLeft; /* The x>=y term */
63618 Expr compRight; /* The x<=z term */
69683 ** This routine is called by the parser to add a new term to the
69686 ** if this is the first term of the FROM clause. pTable and pDatabase
69687 ** are the name of the table and database named in the FROM clause term.
69689 ** usual case. If the term has a alias, then pAlias points to the
69690 ** alias token. If the term is a subquery, then pSubquery is the
69696 ** term added.
70776 ** is a limit/offset term to enforce.
70785 ** term for the DELETE or UPDATE statement. For example:
73780 ** that the "OLD.zToCol" term is on the LHS of the = operator, so
73792 /* For ON UPDATE, construct the next term of the WHEN clause.
74684 /* If the INSERT statement included an IDLIST term, then make sure
74722 /* If there is no IDLIST term but the table has an integer primary
75618 return 0; /* FROM clause must have exactly one term */
79456 ** WHERE clause expression of a SELECT statement. The new term, which
79500 ** And set the Expr.iRightJoinTable to iTable for every term in the
79504 ** the LEFT OUTER JOIN processing logic that this term is part of the
79518 ** term until after the t2 loop of the join. In that way, a
79615 char *zName; /* Name of the term in the USING clause */
80637 ** left-most term of the select that has a collating sequence.
81323 ** the ORDER BY clause covers every term of the result set. Add
81887 ** Ticket #3300 shows that flattening the right term of a LEFT JOIN
81889 ** subquery is the right term of a LEFT JOIN, then do not flatten.
82027 /* The following loop runs once for each term in a compound-subquery
86795 ** When a term is of the form:
86814 ** If a term in the WHERE clause does not match either of the two previous
86837 Expr *pExpr; /* Pointer to the subexpression that is this term */
86838 int iParent; /* Disable pWC->a[iParent] when this term disabled */
86848 WhereClause *pWC; /* The clause this term is part of */
86858 #define TERM_CODED 0x04 /* This term is already coded */
86875 WhereTerm *a; /* Each a[] describes a term of the WHERE cluase */
87214 ** allowed for an indexable WHERE clause term. The allowed operators are
87287 ** Search for a term in the WHERE clause that is of the form "X <op> <expr>"
87290 ** Return a pointer to the term. Return 0 if not found.
87507 ** Analyze a term that consists of two or more OR-connected
87513 ** This routine analyzes terms such as the middle term in the above example.
87514 ** A WhereOrTerm object is computed and attached to the term under
87520 ** The term being analyzed must have two or more of OR-connected subterms.
87534 ** term that is an equivalent IN expression. In other words, if the term
87539 ** then create a new virtual term like this:
87564 ** All examples A through E above all satisfy case 2. But if a term
87580 ** zero. This term is not useful for search.
87585 int idxTerm /* Index of the OR-term to be analyzed */
87589 WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */
87590 Expr *pExpr = pTerm->pExpr; /* The expression of the term */
87594 WhereTerm *pOrTerm; /* A Sub-term within the pOrWc */
87602 ** object that is attached to the original OR clause term.
87652 /* Skip this term for now. We revisit it when we process the
87653 ** corresponding TERM_VIRTUAL term */
87686 ** case means that every term of the OR clause is of the form
87692 ** or table2.column as the LHS if either is common to every term of
87717 ** current term is from the first iteration. So skip this term. */
87722 /* This term must be of the form t1.a==t2.b where t2 is in the
87723 ** chngToIN set but t1 is not. This term will be either preceeded
87724 ** or follwed by an inverted copy (t2.b==t1.a). Skip this term
87746 ** table and column is common to every term in the OR clause */
87772 ** case 1. In that case, construct a new virtual term that is
87825 ** term of the form "Y <op> X" is added to the WHERE clause and
87826 ** analyzed separately. The original term is marked with TERM_COPIED
87827 ** and the new term is marked with TERM_DYNAMIC (because it's pExpr
87829 ** is a commuted copy of a prior term.) The original term has nChild=1
87830 ** and the copy has idxParent set to the index of the original term.
87835 int idxTerm /* Index of the term to be analyzed */
87837 WhereTerm *pTerm; /* The term to be analyzed */
87921 /* If a term is the BETWEEN operator, create two new virtual terms
87932 ** term. That means that if the BETWEEN term is coded, the children are
87934 ** BETWEEN term is skipped.
87959 /* Analyze a term that is composed of two or more subterms connected by
88027 /* Add a WO_MATCH auxiliary term to the constraint set if the
88120 struct ExprList_item *pTerm; /* A term of the ORDER BY clause */
88143 int termSortOrder; /* Sort order for this term */
88145 int iSortOrder; /* 1 for DESC, 0 for ASC on the i-th index term */
88146 const char *zColl; /* Name of the collating sequence for i-th index term */
88171 /* Term j of the ORDER BY clause does not match column i of the index */
88174 ** ORDER BY term, that is OK. Just ignore that column of the index
88301 ** The table associated with FROM clause term pSrc may be either a
88307 struct SrcList_item *pSrc, /* The FROM clause term to search */
88316 WhereTerm *pTerm; /* A single term of the WHERE clause */
88318 /* Search the WHERE clause terms for a usable WO_OR term. */
88334 WHERETRACE(("... Multi-index OR testing for term %d of %d....\n",
88364 /* If the cost of scanning using this OR term for optimization is
88551 struct SrcList_item *pSrc, /* The FROM clause term to search */
88952 struct SrcList_item *pSrc, /* The FROM clause term to search */
89053 ** If there exists a WHERE term of the form "x IN (SELECT ...)", then
89058 ** Set to true if there was at least one "x IN (SELECT ...)" term used
89096 WhereTerm *pTerm; /* A single term of the WHERE clause */
89276 struct SrcList_item *pSrc, /* The FROM clause term to search */
89297 ** Disable a term in the WHERE clause. Except, do not disable the term
89301 ** Consider the term t2.z='ok' in the following queries:
89308 ** in the ON clause. The term is disabled in (3) because it is not part
89309 ** of a LEFT OUTER JOIN. In (1), the term is not disabled.
89311 ** Disabling a term causes that term to not be tested in the inner loop
89375 ** Generate code for a single equality term of the WHERE clause. An equality
89376 ** term can be either X=expr or X IN (...). pTerm is the term to be
89387 WhereTerm *pTerm, /* The term of the WHERE clause to be coded */
89490 WhereTerm *pTerm; /* A single constraint term */
89565 WhereTerm *pTerm; /* A WHERE clause term */
89568 struct SrcList_item *pTabItem; /* FROM clause term being coded */
89760 ** The z<10 term of the following cannot be used, only
89761 ** the x=5 term:
89984 ** Then, for each indexed term, the following. The arguments to
89989 ** sqlite3WhereBegin(<term>)
90071 WhereInfo *pSubWInfo; /* Info for single OR-term scan */
90072 /* Loop through table entries that match term pOrTerm. */
90087 /* The pSubWInfo->untestedTerms flag means that this OR term
90088 ** contained one or more AND term from a notReady table. The
90094 /* Finish the loop through table entries that match term pOrTerm. */
90374 /* Assign a bit from the bitmask to every term in the FROM clause.
90377 ** the case that if X is the bitmask for the N-th FROM clause term then
90378 ** the bitmask for all FROM clause terms to the left of the N-th term
90432 ** pWInfo->a[].iFrom Which term of the FROM clause is being coded
90435 ** pWInfo->a[].pTerm When wsFlags==WO_OR, the OR-clause term
91804 "carg", "ccons", "term", "expr",
91889 /* 57 */ "ccons ::= DEFAULT term",
91891 /* 59 */ "ccons ::= DEFAULT PLUS term",
91892 /* 60 */ "ccons ::= DEFAULT MINUS term",
92016 /* 184 */ "expr ::= term",
92018 /* 186 */ "term ::= NULL",
92023 /* 191 */ "term ::= INTEGER|FLOAT|BLOB",
92024 /* 192 */ "term ::= STRING",
92031 /* 199 */ "term ::= CTIME_KW",
92246 case 174: /* term */
93081 case 57: /* ccons ::= DEFAULT term */
93082 case 59: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==59);
93088 case 60: /* ccons ::= DEFAULT MINUS term */
93453 case 184: /* expr ::= term */
93460 case 186: /* term ::= NULL */
93461 case 191: /* term ::= INTEGER|FLOAT|BLOB */ yytestcase(yyruleno==191);
93462 case 192: /* term ::= STRING */ yytestcase(yyruleno==192);
93540 case 199: /* term ::= CTIME_KW */
98182 ** given term. Doclists hold docids, and can optionally associate
98223 ** Segment leaf nodes store terms and doclists, ordered by term. Leaf
98230 ** varint nTerm; (length of first term)
98231 ** char pTerm[nTerm]; (content of first term)
98232 ** varint nDoclist; (length of term's associated doclist)
98236 ** varint nPrefix; (length of prefix shared with previous term)
98238 ** char pTermSuffix[nSuffix];(unshared suffix of next term)
98239 ** varint nDoclist; (length of term's associated doclist)
98248 ** of a node is reached, the next term is in the node with the next
98254 ** node (a leaf node with a single term and doclist). The goal of
98278 ** varint nTerm; (length of first term)
98279 ** char pTerm[nTerm]; (content of first term)
98282 ** varint nPrefix; (length of shared prefix with previous term)
98284 ** char pTermSuffix[nSuffix]; (unshared suffix of next term)
98294 ** than the first term encoded (or all terms if no term is encoded).
98296 ** than pTerm[i+1], the subtree for that term will be rooted at
98297 ** iBlockid+i. Interior nodes only store enough term data to
98298 ** distinguish adjacent children (if the rightmost term of the left
98299 ** child is "something", and the leftmost term of the right child is
98387 ** index into the term index, we clearly cannot simply update the term
99559 ** term specified by arguments zTerm and nTerm and writes its block number
99563 ** term. However, if the segment does contain said term, it is stored on
99572 const char *zTerm, /* Term to select leaves for */
99573 int nTerm, /* Size of term zTerm in bytes */
99585 int isFirstTerm = 1; /* True when processing first term on page */
99595 int nSuffix; /* Size of term suffix */
99596 int nPrefix = 0; /* Size of term prefix */
99597 int nBuffer; /* Total term size */
99599 /* Load the next term on the node into zBuffer */
99619 /* Compare the term we are searching for with the term just loaded from
99620 ** the interior node. If the specified term is greater than or equal
99621 ** to the term from the interior node, then all terms on the sub-tree
99625 ** If the interior node term is larger than the specified term, then
99626 ** the tree headed by iChild may contain the specified term.
99634 ** specified term may be present on leaf node iChild.
100169 ** querying the full-text index for a doclist associated with a term or
100170 ** term-prefix.
100193 /* If this is the first term selected, copy the doclist to the output
100217 ** This function retreives the doclist for the specified term (or term
100230 const char *zTerm, /* Term to query for */
100239 Fts3SegFilter filter; /* Segment term filter configuration */
100257 ** that may contain a term that matches zTerm/nTerm. For non-prefix
100386 /* Merge the new term list and the current output. If this is the
100387 ** last term in the phrase, and positions are not required in the
100490 ** sum of the sizes of the two input buffers. The +1 term is
103269 char *zEnd; /* Pointer to nul-term of zCopy */
103861 ** table. The hash table entry maps from term (a string) to a malloc'd
103905 int nTerm; /* Number of bytes in current term */
103906 char *zTerm; /* Pointer to current term */
103930 char *zTerm; /* Pointer to previous term buffer */
103954 char *zTerm; /* Pointer to previous term buffer */
104214 sqlite3_int64 iPos, /* Position of term for entry to add */
104331 ** fts3PendingTermsAdd() are to add term/position-list pairs for the
104360 ** operation. It adds entries for each term in the new record to the
104551 ** Move the iterator passed as the first argument to the next term in the
104552 ** segment. If successful, SQLITE_OK is returned. If there is no next term,
104557 int nPrefix; /* Number of bytes in term prefix */
104558 int nSuffix; /* Number of bytes in term suffix */
104621 ** with the current term.
104633 ** associated with the current term.
104793 ** an array of pending terms by term. This occurs as part of flushing
104816 const char *zTerm, /* Term to search for */
104818 int isPrefix, /* True for a term-prefix query */
104822 Fts3HashElem **aElem = 0; /* Array of term hash entries to scan */
104851 /* If more than one term matches the prefix, sort the Fts3HashElem
104852 ** objects in term order using qsort(). This uses the same comparison
104905 ** If successful, the Fts3SegReader is left pointing to the first term
104932 ** term is a prefix of another, the longer term is considered the
104984 ** Compare the term that the Fts3SegReader object passed as the first argument
104985 ** points to with the term specified by arguments zTerm and nTerm.
104988 ** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are
104989 ** equal, or +ve if the pSeg term is greater than zTerm/nTerm.
104993 const char *zTerm, /* Term to compare to */
104994 int nTerm /* Size of term zTerm in bytes */
105103 const char *zPrev, /* Buffer containing previous term */
105105 const char *zNext, /* Buffer containing next term */
105115 ** Add term zTerm to the SegmentNode. It is guaranteed that zTerm is larger
105116 ** (according to memcmp) than the previous term.
105122 const char *zTerm, /* Pointer to buffer containing term */
105123 int nTerm /* Size of term in bytes */
105129 /* First try to append the term to the current node. Return early if
105145 /* An unusual case: this is the first term to be added to the node
105160 /* There is no prefix-length field for first term in a node */
105191 ** If this is the first node in the tree, the term is added to it.
105193 ** Otherwise, the term is not added to the new node, it is left empty for
105194 ** now. Instead, the term is inserted into the parent of pTree. If pTree
105317 ** Add a term to the segment being constructed by the SegmentWriter object
105318 ** *ppWriter. When adding the first term to a segment, *ppWriter should
105328 const char *zTerm, /* Pointer to buffer containing term */
105329 int nTerm, /* Size of term in bytes */
105333 int nPrefix; /* Size of term prefix in bytes */
105334 int nSuffix; /* Size of term suffix in bytes */
105372 nSuffix + /* Term suffix */
105383 /* Add the current term to the interior node tree. The term added to
105386 ** a) be greater than the largest term on the leaf node just written
105389 ** b) be less than or equal to the term about to be added to the new
105406 nTerm + /* Term suffix */
105422 /* Append the prefix-compressed term and doclist to the buffer. */
105431 /* Save the current term so that it can be used to prefix-compress the next.
105433 ** zTerm is transient, so take a copy of the term data. Otherwise, just
105670 char *zTerm, /* Term to write to the db */
105686 char *zTerm, /* Term to write to the db */
105702 ** of terms selected by each SegReader. If a single term is present in
105704 ** term and (possibly merged) doclist in the merged range, the callback
105709 ** arg 2: Pointer to buffer containing term
105743 /* If the Fts3SegFilter defines a specific term (or term prefix) to search
105744 ** for, then advance each segment iterator until it points to a term of
105745 ** equal or greater value than the specified term. This prevents many
105747 ** b-tree leaf nodes contain more than one term.
105766 /* If this is a prefix-search, and if the term that apSegment[0] points
105770 ** Similarly, if this is a search for an exact match, and the first term
105799 /* The current term of the first nMerge entries in the array
105801 ** and a single term added to the new segment.
105857 /* If there is a term specified to filter on, and this is not a prefix
105859 ** term (if such a term exists in the index) has already been made.
105898 Fts3SegFilter filter; /* Segment term filter condition */
106013 ** writes each term (along with its doclist) to the database via the
106188 struct snippetMatch { /* One entry for each matching term */
106190 short int nByte; /* Number of bytes in the term */
106192 short int iTerm; /* The index in Query.pTerms[] of the matching term */
106194 int iStart; /* The offset to the first character of the term */
106296 int iCol, int iTerm, /* The column and query term */
106538 /* Snippet ii is an occurence of query term iLeft in the document.
107221 const char *zOpen, /* String inserted before highlighted term */
107222 const char *zClose, /* String inserted after highlighted term */
107333 ** list of term offsets within a single column of a single row).
