Lines Matching defs:leaf
30873 /* only mkdir if leaf dir != "." or "/" or ".." */
38498 ** (b) The page was a freelist leaf page at the start of the transaction.
38532 ** all queries. Note in particular the the content of freelist leaf
43423 ** a) When reading a free-list leaf page from the database, and
44016 ** the page has been added as a leaf of the freelist and so its
48531 ** 23 1 Min leaf payload fraction
48566 ** The min leaf payload fraction is like the min embedded payload fraction
48567 ** except that it applies to leaf nodes in a LEAFDATA tree. The maximum
48594 ** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
48601 ** The flags define the format of this btree page. The leaf flag means that
48657 ** 4 Page number of the left child. Omitted if leaf flag is set.
48671 ** Freelist pages come in two subtypes: trunk pages and leaf pages. The
48673 ** page points to multiple leaf pages. The content of a leaf page is
48678 ** 4 Number of leaf pointers on this page
48730 ** walk up the BTree from any leaf to the root. Care must be taken to
48741 u8 leaf; /* True if leaf flag is set */
48744 u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */
49882 ** when a page that previously contained data becomes a free-list leaf
49887 ** free-list leaf pages:
49890 ** a free-list leaf page, the page is not written to the database
49891 ** (as free-list leaf pages contain no meaningful data). Sometimes
49895 ** 2) When a free-list leaf page is reused, its content is not read
49909 ** moved to become a free-list leaf page, the corresponding bit is
49910 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
49933 ** This function is called when a free-list leaf page is removed from the
50296 assert( pPage->leaf==0 || pPage->leaf==1 );
50298 assert( n==4-4*pPage->leaf );
50563 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
50741 pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
50743 pPage->childPtrSize = 4-4*pPage->leaf;
50747 pPage->hasData = pPage->leaf;
50800 pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
50825 if( !pPage->leaf ) iCellLast--;
50839 if( !pPage->leaf ) iCellLast++;
51759 ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
52101 if( !pPage->leaf ){
52107 if( !pPage->leaf ){
53579 ** Page pParent is an internal (non-leaf) tree page. This function
53712 if( pRoot->nCell==0 && !pRoot->leaf ){
53725 ** Move the cursor down to the left-most leaf entry beneath the
53728 ** The left-most leaf is the one with the smallest key - the first
53738 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53747 ** Move the cursor down to the right-most leaf entry beneath the
53763 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53819 assert( pCur->apPage[pCur->iPage]->leaf );
53847 ** left pointing at a leaf page which would hold the entry if it
54003 if( pPage->intKey && !pPage->leaf ){
54022 assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
54024 if( pPage->leaf ){
54105 if( !pPage->leaf ){
54130 if( pPage->leaf ){
54167 if( !pPage->leaf ){
54188 if( pPage->intKey && !pPage->leaf ){
54339 ** pointers to free-list leaves. The first leaf becomes a trunk
54377 /* Extract a leaf from the trunk */
54407 TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
54548 ** new free-list trunk page. Otherwise, it will become a leaf of the
54550 ** is possible to add the page as a new free-list leaf.
54553 u32 nLeaf; /* Initial number of leaf cells on trunk page */
54569 ** being freed as a new leaf.
54591 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
54597 ** the page being freed as a leaf page of the first trunk in the free-list.
54735 if( !pPage->leaf ){
54948 ** malformed cell from a leaf page to an interior page, if the cell size
54949 ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
54950 ** might be less than 8 (leaf-size + pointer) on the interior node. Hence
55073 ** Instead of trying to balance the 3 right-most leaf pages, just add
55080 ** pPage is the leaf page which is the right-most page in the tree.
55197 if( !pPage->leaf ){
55203 if( !pPage->leaf ){
55215 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
55325 u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
55326 int leafData; /* True if pPage is a leaf of a LEAFDATA tree */
55473 ** If the siblings are on leaf pages, then the child pointers of the
55480 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
55483 leafCorrection = apOld[0]->leaf*4;
55529 if( !pOld->leaf ){
55740 if( !pNew->leaf ){
55743 /* If the tree is a leaf-data tree, and the siblings are leaves,
55756 /* Obscure case for non-leaf-data trees: If the cell at pCell was
55757 ** previously stored on a leaf node, and its reported size was 4
55855 ** sibling page j. If the siblings are not leaf pages of an
55879 ** sibling page k. If the siblings are not leaf pages of an
56212 assert( pPage->leaf || !pPage->intKey );
56234 if( !pPage->leaf ){
56242 assert( pPage->leaf );
56245 assert( pPage->leaf );
56325 /* If the page containing the entry to delete is not a leaf page, move
56332 if( !pPage->leaf ){
56351 /* If the cell deleted was not located on a leaf page, then the cursor
56354 ** node. The cell from the leaf node needs to be moved to the internal
56356 if( !pPage->leaf ){
56375 /* Balance the tree. If the entry deleted was located on a leaf page,
56381 ** pCur is pointing to the leaf page from which a cell was removed to
56383 ** tricky as the leaf node may be underfull, and the internal node may
56385 ** on the leaf node first. If the balance proceeds far enough up the
56387 ** been corrected, so be it. Otherwise, after balancing the leaf node,
56582 if( !pPage->leaf ){
56589 if( !pPage->leaf ){
56860 /* If this is a leaf page or the tree is not an int-key tree, then
56865 if( pPage->leaf || !pPage->intKey ){
56869 /* pPage is a leaf node. This loop navigates the cursor so that it
56879 if( pPage->leaf ){
57038 "freelist leaf count too big on page %d", iPage);
57176 if( !pPage->leaf ){
57191 if( !pPage->leaf ){
57203 /* For intKey leaf pages, check that the min/max keys are in order
57206 if( pPage->leaf && pPage->intKey ){
57252 cellStart = hdr + 12 - 4*pPage->leaf;
115977 **** Segment leaf nodes ****
115978 ** Segment leaf nodes store terms and doclists, ordered by term. Leaf
115980 ** iterate through a single leaf node's data) and LeavesReader (to
115981 ** iterate through a segment's entire leaf layer). Leaf nodes have
115984 ** varint iHeight; (height from leaf level, always 0)
116001 ** Leaf nodes are broken into blocks which are stored contiguously in
116006 ** New data is spilled to a new leaf node when the current node
116009 ** node (a leaf node with a single term and doclist). The goal of
116016 ** dynamic. For instance, it may make more sense to have a 2.5k leaf
116026 ** SegmentWriter creates new leaf nodes, or when an interior node
116030 ** varint iHeight; (height from leaf level, always >0)
116072 ** This could be either a leaf node or an interior node. If the top
116082 ** start_block - first leaf node
116083 ** leaves_end_block - last leaf node
116087 ** If the root node is a leaf node, then start_block,
116106 ** leaf nodes are written in to the %_segments table in order, this
118358 ** node for the range of leaf nodes that may contain the specified term
118362 ** left-most leaf node in the tree that may contain the specified term.
118364 ** right-most leaf node that may contain a term for which the specified
118367 ** It is possible that the range of returned leaf nodes does not contain
118371 ** never loads leaf nodes into memory), it is not possible to be sure.
118381 sqlite3_int64 *piLeaf, /* Selected leaf node */
118382 sqlite3_int64 *piLeaf2 /* Selected leaf node */
120811 ** of data that will fit on a single leaf page of an intkey table in
125199 ** a contiguous set of segment b-tree leaf nodes. Although the details of
125218 sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */
125219 sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */
125221 sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */
125277 leaf nodes). These functions and type are only ever used by code
126330 /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf
126576 sqlite3_int64 iStartLeaf, /* First leaf to traverse */
126577 sqlite3_int64 iEndLeaf, /* Final leaf to traverse */
127083 sqlite3_int64 iLeaf, /* Block id of first leaf node */
127159 int nReq; /* Number of bytes required on leaf page */
127203 /* The current leaf node is full. Write it out to the database. */
127210 ** a) be greater than the largest term on the leaf node just written
127214 ** leaf node (zTerm/nTerm).
127295 sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */
127609 ** b-tree leaf nodes contain more than one term.
130211 leaf nodes the integer is the rowid
130317 ** headed by the node (leaf nodes have RtreeNode.iNode==0).
130820 ** node pNode. If pNode is a leaf node, this is a rowid. If it is
131043 ** Cursor pCursor currently points to a cell in a non-leaf page.
131103 ** This function assumes that the cell is part of a leaf node.
131146 ** height iHeight (if iHeight==0, then the node is a leaf). Descend
131323 ** Use nodeAcquire() to obtain the leaf node containing the record with
131411 RtreeNode *pLeaf; /* Leaf on which the required cell resides */
131719 RtreeNode **ppLeaf /* OUT: Selected leaf page */
132468 ** rowid of the row to delete, which can be used to find the leaf on which
132469 ** the entry resides (argument pLeaf). Once the leaf is located, this
132712 ** subtree iHeight high (leaf nodes have iHeight==0).
132797 RtreeNode *pLeaf; /* Leaf node containing record iDelete */
132805 /* Obtain a reference to the leaf node that contains the entry
132812 /* Delete the cell in question from the leaf node. */
