Lines Matching defs:node
10941 sqlite3_rtree_dbl *aCoord; /* Coordinates of node or entry to check */
10944 int iLevel; /* Level of current node or entry */
10947 sqlite3_rtree_dbl rParentScore; /* Score of parent node */
10948 int eParentWithin; /* Visibility of parent node */
15596 ** then the value of the node is the value in Mem[pExpr.iTable]. Any
15597 ** TK_COLUMN node in the expression tree refers to the Expr.iColumn-th
18186 ** code for that node.
18242 ** Each node of an expression in the parse tree is an instance
18305 u8 op; /* Operation performed by this node */
18338 int nHeight; /* Height of the tree headed by this node */
18435 #define EP_Immutable 0x02 /* Do not change this Expr node */
36969 typedef struct unixInodeInfo unixInodeInfo; /* An i-node */
41170 unixInodeInfo *pInode; /* unixInodeInfo that owns this SHM node */
55147 ** node taken from the head of *ppList. A depth of 2 means a tree with
68058 ** root-node and 3 for all other internal nodes.
74668 ** will always point to a leaf node. */
76401 ** This function is used to copy the contents of the b-tree node stored
76432 /* Copy the b-tree node content from page pFrom to page pTo. */
76492 ** size of a cell stored within an internal node is always less than 1/4
77105 ** previously stored on a leaf node, and its reported size was 4
77302 ** of the node stored on pRoot into the new child page.
78063 int iCellDepth; /* Depth of node containing pCell */
78131 ** from the internal node. The 'previous' entry is used for this instead
78166 ** node. The cell from the leaf node needs to be moved to the internal
78167 ** node to replace the deleted cell. */
78202 ** Otherwise, if the entry deleted was on an internal node page, then
78204 ** replace the cell deleted from the internal node. This is slightly
78205 ** tricky as the leaf node may be underfull, and the internal node may
78207 ** on the leaf node first. If the balance proceeds far enough up the
78208 ** tree that we can be sure that any problem in the internal node has
78209 ** been corrected, so be it. Otherwise, after balancing the leaf node,
78210 ** walk the cursor up the tree to the internal node and balance it as
78730 int iIdx; /* Index of child node in parent */
78742 /* pPage is a leaf node. This loop navigates the cursor so that it
78766 /* Descend to the child node of the cell that the cursor currently
78968 ** The heap property is this: Every node is less than or equal to both
78970 ** root node aHeap[1] is always the minimum value currently in the heap.
102220 MergeEngine *pRoot = 0; /* Root node of tree for this task */
103461 ** Walk an expression tree. Invoke the callback once for each node
103655 ** are walked without any actions being taken at each node. Presumably,
103701 ** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node.
103702 ** This needs to occur when copying a TK_AGG_FUNCTION node from an
103832 ** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN.
103883 ** expression node refer back to that source column. The following changes
103913 Expr *pExpr /* Make this EXPR node point to the selected column */
103934 /* Initialize the node to no-match */
104524 ** node in the expression tree. Return 0 to continue the search down
105617 ** The node at the root of the subtree is modified as follows:
105904 ** sequence named by pToken. Return a pointer to a new Expr node that
106225 ** columns of result. Every TK_VECTOR node is an vector because the
106314 /* The TK_SELECT_COLUMN Expr node:
106325 ** can be attached to pRight to cause this node to take ownership of
106634 ** Construct a new expression node and return a pointer to it. Memory
106635 ** for this node and for the pToken argument is a single allocation
106637 ** is responsible for making sure the node eventually gets freed.
106643 ** then the EP_DblQuoted flag is set on the expression node.
106696 ** Allocate a new expression node from a zero-terminated token that has
106711 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
106751 ** Allocate an Expr node which joins as many as two subtrees.
106754 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
106877 ** Construct a new expression node for a function with multiple
107880 ** This is a SELECT-node callback for the expression walker that
107926 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
108226 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
109675 ** Convert a scalar expression node to a TK_REGISTER referencing
109918 Expr tempX; /* Temporary expression node */
110068 ** Expr node to be passed into this function, it will be handled
111654 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
111655 ** If the expression node requires that the table at pWalker->iCur
111970 ** This is a Walker expression node callback.
113328 ** For every TK_COLUMN node in the expression tree, search to see
116575 ** This only applies to the root node of pExpr, so the statement:
130059 ** expression node references any of the
143059 ** This is a Walker expression callback. pExpr is a node from the WHERE
144657 ** If the node passed to the callback is a TK_AND node, return
149330 ** single column of an index. The sCol[0] node will be the TK_COLLATE
151498 ** Think of each WhereLoop object as a node in a graph with arcs
152847 ** This function is called for every node of an expression that is a candidate
152871 ** a TK_COLUMN node that does affect the value of the expression is set
152898 ** This function is called on every node of an expression tree used as an
152899 ** argument to the OP_CursorHint instruction. If the node is a TK_COLUMN
152906 ** 2) transform the expression node to a TK_REGISTER node that reads
152909 ** Also, if the node is a TK_COLUMN that does access the table idenified
152933 ** todo: It should be possible to replace this node with a TK_REGISTER
159811 ** If the Expr node references the table with cursor pCk->iTabCur, then
159819 ** If this node does not disprove that the index can be a covering index,
163978 ** Append the node to output expression-list (*ppSub). And replace it
178821 ** iterate through a single leaf node's data) and LeavesReader (to
178844 ** of a node is reached, the next term is in the node with the next
178845 ** greater node id.
178847 ** New data is spilled to a new leaf node when the current node
178850 ** node (a leaf node with a single term and doclist). The goal of
178858 ** node rather than splitting into 2k and .5k nodes. My intuition is
178867 ** SegmentWriter creates new leaf nodes, or when an interior node
178872 ** varint iBlockid; (block id of node's leftmost subtree)
178887 ** An interior node encodes n terms separating n+1 subtrees. The
178898 ** New data is spilled to a new interior node at the same height when
178899 ** the current node exceeds INTERIOR_MAX bytes (default 2048).
178908 ** merging and deleting segments, and also the root node of the
178911 ** The root node is the top node of the segment's tree after encoding
178913 ** This could be either a leaf node or an interior node. If the top
178914 ** node requires more than ROOT_MAX bytes, it is flushed to %_segments
178915 ** and a new root interior node is generated (which should always fit
178923 ** start_block - first leaf node
178924 ** leaves_end_block - last leaf node
178926 ** root - contents of root node
178928 ** If the root node is a leaf node, then start_block,
179534 int nNodeSize; /* Soft limit for node size */
179730 ** when the expression node is.
181514 ** This function is used to process a single interior node when searching
181515 ** a b-tree for a term or term prefix. The node data is passed to this
181520 ** of the child node that heads the sub-tree that may contain the term.
181522 ** If piLast is not NULL, then *piLast is set to the right-most child node
181531 const char *zNode, /* Buffer containing segment interior node */
181533 sqlite3_int64 *piFirst, /* OUT: Selected child node */
181534 sqlite3_int64 *piLast /* OUT: Selected child node */
181537 const char *zCsr = zNode; /* Cursor to iterate through node */
181538 const char *zEnd = &zCsr[nNode];/* End of interior node buffer */
181542 u64 iChild; /* Block id of child node to descend to */
181546 ** interior node. Then load the blockid of the left-child of the b-tree
181547 ** node into variable iChild.
181551 ** root node, then the buffer comes from a SELECT statement. SQLite does
181554 ** contents, or two zero bytes. Or, if the node is read from the %_segments
181569 /* Load the next term on the node into zBuffer. Use realloc() to expand
181602 ** the interior node. If the specified term is greater than or equal
181603 ** to the term from the interior node, then all terms on the sub-tree
181604 ** headed by node iChild are smaller than zTerm. No need to search
181607 ** If the interior node term is larger than the specified term, then
181635 ** interior node of a b-tree segment. The zTerm buffer (size nTerm bytes)
181637 ** node for the range of leaf nodes that may contain the specified term
181641 ** left-most leaf node in the tree that may contain the specified term.
181643 ** right-most leaf node that may contain a term for which the specified
181658 const char *zNode, /* Buffer containing segment interior node */
181660 sqlite3_int64 *piLeaf, /* Selected leaf node */
181661 sqlite3_int64 *piLeaf2 /* Selected leaf node */
181664 int iHeight; /* Height of this node in tree */
182652 ** root node, the range of leaves scanned can be reduced. Do this. */
183165 ** entry and each block (if any) between the leaf and the root node. So
184630 ** the cluster with root node pRoot. See comments above the definition
184639 Fts3Expr *pRoot, /* Consider tokens with this root node */
185055 ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
185088 ** The right-hand child of a NEAR node is always a phrase. The
185089 ** left-hand child may be either a phrase or a NEAR node. There are
185445 /* Allocate space for the aMSI[] array of each FTSQUERY_PHRASE node */
185504 ** expression node for the following information:
185611 /* Check if this phrase descends from an OR expression node. If not,
185614 ** tree that the node is part of has been marked as EOF, but the node
185624 /* This is the descendent of an OR node. In this case we cannot use
186406 ** called, it sets ParseContext.isNot to true if the 'next node' is a
186894 ** expression tree being parsed. pPrev is the expression node most recently
186896 ** operator node, into the expression tree based on the relative precedence
186898 ** of the tree changing, in which case *ppHead is set to the new root node.
186901 Fts3Expr **ppHead, /* Pointer to the root node of a tree */
186903 Fts3Expr *pNew /* New binary node to insert into expression tree */
187099 ** new root expression node.
187108 Fts3Expr *pRoot = *pp; /* Initial root node */
187110 int eType = pRoot->eType; /* Type of node in this tree */
187174 /* If that was the last leaf node, break out of the loop */
187190 /* Link pParent into the free node list. It will be used as an
187191 ** internal node of the new tree. */
187385 ** Free a single node of an expression tree.
189920 ** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer
189923 ** This means that if we have a pointer into a buffer containing node data,
189925 ** overread, even if the node data is corrupted.
190034 char *aNode; /* Pointer to node data (or NULL) */
190037 sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */
190105 SegmentNode *pParent; /* Parent node (or NULL for root node) */
190107 SegmentNode *pLeftmost; /* Pointer to left-most node of this depth */
190108 int nEntry; /* Number of terms written to node so far */
191278 ** safe (no risk of overread) even if the node data is corrupted. */
191312 ** b-tree node. And that the final byte of the doclist is 0x00. If either
191400 ** position. The exception is if this node is being loaded from disk
191507 const char *zRoot, /* Buffer containing root node */
191508 int nRoot, /* Size of buffer containing root node */
191512 int nExtra = 0; /* Bytes to allocate segment root node */
191536 /* The entire segment is stored in the root node. */
191921 /* First try to append the term to the current node. Return early if
191925 int nData = pTree->nData; /* Current size of node in bytes */
191942 /* An unusual case: this is the first term to be added to the node
191943 ** and the static node buffer (p->nNodeSize bytes) is not large
191957 /* There is no prefix-length field for first term in a node */
191987 ** current node. Create a new node (a right-sibling of the current node).
191988 ** If this is the first node in the tree, the term is added to it.
191990 ** Otherwise, the term is not added to the new node, it is left empty for
192040 ** Write the buffer for the segment node pTree and all of its peers to the
192044 ** Except, if pTree is a root node, do not write it to the database. Instead,
192045 ** set output variables *paRoot and *pnRoot to contain the root node.
192055 int iHeight, /* Height of this node in tree */
192056 sqlite3_int64 iLeaf, /* Block id of first leaf node */
192059 char **paRoot, /* OUT: Data for root node */
192060 int *pnRoot /* OUT: Size of root node in bytes */
192065 /* Root node of the tree. */
192181 /* The current leaf node is full. Write it out to the database. */
192187 /* Add the current term to the interior node tree. The term added to
192190 ** a) be greater than the largest term on the leaf node just written
192194 ** leaf node (zTerm/nTerm).
192282 char *zRoot = NULL; /* Pointer to buffer containing root node */
192296 /* The entire tree fits on the root node. Write it to the segdir table. */
193612 ** FTS segment node. See the following functions:
193623 /* Output variables. Containing the current node entry. */
193624 sqlite3_int64 iChild; /* Pointer to child node */
193653 ** Attempt to advance the node-reader object passed as the first argument to
193654 ** the next entry on the node.
193657 ** Otherwise return SQLITE_OK. If there is no next entry on the node
193663 int bFirst = (p->term.n==0); /* True for first term on the node */
193703 ** Release all dynamic resources held by node-reader object *p.
193710 ** Initialize a node-reader object to read the node in buffer aNode/nNode.
193713 ** point to the first entry on the node (if any). Otherwise, an SQLite
193721 /* Figure out if this is a leaf or an internal node. */
193723 /* An internal node. */
193734 ** node is finished and written to disk. The key (zTerm/nTerm) is guaranteed
193735 ** to be greater than the largest key on the node just written, but smaller
193737 ** node.
193739 ** The block id of the leaf node just written to disk may be found in
193745 const char *zTerm, /* Term to write to internal node */
193761 ** the current node of layer iLayer. Due to the prefix compression,
193762 ** the space required changes depending on which node the key is to
193771 /* If the current node of layer iLayer contains zero keys, or if adding
193800 /* Otherwise, flush the current node of layer iLayer to disk.
193801 ** Then allocate a new, empty sibling node. The key will be written
193802 ** into the parent of this node. */
193823 ** Append a term and (optionally) doclist to the FTS segment node currently
193824 ** stored in blob *pNode. The node need not contain any terms, but the
193827 ** A node header is a single 0x00 byte for a leaf node, or a height varint
193828 ** followed by the left-hand-child varint for an internal node.
193831 ** leaf node, the doclist is passed as aDoclist/nDoclist. For an internal
193832 ** node, both aDoclist and nDoclist must be passed 0.
193835 ** term written to the node. Otherwise, pPrev contains a copy of the
193847 Blob *pNode, /* Current node image to append to */
193860 ** leaf node, and there must not be a doclist for an internal node. */
193928 /* Add the current term to the parent node. The term added to the
193931 ** a) be greater than the largest term on the leaf node just written
193935 ** leaf node (zTerm/nTerm).
193973 ** all outstanding node buffers held by pWriter to disk.
193990 NodeWriter *pRoot; /* NodeWriter for root node */
193994 ** root node. If the segment fits entirely on a single leaf node, iRoot
193995 ** will be set to 0. If the root node is the parent of the leaves, iRoot
194009 /* The entire output segment fits on a single node. Normally, this means
194010 ** the node would be stored as a blob in the "root" column of the %_segdir
194015 ** segments that fit entirely on the root node with start_block!=0.
194017 ** Instead, create a synthetic root node that contains nothing but a
194018 ** pointer to the single content node. So that the segment consists of a
194019 ** single leaf and a single interior (root) node.
194488 ** node. The node may be a leaf or an internal node.
194490 ** This function creates a new node image in blob object *pNew by copying
194495 const char *aNode, /* Current node image */
194497 Blob *pNew, /* OUT: Write new node image here */
194503 Blob prev = {0, 0, 0}; /* Previous term written to new node */
194505 int bLeaf; /* True for a leaf node */
194515 /* Populate new node buffer */
194597 /* Variable iNewStart now contains the first valid leaf node. */
195960 int eType = pExpr->eType; /* Type of expression node pExpr */
195978 ** For each phrase node found, the supplied callback function is invoked.
196569 Fts3Expr *pExpr, /* Phrase expression node */
196651 Fts3Expr *pExpr, /* Phrase expression node */
196667 Fts3Expr *pExpr, /* Phrase expression node */
196802 Fts3Expr *pExpr, /* Phrase expression node */
198353 /* A single node of parsed JSON
198376 u32 *aUp; /* Index of parent of each node */
198639 JsonNode *pNode, /* The node to render */
198947 JsonParse *pParse, /* Append the node to this object */
198949 u32 n, /* Content size or sub-node count */
198971 ** new node, or -1 if a memory allocation fails.
198974 JsonParse *pParse, /* Append the node to this object */
198976 u32 n, /* Content size or sub-node count */
199200 /* Mark node i of pParse as being a child of iParent. Call recursively
199201 ** to fill in all the descendants of node i.
199333 ** Search along zPath to find the node specified. Return a pointer
199334 ** to that node, or NULL if zPath is malformed or if there is no such
199335 ** node.
199338 ** possible to do so and if no existing node corresponds to zPath. If
199343 u32 iRoot, /* Begin the search at this node */
199492 ** to the inserted node, or return NULL if the append fails.
199525 ** Do a node lookup using zPath. Return a pointer to the node on success.
199632 jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d",
200370 u32 iBegin; /* The first node of the scan */
200975 ** The data for each node of the r-tree structure is stored in the %_node
200976 ** table. For each node that is not the root node of the r-tree, there is
200977 ** an entry in the %_parent table associating the node with its parent.
200979 ** table that maps from the entries rowid to the id of the node that it
200983 ** The root node of an r-tree always exists, even if the r-tree table is
200984 ** empty. The nodeno of the root node is always 1. All other nodes in the
200985 ** table must be the same size as the root node. The content of each node
200988 ** 1. If the node is the root node (node 1), then the first 2 bytes
200989 ** of the node contain the tree depth as a big-endian integer.
200993 ** stored in the node.
200995 ** 3. The remainder of the node contains the node entries. Each entry
200998 ** of a record. For internal nodes it is the node number of a
201094 int iNodeSize; /* Size in bytes of each node in the node table */
201119 ** headed by the node (leaf nodes have RtreeNode.iNode==0).
201179 ** The id is always a node-id. For iLevel>=1 the id is the node-id of
201180 ** the node that the RtreeSearchPoint represents. When iLevel==0, however,
201181 ** the id is of the parent node and the cell that RtreeSearchPoint
201182 ** represents is the iCell-th entry in the parent node.
201185 RtreeDValue rScore; /* The score for this node. Smallest goes first. */
201187 u8 iLevel; /* 0=entries. 1=leaf node. 2+ for higher */
201189 u8 iCell; /* Cell index within the node */
201193 ** The minimum number of cells allowed for a node is a third of the
201199 ** cells are removed from the overfull node and reinserted into the tree.
201206 ** The smallest possible node-size is (512-64)==448 bytes. And the largest
201239 RtreeNode *aNode[RTREE_CACHE_SZ]; /* Rtree node cache */
201303 ** An rtree structure node.
201306 RtreeNode *pParent; /* Parent node */
201307 i64 iNode; /* The node number */
201308 int nRef; /* Number of references to this node */
201309 int isDirty; /* True if the node needs to be written to disk */
201310 u8 *zData; /* Content of the node, as should be on disk */
201311 RtreeNode *pNext; /* Next node in this hash collision chain */
201314 /* Return the number of cells in a node */
201318 ** A single cell from a node, deserialized
201548 ** Increment the reference count of node p.
201558 ** Clear the content of node p (set all bytes to 0x00).
201566 ** Given a node number iNode, return the corresponding key to use
201574 ** Search the node hash table for node iNode. If found, return a pointer
201584 ** Add node pNode to the node hash table.
201595 ** Remove node pNode from the node hash table.
201608 ** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0),
201609 ** indicating that node has not yet been assigned a node number. It is
201610 ** assigned a node number when nodeWrite() is called to write the
201611 ** node contents out to the database.
201640 ** Obtain a reference to an r-tree node.
201645 RtreeNode *pParent, /* Either the parent node or NULL */
201646 RtreeNode **ppNode /* OUT: Acquired node */
201651 /* Check if the requested node is already in the hash table. If so,
201707 /* If the root node was just loaded, set pRtree->iDepth to the height
201709 ** the root node. A height of one means the children of the root node
201710 ** are the leaves, and so on. If the depth as specified on the root node
201722 ** field on the node is too large. If so, set the return code to
201753 ** Overwrite cell iCell of node pNode with the contents of pCell.
201757 RtreeNode *pNode, /* The node into which the cell is to be written */
201771 ** Remove the cell with index iCell from node pNode.
201783 ** Insert the contents of cell pCell into node pNode. If the insert
201790 RtreeNode *pNode, /* Write new cell into this node */
201810 ** If the node is dirty, write it out to the database.
201835 ** Release a reference to a node. If the node is dirty and the reference
201836 ** count drops to zero, the node data is written to the database.
201864 ** node pNode. If pNode is a leaf node, this is a rowid. If it is
201865 ** an internal node, then the 64-bit integer is a child page number.
201869 RtreeNode *pNode, /* The node from which to extract the ID */
201877 ** Return coordinate iCoord from cell iCell in node pNode.
201881 RtreeNode *pNode, /* The node from which to extract a coordinate */
201882 int iCell, /* The index of the cell within the node */
201890 ** Deserialize cell iCell of node pNode. Populate the structure pointed
201895 RtreeNode *pNode, /* The node containing the cell to be read */
201896 int iCell, /* Index of the cell within the node */
202137 ** Check the RTree node or entry given by pCellData and p against the MATCH
202212 ** Check the internal RTree node given by pCellData against constraint p.
202213 ** If this constraint cannot be satisfied by any child within the node,
202300 ** One of the cells in node pNode is guaranteed to have a 64-bit
202323 ** Return the index of the cell containing a pointer to node pNode
202324 ** in its parent. If pNode is the root node, return -1.
202716 ** Use nodeAcquire() to obtain the leaf node containing the record with
202717 ** rowid iRowid. If successful, set *ppLeaf to point to the node and
202725 RtreeNode **ppLeaf, /* Write the node here */
202726 sqlite3_int64 *piNode /* Write the node-id here */
202970 ** and then a linear search of an R-Tree node. This should be
203167 /* Select the child node which will be enlarged the least if pCell
203200 ** the node pNode. This function updates the bounding box cells in
203205 RtreeNode *pNode, /* Adjust ancestry of this node. */
203546 ** all cells from node pLeft. Then zero the original node.
203588 /* Ensure both child nodes have node numbers assigned to them by calling
203589 ** nodeWrite(). Node pRight always needs a node number, as it was created
203590 ** by nodeNew() above. But node pLeft sometimes already has a node number.
203663 ** If node pLeaf is not the root of the r-tree and its pParent pointer is
203665 ** the pLeaf->pParent chain all the way up to the root node.
203682 i64 iNode; /* Node number of parent node */
203687 ** the referenced counted node structures.
203746 /* Remove the node from the in-memory hash table and link it into
203782 ** Delete the cell at index iCell of node pNode. After removing the
203793 /* Remove the cell from the node. This call just moves bytes around
203794 ** the in-memory node image, so it cannot fail.
203798 /* If the node is not the tree root and now has less than the minimum
203800 ** cell in the parent node so that it tightly contains the updated
203801 ** node.
203897 /* Find a node to store this cell in. pNode->iNode currently contains
203918 ** Insert cell pCell into node pNode. Node pNode is the head of a
203966 /* Find a node to store this cell in. pNode->iNode currently contains
204000 RtreeNode *pLeaf = 0; /* Leaf node containing record iDelete */
204002 RtreeNode *pRoot = 0; /* Root node of rtree structure */
204005 /* Obtain a reference to the root node to initialize Rtree.iDepth */
204008 /* Obtain a reference to the leaf node that contains the entry
204019 /* Delete the cell in question from the leaf node. */
204039 /* Check if the root node now has exactly one child. If so, remove
204044 ** the root node (the operation that Gutman's paper says to perform
204074 /* Release the reference to the root node. */
204417 "node", "parent", "rowid"
204603 ** determine the node-size used by the rtree table being created or connected
204608 ** table already exists. In this case the node-size is determined by inspecting
204609 ** the root node of the tree.
204612 ** This ensures that each node is stored on a single database page. If the
204614 ** would fit in a single node, use a smaller node-size.
204773 /* Figure out the node size to use. */
204800 ** an r-tree node. For a two-dimensional r-tree structure called "rt", to
204806 ** entry for each cell in the r-tree node. Each entry is itself a
204811 RtreeNode node;
204819 memset(&node, 0, sizeof(RtreeNode));
204825 node.zData = (u8 *)sqlite3_value_blob(apArg[1]);
204826 if( node.zData==0 ) return;
204829 if( nData<NCELL(&node)*tree.nBytesPerCell ) return;
204832 for(ii=0; ii<NCELL(&node); ii++){
204836 nodeGetCell(&tree, &node, ii, &cell);
204854 ** from the front of a blob that is an r-tree node. For example:
204858 ** The depth value is 0 for all nodes other than the root node, and the root
204859 ** node always has nodeno=1, so the example above is the primary use for this
204972 ** Otherwise, the contents of rtree table node iNode are loaded from
205095 "Dimension %d of cell %d on node %lld is corrupt", i, iCell, iNode
205107 "Dimension %d of cell %d on node %lld is corrupt relative to parent"
205116 ** Run rtreecheck() checks on node iNode, which is at depth iDepth within
205118 ** that bound node iNode on the parent node.
205297 ** b) unless the cell is on the root node, that the cell is bounded
205298 ** by the parent cell on the parent node.
205302 ** points to the correct node.
205305 ** %_parent table mapping from the cell's child node to the
205306 ** node that it resides on.
206631 /* Figure out the node size to use. */
214225 ** root-node of the b-tree structure to each page. The value of the
214226 ** root-node path is '/'.
214278 u32 iChildPg; /* Child node (or 0 if this is a leaf) */
214561 if( flags==0x0D ){ /* Table leaf node */
214637 /* A table interior node. nPayload==0. */
226425 ** Expression node type. Always one of:
226438 /* Next method for this node. */
226444 /* Child nodes. For a NOT node, this array always contains 2 entries. For
226475 Fts5ExprNode *pNode; /* FTS5_STRING node this phrase is part of */
226740 ** Free the expression node object passed as the only argument.
227208 Fts5ExprNode *pNode /* The "NEAR" node (FTS5_STRING) */
227413 /* Check that this node should not be FTS5_TERM */
227473 Fts5ExprNode *pNode, /* FTS5_STRING or FTS5_TERM node */
227538 Fts5ExprNode *pNode /* The "NEAR" node (FTS5_TERM) */
227562 ** xNext() method for a node of type FTS5_TERM.
227590 Fts5ExprNode *pNode /* Expression node to test */
227637 ** Argument pNode is an FTS5_AND node.
227641 Fts5ExprNode *pAnd /* FTS5_AND node to advance */
227664 /* If the child node is now at EOF, so is the parent AND node. Otherwise,
227665 ** the child node is guaranteed to have advanced at least as far as
227708 Fts5ExprNode *pNode /* FTS5_NOT node to advance */
227757 Fts5ExprNode *pNode /* Expression node to test */
227794 ** Set node pNode, which is part of expression pExpr, to point to the first
228474 ** Recursively apply colset pColset to expression node pNode and all of
228515 ** Apply colset pColset to expression node pExpr and all of its descendents.
228652 int nChild = 0; /* Number of children of returned node */
228653 sqlite3_int64 nByte; /* Bytes of space to allocate for this node */
233899 ** hierarchy. If the node being flushed is currently the root node,
233901 pDlidx->buf.p[0] = 0x01; /* Not the root node */
233911 /* This was the root node. Push its first rowid up to the new root. */
234036 ** copy of (pTerm/nTerm) into the parent node. This is slightly