Lines Matching defs:overflow
8692 ** buffer and where forced to overflow to [sqlite3_malloc()]. The
13361 ** level of recursion for each term. A stack overflow can result
23582 char isError; /* An overflow has occurred */
29322 ** signed integer overflow bugs when computing memory allocation sizes.
30928 /* Force exponential buffer size growth as long as it does not overflow,
34387 ** special case 2 overflow if positive */
35033 ** overflow, leave *pA unchanged and return 1.
53374 ** One extra bucket is added to catch overflow in case something
67606 ** bytes are stored on overflow pages. The payload for an entry
67616 ** Each page can be either a btree page, a freelist page, an overflow
67663 ** payload is spilled to overflow pages. Once an overflow page is allocated,
67664 ** as many bytes as possible are moved into the overflow pages without letting
67762 ** 4 First page of the overflow chain. Omitted if no overflow
67769 ** 4 Page number of next overflow page
67850 u8 nOverflow; /* Number of overflow cell bodies in aCell[] */
67857 u16 aiOvfl[4]; /* Insert the i-th overflow cell before the aiOvfl-th
67858 ** non-overflow cell */
67859 u8 *apOvfl[4]; /* Pointers to the body of overflow cells */
67864 ** corruption-induced buffer overflow. */
68050 u16 nLocal; /* Amount of payload held locally, not on overflow */
68099 Pgno *aOverflow; /* Cache of overflow page locations */
68211 ** overflow pages. The page number identifies the page that
68212 ** contains the cell with a pointer to this overflow page.
68215 ** overflow pages. The page-number identifies the previous
68216 ** page in the overflow page list.
69130 ** Invalidate the overflow cache of the cursor passed as the first argument.
69136 ** Invalidate the overflow page-list cache for all cursors opened
69717 ** This routine works only for pages that do not contain overflow cells.
69738 ** overflow pages. The strategy is to minimize the amount of unused
69739 ** space on overflow pages while keeping the amount of local storage
69742 ** Warning: changing the way overflow payload is distributed in any
69884 ** on the local page. No overflow is required.
69921 ** on the local page. No overflow is required.
69944 ** data header and the local payload, but not any overflow page or
70079 ** pointer to an overflow page, insert an entry into the pointer-map for
70080 ** the overflow page that will be valid after pCell has been moved to pPage.
71024 /* pPage might not be a btree page; it might be an overflow page
71965 ** 4-byte overflow page pointer
71967 ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
72304 ** pPage contains cells that point to overflow pages, set the pointer
72305 ** map entries for the overflow pages as well.
72346 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
72349 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
72350 ** overflow page in the list.
72445 ** that point to overflow pages. The pointer map entries for all these
72448 ** If pDbPage is an overflow page, then the first 4 bytes may store a
72449 ** pointer to a subsequent overflow page. If this is the case, then
72450 ** the pointer map needs to be updated for the subsequent overflow page.
73444 ** Given the page number of an overflow page in the database (parameter
73446 ** linked list of overflow pages. If possible, it uses the auto-vacuum
73451 ** The page number of the next overflow page in the linked list is
73464 Pgno ovfl, /* Current overflow page number */
73466 Pgno *pPgnoNext /* OUT: Next overflow page number */
73476 /* Try to find the next page in the overflow list using the
73478 ** the overflow list is page number (ovfl+1). If that guess turns
73556 ** 0: The operation is a read. Populate the overflow cache.
73557 ** 1: The operation is a write. Populate the overflow cache.
73563 ** or be scattered out on multiple overflow pages.
73565 ** If the current cursor entry uses one or more overflow pages
73567 ** the overflow page-list cache array (BtCursor.aOverflow).
73571 ** Once an overflow page-list cache has been allocated, it must be
73574 ** mode, the following events may invalidate an overflow page-list cache.
73578 ** * Creating a table (may require moving an overflow page).
73613 ** but is recast into its current form to avoid integer overflow problems
73641 ** The aOverflow[] array is sized at one entry for each overflow page
73642 ** in the overflow chain. The page number of the first overflow page is
73663 /* If the overflow page-list cache has been allocated and the
73664 ** entry for the first required overflow page is valid, skip
73676 /* If required, populate the overflow page-list cache. */
73685 ** number for the next page in the overflow chain. The page
73686 ** data is not required. So first try to lookup the overflow
73711 ** 2) data is required from the start of this overflow page, and
73719 ** up loading large records that span many overflow pages.
73830 ** and data to fit on the local page and for there to be no overflow
73833 ** onto overflow pages, then accessPayload() must be used to reassemble
73877 ** in the common case where no overflow pages are used.
74387 /* If the record extends into overflow pages, do not attempt
74556 /* The record flows over onto one or more overflow pages. In
75342 ** Free the overflow pages associated with the given Cell.
75376 ** overflow page. Therefore if ovflPgno<2 or past the end of the
75389 ** to an overflow page belonging to a cell that is being deleted/updated.
75391 ** must not really be an overflow page and the database must be corrupt.
75394 ** enabled. If this 'overflow' page happens to be a page that the
75413 ** overflow, then invoke cellClearOverflow to clear out that overflow.
75483 ** and no overflow pages are required. */
75497 ** to spill onto overflow pages.
75516 ** that means content must spill into overflow pages.
75517 ** *pnSize Size of the local cell (not counting overflow pages)
75518 ** pPrior Where to write the pgno of the first overflow page
75534 /* Write the payload into the local Cell and any extra into overflow pages */
75577 ** overflow page is being allocated, add an entry to the pointer-map
75580 ** If this is the first overflow page, then write a partial entry
75582 ** then the optimistic overflow chain processing in clearCell()
75720 ** as a contingency. In other words, never need more than 3 overflow
75770 /* The cell may contain a pointer to an overflow page. If so, write
75771 ** the entry for the overflow page into the pointer map.
75812 ** to overflow cells. In other words, some apCel[] pointers might not point
76187 /* Add any overflow cells */
76253 ** pParent is its parent. pPage must have a single overflow entry
76308 ** cell on the page to an overflow page. If either of these
76405 ** any cells with overflow page pointers, then the corresponding pointer
76408 ** If pFrom is currently carrying any overflow cells (entries in the
76451 ** for any b-tree or overflow pages that pTo now contains the pointers to.
76490 ** used to store the parent's overflow cells. Because this function inserts
76494 ** enough for all overflow cells.
76539 /* At this point pParent may have at most one overflow cell. And if
76540 ** this overflow cell is present, it must be the cell with
76560 ** overflow cells in the parent page, since if any existed they will
76698 ** contains overflow cells, include them in the b.apCell[] array
76701 ** Note that when there are multiple overflow cells, it is always the
76706 ** with "NOTE 1" in the overflow cell insertion loop to prove this
77021 ** a) if the cell contains a reference to an overflow chain, the
77022 ** entry associated with the first page in the overflow chain, and
77054 ** was either part of sibling page iOld (possibly an overflow cell),
77058 ** overflow cell), we can skip updating the pointer map entries. */
77274 ** overfull (has one or more overflow pages).
77277 ** page, including overflow cells, are copied into the child. The root
77323 /* Copy the overflow cells from pRoot to pChild */
77387 ** (1) There are no overflow cells
77434 ** to store the overflow cell. balance_quick() inserts a new cell
77435 ** into pParent, which may cause pParent overflow. If this
77438 ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
77458 ** If the parent page becomes overfull, the overflow cell or cells
77462 ** but it doesn't deal with overflow cells - just moves them to a
77465 ** the previous call, as the overflow cell data will have been
77555 Pgno ovflPgno; /* Next overflow page to write */
77556 u32 ovflPageSize; /* Size to write on overflow page */
77569 /* Now overwrite the overflow pages */
77849 ** new entry uses overflow pages, as the insertCell() call below is
77874 /* If no error has occurred and pPage has an overflow cell, call balance()
77934 ** Instead, it creates and populates any required overflow pages and
78155 ** overflow pages associated with the entry and finally remove the cell
78289 ** out to be an overflow page, delete all overflow page-map caches
78727 ** page in the B-Tree structure (not including overflow pages).
78891 ** Check the integrity of the freelist or of an overflow page list.
78896 int isFreeList, /* True for a freelist. False for overflow page list */
78940 ** page in this overflow list, check that the pointer-map entry for
78955 isFreeList ? "size" : "overflow list length",
79023 ** 3. Check the integrity of overflow pages.
79158 /* Check the content overflow list */
79160 u32 nPage; /* Number of pages on the overflow chain */
79161 Pgno pgnoOvfl; /* First page of the overflow chain */
81247 ** the second condition under the assumption that addition overflow causes
93389 ** page - where the content is not on an overflow page */
93415 /* This branch happens only when content is on overflow pages */
124883 ** then abs(X) throws an integer overflow error since there is no
124885 sqlite3_result_error(context, "integer overflow", -1);
126263 u8 overflow; /* True if integer overflow seen */
126289 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
126290 p->approx = p->overflow = 1;
126328 if( p->overflow ){
126329 sqlite3_result_error(context,"integer overflow",-1);
156836 ** array will never overflow.
168892 sqlite3ErrorMsg(pParse, "parser stack overflow");
179328 ** of stack space (perhaps causing a stack overflow).
180610 ** consumed. If an overflow error occurs return a negative value.
184511 int nOvfl; /* Number of overflow pages to load doclist */
184574 ** the number of overflow pages consumed by a record B bytes in size.
184647 int nOvfl = 0; /* Total overflow pages used by doclists */
184663 ** associated with the tokens spill onto overflow pages, or if there is
184679 ** of the number of overflow pages that will be loaded by the pager layer
184696 ** loading N or more overflow pages into memory, where N is computed as:
184715 /* The number of overflow pages to load for this (and therefore all
187399 ** could cause a stack overflow.
191290 ** overflow - hence the (i64) casts. */
198387 ** This limit is needed to avoid a stack overflow in the recursive
214238 ** from. For example, the three overflow pages in a chain linked from
214242 ** '/1c2/000+000000' // First page in overflow chain
214243 ** '/1c2/000+000001' // Second page in overflow chain
214244 ** '/1c2/000+000002' // Third page in overflow chain
214247 ** the overflow pages associated with a cell will appear earlier in the
214257 " pagetype TEXT," /* 3 'internal', 'leaf', 'overflow', or NULL */
214258 " ncell INTEGER," /* 4 Cells on page (0 for overflow) */
214280 u32 *aOvfl; /* Array of overflow page numbers */
214281 int nLastOvfl; /* Bytes of payload on final overflow page */
214550 ** number of bytes of content not found on overflow pages.
214639 u32 nPayload; /* Bytes of payload total (local+overflow) */
214814 pCsr->zPagetype = "overflow";
223628 sqlite3Fts5ParseError(pParse, "fts5: parser stack overflow");