Lines Matching refs:leaf
30858 /* only mkdir if leaf dir != "." or "/" or ".." */
38483 ** (b) The page was a freelist leaf page at the start of the transaction.
38517 ** all queries. Note in particular the the content of freelist leaf
43408 ** a) When reading a free-list leaf page from the database, and
44001 ** the page has been added as a leaf of the freelist and so its
48516 ** 23 1 Min leaf payload fraction
48551 ** The min leaf payload fraction is like the min embedded payload fraction
48552 ** except that it applies to leaf nodes in a LEAFDATA tree. The maximum
48579 ** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
48586 ** The flags define the format of this btree page. The leaf flag means that
48642 ** 4 Page number of the left child. Omitted if leaf flag is set.
48656 ** Freelist pages come in two subtypes: trunk pages and leaf pages. The
48658 ** page points to multiple leaf pages. The content of a leaf page is
48663 ** 4 Number of leaf pointers on this page
48715 ** walk up the BTree from any leaf to the root. Care must be taken to
48726 u8 leaf; /* True if leaf flag is set */
48729 u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */
49867 ** when a page that previously contained data becomes a free-list leaf
49872 ** free-list leaf pages:
49875 ** a free-list leaf page, the page is not written to the database
49876 ** (as free-list leaf pages contain no meaningful data). Sometimes
49880 ** 2) When a free-list leaf page is reused, its content is not read
49894 ** moved to become a free-list leaf page, the corresponding bit is
49895 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
49918 ** This function is called when a free-list leaf page is removed from the
50281 assert( pPage->leaf==0 || pPage->leaf==1 );
50283 assert( n==4-4*pPage->leaf );
50548 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
50726 pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
50728 pPage->childPtrSize = 4-4*pPage->leaf;
50732 pPage->hasData = pPage->leaf;
50785 pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
50810 if( !pPage->leaf ) iCellLast--;
50824 if( !pPage->leaf ) iCellLast++;
51744 ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
52086 if( !pPage->leaf ){
52092 if( !pPage->leaf ){
53564 ** Page pParent is an internal (non-leaf) tree page. This function
53697 if( pRoot->nCell==0 && !pRoot->leaf ){
53710 ** Move the cursor down to the left-most leaf entry beneath the
53713 ** The left-most leaf is the one with the smallest key - the first
53723 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53732 ** Move the cursor down to the right-most leaf entry beneath the
53748 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53804 assert( pCur->apPage[pCur->iPage]->leaf );
53832 ** left pointing at a leaf page which would hold the entry if it
53988 if( pPage->intKey && !pPage->leaf ){
54007 assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
54009 if( pPage->leaf ){
54090 if( !pPage->leaf ){
54115 if( pPage->leaf ){
54152 if( !pPage->leaf ){
54173 if( pPage->intKey && !pPage->leaf ){
54324 ** pointers to free-list leaves. The first leaf becomes a trunk
54362 /* Extract a leaf from the trunk */
54392 TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
54533 ** new free-list trunk page. Otherwise, it will become a leaf of the
54535 ** is possible to add the page as a new free-list leaf.
54538 u32 nLeaf; /* Initial number of leaf cells on trunk page */
54554 ** being freed as a new leaf.
54576 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
54582 ** the page being freed as a leaf page of the first trunk in the free-list.
54720 if( !pPage->leaf ){
54933 ** malformed cell from a leaf page to an interior page, if the cell size
54934 ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
54935 ** might be less than 8 (leaf-size + pointer) on the interior node. Hence
55058 ** Instead of trying to balance the 3 right-most leaf pages, just add
55065 ** pPage is the leaf page which is the right-most page in the tree.
55182 if( !pPage->leaf ){
55188 if( !pPage->leaf ){
55200 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
55310 u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
55311 int leafData; /* True if pPage is a leaf of a LEAFDATA tree */
55458 ** If the siblings are on leaf pages, then the child pointers of the
55465 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
55468 leafCorrection = apOld[0]->leaf*4;
55514 if( !pOld->leaf ){
55725 if( !pNew->leaf ){
55728 /* If the tree is a leaf-data tree, and the siblings are leaves,
55741 /* Obscure case for non-leaf-data trees: If the cell at pCell was
55742 ** previously stored on a leaf node, and its reported size was 4
55840 ** sibling page j. If the siblings are not leaf pages of an
55864 ** sibling page k. If the siblings are not leaf pages of an
56197 assert( pPage->leaf || !pPage->intKey );
56219 if( !pPage->leaf ){
56227 assert( pPage->leaf );
56230 assert( pPage->leaf );
56310 /* If the page containing the entry to delete is not a leaf page, move
56317 if( !pPage->leaf ){
56336 /* If the cell deleted was not located on a leaf page, then the cursor
56339 ** node. The cell from the leaf node needs to be moved to the internal
56341 if( !pPage->leaf ){
56360 /* Balance the tree. If the entry deleted was located on a leaf page,
56366 ** pCur is pointing to the leaf page from which a cell was removed to
56368 ** tricky as the leaf node may be underfull, and the internal node may
56370 ** on the leaf node first. If the balance proceeds far enough up the
56372 ** been corrected, so be it. Otherwise, after balancing the leaf node,
56567 if( !pPage->leaf ){
56574 if( !pPage->leaf ){
56845 /* If this is a leaf page or the tree is not an int-key tree, then
56850 if( pPage->leaf || !pPage->intKey ){
56854 /* pPage is a leaf node. This loop navigates the cursor so that it
56864 if( pPage->leaf ){
57023 "freelist leaf count too big on page %d", iPage);
57161 if( !pPage->leaf ){
57176 if( !pPage->leaf ){
57188 /* For intKey leaf pages, check that the min/max keys are in order
57191 if( pPage->leaf && pPage->intKey ){
57237 cellStart = hdr + 12 - 4*pPage->leaf;
115969 **** Segment leaf nodes ****
115970 ** Segment leaf nodes store terms and doclists, ordered by term. Leaf
115972 ** iterate through a single leaf node's data) and LeavesReader (to
115973 ** iterate through a segment's entire leaf layer). Leaf nodes have
115976 ** varint iHeight; (height from leaf level, always 0)
115998 ** New data is spilled to a new leaf node when the current node
116001 ** node (a leaf node with a single term and doclist). The goal of
116008 ** dynamic. For instance, it may make more sense to have a 2.5k leaf
116018 ** SegmentWriter creates new leaf nodes, or when an interior node
116022 ** varint iHeight; (height from leaf level, always >0)
116064 ** This could be either a leaf node or an interior node. If the top
116074 ** start_block - first leaf node
116075 ** leaves_end_block - last leaf node
116079 ** If the root node is a leaf node, then start_block,
116098 ** leaf nodes are written in to the %_segments table in order, this
118350 ** node for the range of leaf nodes that may contain the specified term
118354 ** left-most leaf node in the tree that may contain the specified term.
118356 ** right-most leaf node that may contain a term for which the specified
118359 ** It is possible that the range of returned leaf nodes does not contain
118363 ** never loads leaf nodes into memory), it is not possible to be sure.
118373 sqlite3_int64 *piLeaf, /* Selected leaf node */
118374 sqlite3_int64 *piLeaf2 /* Selected leaf node */
120796 ** of data that will fit on a single leaf page of an intkey table in
125184 ** a contiguous set of segment b-tree leaf nodes. Although the details of
125203 sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */
125204 sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */
125206 sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */
125262 ** the leaf nodes). These functions and type are only ever used by code
126315 /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf
126561 sqlite3_int64 iStartLeaf, /* First leaf to traverse */
126562 sqlite3_int64 iEndLeaf, /* Final leaf to traverse */
127068 sqlite3_int64 iLeaf, /* Block id of first leaf node */
127144 int nReq; /* Number of bytes required on leaf page */
127188 /* The current leaf node is full. Write it out to the database. */
127195 ** a) be greater than the largest term on the leaf node just written
127199 ** leaf node (zTerm/nTerm).
127280 sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */
127594 ** b-tree leaf nodes contain more than one term.
130196 ** of 4-byte coordinates. For leaf nodes the integer is the rowid
130302 ** headed by the node (leaf nodes have RtreeNode.iNode==0).
130805 ** node pNode. If pNode is a leaf node, this is a rowid. If it is
131028 ** Cursor pCursor currently points to a cell in a non-leaf page.
131088 ** This function assumes that the cell is part of a leaf node.
131131 ** height iHeight (if iHeight==0, then the node is a leaf). Descend
131308 ** Use nodeAcquire() to obtain the leaf node containing the record with
131704 RtreeNode **ppLeaf /* OUT: Selected leaf page */
132453 ** rowid of the row to delete, which can be used to find the leaf on which
132454 ** the entry resides (argument pLeaf). Once the leaf is located, this
132697 ** subtree iHeight high (leaf nodes have iHeight==0).
132790 /* Obtain a reference to the leaf node that contains the entry
132797 /* Delete the cell in question from the leaf node. */