Lines Matching full:cells
7754 int nMem; /* Number of memory cells required */
10304 int nMem; /* Number of memory cells used so far */
12076 ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
12088 Mem *aMem; /* Array of memory cells for parent frame */
12093 int nChildMem; /* Number of memory cells for child frame */
44469 ** is to limit the maximum cell size so that at least 4 cells will fit
44507 ** 3 2 number of cells on this page
44522 ** to keep free space after the last cell pointer so that new cells can
44541 ** Cells are of variable length. Cells are stored in the cell content area at
44542 ** the end of the page. Pointers to the cells are in the cell pointer array
44543 ** that immediately follows the page header. Cells is not necessarily
44599 /* The maximum number of cells on a single page of the database. This
44602 ** small cells will be rare, but they are possible.
44660 u16 nCell; /* Number of cells on this page, local and ovfl */
44662 struct _OvflCell { /* Cells that will not fit on aData[] */
46214 ** This routine works only for pages that do not contain overflow cells.
46221 ** pages that do contain overflow cells.
46419 ** Defragment the page given. All Cells are moved to the
46432 int nCell; /* Number of cells on the page */
46633 ** btreeInitPage() did not detect overlapping cells or
46634 ** freeblocks that overlapped cells. Nor does it detect when the
46773 /* To many cells for a single page. The page must be corrupt */
47770 ** cells can will fit on one page. We assume a 10-byte page header.
48032 ** pPage contains cells that point to overflow pages, set the pointer
48037 int nCell; /* Number of cells in page pPage */
48080 ** page pointed to by one of the cells on pPage.
48171 /* If pDbPage was a btree-page, then it may have child pages and/or cells
49491 ** cells in pParent, that page number iChild is the right-child of
49535 ** virtual root page when the actual root page contains no cells and a
50441 u32 nLeaf; /* Initial number of leaf cells on trunk page */
50887 ** Add a list of cells to a page. The page should be initially empty.
50888 ** The cells are guaranteed to fit on the page.
50892 int nCell, /* The number of cells to add to this page */
50894 u16 *aSize /* Sizes of the cells */
51094 ** any cells with overflow page pointers, then the corresponding pointer
51097 ** If pFrom is currently carrying any overflow cells (entries in the
51148 ** This routine redistributes cells on the iParentIdx'th child of pParent
51160 ** Note that when this routine is called, some of the cells on the page
51162 ** if the page is overfull. This routine ensures that all cells allocated
51165 ** In the course of balancing the page and its siblings, cells may be
51176 ** buffer big enough to hold one page. If while inserting cells into the parent
51178 ** used to store the parent's overflow cells. Because this function inserts
51179 ** a maximum of four divider cells into the parent page, and the maximum
51182 ** enough for all overflow cells.
51194 int nCell = 0; /* Number of cells in apCell[] */
51205 int subtotal; /* Subtotal of bytes in cells on one page */
51213 u8 *apDiv[NB-1]; /* Divider cells in pParent */
51215 int szNew[NB+2]; /* Combined size of cells place on i-th page */
51216 u8 **apCell = 0; /* All cells begin balanced */
51217 u16 *szCell; /* Local size of all cells in apCell[] */
51218 u8 *aSpace1; /* Space for copies of dividers cells */
51241 /* Find the sibling pages to balance. Also locate the cells in pParent
51247 ** This loop also drops the divider cells from the parent page. This
51249 ** overflow cells in the parent page, since if any existed they will
51342 ** Load pointers to all cells on sibling pages and the divider cells
51343 ** into the local apCell[] array. Make copies of the divider cells
51344 ** into space obtained from aSpace1[] and remove the the divider Cells
51348 ** divider cells are stripped from the cells before they are copied
51349 ** into aSpace1[]. In this way, all cells in apCell[] are without
51351 ** apCell[] include child pointers. Either way, all cells in apCell[]
51400 /* Do not allow any cells smaller than 4 bytes. */
51409 ** Figure out the number of pages needed to hold all nCell cells.
51411 ** size of all cells on the i-th page and cntNew[] which is the index
51472 /* Either we found one or more cells (cntnew[0])>0) or pPage is
51571 ** Insert divider cells into pParent as necessary.
51622 ** cells are at least 4 bytes. It only happens in b-trees used
51650 /* The root page of the b-tree now contains no cells. The only sibling
51671 /* Fix the pointer-map entries for all the cells that were shifted around.
51683 ** page in any overflow chains used by new divider cells. These
51687 ** cells stored on the sibling pages may need to be updated.
51690 ** overflow pages used by these cells may need to be updated
51776 TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
51800 ** page, including overflow cells, are copied into the child. The root
51846 /* Copy the overflow cells from pRoot to pChild */
51932 /* In this case, call balance_nonroot() to redistribute cells
51938 ** If the parent page becomes overfull, the overflow cell or cells
51942 ** but it doesn't deal with overflow cells - just moves them to a
52104 ** to redistribute the cells within the tree. Since balance() may move
52419 int *pnChange /* Add number of Cells freed to this counter */
52719 ** of the page, or to the number of cells in the page if the next page
52925 ** 1. Make sure that cells and freeblocks do not overlap
52980 /* Check out all the cells.
54933 ** Compare the values contained by the two memory cells, returning
56412 /* The first 8 memory cells are used for the result set. So we will
56415 ** cells. */
56663 int nMem, /* Number of memory cells to allocate */
56683 ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
59972 ** Invoke this macro on memory cells just prior to changing the
60124 ** different sized allocations. Memory cells provide growable
60131 ** Memory cells for cursors are allocated at the top of the address
60894 Mem *pMem; /* Used to iterate through memory cells */
65405 Mem *pMem; /* Used to iterate through memory cells */
65445 /* SubProgram.nMem is set to the number of memory cells used by the
66261 ** are contiguous memory cells starting at P3 to pass to the xUpdate
73579 /* The block of memory cells initialized here is used as follows.
73592 ** Cells iMem through iMem+nCol are initialized to 0. The others are
91341 ** The aggregate accumulator is a set of memory cells that hold
91343 ** routine simply stores NULLs in all of those memory cells.
91390 ** Update the accumulator memory cells for an aggregate based on
98567 ** this routine allocates an additional nEq memory cells for internal
98607 /* Figure out how many memory cells we will need then allocate them.
119302 ** The minimum number of cells allowed for a node is a third of the
119308 ** cells are removed from the overfull node and reinserted into the tree.
119707 int nCell; /* Current number of cells in pNode */
119708 int nMaxCell; /* Maximum number of cells for pNode */
120164 ** One of the cells in node pNode is guaranteed to have a 64-bit
120588 ** Store the union of cells p1 and p2 in p1.
120790 ** the node pNode. This function updates the bounding box cells in
120876 /* Pick two "seed" cells from the array of cells. The algorithm used
120878 ** indices of the two seed cells in the array are stored in local
121067 ** in aIdx according to dimension iDim of the cells in aCell. The
121328 ** all cells from node pLeft. Then zero the original node.
121575 ** number of cells, remove it from the tree. Otherwise, update the
