Lines Matching defs:leaf
30845 /* only mkdir if leaf dir != "." or "/" or ".." */
38470 ** (b) The page was a freelist leaf page at the start of the transaction.
38504 ** all queries. Note in particular the the content of freelist leaf
43395 ** a) When reading a free-list leaf page from the database, and
43988 ** the page has been added as a leaf of the freelist and so its
48503 ** 23 1 Min leaf payload fraction
48538 ** The min leaf payload fraction is like the min embedded payload fraction
48539 ** except that it applies to leaf nodes in a LEAFDATA tree. The maximum
48566 ** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
48573 ** The flags define the format of this btree page. The leaf flag means that
48629 ** 4 Page number of the left child. Omitted if leaf flag is set.
48643 ** Freelist pages come in two subtypes: trunk pages and leaf pages. The
48645 ** page points to multiple leaf pages. The content of a leaf page is
48650 ** 4 Number of leaf pointers on this page
48702 ** walk up the BTree from any leaf to the root. Care must be taken to
48713 u8 leaf; /* True if leaf flag is set */
48716 u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */
49854 ** when a page that previously contained data becomes a free-list leaf
49859 ** free-list leaf pages:
49862 ** a free-list leaf page, the page is not written to the database
49863 ** (as free-list leaf pages contain no meaningful data). Sometimes
49867 ** 2) When a free-list leaf page is reused, its content is not read
49881 ** moved to become a free-list leaf page, the corresponding bit is
49882 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
49905 ** This function is called when a free-list leaf page is removed from the
50268 assert( pPage->leaf==0 || pPage->leaf==1 );
50270 assert( n==4-4*pPage->leaf );
50535 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
50713 pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
50715 pPage->childPtrSize = 4-4*pPage->leaf;
50719 pPage->hasData = pPage->leaf;
50772 pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
50797 if( !pPage->leaf ) iCellLast--;
50811 if( !pPage->leaf ) iCellLast++;
51731 ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
52073 if( !pPage->leaf ){
52079 if( !pPage->leaf ){
53551 ** Page pParent is an internal (non-leaf) tree page. This function
53684 if( pRoot->nCell==0 && !pRoot->leaf ){
53697 ** Move the cursor down to the left-most leaf entry beneath the
53700 ** The left-most leaf is the one with the smallest key - the first
53710 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53719 ** Move the cursor down to the right-most leaf entry beneath the
53735 while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53791 assert( pCur->apPage[pCur->iPage]->leaf );
53819 ** left pointing at a leaf page which would hold the entry if it
53975 if( pPage->intKey && !pPage->leaf ){
53994 assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
53996 if( pPage->leaf ){
54077 if( !pPage->leaf ){
54102 if( pPage->leaf ){
54139 if( !pPage->leaf ){
54160 if( pPage->intKey && !pPage->leaf ){
54311 ** pointers to free-list leaves. The first leaf becomes a trunk
54349 /* Extract a leaf from the trunk */
54379 TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
54520 ** new free-list trunk page. Otherwise, it will become a leaf of the
54522 ** is possible to add the page as a new free-list leaf.
54525 u32 nLeaf; /* Initial number of leaf cells on trunk page */
54541 ** being freed as a new leaf.
54563 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
54569 ** the page being freed as a leaf page of the first trunk in the free-list.
54707 if( !pPage->leaf ){
54920 ** malformed cell from a leaf page to an interior page, if the cell size
54921 ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
54922 ** might be less than 8 (leaf-size + pointer) on the interior node. Hence
55045 ** Instead of trying to balance the 3 right-most leaf pages, just add
55052 ** pPage is the leaf page which is the right-most page in the tree.
55169 if( !pPage->leaf ){
55175 if( !pPage->leaf ){
55187 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
55297 u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
55298 int leafData; /* True if pPage is a leaf of a LEAFDATA tree */
55445 ** If the siblings are on leaf pages, then the child pointers of the
55452 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
55455 leafCorrection = apOld[0]->leaf*4;
55501 if( !pOld->leaf ){
55712 if( !pNew->leaf ){
55715 /* If the tree is a leaf-data tree, and the siblings are leaves,
55728 /* Obscure case for non-leaf-data trees: If the cell at pCell was
55729 ** previously stored on a leaf node, and its reported size was 4
55827 ** sibling page j. If the siblings are not leaf pages of an
55851 ** sibling page k. If the siblings are not leaf pages of an
56184 assert( pPage->leaf || !pPage->intKey );
56206 if( !pPage->leaf ){
56214 assert( pPage->leaf );
56217 assert( pPage->leaf );
56297 /* If the page containing the entry to delete is not a leaf page, move
56304 if( !pPage->leaf ){
56323 /* If the cell deleted was not located on a leaf page, then the cursor
56326 ** node. The cell from the leaf node needs to be moved to the internal
56328 if( !pPage->leaf ){
56347 /* Balance the tree. If the entry deleted was located on a leaf page,
56353 ** pCur is pointing to the leaf page from which a cell was removed to
56355 ** tricky as the leaf node may be underfull, and the internal node may
56357 ** on the leaf node first. If the balance proceeds far enough up the
56359 ** been corrected, so be it. Otherwise, after balancing the leaf node,
56554 if( !pPage->leaf ){
56561 if( !pPage->leaf ){
56832 /* If this is a leaf page or the tree is not an int-key tree, then
56837 if( pPage->leaf || !pPage->intKey ){
56841 /* pPage is a leaf node. This loop navigates the cursor so that it
56851 if( pPage->leaf ){
57010 "freelist leaf count too big on page %d", iPage);
57148 if( !pPage->leaf ){
57163 if( !pPage->leaf ){
57175 /* For intKey leaf pages, check that the min/max keys are in order
57178 if( pPage->leaf && pPage->intKey ){
57224 cellStart = hdr + 12 - 4*pPage->leaf;
115941 **** Segment leaf nodes ****
115942 ** Segment leaf nodes store terms and doclists, ordered by term. Leaf
115944 ** iterate through a single leaf node's data) and LeavesReader (to
115945 ** iterate through a segment's entire leaf layer). Leaf nodes have
115948 ** varint iHeight; (height from leaf level, always 0)
115965 ** Leaf nodes are broken into blocks which are stored contiguously in
115970 ** New data is spilled to a new leaf node when the current node
115973 ** node (a leaf node with a single term and doclist). The goal of
115980 ** dynamic. For instance, it may make more sense to have a 2.5k leaf
115990 ** SegmentWriter creates new leaf nodes, or when an interior node
115994 ** varint iHeight; (height from leaf level, always >0)
116036 ** This could be either a leaf node or an interior node. If the top
116046 ** start_block - first leaf node
116047 ** leaves_end_block - last leaf node
116051 ** If the root node is a leaf node, then start_block,
116070 ** leaf nodes are written in to the %_segments table in order, this
118322 ** node for the range of leaf nodes that may contain the specified term
118326 ** left-most leaf node in the tree that may contain the specified term.
118328 ** right-most leaf node that may contain a term for which the specified
118331 ** It is possible that the range of returned leaf nodes does not contain
118335 ** never loads leaf nodes into memory), it is not possible to be sure.
118345 sqlite3_int64 *piLeaf, /* Selected leaf node */
118346 sqlite3_int64 *piLeaf2 /* Selected leaf node */
120765 ** of data that will fit on a single leaf page of an intkey table in
125153 ** a contiguous set of segment b-tree leaf nodes. Although the details of
125172 sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */
125173 sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */
125175 sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */
125231 ** the leaf nodes). These functions and type are only ever used by code
126284 /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf
126530 sqlite3_int64 iStartLeaf, /* First leaf to traverse */
126531 sqlite3_int64 iEndLeaf, /* Final leaf to traverse */
127037 sqlite3_int64 iLeaf, /* Block id of first leaf node */
127113 int nReq; /* Number of bytes required on leaf page */
127157 /* The current leaf node is full. Write it out to the database. */
127164 ** a) be greater than the largest term on the leaf node just written
127168 ** leaf node (zTerm/nTerm).
127249 sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */
127563 ** b-tree leaf nodes contain more than one term.
130165 ** of 4-byte coordinates. For leaf nodes the integer is the rowid
130271 ** headed by the node (leaf nodes have RtreeNode.iNode==0).
130774 ** node pNode. If pNode is a leaf node, this is a rowid. If it is
130997 ** Cursor pCursor currently points to a cell in a non-leaf page.
131057 ** This function assumes that the cell is part of a leaf node.
131100 ** height iHeight (if iHeight==0, then the node is a leaf). Descend
131277 ** Use nodeAcquire() to obtain the leaf node containing the record with
131365 RtreeNode *pLeaf; /* Leaf on which the required cell resides */
131673 RtreeNode **ppLeaf /* OUT: Selected leaf page */
132422 ** rowid of the row to delete, which can be used to find the leaf on which
132423 ** the entry resides (argument pLeaf). Once the leaf is located, this
132666 ** subtree iHeight high (leaf nodes have iHeight==0).
132751 RtreeNode *pLeaf; /* Leaf node containing record iDelete */
132759 /* Obtain a reference to the leaf node that contains the entry
132766 /* Delete the cell in question from the leaf node. */
