Lines Matching defs:node
8757 int tnum; /* Root BTree node for this table (see note above) */
9002 ** code for that node.
9056 ** Each node of an expression in the parse tree is an instance
9119 u8 op; /* Operation performed by this node */
9157 int nHeight; /* Height of the tree headed by this node */
31310 ** node taken from the head of *ppList. A depth of 2 means a tree with
37258 ** root-node and 3 for all other internal nodes.
43098 ** might be less than 8 (leaf-size + pointer) on the interior node. Hence
43356 ** This function is used to copy the contents of the b-tree node stored
43387 /* Copy the b-tree node content from page pFrom to page pTo. */
43446 ** size of a cell stored within an internal node is always less than 1/4
43874 ** previously stored on a leaf node, and its reported size was 4
44084 ** of the node stored on pRoot into the new child page.
44411 int iCellDepth; /* Depth of node containing pCell */
44440 ** from the internal node. The 'previous' entry is used for this instead
44466 ** node. The cell from the leaf node needs to be moved to the internal
44467 ** node to replace the deleted cell. */
44492 ** Otherwise, if the entry deleted was on an internal node page, then
44494 ** replace the cell deleted from the internal node. This is slightly
44495 ** tricky as the leaf node may be underfull, and the internal node may
44497 ** on the leaf node first. If the balance proceeds far enough up the
44498 ** tree that we can be sure that any problem in the internal node has
44499 ** been corrected, so be it. Otherwise, after balancing the leaf node,
44500 ** walk the cursor up the tree to the internal node and balance it as
44949 int iIdx; /* Index of child node in parent */
44961 /* pPage is a leaf node. This loop navigates the cursor so that it
44985 /* Descend to the child node of the cell that the cursor currently
59195 ** Walk an expression tree. Invoke the callback once for each node
59414 ** expression node refer back to that source column. The following changes
59444 Expr *pExpr /* Make this EXPR node point to the selected column */
59460 /* Initialize the node to no-match */
59739 ** node in the expression tree. Return 0 to continue the search down
60416 ** The node at the root of the subtree is modified as follows:
60871 ** Construct a new expression node and return a pointer to it. Memory
60872 ** for this node and for the pToken argument is a single allocation
60874 ** is responsible for making sure the node eventually gets freed.
60880 ** then the EP_DblQuoted flag is set on the expression node.
60932 ** Allocate a new expression node from a zero-terminated token that has
60947 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
60982 ** Allocate a Expr node which joins as many as two subtrees.
60985 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
61017 ** Construct a new expression node for a function with multiple
65722 ** This only applies to the root node of pExpr, so the statement:
82517 ** are walked without any actions being taken at each node. Presumably,
90946 /* This routine constructs a binary expression node out of two ExprSpan
90961 /* Construct an expression node for a unary postfix operator
90964 ExprSpan *pOut, /* Write the new expression node here */
90986 /* Construct an expression node for a unary prefix operator
90989 ExprSpan *pOut, /* Write the new expression node here */
98259 ** iterate through a single leaf node's data) and LeavesReader (to
98282 ** of a node is reached, the next term is in the node with the next
98283 ** greater node id.
98285 ** New data is spilled to a new leaf node when the current node
98288 ** node (a leaf node with a single term and doclist). The goal of
98296 ** node rather than splitting into 2k and .5k nodes. My intuition is
98305 ** SegmentWriter creates new leaf nodes, or when an interior node
98310 ** varint iBlockid; (block id of node's leftmost subtree)
98325 ** An interior node encodes n terms separating n+1 subtrees. The
98336 ** New data is spilled to a new interior node at the same height when
98337 ** the current node exceeds INTERIOR_MAX bytes (default 2048).
98346 ** merging and deleting segments, and also the root node of the
98349 ** The root node is the top node of the segment's tree after encoding
98351 ** This could be either a leaf node or an interior node. If the top
98352 ** node requires more than ROOT_MAX bytes, it is flushed to %_segments
98353 ** and a new root interior node is generated (which should always fit
98361 ** start_block - first leaf node
98362 ** leaves_end_block - last leaf node
98364 ** root - contents of root node
98366 ** If the root node is a leaf node, then start_block,
98832 int nNodeSize; /* Soft limit for node size */
99590 ** root node of a b-tree segment. The segment is guaranteed to be at least
99591 ** one level high (i.e. the root node is not also a leaf). If successful,
99592 ** this function locates the leaf node of the segment that may contain the
99596 ** It is possible that the returned leaf node does not contain the specified
99598 ** the identified leaf node. Because this function only inspects interior
99608 const char *zNode, /* Buffer containing segment interior node */
99610 sqlite3_int64 *piLeaf /* Selected leaf node */
99613 const char *zCsr = zNode; /* Cursor to iterate through node */
99614 const char *zEnd = &zCsr[nNode];/* End of interior node buffer */
99620 int iHeight; /* Height of this node in tree */
99621 sqlite3_int64 iChild; /* Block id of child node to descend to */
99622 int nBlock; /* Size of child node in bytes */
99633 /* Load the next term on the node into zBuffer */
99654 ** the interior node. If the specified term is greater than or equal
99655 ** to the term from the interior node, then all terms on the sub-tree
99656 ** headed by node iChild are smaller than zTerm. No need to search
99659 ** If the interior node term is larger than the specified term, then
99667 /* If (iHeight==1), the children of this interior node are leaves. The
99668 ** specified term may be present on leaf node iChild.
99675 /* Descend to interior node iChild. */
100296 ** (unless the root node happens to be a leaf). It simply examines the
100305 /* The entire segment is stored on the root node (which must be a
101697 ** expression tree being parsed. pPrev is the expression node most recently
101699 ** operator node, into the expression tree based on the relative precedence
101701 ** of the tree changing, in which case *ppHead is set to the new root node.
101704 Fts3Expr **ppHead, /* Pointer to the root node of a tree */
101705 Fts3Expr *pPrev, /* Node most recently inserted into the tree */
101706 Fts3Expr *pNew /* New binary node to insert into expression tree */
103935 char *aNode; /* Pointer to node data (or NULL) */
103990 SegmentNode *pParent; /* Parent node (or NULL for root node) */
103992 SegmentNode *pLeftmost; /* Pointer to left-most node of this depth */
103993 int nEntry; /* Number of terms written to node so far */
103999 char *aData; /* Node data */
104748 const char *zRoot, /* Buffer containing root node */
104749 int nRoot, /* Size of buffer containing root node */
104754 int nExtra = 0; /* Bytes to allocate segment root node */
104770 /* The entire segment is stored in the root node. */
105169 /* First try to append the term to the current node. Return early if
105173 int nData = pTree->nData; /* Current size of node in bytes */
105185 /* An unusual case: this is the first term to be added to the node
105186 ** and the static node buffer (p->nNodeSize bytes) is not large
105200 /* There is no prefix-length field for first term in a node */
105230 ** current node. Create a new node (a right-sibling of the current node).
105231 ** If this is the first node in the tree, the term is added to it.
105233 ** Otherwise, the term is not added to the new node, it is left empty for
105283 ** Write the buffer for the segment node pTree and all of its peers to the
105287 ** Except, if pTree is a root node, do not write it to the database. Instead,
105288 ** set output variables *paRoot and *pnRoot to contain the root node.
105298 int iHeight, /* Height of this node in tree */
105299 sqlite3_int64 iLeaf, /* Block id of first leaf node */
105302 char **paRoot, /* OUT: Data for root node */
105303 int *pnRoot /* OUT: Size of root node in bytes */
105308 /* Root node of the tree. */
105419 /* The current leaf node is full. Write it out to the database. */
105423 /* Add the current term to the interior node tree. The term added to
105426 ** a) be greater than the largest term on the leaf node just written
105430 ** leaf node (zTerm/nTerm).
105512 char *zRoot = NULL; /* Pointer to buffer containing root node */
105526 /* The entire tree fits on the root node. Write it to the segdir table. */
106416 ** Return TRUE if the expression node pExpr is located beneath the
106949 ** For each phrase node found, the supplied callback function is invoked.
107409 Fts3Expr *pExpr, /* Phrase expression node */
107432 Fts3Expr *pExpr, /* Phrase expression node */
107636 int iNodeSize; /* Size in bytes of each node in the node table */
107648 ** headed by the node (leaf nodes have RtreeNode.iNode==0).
107676 ** The minimum number of cells allowed for a node is a third of the
107682 ** cells are removed from the overfull node and reinserted into the tree.
107693 RtreeNode *pNode; /* Node cursor is currently pointing at */
107733 ** An rtree structure node.
107737 ** 1. If the node is the root node (node 1), then the first 2 bytes
107738 ** of the node contain the tree depth as a big-endian integer.
107742 ** stored in the node.
107744 ** 3. The remainder of the node contains the node entries. Each entry
107747 ** of a record. For internal nodes it is the node number of a
107751 RtreeNode *pParent; /* Parent node */
107756 RtreeNode *pNext; /* Next node in this hash chain */
107838 ** Increment the reference count of node p.
107847 ** Clear the content of node p (set all bytes to 0x00).
107857 ** Given a node number iNode, return the corresponding key to use
107868 ** Search the node hash table for node iNode. If found, return a pointer
107879 ** Add node pNode to the node hash table.
107892 ** Remove node pNode from the node hash table.
107905 ** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0),
107906 ** indicating that node has not yet been assigned a node number. It is
107907 ** assigned a node number when nodeWrite() is called to write the
107908 ** node contents out to the database.
107925 ** Obtain a reference to an r-tree node.
107930 i64 iNode, /* Node number to load */
107931 RtreeNode *pParent, /* Either the parent node or NULL */
107932 RtreeNode **ppNode /* OUT: Acquired node */
107937 /* Check if the requested node is already in the hash table. If so,
107988 ** Overwrite cell iCell of node pNode with the contents of pCell.
108006 ** Remove cell the cell with index iCell from node pNode.
108018 ** Insert the contents of cell pCell into node pNode. If the insert
108047 ** If the node is dirty, write it out to the database.
108072 ** Release a reference to a node. If the node is dirty and the reference
108073 ** count drops to zero, the node data is written to the database.
108100 ** node pNode. If pNode is a leaf node, this is a rowid. If it is
108101 ** an internal node, then the 64-bit integer is a child page number.
108113 ** Return coordinate iCoord from cell iCell in node pNode.
108126 ** Deserialize cell iCell of node pNode. Populate the structure pointed
108318 ** This function assumes that the cell is part of a leaf node.
108347 ** Cursor pCursor currently points at a node that heads a sub-tree of
108348 ** height iHeight (if iHeight==0, then the node is a leaf). Descend
108409 ** One of the cells in node pNode is guaranteed to have a 64-bit
108421 ** Return the index of the cell containing a pointer to node pNode
108422 ** in its parent. If pNode is the root node, return -1.
108508 ** Use nodeAcquire() to obtain the leaf node containing the record with
108509 ** rowid iRowid. If successful, set *ppLeaf to point to the node and
108665 ** and then a linear search of an R-Tree node. This should be
108901 /* Select the child node which will be enlarged the least if pCell
108941 ** the node pNode. This function updates the bounding box cells in
108946 RtreeNode *pNode, /* Adjust ancestry of this node. */
109474 ** all cells from node pLeft. Then zero the original node.
109515 /* Ensure both child nodes have node numbers assigned to them. */
109629 /* Remove the node from the in-memory hash table and link it into
109661 ** Delete the cell at index iCell of node pNode. After removing the
109671 /* Remove the cell from the node. This call just moves bytes around
109672 ** the in-memory node image, so it cannot fail.
109676 /* If the node is not the tree root and now has less than the minimum
109678 ** cell in the parent node so that it tightly contains the updated
109679 ** node.
109774 /* Find a node to store this cell in. pNode->iNode currently contains
109795 ** Insert cell pCell into node pNode. Node pNode is the head of a
109845 /* Find a node to store this cell in. pNode->iNode currently contains
109907 RtreeNode *pLeaf; /* Leaf node containing record iDelete */
109911 /* Obtain a reference to the root node to initialise Rtree.iDepth */
109914 /* Obtain a reference to the leaf node that contains the entry
109922 /* Delete the cell in question from the leaf node. */
109940 /* Check if the root node now has exactly one child. If so, remove
109945 ** the root node (the operation that Gutman's paper says to perform
109973 /* Release the reference to the root node. */
110250 /* Figure out the node size to use. By default, use 64 bytes less than
110251 ** the database page-size. This ensures that each node is stored on
110255 ** entries would fit in a single node, use a smaller node-size.
110304 ** an r-tree node, and the number of dimensions the r-tree indexes.
110311 ** entry for each cell in the r-tree node. Each entry is itself a
110317 RtreeNode node;
110321 memset(&node, 0, sizeof(RtreeNode));
110325 node.zData = (u8 *)sqlite3_value_blob(apArg[1]);
110327 for(ii=0; ii<NCELL(&node); ii++){
110333 nodeGetCell(&tree, &node, ii, &cell);
