Lines Matching full:cells
7747 int nMem; /* Number of memory cells required */
10297 int nMem; /* Number of memory cells used so far */
12069 ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
12081 Mem *aMem; /* Array of memory cells for parent frame */
12086 int nChildMem; /* Number of memory cells for child frame */
44462 ** is to limit the maximum cell size so that at least 4 cells will fit
44500 ** 3 2 number of cells on this page
44515 ** to keep free space after the last cell pointer so that new cells can
44534 ** Cells are of variable length. Cells are stored in the cell content area at
44535 ** the end of the page. Pointers to the cells are in the cell pointer array
44536 ** that immediately follows the page header. Cells is not necessarily
44592 /* The maximum number of cells on a single page of the database. This
44595 ** small cells will be rare, but they are possible.
44653 u16 nCell; /* Number of cells on this page, local and ovfl */
44655 struct _OvflCell { /* Cells that will not fit on aData[] */
46207 ** This routine works only for pages that do not contain overflow cells.
46214 ** pages that do contain overflow cells.
46412 ** Defragment the page given. All Cells are moved to the
46425 int nCell; /* Number of cells on the page */
46626 ** btreeInitPage() did not detect overlapping cells or
46627 ** freeblocks that overlapped cells. Nor does it detect when the
46766 /* To many cells for a single page. The page must be corrupt */
47763 ** cells can will fit on one page. We assume a 10-byte page header.
48025 ** pPage contains cells that point to overflow pages, set the pointer
48030 int nCell; /* Number of cells in page pPage */
48073 ** page pointed to by one of the cells on pPage.
48164 /* If pDbPage was a btree-page, then it may have child pages and/or cells
49484 ** cells in pParent, that page number iChild is the right-child of
49528 ** virtual root page when the actual root page contains no cells and a
50434 u32 nLeaf; /* Initial number of leaf cells on trunk page */
50880 ** Add a list of cells to a page. The page should be initially empty.
50881 ** The cells are guaranteed to fit on the page.
50885 int nCell, /* The number of cells to add to this page */
50887 u16 *aSize /* Sizes of the cells */
51087 ** any cells with overflow page pointers, then the corresponding pointer
51090 ** If pFrom is currently carrying any overflow cells (entries in the
51141 ** This routine redistributes cells on the iParentIdx'th child of pParent
51153 ** Note that when this routine is called, some of the cells on the page
51155 ** if the page is overfull. This routine ensures that all cells allocated
51158 ** In the course of balancing the page and its siblings, cells may be
51169 ** buffer big enough to hold one page. If while inserting cells into the parent
51171 ** used to store the parent's overflow cells. Because this function inserts
51172 ** a maximum of four divider cells into the parent page, and the maximum
51175 ** enough for all overflow cells.
51187 int nCell = 0; /* Number of cells in apCell[] */
51198 int subtotal; /* Subtotal of bytes in cells on one page */
51206 u8 *apDiv[NB-1]; /* Divider cells in pParent */
51208 int szNew[NB+2]; /* Combined size of cells place on i-th page */
51209 u8 **apCell = 0; /* All cells begin balanced */
51210 u16 *szCell; /* Local size of all cells in apCell[] */
51211 u8 *aSpace1; /* Space for copies of dividers cells */
51234 /* Find the sibling pages to balance. Also locate the cells in pParent
51240 ** This loop also drops the divider cells from the parent page. This
51242 ** overflow cells in the parent page, since if any existed they will
51335 ** Load pointers to all cells on sibling pages and the divider cells
51336 ** into the local apCell[] array. Make copies of the divider cells
51337 ** into space obtained from aSpace1[] and remove the the divider Cells
51341 ** divider cells are stripped from the cells before they are copied
51342 ** into aSpace1[]. In this way, all cells in apCell[] are without
51344 ** apCell[] include child pointers. Either way, all cells in apCell[]
51393 /* Do not allow any cells smaller than 4 bytes. */
51402 ** Figure out the number of pages needed to hold all nCell cells.
51404 ** size of all cells on the i-th page and cntNew[] which is the index
51465 /* Either we found one or more cells (cntnew[0])>0) or pPage is
51564 ** Insert divider cells into pParent as necessary.
51615 ** cells are at least 4 bytes. It only happens in b-trees used
51643 /* The root page of the b-tree now contains no cells. The only sibling
51664 /* Fix the pointer-map entries for all the cells that were shifted around.
51676 ** page in any overflow chains used by new divider cells. These
51680 ** cells stored on the sibling pages may need to be updated.
51683 ** overflow pages used by these cells may need to be updated
51769 TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
51793 ** page, including overflow cells, are copied into the child. The root
51839 /* Copy the overflow cells from pRoot to pChild */
51925 /* In this case, call balance_nonroot() to redistribute cells
51931 ** If the parent page becomes overfull, the overflow cell or cells
51935 ** but it doesn't deal with overflow cells - just moves them to a
52097 ** to redistribute the cells within the tree. Since balance() may move
52412 int *pnChange /* Add number of Cells freed to this counter */
52712 ** of the page, or to the number of cells in the page if the next page
52918 ** 1. Make sure that cells and freeblocks do not overlap
52973 /* Check out all the cells.
54926 ** Compare the values contained by the two memory cells, returning
56405 /* The first 8 memory cells are used for the result set. So we will
56408 ** cells. */
56656 int nMem, /* Number of memory cells to allocate */
56676 ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
59965 ** Invoke this macro on memory cells just prior to changing the
60117 ** different sized allocations. Memory cells provide growable
60124 ** Memory cells for cursors are allocated at the top of the address
60887 Mem *pMem; /* Used to iterate through memory cells */
65398 Mem *pMem; /* Used to iterate through memory cells */
65438 /* SubProgram.nMem is set to the number of memory cells used by the
66254 ** are contiguous memory cells starting at P3 to pass to the xUpdate
73572 /* The block of memory cells initialized here is used as follows.
73585 ** Cells iMem through iMem+nCol are initialized to 0. The others are
91334 ** The aggregate accumulator is a set of memory cells that hold
91336 ** routine simply stores NULLs in all of those memory cells.
91383 ** Update the accumulator memory cells for an aggregate based on
98560 ** this routine allocates an additional nEq memory cells for internal
98600 /* Figure out how many memory cells we will need then allocate them.
119271 ** The minimum number of cells allowed for a node is a third of the
119277 ** cells are removed from the overfull node and reinserted into the tree.
119676 int nCell; /* Current number of cells in pNode */
119677 int nMaxCell; /* Maximum number of cells for pNode */
120133 ** One of the cells in node pNode is guaranteed to have a 64-bit
120557 ** Store the union of cells p1 and p2 in p1.
120759 ** the node pNode. This function updates the bounding box cells in
120845 /* Pick two "seed" cells from the array of cells. The algorithm used
120847 ** indices of the two seed cells in the array are stored in local
121036 ** in aIdx according to dimension iDim of the cells in aCell. The
121297 ** all cells from node pLeft. Then zero the original node.
121544 ** number of cells, remove it from the tree. Otherwise, update the
