Lines Matching defs:out
413 ** that we have taken it all out and gone back to using simple
510 ** returning the N-th compile time option string. ^If N is out of range,
687 ** coming out of the evaluated SQL statements. ^The 4th argument to
780 #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */
1436 ** the file descriptor out of batch write mode so that all subsequent
1445 ** ^This file control takes the file descriptor out of batch write mode
1613 ** is incremented. The iVersion value started out as 1 in
2028 ** memory allocator that simulates memory out-of-memory conditions in
4874 ** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails.
4932 ** ^If the value N is out of range or if the N-th parameter is
5277 ** column index is out of range, the result is undefined.
5434 ** fail if an out-of-memory error occurs during a format conversion.
5435 ** Only the following subset of interfaces are subject to out-of-memory
5446 ** If an out-of-memory error occurs, then the return value from these
5448 ** Valid SQL NULL returns can be distinguished from out-of-memory errors
5716 ** out of inner loops.
5906 ** fail if an out-of-memory error occurs during a format conversion.
5907 ** Only the following subset of interfaces are subject to out-of-memory
5920 ** If an out-of-memory error occurs, then the return value from these
5922 ** Valid SQL NULL returns can be distinguished from out-of-memory errors
5983 ** N bytes of memory, zeroes out that memory, and returns a pointer
6664 ** find out whether SQLite automatically rolled back the transaction after
6692 ** out of range. An N value of 0 means the main database file. An N of 1 is
8375 ** ^The sqlite3_test_control() interface is used to read out internal
8515 ** valid [sqlite3_str] object, though in the event of an out-of-memory
8595 ** [SQLITE_NOMEM] following any out-of-memory error, or
8663 ** <dd>This parameter is the current amount of memory checked out
8680 ** currently checked out.</dd>)^
8683 ** <dd>This parameter returns the number of pages used out of the
8773 ** checked out.</dd>)^
9356 ** ^If an out-of-memory condition or IO error occurred during any prior
10333 ** Loops are numbered starting from zero. ^If idx is out of range - less than
10369 ** pages in the pager-cache that are not currently in use are written out
10386 ** example an IO error or out-of-memory condition), then processing is
11959 ** returned. Or, if an out-of-memory condition occurs during processing, this
13701 ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
14326 ** not, there are still machines out there that use EBCDIC.)
14897 ** Figure out if we are dealing with Unix, Windows, or some other operating
15010 ** anybody smart enough to figure out the code is also likely smart
15050 ** byte out of a specific range of bytes. The lock byte is obtained at
15064 ** But a single Win95 reader will lock out all WinNT readers and a single
15065 ** WinNT reader will lock out all other Win95 readers.
16689 ** to all source files. We break it out in an effort to keep the code
16699 ** Figure out what version of the code to use. The choices are
16843 ** have been filled out. If the schema changes, these column names might
17838 ** done as a macro so that it will be optimized out when virtual
17922 ** fails and any prior changes from that one operation are backed out,
17925 ** changes due to the same operation are not backed out and no rollback
17950 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
17988 ** This object holds a record which has been parsed out into individual
18165 ** Each token coming out of the lexer is an instance of
18170 ** the Token goes out of scope! Very often, the "z" points to some place
18575 ** The jointype starts out showing the join type between the current table
19118 u8 okConstFactor; /* OK to factor out constants */
20248 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
21052 ** It uses the RDTSC opcode to read the cycle count value out of the
22062 ** index (here shown as [256-OP_Ne]) would be out-of-bounds and thus
22424 ** this header information was factored out.
22508 ** the cache is out of date. */
25335 ** is completely recoverable simply by not carrying out the resize. The
26236 FILE *out;
26240 out = fopen(zFilename, "w");
26241 if( out==0 ){
26249 fprintf(out, "**** %lld bytes at %p from %s ****\n",
26252 fflush(out);
26255 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
26256 fprintf(out, "\n");
26259 fprintf(out, "COUNTS:\n");
26262 fprintf(out, " %5d: %10d %10d %10d\n",
26267 fprintf(out, " %5d: %10d %10d %10d\n",
26271 fclose(out);
26343 ** A chunk is two or more blocks that is either checked out or
26346 ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
26348 ** is true if the previous chunk is checked out and false if the
26351 ** freelist. If the previous chunk is checked out, then
26367 ** out. If a chunk is checked out, the user data may extend into
26399 ** True if we are evaluating an out-of-memory callback.
26539 ** size parameters for check-out and return a pointer to the
26661 ** successful most of the time (about 9 times out of 10).
26765 ** works for chunks that are currently checked out.
26791 assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */
26881 FILE *out;
26885 out = stdout;
26887 out = fopen(zFilename, "w");
26888 if( out==0 ){
26895 fprintf(out, "CHUNKS:\n");
26899 fprintf(out, "%p size error\n", &mem3.aPool[i]);
26904 fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
26909 fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
26914 fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
26916 fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
26922 fprintf(out, "small(%2d):", i);
26924 fprintf(out, " %p(%d)", &mem3.aPool[j],
26927 fprintf(out, "\n");
26931 fprintf(out, "hash(%2d):", i);
26933 fprintf(out, " %p(%d)", &mem3.aPool[j],
26936 fprintf(out, "\n");
26938 fprintf(out, "key=%d\n", mem3.iKeyBlk);
26939 fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szKeyBlk*8);
26940 fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnKeyBlk*8);
26942 if( out==stdout ){
26945 fclose(out);
27064 #define CTRL_FREE 0x20 /* True if not checked out */
27107 ** Space for tracking which blocks are checked out and the size
27179 ** This only works for chunks that are currently checked out.
27509 FILE *out;
27514 out = stdout;
27516 out = fopen(zFilename, "w");
27517 if( out==0 ){
27527 fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
27529 fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc);
27530 fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc);
27531 fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess);
27532 fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut);
27533 fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
27534 fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut);
27535 fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount);
27536 fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest);
27538 if( out==stdout ){
27541 fclose(out);
29236 ** Return the amount of memory currently checked out.
29246 ** checked out since either the beginning of this process
29278 ** or else a crash results. Hence, do not attempt to optimize out the
29853 ** Call this routine to record the fact that an OOM (out-of-memory) error
29874 sqlite3ErrorMsg(db->pParse, "out of memory");
30190 /* pAccum never starts out with an empty buffer that was obtained from
30217 /* Find out what flags are present */
32650 u8 out[64]; /* Output bytes */
32663 static void chacha_block(u32 *out, const u32 *in){
32677 for(i=0; i<16; i++) out[i] = x[i]+in[i];
32740 memcpy(zBuf, &wsdPrng.out[wsdPrng.n-N], N);
32745 memcpy(zBuf, wsdPrng.out, wsdPrng.n);
32750 chacha_block((u32*)wsdPrng.out, wsdPrng.s);
33233 ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
33702 ** Helper function for sqlite3Error() - called rarely. Broken out into
36096 ** This object holds the kvvfs I/O methods which may be swapped out
36099 ** the compiler can hopefully optimize this level of indirection out.
37573 ** Helper function for printing out trace information from debugging
37591 ** Print out information about all locking operations.
39516 /* lock semaphore now but bail out when already locked. */
41506 /* Call fstat() to figure out the permissions on the database file. If
43339 ** other than ".." then back it out and return true. If the last
43400 /* If this is a "/.." directory component then back out the
44154 /* write it out to the temporary break file */
45267 ** Two of the file mapping APIs are different under WinRT. Figure out which
47333 /* out of memory */
47991 ** the file, and that might delete memory out from under existing cursors.
49197 /* Find out which shared locks are already held by sibling connections.
49754 /* caller will handle out of memory */
49775 /* caller will handle out of memory */
49843 /* Figure out the effective temporary directory. First, check if one
52323 ** i is out of range, then return false.
53050 /* Find a dirty page to write-out and recycle. First try to find a
53093 ** This routine is broken out into a separate function since it
54404 ** This steps are broken out into a separate procedure because they are
55164 /* Prevent unnecessary deep recursion when we run out of entries */
55589 ** content out of the database file.
55606 ** to print out file-descriptors.
56275 ** out code that would never execute.
57350 ** out from under us.
58269 ** (7) zero padding out to the next sector size.
58322 /* Figure out how many records are in the journal. Abort early if
58415 /* Copy original pages out of the journal and back into the
58518 ** Read the content for page pPg out of the database file (or out of
58642 ** updated as data is copied out of the rollback journal and into the
58969 /* Continue rolling back records out of the main journal starting at
58971 ** of the main journal file. Continue to skip out-of-range pages and
58999 ** previously rolled back out of the main journal (and are hence in pDone)
59472 ** be necessary to write the current content out to the sub-journal.
59635 /* Verify that the database file has not be deleted or renamed out from
59817 ** out-of-date data that follows it. Database corruption.
59912 ** written out.
59915 ** the pages are written out to the database file in list order. Writing
59921 ** If writing out a page causes the database file to grow, Pager.dbFileSize
59922 ** is updated accordingly. If page 1 is written out, then the value cached
59969 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
59982 /* Write out the page data. */
60108 ** out to the database file, if possible. This may involve syncing the
60175 /* Write the contents of the page out to the database file. */
60273 /* Figure out how much space is required for each journal file-handle
60514 ** database is the same as a temp-file that is never written out to
61709 ** before any of them can be written out to the database file.
61786 ** memory pressure forces page pPg out of the cache, the data does need
61787 ** to be written out to disk so that it may be read back in if the
62162 ** last page is never written out to disk, leaving the database file
62309 ** cache. So call pager_error() on the way out to make any error persistent.
62521 /* Figure out how many savepoints will still be active after this
62775 ** need to rollback later. Just move the page out of the way. */
63885 u8 padToSectorBoundary; /* Pad transactions out to the next sector */
64551 ** via the hash table. This turns out to be a really, really expensive
64942 ** Find the smallest page number out of all pages held in the WAL that
65380 ** Fsync is called on the WAL before writing content out of the WAL and
65841 ** writer truncated the WAL out from under it. If that happens, it
65938 /* Make sure some writer hasn't come in and changed the WAL file out
66000 ** appended to this wal file. Set rc to WAL_RETRY and break out of
66095 ** paged out or take a page-fault that is time-consuming to resolve,
66547 ** This condition filters out normal hash-table collisions.
66550 ** This condition filters out entries that were added to the hash
66896 ** Write out a single frame of the WAL
67059 ** an out-of-order write following a WAL restart could result in
67322 ** out of date. So zero the cached wal-index header to ensure that
67366 ** This function is called to change the WAL subsystem into or out
67373 ** transition out of exclusive-mode is successful, return 1. This
68261 BtShared *pBt; /* The tree being checked out */
68382 ** complex, but seldom used logic, out of sqlite3BtreeLock() and
68459 ** reset out from under us.
68826 /* Figure out the root-page that the lock should be held on. For table
69117 ** connection pointers get out-of-sync, it is possible for routines like
69373 ** need to be saved. It calls out to saveCursorsOnList() in the (unusual)
69391 ** broken out from its caller to avoid unnecessary stack pointer movement.
69500 ** Cursors can move when the row they are pointing at is deleted out
69531 ** a row having been deleted out from under the cursor).
71491 ** Clean out and delete the BtShared object.
71810 ** is returned if we run out of memory.
72764 ** the journal. Then the contents of the journal are flushed out to
72854 ** routine did all the work of writing information out to disk and flushing the
73271 ** to zero. But it turns out that the apPage[] and aiIdx[] arrays
73479 ** out to be wrong, fall back to loading the data of page
73563 ** or be scattered out on multiple overflow pages.
73593 unsigned char * const pBufStart = pBuf; /* Start of original out buffer */
74987 /* Value of k is out of range. Database corruption */
75413 ** overflow, then invoke cellClearOverflow to clear out that overflow.
76622 ** buffer. It will be copied out again as soon as the aSpace[] buffer
76777 ** Figure out the number of pages needed to hold all b.nCell cells.
76864 ** be so out of balance as to be illegal. For example, the right-most
77346 ** rebalance, that can change content out from under the cursor on the
77364 ** some way. This function figures out if this modification means the
77651 ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
78289 ** out to be an overflow page, delete all overflow page-map caches
78638 ** Read the meta-information out of a database file. Meta[0]
78648 ** of reading the value out of the header, it instead loads the "DataVersion"
79136 checkAppendMsg(pCheck, "Offset %d out of range %d..%d",
79149 /* Check for integer primary key out of range */
79152 checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey);
81124 ** If the double is out of range of a 64-bit signed integer then
81781 ** Move data out of a btree key or data field and into a Mem structure.
82693 ** If an out-of-memory error occurs while resizing the array, return
83011 ** Add an OP_ParseSchema opcode. This routine is broken out from
83448 ** to detect invalid escapes out of a subroutine. The OP_Halt opcode
84676 /* We are currently listing subprograms. Figure out which one and
84813 /* Figure out which opcode is next to display */
84914 ** by subcomponents of a prepared statement. Space is allocated out
85048 /* Figure out how much reusable memory is available at the end of the
86003 FILE *out = fopen("vdbe_profile.out", "a");
86004 if( out ){
86005 fprintf(out, "---- ");
86007 fprintf(out, "%02x", p->aOp[i].opcode);
86009 fprintf(out, "\n");
86012 fprintf(out, "-- ");
86014 if( pc=='\n' ) fprintf(out, "-- ");
86015 putc(c, out);
86018 if( pc!='\n' ) fprintf(out, "\n");
86027 fprintf(out, "%s", zHdr);
86028 sqlite3VdbePrintOp(out, i, &p->aOp[i]);
86030 fclose(out);
86162 ** carried out. Seek the cursor now. If an error occurs, return
86185 ** Something has moved cursor "p" out of place. Maybe the row it was
86186 ** pointed to was deleted out from under it. Or maybe the btree was
86188 ** is supposed to be pointing. If the row was deleted out from under the
86278 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
86394 ** the necessary byte swapping is carried out using a 64-bit integer
86431 ** The few cases that require local variables are broken out into a separate
86736 /* rc==0 here means that one of the keys ran out of fields and
87263 /* rc==0 here means that one or both of the keys ran out of fields and
89183 ** xFunc() then return that string. If N is out of range, return 0.
89331 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
89595 ** is out of range or if the wildcard is unnamed.
90158 StrAccum out; /* Accumulate the output here */
90164 sqlite3StrAccumInit(&out, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
90169 sqlite3_str_append(&out, "-- ", 3);
90171 sqlite3_str_append(&out, zStart, (int)(zRawSql-zStart));
90174 sqlite3_str_append(&out, zRawSql, sqlite3Strlen30(zRawSql));
90179 sqlite3_str_append(&out, zRawSql, n);
90205 sqlite3_str_append(&out, "NULL", 4);
90207 sqlite3_str_appendf(&out, "%lld", pVar->u.i);
90209 sqlite3_str_appendf(&out, "%!.15g", pVar->u.r);
90219 out.accError = SQLITE_NOMEM;
90220 out.nAlloc = 0;
90232 sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z);
90235 sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
90242 sqlite3_str_appendf(&out, "zeroblob(%d)", pVar->u.nZero);
90246 sqlite3_str_append(&out, "x'", 2);
90252 sqlite3_str_appendf(&out, "%02x", pVar->z[i]&0xff);
90254 sqlite3_str_append(&out, "'", 1);
90257 sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
90263 if( out.accError ) sqlite3_str_reset(&out);
90264 return sqlite3StrAccumFinish(&out);
90300 ** be changed out from under the copy. This macro verifies that nothing
90508 ** if we run out of memory.
91452 ** then back out all changes that have occurred during this execution of the
93715 ** out how much space is required for the new record. After this loop,
93760 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
94339 ** prepared queries. If such a query is out-of-date, we do not want to
95234 ** <li> If the cursor started out before the target row and a call to
95362 ** early, thus saving work. This is part of the IN-early-out optimization.
95460 ** is less than P4, attempt to find out if a match is possible by running
96194 ** This opcode is normally use to move a record out of the sorter and into
96473 ** correctly optimizing out sorts.
98047 ** If changing into or out of WAL mode the procedure is more complicated.
98100 (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
99143 ** the evaluator loop. So we can leave it out when NDEBUG is defined.
99209 /* This is the only way out of this procedure. We have to
99242 sqlite3VdbeError(p, "out of memory");
99653 /* Request is out of range. Return a transient error. */
100118 ** An instance of the following object is used to read records out of a
100169 ** keys from pMerger by the calling thread whenever the PmaReader runs out
100202 ** held in memory and prior to being written out as part of a PMA.
101568 /* Figure out whether or not the current contents of memory should be
104285 ** we have a match (cnt>0) or when we run out of name contexts.
104729 ** This allows them to be factored out of inner loops. */
105076 ** Generate an ORDER BY or GROUP BY term out-of-range error.
105081 int i, /* The index (1-based) of the term out of range */
105086 "%r %s BY term out of range - should be "
107238 /* Figure out where to write the new Expr structure. */
107984 ** when parsing an existing schema out of the sqlite_schema table and 4
108048 ** statements into a NULL when parsing the CREATE statement text out
108197 ** optimization, so we take the easy way out and simply require the
108735 pParse->nTab--; /* Back out the allocation of the unused cursor */
109297 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
110695 ** once. If no functions are involved, then factor the code out and put it at
110703 ** are factored out into the initialization section at the end of the
110763 ** VDBE program, in order to factor it out of the evaluation loop.
110850 ** factored out into initialization code.
110970 ** for clarity, but we are out of bits in the Expr.flags field so we
112536 /* figure out how many UTF-8 characters are in zName */
115221 ** be out of order. */
116499 /* Load new statistics out of the sqlite_stat1 table */
116821 zErrDyn = sqlite3MPrintf(db, "out of memory");
117121 ** checks out, these routines return 0.
117343 /* An attempt to read a column out of a subquery or other
117704 /* Code constant expressions that where factored out of inner loops.
121566 ** key out of the last column added to the table under construction.
121584 /* Figure out how many bytes of space are required to store explicitly
121936 ** point at most a single index (the newly added index) will be out of
122262 ** out of the way */
124034 /* Figure out if we have any triggers and if the table being
125065 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
127105 #if 0 /* Enable to print out how the built-in functions are hashed */
127385 ** unusable. Bail out early in this case. */
128748 ** which were then optimized out) then this routine becomes a no-op.
129365 /* Figure out if we have any triggers and if the table being
129506 /* Figure out how many columns of data are supplied. If the data
130160 /* Return the next index from the list. Return NULL when out of indexes */
130239 ** any ABORT Back out changes from the current command
130616 /* Figure out what action to take in case of a rowid collision */
130624 /* figure out whether or not upsert applies in this case */
130837 /* Find out what action to take in case there is a uniqueness conflict */
130849 /* Figure out if the upsert clause applies to this index */
133499 /* Common case: early out without every having to acquire a mutex */
135514 sqlite3ErrorMsg(db->pParse, "out of memory");
136921 /* Figure out the best index to use to search a pragma virtual table.
137501 /* Read the schema information out of the schema tables
137630 ** Check schema cookies in all databases. If any cookie is out
137806 if( db->mallocFailed ) sqlite3ErrorMsg(pParse, "out of memory");
137841 if( db->mallocFailed ) sqlite3ErrorMsg(&sParse, "out of memory");
138119 ** tricky bit is figuring out the pointer to return in *pzTail.
139307 int iBreak /* Jump here to break out of the inner loop */
139590 /* At first glance you would think we could optimize out the
139618 ** memory cells and break out of the scan loop.
139628 /* The LIMIT clause will jump out of the loop for us */
140888 /* Figure out how many elements of the compound SELECT are part of the
141506 ** store the results in the appropriate memory cell and break out
141513 /* The LIMIT clause will jump out of the loop for us */
141982 ** it will not be NULLed out. So instead, we insert an OP_IfNullRow opcode
143199 ** to filter out entire partitions, but not rows within partitions, as
143275 ** filter out entire partitions, as this does not change the
145425 ** changed to an OP_Noop once we figure out that the sorting index is
145448 /* Delete or NULL-out result columns that will never be used */
145594 ** on the grounds that the GROUP BY will cause elements to come out
145738 ** implement it. Allocate that sorting index now. If it turns out
145789 /* Rows are coming out in undetermined order. We have to push
146498 /* Figure out the db that the trigger will be created in */
146514 ** name on pTableName if we are reparsing out of the schema table
146842 ** Build a trigger step out of an INSERT statement. Return a pointer
147405 /* Figure out the ON CONFLICT policy that will be used for this step
148162 int labelBreak; /* Jump here to break out of UPDATE loop */
148205 /* Figure out if we have any triggers and if the table being
148448 ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be
149138 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
149628 ** to VACUUM are silently ignored. This is a back-out of a bug fix that
150396 ** created now instead of just being read out of sqlite_schema) then
151320 ** planner logic in "where.c". These definitions are broken out into
151383 int addrBrk; /* Jump here to break out of the loop */
151562 ** spread out over the non-negative integers. For example, the cursor
151679 WhereClause wc; /* The subexpression broken out */
151779 int iBreak; /* Jump here to break out of the loop */
152714 /* Figure out how many memory cells we will need then allocate them.
152989 ** pushed down to the cursor, this row is filtered out, causing
153259 int addrBrk; /* Jump here to break out of the loop */
153292 ** for the current loop. Jump to addrBrk to break out of a loop.
153382 ** the u.vtab.idxStr. NULL it out to prevent a use-after-free */
154054 WhereClause *pOrWc; /* The OR-clause broken out into subterms */
154712 ** This file was originally part of where.c but was split out to improve
156426 ** computations done by this routine are broken out into a separate
156695 ** out of a WHERE loop.
156958 ** It is factored out into a separate tail-recursion subroutine so that
157459 ** if they go out of sync.
157814 /* No matches cause a break out of the loop */
157834 sqlite3ErrorMsg(pParse, "out of memory");
159166 ** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the
159598 if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */
161288 ** terms are out of order, then block-sorting will reduce the
162461 ** This query optimization is factored out into a separate "no-inline"
164152 ** sub-select expression list. They are required to figure out where
165900 ** The text above leaves out many details. Refer to the code and comments
165956 /* Figure out when rows may be deleted from the ephemeral table. There
167675 int yyerrcnt; /* Shifts left before out of the error */
168754 ** Write into out a description of every state/lookahead combination that
168762 SQLITE_PRIVATE int sqlite3ParserCoverage(FILE *out){
168770 if( out ){
168771 fprintf(out,"State %d lookahead %s %s\n", stateno,
172674 /* This token started out using characters that can appear in keywords,
173036 ** separating it out, the code will be automatically omitted from
175026 /* SQLITE_NOMEM */ "out of memory",
175048 /* SQLITE_RANGE */ "column index out of range",
175404 goto out;
175419 out:
177830 /* sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out)
177833 ** -DYYCOVERAGE) writes a report onto "out" that shows all
177839 FILE *out = va_arg(ap, FILE*);
177840 if( sqlite3ParserCoverage(out) ) rc = SQLITE_ERROR;
178132 ** Return the name of the N-th database schema. Return NULL if N is out
178352 ** Return the N-th compile-time option string. If N is out of range,
178988 ** will eventually overtake the earlier data and knock it out. The
178989 ** query logic likewise merges doclists so that newer data knocks out
180877 ** + Figures out the number of columns the FTSX table will have, and
181158 /* Figure out the page-size for the database. This is required in order to
182627 ** calls out here. */
183058 ** routine to find out if it has reached the end of a result set.
186571 ** Enlarge a memory allocation. If an out-of-memory allocation occurs,
186590 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
186791 /* Turns out that wasn't a keyword after all. This happens if the
186833 ** interface. Before doing so, figure out if there is an explicit
186929 ** (out of memory error) or SQLITE_ERROR (parse error) is returned.
187174 /* If that was the last leaf node, break out of the loop */
187325 ** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse
188758 sqlite3_result_error(context, "out of memory", -1);
190099 ** the tree is assembled in memory and written out only once all leaves have
192171 /* Figure out how many bytes are required by this new entry */
192181 /* The current leaf node is full. Write it out to the database. */
192509 int bZero, /* Zero out anything following *ppList */
193721 /* Figure out if this is a leaf or an internal node. */
193760 /* Figure out how much space the key will consume if it is written to
193923 ** bytes, write this block out to the database. */
196486 ** Then break out of the loop. */
197219 ** one of the nSnippet snippet fragments, break out of the loop.
198377 u8 oom; /* Set to true if out of memory */
198424 /* Report an out-of-memory (OOM) condition
201611 ** node contents out to the database.
201810 ** If the node is dirty, write it out to the database.
204274 /* Figure out the rowid of the new row. */
204773 /* Figure out the node size to use. */
205147 rtreeCheckAppendMsg(pCheck, "Rtree depth out of range (%d)", iDepth);
205510 /* Parse out a number. Write the value into *pVal if pVal!=0.
206631 /* Figure out the node size to use. */
207244 ** out which elements of the R-Tree should be returned by the query.
208236 ** wrong moment they might get out of sync. As the main database will be
208243 ** not really clear how to get out of this state. The system could just
208571 ** not work out of the box with zipvfs. Refer to the comment describing
209506 /* Figure out the size of the output */
210143 /* Figure out the type of table this step will deal with. */
210859 /* Figure out the name of the primary key index for the current table.
215365 /* The pending byte page. Assume it is zeroed out. Attempting to
216885 /* Figure out how large an allocation is required */
218958 ** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
218986 ** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
219020 ** If value iVal is out-of-range or some other error occurs, an SQLite error
223144 int fts5yyerrcnt; /* Shifts left before out of the error */
223490 ** Write into out a description of every state/lookahead combination that
223498 static int sqlite3Fts5ParserCoverage(FILE *out){
223506 if( out ){
223507 fprintf(out,"State %d lookahead %s %s\n", stateno,
224950 /* Figure out the total size of the current row in tokens. */
225689 *pzErr = sqlite3_mprintf("prefix length out of range (max 999)");
227041 ** If in/out parameter (*pRc) is set to other than SQLITE_OK when this
227231 ** phrase is not a match, break out of the loop early. */
229715 /* Figure out how much space to allocate */
232316 /* Figure out how many new bytes are in this term */
233803 ** writes it out to disk. Or, if it is too small to bother with, discards
233963 /* Write the page out to disk */
234750 /* Figure out if this structure requires optimization. A structure does
234988 Fts5Buffer out;
234991 memset(&out, 0, sizeof(out));
234993 sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n);
235001 fts5BufferSafeAppendVarint(&out, iRowid1 - iOut);
235006 fts5BufferSafeAppendVarint(&out, iRowid2 - iOut);
235015 fts5BufferSwap(&out, p1);
235016 fts5BufferFree(&out);
235074 Fts5Buffer out = {0, 0, 0};
235105 if( sqlite3Fts5BufferSize(&p->rc, &out, nOut) ) return;
235108 fts5MergeAppendDocid(&out, iLastRowid, pHead->iter.iRowid);
235173 fts5BufferSafeAppendVarint(&out, (tmp.n+nTail) * 2);
235174 fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
235176 fts5BufferSafeAppendBlob(&out, &pHead->aPos[pHead->iOff], nTail);
235192 fts5BufferSafeAppendBlob(&out, pI->aPoslist, pI->nPoslist+pI->nSize);
235201 memset(&out.p[out.n], 0, FTS5_DATA_ZERO_PADDING);
235202 *p1 = out;
235577 /* Figure out which index to search and set iIdx accordingly. If this
236629 /* Figure out where the doclist for this term ends */
238224 ** routine to find out if it has reached the end of a result set.
238502 /* Filter out attempts to run UPDATE or DELETE on contentless tables.
241396 ** a separator character. Or break out of the loop if it is not. */
241433 ** it is a token character, or break out of the loop if it is not. */
244137 ** routine to find out if it has reached the end of a result set.