Lines Matching defs:zTerm
34451 ** During translation, assume that the byte that zTerm points
34475 #define READ_UTF8(zIn, zTerm, c) \
34479 while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \
34491 /* Same as READ_UTF8() above but without the zTerm parameter.
34557 unsigned char *zTerm; /* End of input */
34590 zTerm = &zIn[pMem->n&~1];
34591 while( zIn<zTerm ){
34619 /* Set zIn to point at the start of the input buffer and zTerm to point 1
34626 zTerm = &zIn[pMem->n];
34636 while( zIn<zTerm ){
34637 READ_UTF8(zIn, zTerm, c);
34643 while( zIn<zTerm ){
34644 READ_UTF8(zIn, zTerm, c);
34654 while( zIn<zTerm ){
34659 if( c>=0xdc00 || zIn>=zTerm ){
34672 if( zIn<zTerm ){
34683 while( zIn<zTerm ){
34688 if( c>=0xdc00 || zIn>=zTerm ){
34701 if( zIn<zTerm ){
34789 const u8 *zTerm;
34791 zTerm = &z[nByte];
34793 zTerm = (const u8*)(-1);
34795 assert( z<=zTerm );
34796 while( *z!=0 && z<zTerm ){
186328 const char *zTerm;
186351 char *zTerm; /* Pointer to term buffer */
186352 int nTerm; /* Size of zTerm in bytes */
188027 ** passed in zTerm/nTerm.
188033 ** that heads a sub-tree that may contain a term for which zTerm/nTerm is
188039 const char *zTerm, /* Term to select leaves for */
188040 int nTerm, /* Size of term zTerm in bytes */
188114 ** headed by node iChild are smaller than zTerm. No need to search
188120 cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer));
188145 ** interior node of a b-tree segment. The zTerm buffer (size nTerm bytes)
188166 const char *zTerm, /* Term to select leaves for */
188167 int nTerm, /* Size of term zTerm in bytes */
188179 rc = fts3ScanInteriorNode(zTerm, nTerm, zNode, nNode, piLeaf, piLeaf2);
188189 rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, 0);
188205 rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, piLeaf2);
189122 const char *zTerm, /* Term to query for */
189123 int nTerm, /* Size of zTerm in bytes */
189125 int isScan, /* True to scan from zTerm to EOF */
189140 rc = sqlite3Fts3SegReaderPending(p, iIndex, zTerm, nTerm, isPrefix||isScan, &pSeg);
189161 /* If zTerm is not NULL, and this segment is not stored entirely on its
189163 if( iStartBlock && zTerm && zRoot ){
189165 rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi);
189196 const char *zTerm, /* Term to query for */
189197 int nTerm, /* Size of zTerm in bytes */
189199 int isScan, /* True to scan from zTerm to EOF */
189213 p, iLangid, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
189219 ** passed as the 4th argument also scan the doclist for term zTerm/nTerm.
189226 const char *zTerm, /* Term to scan doclist of */
189227 int nTerm, /* Number of bytes in zTerm */
189231 iLangid, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0,pCsr
189236 ** Open an Fts3MultiSegReader to scan the doclist for term zTerm/nTerm. Or,
189238 ** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
189250 const char *zTerm, /* Term to query for */
189251 int nTerm, /* Size of zTerm in bytes */
189269 i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0, pSegcsr
189279 i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 1, 0, pSegcsr
189283 p, pCsr->iLangid, zTerm, nTerm, pSegcsr
189292 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, isPrefix, 0, pSegcsr
189334 filter.zTerm = pTok->z;
192583 sqlite3_free((void *)pCsr->filter.zTerm);
192632 int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n);
192751 testcase(pCsr->filter.zTerm);
192753 sqlite3_free((void *)pCsr->filter.zTerm);
192765 pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr);
192766 if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM;
192767 pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm);
192790 pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr
192821 sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
196631 char *zTerm; /* Pointer to current term */
196632 int nTermAlloc; /* Allocated size of zTerm buffer */
196660 char *zTerm; /* Pointer to previous term buffer */
196661 int nTerm; /* Number of bytes in zTerm */
196663 char *zMalloc; /* Malloc'd space (possibly) used for zTerm */
196693 char *zTerm; /* Pointer to previous term buffer */
196694 int nTerm; /* Number of bytes in zTerm */
196696 char *zMalloc; /* Malloc'd space (possibly) used for zTerm */
197812 sqlite3_free(pReader->zTerm);
197813 pReader->zTerm = (char*)sqlite3_malloc64(((i64)nTerm+1)*2);
197814 if( !pReader->zTerm ) return SQLITE_NOMEM;
197817 memcpy(pReader->zTerm, fts3HashKey(pElem), nTerm);
197818 pReader->zTerm[nTerm] = '\0';
197877 char *zNew = sqlite3_realloc64(pReader->zTerm, nNew);
197881 pReader->zTerm = zNew;
197888 memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
198073 sqlite3_free(pReader->zTerm);
198177 const char *zTerm, /* Term to search for */
198178 int nTerm, /* Size of buffer zTerm */
198196 if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){
198231 pE = fts3HashFindElem(pHash, zTerm, nTerm);
198276 rc = memcmp(pLhs->zTerm, pRhs->zTerm, pLhs->nTerm);
198278 rc = memcmp(pLhs->zTerm, pRhs->zTerm, pRhs->nTerm);
198331 ** points to with the term specified by arguments zTerm and nTerm.
198334 ** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are
198335 ** equal, or +ve if the pSeg term is greater than zTerm/nTerm.
198339 const char *zTerm, /* Term to compare to */
198340 int nTerm /* Size of term zTerm in bytes */
198345 res = memcmp(pSeg->zTerm, zTerm, nTerm);
198347 res = memcmp(pSeg->zTerm, zTerm, pSeg->nTerm);
198491 ** Add term zTerm to the SegmentNode. It is guaranteed that zTerm is larger
198497 int isCopyTerm, /* True if zTerm/nTerm is transient */
198498 const char *zTerm, /* Pointer to buffer containing term */
198510 int nReq = nData; /* Required space after adding zTerm */
198514 nPrefix = fts3PrefixCompress(pTree->zTerm, pTree->nTerm, zTerm, nTerm);
198517 /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of
198518 ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when
198523 if( nReq<=p->nNodeSize || !pTree->zTerm ){
198540 if( pTree->zTerm ){
198546 memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix);
198559 pTree->zTerm = pTree->zMalloc;
198560 memcpy(pTree->zTerm, zTerm, nTerm);
198563 pTree->zTerm = (char *)zTerm;
198570 /* If control flows to here, it was not possible to append zTerm to the
198588 rc = fts3NodeAddTerm(p, &pParent, isCopyTerm, zTerm, nTerm);
198600 rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm);
198708 int isCopyTerm, /* True if buffer zTerm must be copied */
198709 const char *zTerm, /* Pointer to buffer containing term */
198747 nPrefix = fts3PrefixCompress(pWriter->zTerm, pWriter->nTerm, zTerm, nTerm);
198750 /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of
198751 ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when
198775 ** to the database (still available in pWriter->zTerm), and
198778 ** leaf node (zTerm/nTerm).
198780 ** In other words, it must be the prefix of zTerm 1 byte longer than
198781 ** the common prefix (if any) of zTerm and pWriter->zTerm.
198784 rc = fts3NodeAddTerm(p, &pWriter->pTree, isCopyTerm, zTerm, nPrefix+1);
198817 memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix);
198826 ** zTerm is transient, so take a copy of the term data. Otherwise, just
198837 pWriter->zTerm = zNew;
198839 assert( pWriter->zTerm==pWriter->zMalloc );
198841 memcpy(pWriter->zTerm, zTerm, nTerm);
198843 pWriter->zTerm = (char *)zTerm;
199227 const char *zTerm, /* Term searched for (or NULL) */
199228 int nTerm /* Length of zTerm in bytes */
199245 }while( zTerm && (res = fts3SegReaderTermCmp(pSeg, zTerm, nTerm))<0 );
199262 return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm);
199269 const char *zTerm, /* Term to iterate through a doclist for */
199270 int nTerm /* Number of bytes in zTerm */
199280 assert( zTerm && nTerm>0 );
199282 /* Advance each segment iterator until it points to the term zTerm/nTerm. */
199283 rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm);
199286 /* Determine how many of the segments actually point to zTerm/nTerm. */
199289 if( !pSeg->aNode || fts3SegReaderTermCmp(pSeg, zTerm, nTerm) ){
199323 assert( pCsr->zTerm==0 );
199399 pCsr->zTerm = apSegment[0]->zTerm;
199402 ** to does not share a suffix with pFilter->zTerm/nTerm, then all
199408 if( pFilter->zTerm && !isScan ){
199411 || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm)
199421 && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm)
199761 csr.zTerm, csr.nTerm, csr.aDoclist, csr.nDoclist);
200323 ** node is finished and written to disk. The key (zTerm/nTerm) is guaranteed
200334 const char *zTerm, /* Term to write to internal node */
200335 int nTerm /* Bytes at zTerm */
200353 nPrefix = fts3PrefixCompress(pNode->key.a, pNode->key.n, zTerm, nTerm);
200382 memcpy(&pBlk->a[pBlk->n], &zTerm[nPrefix], nSuffix);
200385 memcpy(pNode->key.a, zTerm, nTerm);
200419 ** The term to be appended is passed via arguments zTerm/nTerm. For a
200426 ** copy of zTerm/nTerm.
200438 const char *zTerm, /* New term to write */
200439 int nTerm, /* Size of zTerm in bytes */
200458 nPrefix = fts3PrefixCompress(pPrev->a, pPrev->n, zTerm, nTerm);
200461 memcpy(pPrev->a, zTerm, nTerm);
200468 memcpy(&pNode->a[pNode->n], &zTerm[nPrefix], nSuffix);
200493 const char *zTerm = pCsr->zTerm;
200504 nPrefix = fts3PrefixCompress(pLeaf->key.a, pLeaf->key.n, zTerm, nTerm);
200530 ** leaf node (zTerm/nTerm).
200532 ** In other words, it must be the prefix of zTerm 1 byte longer than
200533 ** the common prefix (if any) of zTerm and pWriter->zTerm.
200536 rc = fts3IncrmergePush(p, pWriter, zTerm, nPrefix+1);
200558 &pLeaf->block, &pLeaf->key, zTerm, nTerm, aDoclist, nDoclist
201087 ** all terms that are greater than or equal to zTerm/nTerm (for leaf nodes)
201088 ** or greater than zTerm/nTerm (for internal nodes) from aNode/nNode.
201094 const char *zTerm, /* Omit all terms smaller than this */
201095 int nTerm, /* Size of zTerm in bytes */
201117 int res = fts3TermCmp(reader.term.a, reader.term.n, zTerm, nTerm);
201140 ** Remove all terms smaller than zTerm/nTerm from segment iIdx in absolute
201152 const char *zTerm, /* Remove terms smaller than this */
201153 int nTerm /* Number of bytes in buffer zTerm */
201172 rc = fts3TruncateNode(aRoot, nRoot, &root, zTerm, nTerm, &iBlock);
201185 rc = fts3TruncateNode(aBlock, nBlock, &block, zTerm, nTerm, &iBlock);
201266 ** so that it contains no keys smaller than zTerm/nTerm. */
201267 const char *zTerm = pSeg->zTerm;
201269 rc = fts3TruncateSegment(p, iAbsLevel, pSeg->iIdx, zTerm, nTerm);
201514 const char *zKey = pCsr->zTerm;
201661 const char *zTerm, /* Pointer to buffer containing term */
201662 int nTerm, /* Size of zTerm in bytes */
201676 for(i=0; i<nTerm; i++) ret += (ret<<3) + zTerm[i];
201745 csr.zTerm, csr.nTerm, iLangid, iIndex, iDocid,
204112 #define READ_UTF8(zIn, zTerm, c) \
204116 while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \
204204 const unsigned char *zTerm = &z[nIn];
204210 while( z<zTerm ){
204211 READ_UTF8(z, zTerm, iCode);
204229 while( z<zTerm ){
204230 READ_UTF8(z, zTerm, iCode);
204396 const unsigned char *zTerm = &pCsr->aInput[pCsr->nInput];
204401 while( z<zTerm ){
204402 READ_UTF8(z, zTerm, iCode);
204406 if( zStart>=zTerm ) return SQLITE_DONE;
204429 if( z>=zTerm ) break;
204430 READ_UTF8(z, zTerm, iCode);
239348 char *zTerm = fts5ExprTermPrint(&pPhrase->aTerm[iTerm]);
239349 if( zTerm ){
239350 zRet = fts5PrintfAppend(zRet, "%s%s", iTerm==0?"":" + ", zTerm);
239351 sqlite3_free(zTerm);
239353 if( zTerm==0 || zRet==0 ){
242724 const char *zTerm = 0;
242728 sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &nTerm, &pList, &nList);
242734 sqlite3Fts5BufferSet(&p->rc,&pIter->term, nTerm, (u8*)zTerm);
242799 const char *zTerm = 0;
242805 sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &nTerm, &pList, &nList);
242815 sqlite3Fts5BufferSet(&p->rc, &pIter->term, nTerm, (u8*)zTerm);
245981 ** pStruct to remove the entries for term zTerm, rowid iRowid.
245986 const char *zTerm,
245993 fts5MultiIterNew(p, pStruct, f, 0, (const u8*)zTerm, nTerm, -1, 0, &pIter);
246058 const char *zTerm; /* Buffer containing term */
246059 int nTerm; /* Size of zTerm in bytes */
246064 sqlite3Fts5HashScanEntry(pHash, &zTerm, &nTerm, &pDoclist, &nDoclist);
246066 fts5WriteAppendTerm(p, &writer, nTerm, (const u8*)zTerm);
246094 fts5FlushSecureDelete(p, pStruct, zTerm, nTerm, iRowid);
246104 fts5FlushSecureDelete(p, pStruct, zTerm, nTerm, iRowid);
246113 fts5WriteAppendTerm(p, &writer, nTerm, (const u8*)zTerm);
248384 const char *zTerm = (const char*)&pPrev->p[1]; /* term sans prefix-byte */
248385 int nTerm = pPrev->n-1; /* Size of zTerm in bytes */
248393 rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, flags, &ck1);
248396 rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, f, &ck2);
248408 ** Also only do this if buffer zTerm contains nTerm bytes of valid
248413 if( p->nPendingData==0 && 0==fts5TestUtf8(zTerm, nTerm) ){
248417 rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, f, &ck2);
248423 rc = fts5QueryCksum(p, iIdx, zTerm, nTerm, f, &ck2);
254141 #define READ_UTF8(zIn, zTerm, c) \
254145 while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \
254214 const unsigned char *zTerm = (const unsigned char*)&z[n];
254215 while( zCsr<zTerm ){
254218 READ_UTF8(zCsr, zTerm, iCode);
254399 unsigned char *zTerm = (unsigned char*)&pText[nText];
254419 if( zCsr>=zTerm ) goto tokenize_done;
254424 READ_UTF8(zCsr, zTerm, iCode);
254439 while( zCsr<zTerm ){
254460 READ_UTF8(zCsr, zTerm, iCode);
256953 const char *zTerm;
256955 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
256958 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
256964 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
257025 const char *zTerm;
257028 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
257032 int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
257039 sqlite3Fts5BufferSet(&rc, &pCsr->term, nTerm, (const u8*)zTerm);
257105 zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
257107 || (nTerm>0 && memcmp(zTerm, pCsr->term.p, nTerm))
257143 const char *zTerm = 0;
257158 zTerm = (const char *)sqlite3_value_text(pEq);
257163 zTerm = (const char *)sqlite3_value_text(pGe);
257181 rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);