Lines Matching defs:overflow
6752 ** buffer and where forced to overflow to [sqlite3_malloc()]. The
6775 ** buffer and where forced to overflow to [sqlite3_malloc()]. The values
8747 ** level of recursion for each term. A stack overflow can result
21604 ** signed integer value might cause an integer overflow inside of the
22873 /* Force exponential buffer size growth as long as it does not overflow,
25156 ** special case 2 overflow if positive */
25794 ** overflow, leave *pA unchanged and return 1.
25842 /* If both iA1 and iB1 are non-zero, overflow will result */
41016 ** One extra bucket is added to catch overflow in case something
53561 ** bytes are stored on overflow pages. The payload for an entry
53571 ** Each page can be either a btree page, a freelist page, an overflow
53618 ** payload is spilled to overflow pages. Once an overflow page is allocated,
53619 ** as many bytes as possible are moved into the overflow pages without letting
53717 ** 4 First page of the overflow chain. Omitted if no overflow
53719 ** Overflow pages form a linked list. Each page except the last is completely
53724 ** 4 Page number of next overflow page
53797 overflow cell bodies in aCell[] */
53812 u16 aiOvfl[5]; /* Insert the i-th overflow cell before the aiOvfl-th
53813 ** non-overflow cell */
53814 u8 *apOvfl[5]; /* Pointers to the body of overflow cells */
53993 u16 nLocal; /* Amount of payload held locally, not on overflow */
53994 u16 iOverflow; /* Offset to overflow page number. Zero if no overflow */
54032 Pgno *aOverflow; /* Cache of overflow page locations */
54146 ** overflow pages. The page number identifies the page that
54147 ** contains the cell with a pointer to this overflow page.
54150 ** overflow pages. The page-number identifies the previous
54151 ** page in the overflow page list.
54977 ** Invalidate the overflow cache of the cursor passed as the first argument.
54983 ** Invalidate the overflow page-list cache for all cursors opened
55513 ** This routine works only for pages that do not contain overflow cells.
55534 ** overflow pages. The strategy is to minimize the amount of unused
55535 ** space on overflow pages while keeping the amount of local storage
55538 ** Warning: changing the way overflow payload is distributed in any
55543 int surplus; /* Overflow payload available for local storage */
55653 ** on the local page. No overflow is required.
55692 ** on the local page. No overflow is required.
55716 ** data header and the local payload, but not any overflow page or
55805 ** to an overflow page, insert an entry into the pointer-map
55806 ** for the overflow page.
56594 /* pPage might not be a btree page; it might be an overflow page
57455 ** 4-byte overflow page pointer
57457 ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
57759 ** pPage contains cells that point to overflow pages, set the pointer
57760 ** map entries for the overflow pages as well.
57806 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
57809 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
57810 ** overflow page in the list.
57902 ** that point to overflow pages. The pointer map entries for all these
57905 ** If pDbPage is an overflow page, then the first 4 bytes may store a
57906 ** pointer to a subsequent overflow page. If this is the case, then
57907 ** the pointer map needs to be updated for the subsequent overflow page.
58787 ** Given the page number of an overflow page in the database (parameter
58789 ** linked list of overflow pages. If possible, it uses the auto-vacuum
58794 ** The page number of the next overflow page in the linked list is
58807 Pgno ovfl, /* Current overflow page number */
58809 Pgno *pPgnoNext /* OUT: Next overflow page number */
58819 /* Try to find the next page in the overflow list using the
58821 ** the overflow list is page number (ovfl+1). If that guess turns
58899 ** 0: The operation is a read. Populate the overflow cache.
58900 ** 1: The operation is a write. Populate the overflow cache.
58901 ** 2: The operation is a read. Do not populate the overflow cache.
58907 ** or be scattered out on multiple overflow pages.
58909 ** If the current cursor entry uses one or more overflow pages and the
58911 ** populates the overflow page-list cache array (BtCursor.aOverflow).
58915 ** Once an overflow page-list cache has been allocated, it may be
58918 ** mode, the following events may invalidate an overflow page-list cache.
58922 ** * Creating a table (may require moving an overflow page).
58983 ** The aOverflow[] array is sized at one entry for each overflow page
58984 ** in the overflow chain. The page number of the first overflow page is
59007 /* If the overflow page-list cache has been allocated and the
59008 ** entry for the first required overflow page is valid, skip
59021 /* If required, populate the overflow page-list cache. */
59029 ** number for the next page in the overflow chain. The page
59030 ** data is not required. So first try to lookup the overflow
59062 ** 2) data is required from the start of this overflow page, and
59071 ** up loading large records that span many overflow pages.
59174 ** and data to fit on the local page and for there to be no overflow
59177 ** onto overflow pages, then accessPayload() must be used to reassemble
59216 ** in the common case where no overflow pages are used.
59673 /* The record flows over onto one or more overflow pages. In
60457 ** Free any overflow pages associated with the given Cell. Write the
60459 ** overflow) into *pnSize.
60477 return SQLITE_OK; /* No overflow pages. Return without doing anything */
60494 ** overflow page. Therefore if ovflPgno<2 or past the end of the
60507 ** to an overflow page belonging to a cell that is being deleted/updated.
60509 ** must not really be an overflow page and the database must be corrupt.
60512 ** enabled. If this 'overflow' page happens to be a page that the
60532 ** and write that byte sequence into pCell[]. Overflow pages are
60616 ** that means content must spill into overflow pages.
60617 ** *pnSize Size of the local cell (not counting overflow pages)
60618 ** pPrior Where to write the pgno of the first overflow page
60635 /* Write the payload into the local Cell and any extra into overflow pages */
60639 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
60651 ** overflow page is being allocated, add an entry to the pointer-map
60654 ** If this is the first overflow page, then write a partial entry
60656 ** then the optimistic overflow chain processing in clearCell()
60863 /* The cell may contain a pointer to an overflow page. If so, write
60864 ** the entry for the overflow page into the pointer map.
61151 /* Add any overflow cells */
61228 ** pParent is its parent. pPage must have a single overflow entry
61272 ** cell on the page to an overflow page. If either of these
61367 ** any cells with overflow page pointers, then the corresponding pointer
61370 ** If pFrom is currently carrying any overflow cells (entries in the
61412 ** for any b-tree or overflow pages that pTo now contains the pointers to.
61451 ** used to store the parent's overflow cells. Because this function inserts
61455 ** enough for all overflow cells.
61510 /* At this point pParent may have at most one overflow cell. And if
61511 ** this overflow cell is present, it must be the cell with
61530 ** overflow cells in the parent page, since if any existed they will
61662 ** constains overflow cells, include them in the b.apCell[] array
61665 ** Note that when there are multiple overflow cells, it is always the
61670 ** with "NOTE 1" in the overflow cell insertion loop to prove this
61967 ** a) if the cell contains a reference to an overflow chain, the
61968 ** entry associated with the first page in the overflow chain, and
61999 ** was either part of sibling page iOld (possibly an overflow cell),
62003 ** overflow cell), we can skip updating the pointer map entries. */
62215 ** overfull (has one or more overflow pages).
62218 ** page, including overflow cells, are copied into the child. The root
62264 /* Copy the overflow cells from pRoot to pChild */
62336 ** to store the overflow cell. balance_quick() inserts a new cell
62337 ** into pParent, which may cause pParent overflow. If this
62340 ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
62359 ** If the parent page becomes overfull, the overflow cell or cells
62363 ** but it doesn't deal with overflow cells - just moves them to a
62366 ** the previous call, as the overflow cell data will have been
62538 /* If no error has occurred and pPage has an overflow cell, call balance()
62659 ** overflow pages associated with the entry and finally remove the cell
62769 ** out to be an overflow page, delete all overflow page-map caches
63222 ** page in the B-Tree structure (not including overflow pages).
63387 ** Check the integrity of the freelist or of an overflow page list.
63392 int isFreeList, /* True for a freelist. False for overflow page list */
63404 "%d of %d pages missing from overflow list starting at %d",
63441 ** page in this overflow list, check that the pointer-map entry for
63522 ** 3. Check the integrity of overflow pages.
63651 /* Check the content overflow list */
63653 int nPage; /* Number of pages on the overflow chain */
63654 Pgno pgnoOvfl; /* First page of the overflow chain */
65499 ** the second condition under the assumption that addition overflow causes
75459 ** page - where the content is not on an overflow page */
75462 /* This branch happens only when content is on overflow pages */
98734 ** then abs(X) throws an integer overflow error since there is no
98736 sqlite3_result_error(context, "integer overflow", -1);
99989 u8 overflow; /* True if integer overflow seen */
100015 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
100016 p->overflow = 1;
100028 if( p->overflow ){
100029 sqlite3_result_error(context,"integer overflow",-1);
121561 ** array will never overflow.
127681 fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
127689 sqlite3ErrorMsg(pParse, "parser stack overflow");
129377 ** onto the stack here, and skip the stack overflow test in yy_shift().
135595 ** of stack space (perhaps causing a stack overflow).
140565 int nOvfl; /* Number of overflow pages to load doclist */
140628 ** the number of overflow pages consumed by a record B bytes in size.
140701 int nOvfl = 0; /* Total overflow pages used by doclists */
140717 ** associated with the tokens spill onto overflow pages, or if there is
140733 ** of the number of overflow pages that will be loaded by the pager layer
140750 ** loading N or more overflow pages into memory, where N is computed as:
140769 /* The number of overflow pages to load for this (and therefore all
143442 ** could cause a stack overflow.
162923 ** Overflow pages are specified by appending a '+' character and a
162925 ** from. For example, the three overflow pages in a chain linked from
162929 ** '/1c2/000+000000' // First page in overflow chain
162930 ** '/1c2/000+000001' // Second page in overflow chain
162931 ** '/1c2/000+000002' // Third page in overflow chain
162934 ** the overflow pages associated with a cell will appear earlier in the
162944 " pagetype STRING, /* 'internal', 'leaf' or 'overflow' */" \
162945 " ncell INTEGER, /* Cells on page (0 for overflow) */" \
162964 u32 *aOvfl; /* Array of overflow page numbers */
162965 int nLastOvfl; /* Bytes of payload on final overflow page */
163244 u32 nPayload; /* Bytes of payload total (local+overflow) */
163362 pCsr->zPagetype = "overflow";
167545 fprintf(fts5yyTraceFILE,"%sStack Overflow!\n",fts5yyTracePrompt);
167813 ** onto the stack here, and skip the stack overflow test in fts5yy_shift().
