Lines Matching refs:pNode
186734 NodeWriter *pNode = &pWriter->aNodeWriter[iLayer];
186744 nPrefix = fts3PrefixCompress(pNode->key.a, pNode->key.n, zTerm, nTerm);
186750 if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){
186755 Blob *pBlk = &pNode->block;
186764 blobGrowBuffer(&pNode->key, nTerm, &rc);
186767 if( pNode->key.n ){
186774 memcpy(pNode->key.a, zTerm, nTerm);
186775 pNode->key.n = nTerm;
186781 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
186783 assert( pNode->block.nAlloc>=p->nNodeSize );
186784 pNode->block.a[0] = (char)iLayer;
186785 pNode->block.n = 1 + sqlite3Fts3PutVarint(&pNode->block.a[1], iPtr+1);
186787 iNextPtr = pNode->iBlock;
186788 pNode->iBlock++;
186789 pNode->key.n = 0;
186825 Blob *pNode, /* Current node image to append to */
186839 assert( pNode->n>0 );
186840 assert_fts3_nc( (pNode->a[0]=='\0')==(aDoclist!=0) );
186852 pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nPrefix);
186854 pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nSuffix);
186855 memcpy(&pNode->a[pNode->n], &zTerm[nPrefix], nSuffix);
186856 pNode->n += nSuffix;
186859 pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nDoclist);
186860 memcpy(&pNode->a[pNode->n], aDoclist, nDoclist);
186861 pNode->n += nDoclist;
186864 assert( pNode->n<=pNode->nAlloc );
186975 NodeWriter *pNode = &pWriter->aNodeWriter[iRoot];
186976 if( pNode->block.n>0 ) break;
186977 assert( *pRc || pNode->block.nAlloc==0 );
186978 assert( *pRc || pNode->key.nAlloc==0 );
186979 sqlite3_free(pNode->block.a);
186980 sqlite3_free(pNode->key.a);
187016 NodeWriter *pNode = &pWriter->aNodeWriter[i];
187017 if( pNode->block.n>0 && rc==SQLITE_OK ){
187018 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
187020 sqlite3_free(pNode->block.a);
187021 sqlite3_free(pNode->key.a);
187183 NodeWriter *pNode;
187199 pNode = &pWriter->aNodeWriter[nHeight];
187200 pNode->iBlock = pWriter->iStart + pWriter->nLeafEst*nHeight;
187201 blobGrowBuffer(&pNode->block,
187205 memcpy(pNode->block.a, aRoot, nRoot);
187206 pNode->block.n = nRoot;
187207 memset(&pNode->block.a[nRoot], 0, FTS3_NODE_PADDING);
187212 pNode = &pWriter->aNodeWriter[i];
187214 if( pNode->block.a){
187215 rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n);
187217 blobGrowBuffer(&pNode->key, reader.term.n, &rc);
187221 memcpy(pNode->key.a, reader.term.a, reader.term.n);
187223 pNode->key.n = reader.term.n;
187227 pNode = &pWriter->aNodeWriter[i-1];
187228 pNode->iBlock = reader.iChild;
187230 blobGrowBuffer(&pNode->block,
187234 memcpy(pNode->block.a, aBlock, nBlock);
187235 pNode->block.n = nBlock;
187236 memset(&pNode->block.a[nBlock], 0, FTS3_NODE_PADDING);
187452 static void fts3StartNode(Blob *pNode, int iHeight, sqlite3_int64 iChild){
187453 pNode->a[0] = (char)iHeight;
187455 assert( pNode->nAlloc>=1+sqlite3Fts3VarintLen(iChild) );
187456 pNode->n = 1 + sqlite3Fts3PutVarint(&pNode->a[1], iChild);
187458 assert( pNode->nAlloc>=1 );
187459 pNode->n = 1;
191655 static u32 jsonNodeSize(JsonNode *pNode){
191656 return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1;
191686 JsonNode *pNode, /* The node to render */
191690 assert( pNode!=0 );
191691 if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){
191692 if( (pNode->jnFlags & JNODE_REPLACE)!=0 && ALWAYS(aReplace!=0) ){
191693 assert( pNode->eU==4 );
191694 jsonAppendValue(pOut, aReplace[pNode->u.iReplace]);
191697 assert( pNode->eU==5 );
191698 pNode = pNode->u.pPatch;
191700 switch( pNode->eType ){
191702 assert( pNode->eType==JSON_NULL );
191715 if( pNode->jnFlags & JNODE_RAW ){
191716 assert( pNode->eU==1 );
191717 jsonAppendString(pOut, pNode->u.zJContent, pNode->n);
191724 assert( pNode->eU==1 );
191725 jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n);
191732 while( j<=pNode->n ){
191733 if( (pNode[j].jnFlags & JNODE_REMOVE)==0 ){
191735 jsonRenderNode(&pNode[j], pOut, aReplace);
191737 j += jsonNodeSize(&pNode[j]);
191739 if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
191740 assert( pNode->eU==2 );
191741 pNode = &pNode[pNode->u.iAppend];
191751 while( j<=pNode->n ){
191752 if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){
191754 jsonRenderNode(&pNode[j], pOut, aReplace);
191756 jsonRenderNode(&pNode[j+1], pOut, aReplace);
191758 j += 1 + jsonNodeSize(&pNode[j+1]);
191760 if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
191761 assert( pNode->eU==2 );
191762 pNode = &pNode[pNode->u.iAppend];
191775 JsonNode *pNode, /* Node to return */
191781 jsonRenderNode(pNode, &s, aReplace);
191821 JsonNode *pNode, /* Node to return */
191825 switch( pNode->eType ){
191827 assert( pNode->eType==JSON_NULL );
191842 assert( pNode->eU==1 );
191843 z = pNode->u.zJContent;
191852 if( pNode->u.zJContent[0]=='-' ){
191862 if( pNode->u.zJContent[0]=='-' ){ i = -i; }
191872 assert( pNode->eU==1 );
191873 z = pNode->u.zJContent;
191876 assert( pNode->eU==1 );
191877 r = strtod(pNode->u.zJContent, 0);
191886 if( pNode->jnFlags & JNODE_RAW ){
191887 assert( pNode->eU==1 );
191888 sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n,
191892 assert( (pNode->jnFlags & JNODE_RAW)==0 );
191893 if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){
191895 assert( pNode->eU==1 );
191896 sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2,
191901 u32 n = pNode->n;
191905 assert( pNode->eU==1 );
191906 z = pNode->u.zJContent;
191971 jsonReturnJson(pNode, pCtx, aReplace);
192061 JsonNode *pNode;
192078 pNode = &pParse->aNode[pParse->nNode-1];
192079 if( pNode->eType!=JSON_STRING ) return -1;
192080 pNode->jnFlags |= JNODE_LABEL;
192251 JsonNode *pNode = &pParse->aNode[i];
192254 switch( pNode->eType ){
192256 for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){
192262 for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){
192365 static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){
192366 assert( pNode->eU==1 );
192367 if( pNode->jnFlags & JNODE_RAW ){
192368 if( pNode->n!=nKey ) return 0;
192369 return strncmp(pNode->u.zJContent, zKey, nKey)==0;
192371 if( pNode->n!=nKey+2 ) return 0;
192372 return strncmp(pNode->u.zJContent+1, zKey, nKey)==0;
192439 JsonNode *pNode;
192443 pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
192445 if( pNode ){
192453 return pNode;
192517 JsonNode *pNode;
192519 pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
192521 if( pNode ){
192528 return pNode;
192587 JsonNode *pNode = 0;
192596 pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr);
192597 if( zErr==0 ) return pNode;
192630 static void jsonRemoveAllNulls(JsonNode *pNode){
192632 assert( pNode->eType==JSON_OBJECT );
192633 n = pNode->n;
192634 for(i=2; i<=n; i += jsonNodeSize(&pNode[i])+1){
192635 switch( pNode[i].eType ){
192637 pNode[i].jnFlags |= JNODE_REMOVE;
192640 jsonRemoveAllNulls(&pNode[i]);
192773 JsonNode *pNode;
192780 pNode = jsonLookup(p, zPath, 0, ctx);
192782 pNode = p->aNode;
192784 if( pNode==0 ){
192787 if( pNode->eType==JSON_ARRAY ){
192788 assert( (pNode->jnFlags & JNODE_APPEND)==0 );
192789 for(i=1; i<=pNode->n; n++){
192790 i += jsonNodeSize(&pNode[i]);
192810 JsonNode *pNode;
192822 pNode = jsonLookup(p, zPath, 0, ctx);
192826 if( pNode ){
192827 jsonRenderNode(pNode, &jx, 0);
192831 }else if( pNode ){
192832 jsonReturn(pNode, ctx, 0);
193007 JsonNode *pNode;
193017 pNode = jsonLookup(&x, zPath, 0, ctx);
193019 if( pNode ) pNode->jnFlags |= JNODE_REMOVE;
193040 JsonNode *pNode;
193053 pNode = jsonLookup(&x, zPath, 0, ctx);
193055 if( pNode ){
193056 assert( pNode->eU==0 || pNode->eU==1 || pNode->eU==4 );
193057 json_testcase( pNode->eU!=0 && pNode->eU!=1 );
193058 pNode->jnFlags |= (u8)JNODE_REPLACE;
193059 VVA( pNode->eU = 4 );
193060 pNode->u.iReplace = i + 1;
193091 JsonNode *pNode;
193107 pNode = jsonLookup(&x, zPath, &bApnd, ctx);
193113 }else if( pNode && (bApnd || bIsSet) ){
193114 json_testcase( pNode->eU!=0 && pNode->eU!=1 && pNode->eU!=4 );
193115 assert( pNode->eU!=3 || pNode->eU!=5 );
193116 VVA( pNode->eU = 4 );
193117 pNode->jnFlags |= (u8)JNODE_REPLACE;
193118 pNode->u.iReplace = i + 1;
193145 JsonNode *pNode;
193151 pNode = jsonLookup(p, zPath, 0, ctx);
193153 pNode = p->aNode;
193155 if( pNode ){
193156 sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC);
193511 JsonNode *pNode, *pUp;
193519 pNode = &p->sParse.aNode[i];
193527 if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--;
193528 assert( pNode->eType==JSON_STRING );
193529 assert( pNode->jnFlags & JNODE_LABEL );
193530 assert( pNode->eU==1 );
193531 jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1);
193740 JsonNode *pNode = 0;
193752 pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr);
193759 }else if( pNode==0 ){
193763 pNode = p->sParse.aNode;
193765 p->iBegin = p->i = (int)(pNode - p->sParse.aNode);
193766 p->eType = pNode->eType;
193768 assert( pNode->eU==0 );
193769 VVA( pNode->eU = 3 );
193770 pNode->u.iKey = 0;
193771 p->iEnd = p->i + pNode->n + 1;
194314 #define NCELL(pNode) readInt16(&(pNode)->zData[2])
194585 static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){
194587 assert( pNode->pNext==0 );
194588 iHash = nodeHash(pNode->iNode);
194589 pNode->pNext = pRtree->aHash[iHash];
194590 pRtree->aHash[iHash] = pNode;
194596 static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){
194598 if( pNode->iNode!=0 ){
194599 pp = &pRtree->aHash[nodeHash(pNode->iNode)];
194600 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
194601 *pp = pNode->pNext;
194602 pNode->pNext = 0;
194613 RtreeNode *pNode;
194614 pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode) + pRtree->iNodeSize);
194615 if( pNode ){
194616 memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize);
194617 pNode->zData = (u8 *)&pNode[1];
194618 pNode->nRef = 1;
194620 pNode->pParent = pParent;
194621 pNode->isDirty = 1;
194624 return pNode;
194648 RtreeNode *pNode = 0;
194653 if( (pNode = nodeHashLookup(pRtree, iNode))!=0 ){
194654 if( pParent && pParent!=pNode->pParent ){
194658 pNode->nRef++;
194659 *ppNode = pNode;
194690 pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode)+pRtree->iNodeSize);
194691 if( !pNode ){
194694 pNode->pParent = pParent;
194695 pNode->zData = (u8 *)&pNode[1];
194696 pNode->nRef = 1;
194698 pNode->iNode = iNode;
194699 pNode->isDirty = 0;
194700 pNode->pNext = 0;
194701 rc = sqlite3_blob_read(pRtree->pNodeBlob, pNode->zData,
194712 if( rc==SQLITE_OK && pNode && iNode==1 ){
194713 pRtree->iDepth = readInt16(pNode->zData);
194724 if( pNode && rc==SQLITE_OK ){
194725 if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){
194732 if( pNode!=0 ){
194734 nodeHashInsert(pRtree, pNode);
194739 *ppNode = pNode;
194741 if( pNode ){
194743 sqlite3_free(pNode);
194756 RtreeNode *pNode, /* The node into which the cell is to be written */
194761 u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
194766 pNode->isDirty = 1;
194772 static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){
194773 u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
194775 int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell;
194777 writeInt16(&pNode->zData[2], NCELL(pNode)-1);
194778 pNode->isDirty = 1;
194789 RtreeNode *pNode, /* Write new cell into this node */
194796 nCell = NCELL(pNode);
194800 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
194801 writeInt16(&pNode->zData[2], nCell+1);
194802 pNode->isDirty = 1;
194811 static int nodeWrite(Rtree *pRtree, RtreeNode *pNode){
194813 if( pNode->isDirty ){
194815 if( pNode->iNode ){
194816 sqlite3_bind_int64(p, 1, pNode->iNode);
194820 sqlite3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLITE_STATIC);
194822 pNode->isDirty = 0;
194825 if( pNode->iNode==0 && rc==SQLITE_OK ){
194826 pNode->iNode = sqlite3_last_insert_rowid(pRtree->db);
194827 nodeHashInsert(pRtree, pNode);
194837 static int nodeRelease(Rtree *pRtree, RtreeNode *pNode){
194839 if( pNode ){
194840 assert( pNode->nRef>0 );
194842 pNode->nRef--;
194843 if( pNode->nRef==0 ){
194845 if( pNode->iNode==1 ){
194848 if( pNode->pParent ){
194849 rc = nodeRelease(pRtree, pNode->pParent);
194852 rc = nodeWrite(pRtree, pNode);
194854 nodeHashDelete(pRtree, pNode);
194855 sqlite3_free(pNode);
194868 RtreeNode *pNode, /* The node from which to extract the ID */
194871 assert( iCell<NCELL(pNode) );
194872 return readInt64(&pNode->zData[4 + pRtree->nBytesPerCell*iCell]);
194880 RtreeNode *pNode, /* The node from which to extract a coordinate */
194885 readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord);
194894 RtreeNode *pNode, /* The node containing the cell to be read */
194901 pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
194902 pData = pNode->zData + (12 + pRtree->nBytesPerCell*iCell);
195304 RtreeNode *pNode,
195309 int nCell = NCELL(pNode);
195312 if( nodeGetRowid(pRtree, pNode, ii)==iRowid ){
195325 static int nodeParentIndex(Rtree *pRtree, RtreeNode *pNode, int *piIndex){
195326 RtreeNode *pParent = pNode->pParent;
195328 return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex);
195557 RtreeNode *pNode;
195569 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
195571 nCell = NCELL(pNode);
195573 pCellData = pNode->zData + (4+pRtree->nBytesPerCell*p->iCell);
195657 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
195659 *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
195673 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
195678 sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell));
195680 nodeGetCoord(pRtree, pNode, p->iCell, i-1, &c);
195698 nodeGetRowid(pRtree, pNode, p->iCell));
196150 RtreeNode *pNode = 0;
196151 rc = nodeAcquire(pRtree, 1, 0, &pNode);
196160 int nCell = NCELL(pNode);
196174 nodeGetCell(pRtree, pNode, iCell, &cell);
196188 rc = nodeAcquire(pRtree, iBest, pNode, &pChild);
196189 nodeRelease(pRtree, pNode);
196190 pNode = pChild;
196193 *ppLeaf = pNode;
196204 RtreeNode *pNode, /* Adjust ancestry of this node. */
196207 RtreeNode *p = pNode;
196503 RtreeNode *pNode,
196511 for(p=pNode; p; p=p->pParent){
196516 nodeReference(pNode);
196517 pChild->pParent = pNode;
196520 if( NEVER(pNode==0) ) return SQLITE_ERROR;
196521 return xSetMapping(pRtree, iRowid, pNode->iNode);
196526 RtreeNode *pNode,
196534 int nCell = NCELL(pNode);
196555 nodeGetCell(pRtree, pNode, i, &aCell[i]);
196557 nodeZero(pRtree, pNode);
196561 if( pNode->iNode==1 ){
196562 pRight = nodeNew(pRtree, pNode);
196563 pLeft = nodeNew(pRtree, pNode);
196565 pNode->isDirty = 1;
196566 writeInt16(pNode->zData, pRtree->iDepth);
196568 pLeft = pNode;
196601 if( pNode->iNode==1 ){
196633 if( pNode->iNode==1 ){
196707 static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){
196713 assert( pNode->nRef==1 );
196716 rc = nodeParentIndex(pRtree, pNode, &iCell);
196718 pParent = pNode->pParent;
196719 pNode->pParent = 0;
196732 sqlite3_bind_int64(pRtree->pDeleteNode, 1, pNode->iNode);
196739 sqlite3_bind_int64(pRtree->pDeleteParent, 1, pNode->iNode);
196748 nodeHashDelete(pRtree, pNode);
196749 pNode->iNode = iHeight;
196750 pNode->pNext = pRtree->pDeleted;
196751 pNode->nRef++;
196752 pRtree->pDeleted = pNode;
196757 static int fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){
196758 RtreeNode *pParent = pNode->pParent;
196762 int nCell = NCELL(pNode);
196764 nodeGetCell(pRtree, pNode, 0, &box);
196767 nodeGetCell(pRtree, pNode, ii, &cell);
196770 box.iRowid = pNode->iNode;
196771 rc = nodeParentIndex(pRtree, pNode, &ii);
196784 static int deleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell, int iHeight){
196788 if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
196795 nodeDeleteCell(pRtree, pNode, iCell);
196802 pParent = pNode->pParent;
196803 assert( pParent || pNode->iNode==1 );
196805 if( NCELL(pNode)<RTREE_MINCELLS(pRtree) ){
196806 rc = removeNode(pRtree, pNode, iHeight);
196808 rc = fixBoundingBox(pRtree, pNode);
196817 RtreeNode *pNode,
196834 nCell = NCELL(pNode)+1;
196857 nodeGetCell(pRtree, pNode, ii, &aCell[ii]);
196879 nodeZero(pRtree, pNode);
196883 nodeInsertCell(pRtree, pNode, p);
196886 rc = rowidWrite(pRtree, p->iRowid, pNode->iNode);
196888 rc = parentWrite(pRtree, p->iRowid, pNode->iNode);
196893 rc = fixBoundingBox(pRtree, pNode);
196922 RtreeNode *pNode,
196931 nodeReference(pNode);
196932 pChild->pParent = pNode;
196935 if( nodeInsertCell(pRtree, pNode, pCell) ){
196936 if( iHeight<=pRtree->iReinsertHeight || pNode->iNode==1){
196937 rc = SplitNode(pRtree, pNode, pCell, iHeight);
196940 rc = Reinsert(pRtree, pNode, pCell, iHeight);
196943 rc = AdjustTree(pRtree, pNode, pCell);
196946 rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
196948 rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);
196955 static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){
196958 int nCell = NCELL(pNode);
196963 nodeGetCell(pRtree, pNode, ii, &cell);
196968 rc = ChooseLeaf(pRtree, &cell, (int)pNode->iNode, &pInsert);
196971 rc = rtreeInsertCell(pRtree, pInsert, &cell, (int)pNode->iNode);
197994 const u8 *pNode = (const u8*)sqlite3_column_blob(pCheck->pGetNode, 0);
197999 memcpy(pRet, pNode, nNode);
199882 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
199895 nodeGetRowid(pRtree, pNode, p->iCell));
219393 Fts5ExprNode *pNode; /* FTS5_STRING node this phrase is part of */
219831 Fts5ExprNode *pNode, /* Node pPhrase belongs to */
219861 rc = fts5ExprSynonymList(pTerm, pNode->iRowid, &buf, &a, &n);
220126 Fts5ExprNode *pNode /* The "NEAR" node (FTS5_STRING) */
220128 Fts5ExprNearset *pNear = pNode->pNear;
220138 if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
220156 rc = fts5ExprPhraseIsMatch(pNode, pPhrase, &bMatch);
220184 Fts5ExprNode *pNode
220186 Fts5ExprNearset *pNear = pNode->pNear;
220189 assert( pNode->bNomatch==0 );
220193 pNode->bEof = 1;
220223 pNode->bEof = 1;
220230 pNode->bEof = 0;
220259 static void fts5ExprSetEof(Fts5ExprNode *pNode){
220261 pNode->bEof = 1;
220262 pNode->bNomatch = 0;
220263 for(i=0; i<pNode->nChild; i++){
220264 fts5ExprSetEof(pNode->apChild[i]);
220268 static void fts5ExprNodeZeroPoslist(Fts5ExprNode *pNode){
220269 if( pNode->eType==FTS5_STRING || pNode->eType==FTS5_TERM ){
220270 Fts5ExprNearset *pNear = pNode->pNear;
220278 for(i=0; i<pNode->nChild; i++){
220279 fts5ExprNodeZeroPoslist(pNode->apChild[i]);
220321 Fts5ExprNode *pNode
220323 Fts5ExprNearset *pNear = pNode->pNear;
220359 pNode->bNomatch = 0;
220360 pNode->bEof = 1;
220367 if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
220375 pNode->iRowid = iLast;
220376 pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
220377 assert( pNode->bEof==0 || pNode->bNomatch==0 );
220391 Fts5ExprNode *pNode, /* FTS5_STRING or FTS5_TERM node */
220395 Fts5ExprTerm *pTerm = &pNode->pNear->apPhrase[0]->aTerm[0];
220398 pNode->bNomatch = 0;
220431 pNode->bEof = (rc || bEof);
220435 assert( Fts5NodeIsString(pNode) );
220442 pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
220445 if( pNode->bEof==0 ){
220447 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
220456 Fts5ExprNode *pNode /* The "NEAR" node (FTS5_TERM) */
220463 Fts5ExprPhrase *pPhrase = pNode->pNear->apPhrase[0];
220466 assert( pNode->eType==FTS5_TERM );
220467 assert( pNode->pNear->nPhrase==1 && pPhrase->nTerm==1 );
220474 pNode->iRowid = pIter->iRowid;
220475 pNode->bNomatch = (pPhrase->poslist.n==0);
220484 Fts5ExprNode *pNode,
220489 Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
220491 assert( pNode->bEof==0 );
220498 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
220500 pNode->bEof = 1;
220501 pNode->bNomatch = 0;
220508 Fts5ExprNode *pNode /* Expression node to test */
220510 Fts5ExprNode *pNext = pNode->apChild[0];
220513 for(i=1; i<pNode->nChild; i++){
220514 Fts5ExprNode *pChild = pNode->apChild[i];
220520 pNode->iRowid = pNext->iRowid;
220521 pNode->bEof = pNext->bEof;
220522 pNode->bNomatch = pNext->bNomatch;
220527 Fts5ExprNode *pNode,
220532 i64 iLast = pNode->iRowid;
220534 for(i=0; i<pNode->nChild; i++){
220535 Fts5ExprNode *p1 = pNode->apChild[i];
220543 pNode->bNomatch = 0;
220550 fts5ExprNodeTest_OR(pExpr, pNode);
220611 Fts5ExprNode *pNode,
220615 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
220617 rc = fts5ExprNodeTest_AND(pExpr, pNode);
220619 pNode->bNomatch = 0;
220626 Fts5ExprNode *pNode /* FTS5_NOT node to advance */
220629 Fts5ExprNode *p1 = pNode->apChild[0];
220630 Fts5ExprNode *p2 = pNode->apChild[1];
220631 assert( pNode->nChild==2 );
220643 pNode->bEof = p1->bEof;
220644 pNode->bNomatch = p1->bNomatch;
220645 pNode->iRowid = p1->iRowid;
220654 Fts5ExprNode *pNode,
220658 int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
220660 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
220663 pNode->bNomatch = 0;
220675 Fts5ExprNode *pNode /* Expression node to test */
220678 if( pNode->bEof==0 ){
220679 switch( pNode->eType ){
220682 rc = fts5ExprNodeTest_STRING(pExpr, pNode);
220687 rc = fts5ExprNodeTest_TERM(pExpr, pNode);
220692 rc = fts5ExprNodeTest_AND(pExpr, pNode);
220697 fts5ExprNodeTest_OR(pExpr, pNode);
220701 default: assert( pNode->eType==FTS5_NOT ); {
220702 rc = fts5ExprNodeTest_NOT(pExpr, pNode);
220718 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
220720 pNode->bEof = 0;
220721 pNode->bNomatch = 0;
220723 if( Fts5NodeIsString(pNode) ){
220725 rc = fts5ExprNearInitAll(pExpr, pNode);
220726 }else if( pNode->xNext==0 ){
220727 pNode->bEof = 1;
220731 for(i=0; i<pNode->nChild && rc==SQLITE_OK; i++){
220732 Fts5ExprNode *pChild = pNode->apChild[i];
220733 rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
220737 pNode->iRowid = pNode->apChild[0]->iRowid;
220739 switch( pNode->eType ){
220741 if( nEof>0 ) fts5ExprSetEof(pNode);
220745 if( pNode->nChild==nEof ) fts5ExprSetEof(pNode);
220749 assert( pNode->eType==FTS5_NOT );
220750 pNode->bEof = pNode->apChild[0]->bEof;
220756 rc = fts5ExprNodeTest(pExpr, pNode);
221133 Fts5Colset *pColsetOrig = pOrig->pNode->pNear->pColset;
221176 sCtx.pPhrase->pNode = pNew->pRoot;
221396 Fts5ExprNode *pNode,
221401 assert( pNode->eType==FTS5_TERM || pNode->eType==FTS5_STRING
221402 || pNode->eType==FTS5_AND || pNode->eType==FTS5_OR
221403 || pNode->eType==FTS5_NOT || pNode->eType==FTS5_EOF
221405 if( pNode->eType==FTS5_STRING || pNode->eType==FTS5_TERM ){
221406 Fts5ExprNearset *pNear = pNode->pNear;
221410 pNode->eType = FTS5_EOF;
221411 pNode->xNext = 0;
221421 assert( pNode->eType!=FTS5_EOF || pNode->nChild==0 );
221422 for(i=0; i<pNode->nChild; i++){
221423 fts5ParseSetColset(pParse, pNode->apChild[i], pColset, ppFree);
221448 static void fts5ExprAssignXNext(Fts5ExprNode *pNode){
221449 switch( pNode->eType ){
221451 Fts5ExprNearset *pNear = pNode->pNear;
221456 pNode->eType = FTS5_TERM;
221457 pNode->xNext = fts5ExprNodeNext_TERM;
221459 pNode->xNext = fts5ExprNodeNext_STRING;
221465 pNode->xNext = fts5ExprNodeNext_OR;
221470 pNode->xNext = fts5ExprNodeNext_AND;
221474 default: assert( pNode->eType==FTS5_NOT ); {
221475 pNode->xNext = fts5ExprNodeNext_NOT;
221601 pNear->apPhrase[iPhrase]->pNode = pRet;
222132 Fts5ExprNode *pNode = pPhrase->pNode;
222133 if( pNode->bEof==0 && pNode->iRowid==pExpr->pRoot->iRowid ){
222166 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
222169 (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
222247 Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
222248 Fts5Colset *pColset = pNode->pNear->pColset;
222263 static void fts5ExprClearPoslists(Fts5ExprNode *pNode){
222264 if( pNode->eType==FTS5_TERM || pNode->eType==FTS5_STRING ){
222265 pNode->pNear->apPhrase[0]->poslist.n = 0;
222268 for(i=0; i<pNode->nChild; i++){
222269 fts5ExprClearPoslists(pNode->apChild[i]);
222274 static int fts5ExprCheckPoslists(Fts5ExprNode *pNode, i64 iRowid){
222275 pNode->iRowid = iRowid;
222276 pNode->bEof = 0;
222277 switch( pNode->eType ){
222280 return (pNode->pNear->apPhrase[0]->poslist.n>0);
222284 for(i=0; i<pNode->nChild; i++){
222285 if( fts5ExprCheckPoslists(pNode->apChild[i], iRowid)==0 ){
222286 fts5ExprClearPoslists(pNode);
222296 for(i=0; i<pNode->nChild; i++){
222297 if( fts5ExprCheckPoslists(pNode->apChild[i], iRowid) ){
222305 assert( pNode->eType==FTS5_NOT );
222306 if( 0==fts5ExprCheckPoslists(pNode->apChild[0], iRowid)
222307 || 0!=fts5ExprCheckPoslists(pNode->apChild[1], iRowid)
222309 fts5ExprClearPoslists(pNode);
222332 Fts5ExprNode *pNode = pPhrase->pNode;
222338 if( pNode->bEof==0
222339 && pNode->iRowid==pExpr->pRoot->iRowid
222346 pTerm, pNode->iRowid, pBuf, (u8**)ppCollist, pnCollist