Lines Matching defs:overflow
8161 ** buffer and where forced to overflow to [sqlite3_malloc()]. The
11942 ** level of recursion for each term. A stack overflow can result
19637 char isError; /* An overflow has occurred */
25373 ** signed integer value might cause an integer overflow inside of the
26645 /* Force exponential buffer size growth as long as it does not overflow,
29147 ** special case 2 overflow if positive */
29785 ** overflow, leave *pA unchanged and return 1.
45917 ** One extra bucket is added to catch overflow in case something
59459 ** bytes are stored on overflow pages. The payload for an entry
59469 ** Each page can be either a btree page, a freelist page, an overflow
59516 ** payload is spilled to overflow pages. Once an overflow page is allocated,
59517 ** as many bytes as possible are moved into the overflow pages without letting
59615 ** 4 First page of the overflow chain. Omitted if no overflow
59617 ** Overflow pages form a linked list. Each page except the last is completely
59622 ** 4 Page number of next overflow page
59704 u8 nOverflow; /* Number of overflow cell bodies in aCell[] */
59711 u16 aiOvfl[4]; /* Insert the i-th overflow cell before the aiOvfl-th
59712 ** non-overflow cell */
59713 u8 *apOvfl[4]; /* Pointers to the body of overflow cells */
59886 u16 nLocal; /* Amount of payload held locally, not on overflow */
59929 Pgno *aOverflow; /* Cache of overflow page locations */
60039 ** overflow pages. The page number identifies the page that
60040 ** contains the cell with a pointer to this overflow page.
60043 ** overflow pages. The page-number identifies the previous
60044 ** page in the overflow page list.
60918 ** Invalidate the overflow cache of the cursor passed as the first argument.
60924 ** Invalidate the overflow page-list cache for all cursors opened
61483 ** This routine works only for pages that do not contain overflow cells.
61504 ** overflow pages. The strategy is to minimize the amount of unused
61505 ** space on overflow pages while keeping the amount of local storage
61508 ** Warning: changing the way overflow payload is distributed in any
61513 int surplus; /* Overflow payload available for local storage */
61618 ** on the local page. No overflow is required.
61655 ** on the local page. No overflow is required.
61678 ** data header and the local payload, but not any overflow page or
61766 ** to an overflow page, insert an entry into the pointer-map
61767 ** for the overflow page.
62635 /* pPage might not be a btree page; it might be an overflow page
63548 ** 4-byte overflow page pointer
63550 ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
63854 ** pPage contains cells that point to overflow pages, set the pointer
63855 ** map entries for the overflow pages as well.
63896 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
63899 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
63900 ** overflow page in the list.
63991 ** that point to overflow pages. The pointer map entries for all these
63994 ** If pDbPage is an overflow page, then the first 4 bytes may store a
63995 ** pointer to a subsequent overflow page. If this is the case, then
63996 ** the pointer map needs to be updated for the subsequent overflow page.
64888 ** Given the page number of an overflow page in the database (parameter
64890 ** linked list of overflow pages. If possible, it uses the auto-vacuum
64895 ** The page number of the next overflow page in the linked list is
64908 Pgno ovfl, /* Current overflow page number */
64910 Pgno *pPgnoNext /* OUT: Next overflow page number */
64920 /* Try to find the next page in the overflow list using the
64922 ** the overflow list is page number (ovfl+1). If that guess turns
65000 ** 0: The operation is a read. Populate the overflow cache.
65001 ** 1: The operation is a write. Populate the overflow cache.
65007 ** or be scattered out on multiple overflow pages.
65009 ** If the current cursor entry uses one or more overflow pages
65011 ** the overflow page-list cache array (BtCursor.aOverflow).
65015 ** Once an overflow page-list cache has been allocated, it must be
65018 ** mode, the following events may invalidate an overflow page-list cache.
65022 ** * Creating a table (may require moving an overflow page).
65055 ** but is recast into its current form to avoid integer overflow problems
65083 ** The aOverflow[] array is sized at one entry for each overflow page
65084 ** in the overflow chain. The page number of the first overflow page is
65104 /* If the overflow page-list cache has been allocated and the
65105 ** entry for the first required overflow page is valid, skip
65117 /* If required, populate the overflow page-list cache. */
65125 ** number for the next page in the overflow chain. The page
65126 ** data is not required. So first try to lookup the overflow
65143 sqlite3_file *fd; /* File from which to do direct overflow read */
65154 ** 2) data is required from the start of this overflow page, and
65162 ** up loading large records that span many overflow pages.
65204 /* Overflow chain ends prematurely */
65274 ** and data to fit on the local page and for there to be no overflow
65277 ** onto overflow pages, then accessPayload() must be used to reassemble
65321 ** in the common case where no overflow pages are used.
65812 /* The record flows over onto one or more overflow pages. In
66611 ** Free any overflow pages associated with the given Cell. Write the
66613 ** overflow) into *pnSize.
66629 return SQLITE_OK; /* No overflow pages. Return without doing anything */
66648 ** overflow page. Therefore if ovflPgno<2 or past the end of the
66661 ** to an overflow page belonging to a cell that is being deleted/updated.
66663 ** must not really be an overflow page and the database must be corrupt.
66666 ** enabled. If this 'overflow' page happens to be a page that the
66686 ** and write that byte sequence into pCell[]. Overflow pages are
66740 ** and no overflow pages are required. */
66754 ** to spill onto overflow pages.
66773 ** that means content must spill into overflow pages.
66774 ** *pnSize Size of the local cell (not counting overflow pages)
66775 ** pPrior Where to write the pgno of the first overflow page
66791 /* Write the payload into the local Cell and any extra into overflow pages */
66822 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
66834 ** overflow page is being allocated, add an entry to the pointer-map
66837 ** If this is the first overflow page, then write a partial entry
66839 ** then the optimistic overflow chain processing in clearCell()
66978 ** as a contingency. In other words, never need more than 3 overflow
67021 /* The cell may contain a pointer to an overflow page. If so, write
67022 ** the entry for the overflow page into the pointer map.
67309 /* Add any overflow cells */
67386 ** pParent is its parent. pPage must have a single overflow entry
67430 ** cell on the page to an overflow page. If either of these
67527 ** any cells with overflow page pointers, then the corresponding pointer
67530 ** If pFrom is currently carrying any overflow cells (entries in the
67572 ** for any b-tree or overflow pages that pTo now contains the pointers to.
67611 ** used to store the parent's overflow cells. Because this function inserts
67615 ** enough for all overflow cells.
67667 /* At this point pParent may have at most one overflow cell. And if
67668 ** this overflow cell is present, it must be the cell with
67687 ** overflow cells in the parent page, since if any existed they will
67817 ** constains overflow cells, include them in the b.apCell[] array
67820 ** Note that when there are multiple overflow cells, it is always the
67825 ** with "NOTE 1" in the overflow cell insertion loop to prove this
68120 ** a) if the cell contains a reference to an overflow chain, the
68121 ** entry associated with the first page in the overflow chain, and
68152 ** was either part of sibling page iOld (possibly an overflow cell),
68156 ** overflow cell), we can skip updating the pointer map entries. */
68364 ** overfull (has one or more overflow pages).
68367 ** page, including overflow cells, are copied into the child. The root
68413 /* Copy the overflow cells from pRoot to pChild */
68488 ** to store the overflow cell. balance_quick() inserts a new cell
68489 ** into pParent, which may cause pParent overflow. If this
68492 ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
68512 ** If the parent page becomes overfull, the overflow cell or cells
68516 ** but it doesn't deal with overflow cells - just moves them to a
68519 ** the previous call, as the overflow cell data will have been
68716 ** new entry uses overflow pages, as the insertCell() call below is
68736 /* If no error has occurred and pPage has an overflow cell, call balance()
68882 ** overflow pages associated with the entry and finally remove the cell
69004 ** out to be an overflow page, delete all overflow page-map caches
69436 ** page in the B-Tree structure (not including overflow pages).
69601 ** Check the integrity of the freelist or of an overflow page list.
69606 int isFreeList, /* True for a freelist. False for overflow page list */
69618 "%d of %d pages missing from overflow list starting at %d",
69655 ** page in this overflow list, check that the pointer-map entry for
69736 ** 3. Check the integrity of overflow pages.
69866 /* Check the content overflow list */
69868 int nPage; /* Number of pages on the overflow chain */
69869 Pgno pgnoOvfl; /* First page of the overflow chain */
71756 ** the second condition under the assumption that addition overflow causes
82603 ** page - where the content is not on an overflow page */
82628 /* This branch happens only when content is on overflow pages */
107677 ** then abs(X) throws an integer overflow error since there is no
107679 sqlite3_result_error(context, "integer overflow", -1);
108997 u8 overflow; /* True if integer overflow seen */
109023 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
109024 p->overflow = 1;
109036 if( p->overflow ){
109037 sqlite3_result_error(context,"integer overflow",-1);
133120 ** array will never overflow.
140103 fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
140111 sqlite3ErrorMsg(pParse, "parser stack overflow");
148535 ** of stack space (perhaps causing a stack overflow).
153546 int nOvfl; /* Number of overflow pages to load doclist */
153609 ** the number of overflow pages consumed by a record B bytes in size.
153681 int nOvfl = 0; /* Total overflow pages used by doclists */
153697 ** associated with the tokens spill onto overflow pages, or if there is
153713 ** of the number of overflow pages that will be loaded by the pager layer
153730 ** loading N or more overflow pages into memory, where N is computed as:
153749 /* The number of overflow pages to load for this (and therefore all
156419 ** could cause a stack overflow.
160302 ** overflow - hence the (i64) casts. */
177716 ** Overflow pages are specified by appending a '+' character and a
177718 ** from. For example, the three overflow pages in a chain linked from
177722 ** '/1c2/000+000000' // First page in overflow chain
177723 ** '/1c2/000+000001' // Second page in overflow chain
177724 ** '/1c2/000+000002' // Third page in overflow chain
177727 ** the overflow pages associated with a cell will appear earlier in the
177737 " pagetype TEXT, /* 'internal', 'leaf' or 'overflow' */" \
177738 " ncell INTEGER, /* Cells on page (0 for overflow) */" \
177757 u32 *aOvfl; /* Array of overflow page numbers */
177758 int nLastOvfl; /* Bytes of payload on final overflow page */
178039 u32 nPayload; /* Bytes of payload total (local+overflow) */
178157 pCsr->zPagetype = "overflow";
183791 ** This limit is needed to avoid a stack overflow in the recursive
188230 fprintf(fts5yyTraceFILE,"%sStack Overflow!\n",fts5yyTracePrompt);
188238 sqlite3Fts5ParseError(pParse, "fts5: parser stack overflow");
