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 */
40998 ** One extra bucket is added to catch overflow in case something
53543 ** bytes are stored on overflow pages. The payload for an entry
53553 ** Each page can be either a btree page, a freelist page, an overflow
53600 ** payload is spilled to overflow pages. Once an overflow page is allocated,
53601 ** as many bytes as possible are moved into the overflow pages without letting
53699 ** 4 First page of the overflow chain. Omitted if no overflow
53701 ** Overflow pages form a linked list. Each page except the last is completely
53706 ** 4 Page number of next overflow page
53779 u8 nOverflow; /* Number of overflow cell bodies in aCell[] */
53794 u16 aiOvfl[5]; /* Insert the i-th overflow cell before the aiOvfl-th
53795 ** non-overflow cell */
53796 u8 *apOvfl[5]; /* Pointers to the body of overflow cells */
53975 u16 nLocal; /* Amount of payload held locally, not on overflow */
53976 u16 iOverflow; /* Offset to overflow page number. Zero if no overflow */
54014 Pgno *aOverflow; /* Cache of overflow page locations */
54128 ** overflow pages. The page number identifies the page that
54129 ** contains the cell with a pointer to this overflow page.
54132 ** overflow pages. The page-number identifies the previous
54133 ** page in the overflow page list.
54959 ** Invalidate the overflow cache of the cursor passed as the first argument.
54965 ** Invalidate the overflow page-list cache for all cursors opened
55495 ** This routine works only for pages that do not contain overflow cells.
55516 ** overflow pages. The strategy is to minimize the amount of unused
55517 ** space on overflow pages while keeping the amount of local storage
55520 ** Warning: changing the way overflow payload is distributed in any
55525 int surplus; /* Overflow payload available for local storage */
55635 ** on the local page. No overflow is required.
55674 ** on the local page. No overflow is required.
55698 ** data header and the local payload, but not any overflow page or
55787 ** to an overflow page, insert an entry into the pointer-map
55788 ** for the overflow page.
56576 /* pPage might not be a btree page; it might be an overflow page
57437 ** 4-byte overflow page pointer
57439 ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
57741 ** pPage contains cells that point to overflow pages, set the pointer
57742 ** map entries for the overflow pages as well.
57788 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
57791 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
57792 ** overflow page in the list.
57884 ** that point to overflow pages. The pointer map entries for all these
57887 ** If pDbPage is an overflow page, then the first 4 bytes may store a
57888 ** pointer to a subsequent overflow page. If this is the case, then
57889 ** the pointer map needs to be updated for the subsequent overflow page.
58769 ** Given the page number of an overflow page in the database (parameter
58771 ** linked list of overflow pages. If possible, it uses the auto-vacuum
58776 ** The page number of the next overflow page in the linked list is
58789 Pgno ovfl, /* Current overflow page number */
58791 Pgno *pPgnoNext /* OUT: Next overflow page number */
58801 /* Try to find the next page in the overflow list using the
58803 ** the overflow list is page number (ovfl+1). If that guess turns
58881 ** 0: The operation is a read. Populate the overflow cache.
58882 ** 1: The operation is a write. Populate the overflow cache.
58883 ** 2: The operation is a read. Do not populate the overflow cache.
58889 ** or be scattered out on multiple overflow pages.
58891 ** If the current cursor entry uses one or more overflow pages and the
58893 ** populates the overflow page-list cache array (BtCursor.aOverflow).
58897 ** Once an overflow page-list cache has been allocated, it may be
58900 ** mode, the following events may invalidate an overflow page-list cache.
58904 ** * Creating a table (may require moving an overflow page).
58965 ** The aOverflow[] array is sized at one entry for each overflow page
58966 ** in the overflow chain. The page number of the first overflow page is
58989 /* If the overflow page-list cache has been allocated and the
58990 ** entry for the first required overflow page is valid, skip
59003 /* If required, populate the overflow page-list cache. */
59011 ** number for the next page in the overflow chain. The page
59012 ** data is not required. So first try to lookup the overflow
59044 ** 2) data is required from the start of this overflow page, and
59053 ** up loading large records that span many overflow pages.
59156 ** and data to fit on the local page and for there to be no overflow
59159 ** onto overflow pages, then accessPayload() must be used to reassemble
59198 ** in the common case where no overflow pages are used.
59655 /* The record flows over onto one or more overflow pages. In
60439 ** Free any overflow pages associated with the given Cell. Write the
60441 ** overflow) into *pnSize.
60459 return SQLITE_OK; /* No overflow pages. Return without doing anything */
60476 ** overflow page. Therefore if ovflPgno<2 or past the end of the
60489 ** to an overflow page belonging to a cell that is being deleted/updated.
60491 ** must not really be an overflow page and the database must be corrupt.
60494 ** enabled. If this 'overflow' page happens to be a page that the
60514 ** and write that byte sequence into pCell[]. Overflow pages are
60598 ** that means content must spill into overflow pages.
60599 ** *pnSize Size of the local cell (not counting overflow pages)
60600 ** pPrior Where to write the pgno of the first overflow page
60617 /* Write the payload into the local Cell and any extra into overflow pages */
60621 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
60633 ** overflow page is being allocated, add an entry to the pointer-map
60636 ** If this is the first overflow page, then write a partial entry
60638 ** then the optimistic overflow chain processing in clearCell()
60845 /* The cell may contain a pointer to an overflow page. If so, write
60846 ** the entry for the overflow page into the pointer map.
61133 /* Add any overflow cells */
61210 ** pParent is its parent. pPage must have a single overflow entry
61254 ** cell on the page to an overflow page. If either of these
61349 ** any cells with overflow page pointers, then the corresponding pointer
61352 ** If pFrom is currently carrying any overflow cells (entries in the
61394 ** for any b-tree or overflow pages that pTo now contains the pointers to.
61433 ** used to store the parent's overflow cells. Because this function inserts
61437 ** enough for all overflow cells.
61492 /* At this point pParent may have at most one overflow cell. And if
61493 ** this overflow cell is present, it must be the cell with
61512 ** overflow cells in the parent page, since if any existed they will
61644 ** constains overflow cells, include them in the b.apCell[] array
61647 ** Note that when there are multiple overflow cells, it is always the
61652 ** with "NOTE 1" in the overflow cell insertion loop to prove this
61949 ** a) if the cell contains a reference to an overflow chain, the
61950 ** entry associated with the first page in the overflow chain, and
61981 ** was either part of sibling page iOld (possibly an overflow cell),
61985 ** overflow cell), we can skip updating the pointer map entries. */
62197 ** overfull (has one or more overflow pages).
62200 ** page, including overflow cells, are copied into the child. The root
62246 /* Copy the overflow cells from pRoot to pChild */
62318 ** to store the overflow cell. balance_quick() inserts a new cell
62319 ** into pParent, which may cause pParent overflow. If this
62322 ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
62341 ** If the parent page becomes overfull, the overflow cell or cells
62345 ** but it doesn't deal with overflow cells - just moves them to a
62348 ** the previous call, as the overflow cell data will have been
62520 /* If no error has occurred and pPage has an overflow cell, call balance()
62641 ** overflow pages associated with the entry and finally remove the cell
62751 ** out to be an overflow page, delete all overflow page-map caches
63204 ** page in the B-Tree structure (not including overflow pages).
63369 ** Check the integrity of the freelist or of an overflow page list.
63374 int isFreeList, /* True for a freelist. False for overflow page list */
63386 "%d of %d pages missing from overflow list starting at %d",
63423 ** page in this overflow list, check that the pointer-map entry for
63504 ** 3. Check the integrity of overflow pages.
63633 /* Check the content overflow list */
63635 int nPage; /* Number of pages on the overflow chain */
63636 Pgno pgnoOvfl; /* First page of the overflow chain */
65481 ** the second condition under the assumption that addition overflow causes
75441 ** page - where the content is not on an overflow page */
75444 /* This branch happens only when content is on overflow pages */
98716 ** then abs(X) throws an integer overflow error since there is no
98718 sqlite3_result_error(context, "integer overflow", -1);
99971 u8 overflow; /* True if integer overflow seen */
99997 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
99998 p->overflow = 1;
100010 if( p->overflow ){
100011 sqlite3_result_error(context,"integer overflow",-1);
121543 ** array will never overflow.
127663 fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
127671 sqlite3ErrorMsg(pParse, "parser stack overflow");
129359 ** onto the stack here, and skip the stack overflow test in yy_shift().
135577 ** of stack space (perhaps causing a stack overflow).
140535 int nOvfl; /* Number of overflow pages to load doclist */
140598 ** the number of overflow pages consumed by a record B bytes in size.
140671 int nOvfl = 0; /* Total overflow pages used by doclists */
140687 ** associated with the tokens spill onto overflow pages, or if there is
140703 ** of the number of overflow pages that will be loaded by the pager layer
140720 ** loading N or more overflow pages into memory, where N is computed as:
140739 /* The number of overflow pages to load for this (and therefore all
143412 ** could cause a stack overflow.
162893 ** Overflow pages are specified by appending a '+' character and a
162895 ** from. For example, the three overflow pages in a chain linked from
162899 ** '/1c2/000+000000' // First page in overflow chain
162900 ** '/1c2/000+000001' // Second page in overflow chain
162901 ** '/1c2/000+000002' // Third page in overflow chain
162904 ** the overflow pages associated with a cell will appear earlier in the
162914 " pagetype STRING, /* 'internal', 'leaf' or 'overflow' */" \
162915 " ncell INTEGER, /* Cells on page (0 for overflow) */" \
162934 u32 *aOvfl; /* Array of overflow page numbers */
162935 int nLastOvfl; /* Bytes of payload on final overflow page */
163214 u32 nPayload; /* Bytes of payload total (local+overflow) */
163332 pCsr->zPagetype = "overflow";
167515 fprintf(fts5yyTraceFILE,"%sStack Overflow!\n",fts5yyTracePrompt);
167783 ** onto the stack here, and skip the stack overflow test in fts5yy_shift().
