• Home
  • Raw
  • Download

Lines Matching refs:pNode

146745     NodeWriter *pNode = &pWriter->aNodeWriter[iLayer];
146755 nPrefix = fts3PrefixCompress(pNode->key.a, pNode->key.n, zTerm, nTerm);
146760 if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){
146765 Blob *pBlk = &pNode->block;
146774 blobGrowBuffer(&pNode->key, nTerm, &rc);
146777 if( pNode->key.n ){
146784 memcpy(pNode->key.a, zTerm, nTerm);
146785 pNode->key.n = nTerm;
146791 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
146793 assert( pNode->block.nAlloc>=p->nNodeSize );
146794 pNode->block.a[0] = (char)iLayer;
146795 pNode->block.n = 1 + sqlite3Fts3PutVarint(&pNode->block.a[1], iPtr+1);
146797 iNextPtr = pNode->iBlock;
146798 pNode->iBlock++;
146799 pNode->key.n = 0;
146835 Blob *pNode, /* Current node image to append to */
146849 assert( pNode->n>0 );
146850 assert( (pNode->a[0]=='\0')==(aDoclist!=0) );
146861 pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nPrefix);
146863 pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nSuffix);
146864 memcpy(&pNode->a[pNode->n], &zTerm[nPrefix], nSuffix);
146865 pNode->n += nSuffix;
146868 pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nDoclist);
146869 memcpy(&pNode->a[pNode->n], aDoclist, nDoclist);
146870 pNode->n += nDoclist;
146873 assert( pNode->n<=pNode->nAlloc );
146984 NodeWriter *pNode = &pWriter->aNodeWriter[iRoot];
146985 if( pNode->block.n>0 ) break;
146986 assert( *pRc || pNode->block.nAlloc==0 );
146987 assert( *pRc || pNode->key.nAlloc==0 );
146988 sqlite3_free(pNode->block.a);
146989 sqlite3_free(pNode->key.a);
147025 NodeWriter *pNode = &pWriter->aNodeWriter[i];
147026 if( pNode->block.n>0 && rc==SQLITE_OK ){
147027 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
147029 sqlite3_free(pNode->block.a);
147030 sqlite3_free(pNode->key.a);
147184 NodeWriter *pNode;
147196 pNode = &pWriter->aNodeWriter[nHeight];
147197 pNode->iBlock = pWriter->iStart + pWriter->nLeafEst*nHeight;
147198 blobGrowBuffer(&pNode->block, MAX(nRoot, p->nNodeSize), &rc);
147200 memcpy(pNode->block.a, aRoot, nRoot);
147201 pNode->block.n = nRoot;
147206 pNode = &pWriter->aNodeWriter[i];
147208 rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n);
147210 blobGrowBuffer(&pNode->key, reader.term.n, &rc);
147212 memcpy(pNode->key.a, reader.term.a, reader.term.n);
147213 pNode->key.n = reader.term.n;
147217 pNode = &pWriter->aNodeWriter[i-1];
147218 pNode->iBlock = reader.iChild;
147220 blobGrowBuffer(&pNode->block, MAX(nBlock, p->nNodeSize), &rc);
147222 memcpy(pNode->block.a, aBlock, nBlock);
147223 pNode->block.n = nBlock;
147438 static void fts3StartNode(Blob *pNode, int iHeight, sqlite3_int64 iChild){
147439 pNode->a[0] = (char)iHeight;
147441 assert( pNode->nAlloc>=1+sqlite3Fts3VarintLen(iChild) );
147442 pNode->n = 1 + sqlite3Fts3PutVarint(&pNode->a[1], iChild);
147444 assert( pNode->nAlloc>=1 );
147445 pNode->n = 1;
151274 #define NCELL(pNode) readInt16(&(pNode)->zData[2])
151433 static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){
151435 assert( pNode->pNext==0 );
151436 iHash = nodeHash(pNode->iNode);
151437 pNode->pNext = pRtree->aHash[iHash];
151438 pRtree->aHash[iHash] = pNode;
151444 static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){
151446 if( pNode->iNode!=0 ){
151447 pp = &pRtree->aHash[nodeHash(pNode->iNode)];
151448 for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
151449 *pp = pNode->pNext;
151450 pNode->pNext = 0;
151461 RtreeNode *pNode;
151462 pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode) + pRtree->iNodeSize);
151463 if( pNode ){
151464 memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize);
151465 pNode->zData = (u8 *)&pNode[1];
151466 pNode->nRef = 1;
151467 pNode->pParent = pParent;
151468 pNode->isDirty = 1;
151471 return pNode;
151485 RtreeNode *pNode;
151490 if( (pNode = nodeHashLookup(pRtree, iNode)) ){
151491 assert( !pParent || !pNode->pParent || pNode->pParent==pParent );
151492 if( pParent && !pNode->pParent ){
151494 pNode->pParent = pParent;
151496 pNode->nRef++;
151497 *ppNode = pNode;
151506 pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode)+pRtree->iNodeSize);
151507 if( !pNode ){
151510 pNode->pParent = pParent;
151511 pNode->zData = (u8 *)&pNode[1];
151512 pNode->nRef = 1;
151513 pNode->iNode = iNode;
151514 pNode->isDirty = 0;
151515 pNode->pNext = 0;
151516 memcpy(pNode->zData, zBlob, pRtree->iNodeSize);
151530 if( pNode && iNode==1 ){
151531 pRtree->iDepth = readInt16(pNode->zData);
151541 if( pNode && rc==SQLITE_OK ){
151542 if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){
151548 if( pNode!=0 ){
151549 nodeHashInsert(pRtree, pNode);
151553 *ppNode = pNode;
151555 sqlite3_free(pNode);
151567 RtreeNode *pNode, /* The node into which the cell is to be written */
151572 u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
151577 pNode->isDirty = 1;
151583 static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){
151584 u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
151586 int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell;
151588 writeInt16(&pNode->zData[2], NCELL(pNode)-1);
151589 pNode->isDirty = 1;
151600 RtreeNode *pNode, /* Write new cell into this node */
151607 nCell = NCELL(pNode);
151611 nodeOverwriteCell(pRtree, pNode, pCell, nCell);
151612 writeInt16(&pNode->zData[2], nCell+1);
151613 pNode->isDirty = 1;
151622 static int nodeWrite(Rtree *pRtree, RtreeNode *pNode){
151624 if( pNode->isDirty ){
151626 if( pNode->iNode ){
151627 sqlite3_bind_int64(p, 1, pNode->iNode);
151631 sqlite3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLITE_STATIC);
151633 pNode->isDirty = 0;
151635 if( pNode->iNode==0 && rc==SQLITE_OK ){
151636 pNode->iNode = sqlite3_last_insert_rowid(pRtree->db);
151637 nodeHashInsert(pRtree, pNode);
151647 static int nodeRelease(Rtree *pRtree, RtreeNode *pNode){
151649 if( pNode ){
151650 assert( pNode->nRef>0 );
151651 pNode->nRef--;
151652 if( pNode->nRef==0 ){
151653 if( pNode->iNode==1 ){
151656 if( pNode->pParent ){
151657 rc = nodeRelease(pRtree, pNode->pParent);
151660 rc = nodeWrite(pRtree, pNode);
151662 nodeHashDelete(pRtree, pNode);
151663 sqlite3_free(pNode);
151676 RtreeNode *pNode, /* The node from which to extract the ID */
151679 assert( iCell<NCELL(pNode) );
151680 return readInt64(&pNode->zData[4 + pRtree->nBytesPerCell*iCell]);
151688 RtreeNode *pNode, /* The node from which to extract a coordinate */
151693 readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord);
151702 RtreeNode *pNode, /* The node containing the cell to be read */
151709 pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
151710 pData = pNode->zData + (12 + pRtree->nBytesPerCell*iCell);
152038 RtreeNode *pNode,
152043 int nCell = NCELL(pNode);
152046 if( nodeGetRowid(pRtree, pNode, ii)==iRowid ){
152058 static int nodeParentIndex(Rtree *pRtree, RtreeNode *pNode, int *piIndex){
152059 RtreeNode *pParent = pNode->pParent;
152061 return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex);
152288 RtreeNode *pNode;
152299 pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc);
152301 nCell = NCELL(pNode);
152305 u8 *pCellData = pNode->zData + (4+pRtree->nBytesPerCell*p->iCell);
152373 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
152375 *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell);
152389 RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
152394 sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell));
152397 nodeGetCoord(pRtree, pNode, p->iCell, i-1, &c);
152821 RtreeNode *pNode;
152822 rc = nodeAcquire(pRtree, 1, 0, &pNode);
152831 int nCell = NCELL(pNode);
152845 nodeGetCell(pRtree, pNode, iCell, &cell);
152859 rc = nodeAcquire(pRtree, iBest, pNode, &pChild);
152860 nodeRelease(pRtree, pNode);
152861 pNode = pChild;
152864 *ppLeaf = pNode;
152875 RtreeNode *pNode, /* Adjust ancestry of this node. */
152878 RtreeNode *p = pNode;
153165 RtreeNode *pNode,
153174 nodeReference(pNode);
153175 pChild->pParent = pNode;
153178 return xSetMapping(pRtree, iRowid, pNode->iNode);
153183 RtreeNode *pNode,
153191 int nCell = NCELL(pNode);
153212 nodeGetCell(pRtree, pNode, i, &aCell[i]);
153214 nodeZero(pRtree, pNode);
153218 if( pNode->iNode==1 ){
153219 pRight = nodeNew(pRtree, pNode);
153220 pLeft = nodeNew(pRtree, pNode);
153222 pNode->isDirty = 1;
153223 writeInt16(pNode->zData, pRtree->iDepth);
153225 pLeft = pNode;
153258 if( pNode->iNode==1 ){
153289 if( pNode->iNode==1 ){
153360 static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){
153366 assert( pNode->nRef==1 );
153369 rc = nodeParentIndex(pRtree, pNode, &iCell);
153371 pParent = pNode->pParent;
153372 pNode->pParent = 0;
153384 sqlite3_bind_int64(pRtree->pDeleteNode, 1, pNode->iNode);
153391 sqlite3_bind_int64(pRtree->pDeleteParent, 1, pNode->iNode);
153400 nodeHashDelete(pRtree, pNode);
153401 pNode->iNode = iHeight;
153402 pNode->pNext = pRtree->pDeleted;
153403 pNode->nRef++;
153404 pRtree->pDeleted = pNode;
153409 static int fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){
153410 RtreeNode *pParent = pNode->pParent;
153414 int nCell = NCELL(pNode);
153416 nodeGetCell(pRtree, pNode, 0, &box);
153419 nodeGetCell(pRtree, pNode, ii, &cell);
153422 box.iRowid = pNode->iNode;
153423 rc = nodeParentIndex(pRtree, pNode, &ii);
153436 static int deleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell, int iHeight){
153440 if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
153447 nodeDeleteCell(pRtree, pNode, iCell);
153454 pParent = pNode->pParent;
153455 assert( pParent || pNode->iNode==1 );
153457 if( NCELL(pNode)<RTREE_MINCELLS(pRtree) ){
153458 rc = removeNode(pRtree, pNode, iHeight);
153460 rc = fixBoundingBox(pRtree, pNode);
153469 RtreeNode *pNode,
153486 nCell = NCELL(pNode)+1;
153509 nodeGetCell(pRtree, pNode, ii, &aCell[ii]);
153531 nodeZero(pRtree, pNode);
153535 nodeInsertCell(pRtree, pNode, p);
153538 rc = rowidWrite(pRtree, p->iRowid, pNode->iNode);
153540 rc = parentWrite(pRtree, p->iRowid, pNode->iNode);
153545 rc = fixBoundingBox(pRtree, pNode);
153574 RtreeNode *pNode,
153583 nodeReference(pNode);
153584 pChild->pParent = pNode;
153587 if( nodeInsertCell(pRtree, pNode, pCell) ){
153588 if( iHeight<=pRtree->iReinsertHeight || pNode->iNode==1){
153589 rc = SplitNode(pRtree, pNode, pCell, iHeight);
153592 rc = Reinsert(pRtree, pNode, pCell, iHeight);
153595 rc = AdjustTree(pRtree, pNode, pCell);
153598 rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
153600 rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);
153607 static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){
153610 int nCell = NCELL(pNode);
153615 nodeGetCell(pRtree, pNode, ii, &cell);
153620 rc = ChooseLeaf(pRtree, &cell, (int)pNode->iNode, &pInsert);
153623 rc = rtreeInsertCell(pRtree, pInsert, &cell, (int)pNode->iNode);