Lines Matching defs:out
285 ** that we have taken it all out and gone back to using simple
377 ** returning the N-th compile time option string. ^If N is out of range,
551 ** coming out of the evaluated SQL statements. ^The 4th argument to
644 #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */
1648 ** memory allocator that simulates memory out-of-memory conditions in
3194 sqlite3 **ppDb /* OUT: SQLite db handle */
3198 sqlite3 **ppDb /* OUT: SQLite db handle */
3202 sqlite3 **ppDb, /* OUT: SQLite db handle */
3520 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3521 const char **pzTail /* OUT: Pointer to unused portion of zSql */
3527 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3528 const char **pzTail /* OUT: Pointer to unused portion of zSql */
3534 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3535 const void **pzTail /* OUT: Pointer to unused portion of zSql */
3541 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3542 const void **pzTail /* OUT: Pointer to unused portion of zSql */
3765 ** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails.
3822 ** ^If the value N is out of range or if the N-th parameter is
4137 ** column index is out of range, the result is undefined.
4618 ** allocates N of memory, zeroes out that memory, and returns a pointer
5231 ** find out whether SQLite automatically rolled back the transaction after
6627 ** ^The sqlite3_test_control() interface is used to read out internal
6722 ** <dd>This parameter is the current amount of memory checked out
6740 ** currently checked out.</dd>)^
6743 ** <dd>This parameter returns the number of pages used out of the
6765 ** <dd>This parameter returns the number of allocations used out of the
6847 ** checked out.</dd>)^
7374 ** ^If an out-of-memory condition or IO error occurred during any prior
7799 int *pnLog, /* OUT: Size of WAL log in frames */
7800 int *pnCkpt /* OUT: Total number of frames checkpointed */
7977 ** Loops are numbered starting from zero. ^If idx is out of range - less than
8118 int eWithin; /* OUT: Visiblity */
8119 sqlite3_rtree_dbl rScore; /* OUT: Write the score here */
9060 ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
9574 ** not, there are still machines out there that use EBCDIC.)
11218 ** Figure out if we are dealing with Unix, Windows, or some other operating
11291 ** anybody smart enough to figure out the code is also likely smart
11331 ** byte out of a specific range of bytes. The lock byte is obtained at
11345 ** But a single Win95 reader will lock out all WinNT readers and a single
11346 ** WinNT reader will lock out all other Win95 readers.
11460 ** to all source files. We break it out in an effort to keep the code
11470 ** Figure out what version of the code to use. The choices are
11582 ** have been filled out. If the schema changes, these column names might
11619 int nOut; /* Number of buffers currently checked out */
12233 #define TF_OOOHidden 0x80 /* Out-of-Order hidden columns */
12238 ** done as a macro so that it will be optimized out when virtual
12303 ** fails and any prior changes from that one operation are backed out,
12306 ** changes due to the same operation are not backed out and no rollback
12325 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
12359 ** single index record that has already been parsed out into individual
12485 ** Each token coming out of the lexer is an instance of
12831 ** The jointype starts out showing the join type between the current table
13217 u8 okConstFactor; /* OK to factor out constants */
13227 int iFixedOp; /* Never back out opcodes iFixedOp-1 or earlier */
13956 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
15215 ** Return the N-th compile-time option string. If N is out of range,
15262 ** this header information was factored out.
15340 ** the cache is out of date.
16560 int *pRc /* OUT: Error code. SQLITE_OK or ERROR */
17377 void volatile **pp /* OUT: Pointer to mapping */
17644 ** is completely recoverable simply by not carrying out the resize. The
18549 FILE *out;
18553 out = fopen(zFilename, "w");
18554 if( out==0 ){
18562 fprintf(out, "**** %lld bytes at %p from %s ****\n",
18565 fflush(out);
18568 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
18569 fprintf(out, "\n");
18572 fprintf(out, "COUNTS:\n");
18575 fprintf(out, " %5d: %10d %10d %10d\n",
18580 fprintf(out, " %5d: %10d %10d %10d\n",
18584 fclose(out);
18656 ** A chunk is two or more blocks that is either checked out or
18659 ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
18661 ** is true if the previous chunk is checked out and false if the
18664 ** freelist. If the previous chunk is checked out, then
18680 ** out. If a chunk is checked out, the user data may extend into
18712 ** True if we are evaluating an out-of-memory callback.
18852 ** size parameters for check-out and return a pointer to the
18974 ** successful most of the time (about 9 times out of 10).
19078 ** works for chunks that are currently checked out.
19104 assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */
19194 FILE *out;
19198 out = stdout;
19200 out = fopen(zFilename, "w");
19201 if( out==0 ){
19208 fprintf(out, "CHUNKS:\n");
19212 fprintf(out, "%p size error\n", &mem3.aPool[i]);
19217 fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
19222 fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
19227 fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
19229 fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
19235 fprintf(out, "small(%2d):", i);
19237 fprintf(out, " %p(%d)", &mem3.aPool[j],
19240 fprintf(out, "\n");
19244 fprintf(out, "hash(%2d):", i);
19246 fprintf(out, " %p(%d)", &mem3.aPool[j],
19249 fprintf(out, "\n");
19251 fprintf(out, "master=%d\n", mem3.iMaster);
19252 fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8);
19253 fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8);
19255 if( out==stdout ){
19258 fclose(out);
19377 #define CTRL_FREE 0x20 /* True if not checked out */
19418 ** Space for tracking which blocks are checked out and the size
19493 ** works for chunks that are currently checked out.
19813 FILE *out;
19818 out = stdout;
19820 out = fopen(zFilename, "w");
19821 if( out==0 ){
19831 fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
19833 fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc);
19834 fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc);
19835 fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess);
19836 fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut);
19837 fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
19838 fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut);
19839 fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount);
19840 fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest);
19842 if( out==stdout ){
19845 fclose(out);
20735 ** It uses the RDTSC opcode to read the cycle count value out of the
21532 ** Return the amount of memory currently checked out.
21542 ** checked out since either the beginning of this process
22351 /* Find out what flags are present */
23820 SQLiteThread **ppThread, /* OUT: Write the thread object here */
23915 SQLiteThread **ppThread, /* OUT: Write the thread object here */
23995 SQLiteThread **ppThread, /* OUT: Write the thread object here */
24237 ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
25081 ** case is broken out because while 9223372036854775808 cannot be a
26756 ** It uses the RDTSC opcode to read the cycle count value out of the
27268 ** Helper function for printing out trace information from debugging
27286 ** Print out information about all locking operations.
27379 /* At one point this code was not commented out. In theory, this branch
27387 ** propagated back to the caller. Commenting this branch out means errno==0
29166 /* lock semaphore now but bail out when already locked. */
29879 int *piErrno /* OUT: Error number if error occurs */
30911 /* Call fstat() to figure out the permissions on the database file. If
31037 void volatile **pp /* OUT: Mapped memory */
31222 /* Find out which shared locks are already held by sibling connections.
32219 mode_t *pMode, /* OUT: Permissions to open file with */
32220 uid_t *pUid, /* OUT: uid to set on the file */
32221 gid_t *pGid /* OUT: gid to set on the file */
33312 /* write it out to the temporary break file */
34276 ** It uses the RDTSC opcode to read the cycle count value out of the
34565 ** Two of the file mapping APIs are different under WinRT. Figure out which
36439 /* out of memory */
38177 /* Find out which shared locks are already held by sibling connections.
38270 void volatile **pp /* OUT: Mapped memory */
38681 /* caller will handle out of memory */
38702 /* caller will handle out of memory */
38757 /* Figure out the effective temporary directory. First, check if one
39392 int *pResOut /* OUT: Result */
40158 ** i is out of range, then return false.
40719 /* Find a dirty page to write-out and recycle. First try to find a
40755 ** This routine is broken out into a separate function since it
41942 ** This steps are broken out into a separate procedure because they are
42337 int *pnCurrent, /* OUT: Total number of pages cached */
42338 int *pnMax, /* OUT: Global maximum cache size */
42339 int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */
42340 int *pnRecyclable /* OUT: Total number of pages available for recycling */
42998 int *pnLog, /* OUT: Number of frames in WAL */
42999 int *pnCkpt /* OUT: Number of backfilled frames in WAL */
43116 ** content out of the database file.
43133 ** to print out file-descriptors.
43784 ** out code that would never execute.
44507 u32 *pNRec, /* OUT: Value read from the nRec field */
44508 u32 *pDbSize /* OUT: Value of original database size field */
44788 ** out from under us.
45366 ** as clean, since there will be no need to write it out to the
45378 ** be written out into the database file before its journal file
45656 ** (7) zero padding out to the next sector size.
45708 /* Figure out how many records are in the journal. Abort early if
45798 /* Copy original pages out of the journal and back into the
45894 ** Read the content for page pPg out of the database file and into
46017 ** updated as data is copied out of the rollback journal and into the
46347 /* Continue rolling back records out of the main journal starting at
46349 ** of the main journal file. Continue to skip out-of-range pages and
46377 ** previously rolled back out of the main journal (and are hence in pDone)
46378 ** will be skipped. Out-of-range pages are also skipped.
46825 ** be necessary to write the current content out to the sub-journal
46918 PgHdr **ppPage /* OUT: Acquired page object */
47127 ** out-of-date data that follows it. Database corruption.
47222 ** written out.
47225 ** the pages are written out to the database file in list order. Writing
47231 ** If writing out a page causes the database file to grow, Pager.dbFileSize
47232 ** is updated accordingly. If page 1 is written out, then the value cached
47278 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
47291 /* Write out the page data. */
47409 ** out to the database file, if possible. This may involve syncing the
47468 /* Write the contents of the page out to the database file. */
47517 Pager **ppPager, /* OUT: Return the Pager structure here */
47539 /* Figure out how much space is required for each journal file-handle
47715 ** database is the same as a temp-file that is never written out to
47811 /* Verify that the database file has not be deleted or renamed out from
48871 ** before any of them can be written out to the database file.
49258 ** last page is never written out to disk, leaving the database file
49404 ** cache. So call pager_error() on the way out to make any error persistent.
49604 /* Figure out how many savepoints will still be active after this
49829 ** need to rollback later. Just move the page out of the way. */
50206 int *pbOpen /* OUT: Set to true if call is a no-op */
50729 u8 padToSectorBoundary; /* Pad transactions out to the next sector */
50900 u32 *aOut /* OUT: Final checksum value output */
50975 u8 *aFrame /* OUT: Write encoded frame here */
50999 u32 *piPage, /* OUT: Database page number for frame */
51000 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
51142 volatile ht_slot **paHash, /* OUT: Pointer to hash index */
51143 volatile u32 **paPgno, /* OUT: Pointer to page number array */
51144 u32 *piZero /* OUT: Frame associated with *paPgno[0] */
51331 ** via the hash table. This turns out to be a really, really expensive
51561 Wal **ppWal /* OUT: Allocated Wal handle */
51630 ** Find the smallest page number out of all pages held in the WAL that
51641 u32 *piPage, /* OUT: The page number of the next page */
51642 u32 *piFrame /* OUT: Wal frame index of next page */
51696 ht_slot **paRight, /* IN/OUT: Right hand input list */
51697 int *pnRight, /* IN/OUT: Elements in *paRight */
51752 ht_slot *aList, /* IN/OUT: List to sort */
51753 int *pnList /* IN/OUT: Number of elements in aList[] */
51977 ** Fsync is called on the WAL before writing content out of the WAL and
52460 ** paged out or take a page-fault that is time-consuming to resolve,
52686 u32 *piRead /* OUT: Frame number (or zero) */
52726 ** This condition filters out normal hash-table collisions.
52729 ** This condition filters out entries that were added to the hash
53061 ** Write out a single frame of the WAL
53160 ** an out-of-order write following a WAL restart could result in
53290 int *pnLog, /* OUT: Number of frames in WAL */
53291 int *pnCkpt /* OUT: Number of backfilled frames in WAL */
53370 ** out of date. So zero the cached wal-index header to ensure that
53400 ** This function is called to change the WAL subsystem into or out
53407 ** transition out of exclusive-mode is successful, return 1. This
54178 BtShared *pBt; /* The tree being checked out */
54299 ** complex, but seldom used logic, out of sqlite3BtreeLock() and
54391 ** reset out from under us.
54672 /* Figure out the root-page that the lock should be held on. For table
55192 ** need to be saved. It calls out to saveCursorsOnList() in the (unusual)
55210 ** broken out from its caller to avoid unnecessary stack pointer movement.
55319 ** Cursors can move when the row they are pointing at is deleted out
55335 ** a row having been deleted out from under the cursor).
57014 ** Clean out and delete the BtShared object.
57294 ** is returned if we run out of memory.
58171 ** the journal. Then the contents of the journal are flushed out to
58261 ** routine did all the work of writing information out to disk and flushing the
58642 ** to zero. But it turns out that the apPage[] and aiIdx[] arrays
58790 MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */
58791 Pgno *pPgnoNext /* OUT: Next overflow page number */
58804 ** out to be wrong, fall back to loading the data of page
58889 ** or be scattered out on multiple overflow pages.
60090 /* Value of k is out of range. Database corruption */
60985 u8 **ppData, /* IN/OUT: Page content -area pointer */
61565 ** buffer. It will be copied out again as soon as the aSpace[] buffer
61719 ** Figure out the number of pages needed to hold all b.nCell cells.
61796 ** be so out of balance as to be illegal. For example, the right-most
62263 ** some way. This function figures out if this modification means the
62448 ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
62751 ** out to be an overflow page, delete all overflow page-map caches
63114 ** Read the meta-information out of a database file. Meta[0]
63124 ** of reading the value out of the header, it instead loads the "DataVersion"
63612 checkAppendMsg(pCheck, "Offset %d out of range %d..%d",
63625 /* Check for integer primary key out of range */
63628 checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey);
64249 sqlite3ErrorWithMsg(pErrorDb, SQLITE_NOMEM, "out of memory");
65379 ** If the double is out of range of a 64-bit signed integer then
65899 ** Move data out
65919 Mem *pMem /* OUT: Return data in this Mem structure. */
65945 Mem *pMem /* OUT: Return data in this Mem structure. */
66454 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
66526 UnpackedRecord **ppRec, /* IN/OUT: Probe record */
66530 int *pbOk /* OUT: True if value was extracted */
66561 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
66579 sqlite3_value **ppVal /* OUT: Extracted value */
66782 ** If an out-of-memory error occurs while resizing the array, return
66975 ** Add an OP_ParseSchema opcode. This routine is broken out from
68148 /* We are currently listing subprograms. Figure out which one and
68322 u8 **ppFrom, /* IN/OUT: Allocate from *ppFrom */
69364 FILE *out = fopen("vdbe_profile.out", "a");
69365 if( out ){
69367 fprintf(out, "---- ");
69369 fprintf(out, "%02x", p->aOp[i].opcode);
69371 fprintf(out, "\n");
69374 fprintf(out, "-- ");
69376 if( pc=='\n' ) fprintf(out, "-- ");
69377 putc(c, out);
69380 if( pc!='\n' ) fprintf(out, "\n");
69389 fprintf(out, "%s", zHdr);
69390 sqlite3VdbePrintOp(out, i, &p->aOp[i]);
69392 fclose(out);
69508 ** carried out. Seek the cursor now. If an error occurs, return
69530 ** Something has moved cursor "p" out of place. Maybe the row it was
69531 ** pointed to was deleted out from under it. Or maybe the btree was
69533 ** is supposed to be pointing. If the row was deleted out from under the
69564 ** deleted out from under the cursor and if it has, mark the row as
69568 ** not been deleted out from under the cursor, then this routine is a no-op.
69633 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
69709 ** the necessary byte swapping is carried out using a 64-bit integer
69797 ** The few cases that require local variables are broken out into a separate
69936 char **ppFree /* OUT: Caller should free this pointer */
70093 /* rc==0 here means that one of the keys ran out of fields and
70521 /* rc==0 here means that one or both of the keys ran out of fields and
72005 ** xFunc() then return that string. If N is out of range, return 0.
72156 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
72400 ** is out of range or if the wildcard is unnamed.
72557 void *pOut /* OUT: Write the answer here */
72702 StrAccum out; /* Accumulate the output here */
72706 sqlite3StrAccumInit(&out, db, zBase, sizeof(zBase),
72712 sqlite3StrAccumAppend(&out, "-- ", 3);
72714 sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
72717 sqlite3StrAccumAppend(&out, zRawSql, sqlite3Strlen30(zRawSql));
72722 sqlite3StrAccumAppend(&out, zRawSql, n);
72748 sqlite3StrAccumAppend(&out, "NULL", 4);
72750 sqlite3XPrintf(&out, 0, "%lld", pVar->u.i);
72752 sqlite3XPrintf(&out, 0, "%!.15g", pVar->u.r);
72773 sqlite3XPrintf(&out, 0, "'%.*q'", nOut, pVar->z);
72776 sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
72783 sqlite3XPrintf(&out, 0, "zeroblob(%d)", pVar->u.nZero);
72787 sqlite3StrAccumAppend(&out, "x'", 2);
72793 sqlite3XPrintf(&out, 0, "%02x", pVar->z[i]&0xff);
72795 sqlite3StrAccumAppend(&out, "'", 1);
72798 sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
72804 return sqlite3StrAccumFinish(&out);
72840 ** be changed out from under the copy. This macro verifies that nothing
72982 ** if we run out of memory.
73326 ** It uses the RDTSC opcode to read the cycle count value out of the
73799 ** then back out all changes that have occurred during this execution of the
74341 char bIntint; /* Started out as two integer operands */
75595 ** out how much space is required for the new record.
76042 ** prepared queries. If such a query is out-of-date, we do not want to
77295 ** This opcode is normally use to move a record out of the sorter and into
77522 ** correctly optimizing out sorts.
77807 ** out from under the cursor. That will never happend for an IdxRowid
78834 ** If changing into or out of WAL mode the procedure is more complicated.
78886 (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
79514 ** the evaluator loop. So we can leave it out when NDEBUG is defined.
79549 /* This is the only way out of this procedure. We have to
79571 sqlite3VdbeError(p, "out of memory");
79982 /* Request is out of range. Return a transient error. */
80420 ** An instance of the following object is used to read records out of a
80471 ** keys from pMerger by the calling thread whenever the PmaReader runs out
80504 ** held in memory and prior to being written out as part of a PMA.
80567 u8 **ppOut /* OUT: Pointer to buffer containing data */
80807 i64 *pnByte /* IN/OUT: Increment this value by PMA size */
80854 ** If IN/OUT parameter *pbKey2Cached is true when this function is called,
81418 SorterRecord **ppOut /* OUT: Head of merged list */
81853 /* Figure out whether or not the current contents of memory should be
82361 i64 *piOffset, /* IN/OUT: Readr offset in pTask->file */
82362 MergeEngine **ppOut /* OUT: New merge-engine */
82715 int *pnKey /* OUT: Size of current key in bytes */
82775 int *pRes /* OUT: Result of comparison */
83899 ** we have a match (cnt>0) or when we run out of name contexts.
84360 ** Generate an ORDER BY or GROUP BY term out-of-range error.
84365 int i, /* The index (1-based) of the term out of range */
84369 "%r %s BY term out of range - should be "
85845 /* Figure out where to write the new Expr structure. */
86322 ** statements into a NULL when parsing the CREATE statement text out
87081 /* Figure out the affinity to use to create a key from the results
88191 ** Factor out the code of the given expression to initialization time.
88223 ** VDBE program, in order to factor it out of the evaluation loop.
88326 ** factored out into initialization code.
89247 /* Ran out of input before finding an opening bracket. Return NULL. */
89371 /* Ran out of input before finding the table name. Return NULL. */
89685 /* figure out how many UTF-8 characters are in zName */
90625 ** be out of order. */
91878 /* Load new statistics out of the sqlite_stat1 table */
92148 zErrDyn = sqlite3MPrintf(db, "out of memory");
92372 ** checks out, these routines return 0.
92658 /* An attempt to read a column out of a subquery or other
92980 /* Code constant expressions that where factored out of inner loops */
95838 ** key out of the last column added to the table under construction.
95854 /* Figure out how many bytes of space are required to store explicitly
96436 ** out of the way */
97950 /* Figure out if we have any triggers and if the table being
98512 int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */
98871 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
100558 Index **ppIdx, /* OUT: Unique index on parent table */
100559 int **paiCol /* OUT: Map of index columns in pFKey */
100630 ** unusable. Bail out early in this case. */
102315 /* Figure out if we have any triggers and if the table being
102426 /* Figure out how many columns of data are supplied. If the data
102896 ** any ABORT Back out changes from the current command
102936 int *pbMayReplace /* OUT: Set to true if constraint may cause a replace */
103057 /* Figure out
103226 /* Find out what action to take in case there is a uniqueness conflict */
105318 /* Common case: early out without every having to acquire a mutex */
107222 addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
107276 addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
108062 /* Read the schema information out of the schema tables
108193 ** Check schema cookies in all databases. If any cookie is out
108291 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
108292 const char **pzTail /* OUT: End of parsed string */
108451 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
108452 const char **pzTail /* OUT: End of parsed string */
108525 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
108526 const char **pzTail /* OUT: End of parsed string */
108537 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
108538 OUT: End of parsed string */
108556 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
108557 const void **pzTail /* OUT: End of parsed string */
108561 ** tricky bit is figuring out the pointer to return in *pzTail.
108613 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
108614 const void **pzTail /* OUT: End of parsed string */
108625 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
108626 const void **pzTail /* OUT: End of parsed string */
108949 Expr **ppWhere /* IN/OUT: The WHERE clause to add to */
109309 int iBreak /* Jump here to break out of the inner loop */
109504 /* At first glance you would think we could optimize out the
109528 ** store the results in the appropriate memory cell and break out
109537 /* The LIMIT clause will jump out of the loop for us */
111269 ** store the results in the appropriate memory cell and break out
111275 /* The LIMIT clause will jump out of the loop for us */
112614 With **ppContext /* OUT: WITH clause return value belongs to */
113684 ** changed to an OP_Noop once we figure out that the sorting index is
113804 ** on the grounds that the GROUP BY will cause elements to come out
113858 ** implement it. Allocate that sorting index now. If it turns out
113903 /* Rows are coming out in undetermined order. We have to push
114146 ** add vdbe code to break out of the processing loop after the
114573 /* Figure out the db that the trigger will be created in */
114589 ** name on pTableName if we are reparsing out of SQLITE_MASTER.
114846 ** Build a trigger step out of an INSERT statement. Return a pointer
115100 int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
115169 /* Figure out the ON CONFLICT policy that will be used for this step
115703 int labelBreak; /* Jump here to break out of UPDATE loop */
115738 /* Figure out if we have any triggers and if the table being
116344 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
117148 ** created now instead of just being read out of sqlite_master) then
118018 ** planner logic in "where.c". These definitions are broken out into
118070 int addrBrk; /* Jump here to break out of the loop */
118236 ** spread out over the non-negative integers. For example, the cursor
118343 WhereClause wc; /* The subexpression broken out */
118425 int iBreak; /* Jump here to break out of the loop */
118989 char **pzAff /* OUT: Set to point to affinity string */
119010 /* Figure out how many memory cells we will need then allocate them.
119134 int addrBrk; /* Jump here to break out of the loop */
119154 ** for the current loop. Jump to addrBrk to break out of a loop.
119671 WhereClause *pOrWc; /* The OR-clause broken out into subterms */
120050 ** This file was originally part of where.c but was split out to improve
121439 ** out of a WHERE loop.
122063 ** if they go out of sync.
122235 sqlite3ErrorMsg(pParse, "out of memory");
122357 tRowcnt *aStat /* OUT: stats written here */
123465 ** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the
123714 if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */
124523 Bitmask *pRevMask /* OUT: Mask of WhereLoops to run in reverse order */
124822 ** terms are out of order, then block-sorting will reduce the
126088 /* This routine constructs a binary expression node out of two ExprSpan
126309 ** If the index value yy_shift_ofst[S]+X is out of range or if the value
126890 int yyerrcnt; /* Shifts left before out of the error */
130438 ** separating it out, the code will be automatically omitted from
132148 /* SQLITE_NOMEM */ "out of memory",
132162 /* SQLITE_MISUSE */ "library routine called out of sequence",
132166 /* SQLITE_RANGE */ "bind or column index out of range",
132479 goto out;
132491 out:
132777 int *pnLog, /* OUT: Size of WAL log in frames */
132778 int *pnCkpt /* OUT: Total number of frames checkpointed */
133235 unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */
133236 sqlite3_vfs **ppVfs, /* OUT: VFS to use */
133237 char **pzFile, /* OUT: Filename component of URI */
133238 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
133461 sqlite3 **ppDb, /* OUT: Returned database handle */
133779 sqlite3 **ppDb, /* OUT: SQLite db handle */
135243 ** will eventually overtake the earlier data and knock it out. The
135244 ** query logic likewise merges doclists so that newer data knocks out
135368 sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */
135385 sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */
135397 ** "OUT" variables identified below, or SQLITE_DONE to indicate that
135420 const char **ppToken, int *pnBytes, /* OUT: Normalized text for token */
135421 int *piStartOffset, /* OUT: Byte offset of token in input buffer */
135422 int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */
135423 int *piPosition /* OUT: Number of tokens returned before this one */
136617 int *pRc, /* IN/OUT: Error code */
136618 char **pz, /* IN/OUT: Pointer to string buffer */
136820 int *pnIndex, /* OUT: size of *apIndex[] array */
136821 struct Fts3Index **apIndex /* OUT: Array of indexes for this table */
136891 const char ***pazCol, /* OUT: Malloc'd array of column names */
136892 int *pnCol, /* OUT: Size of array *pazCol */
136893 int *pnStr, /* OUT
136894 char **pzErr /* OUT: error message */
137026 ** + Figures out the number of columns the FTSX table will have, and
137304 /* Figure out the page-size for the database. This is required in order to
137344 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
137345 char **pzErr /* OUT: sqlite3_malloc'd error message */
137354 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
137355 char **pzErr /* OUT: sqlite3_malloc'd error message */
137633 sqlite3_int64 *piFirst, /* OUT: Selected child node */
137634 sqlite3_int64 *piLast /* OUT: Selected child node */
137798 char **pp, /* IN/OUT: Output pointer */
137799 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
137914 char **pp, /* IN/OUT: Pointer into position-list buffer */
137915 sqlite3_int64 *pi /* IN/OUT: Value read from position-list */
138043 char **pp, /* IN/OUT: Preallocated output buffer */
138047 char **pp1, /* IN/OUT: Left input list */
138048 char **pp2 /* IN/OUT: Right input list */
138171 char **pp1, /* IN/OUT: Left input list */
138172 char **pp2 /* IN/OUT: Right input list */
138225 char **pp, /* IN/OUT: Point to read varint from */
138228 sqlite3_int64 *pVal /* IN/OUT: Integer value */
138259 char **pp, /* IN/OUT: Output pointer */
138261 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
138262 int *pbFirst, /* IN/OUT: True after first int written */
138308 char **paOut, int *pnOut /* OUT: Malloc'd doclist */
138400 char **paRight, int *pnRight /* IN/OUT: Right/output doclist */
138690 ** calls out here. */
138806 Fts3MultiSegReader **ppSegcsr /* OUT: Allocated seg-reader cursor */
138871 int *pnOut, /* OUT: Size of buffer at *ppOut */
138872 char **ppOut /* OUT: Malloced result buffer */
139126 ** routine to find out if it has reached the end of a result set.
139209 sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */
139385 Fts3Cursor **ppCsr /* OUT: Store cursor handle here */
139531 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
139838 int *pnToken, /* OUT: Total number of tokens in phrase. */
139839 int *pnOr, /* OUT: Total number of OR nodes in expr. */
139840 int *pRc /* IN/OUT: Error code */
140150 char **ppIter, /* IN/OUT: Iterator pointer */
140151 sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */
140152 int *pnList, /* OUT: List length pointer */
140153 u8 *pbEof /* OUT: End-of-file flag */
140206 char **ppIter, /* IN/OUT: Iterator pointer */
140207 sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */
140208 u8 *pbEof /* OUT: End-of-file flag */
140306 TokenDoclist *p, /* OUT: Docid and doclist for new entry */
140307 u8 *pbEof /* OUT: True if iterator is at EOF */
140357 u8 *pbEof /* OUT: Set to 1 if EOF */
140457 u8 *pbEof /* OUT: Set to 1 if EOF */
140496 int *pRc /* IN/OUT: Error code */
140552 int *pRc /* IN/OUT: Error code */
140878 char **paPoslist, /* IN/OUT: Position list */
140879 int *pnToken, /* IN/OUT: Tokens in phrase of *paPoslist */
140952 int *pRc /* IN/OUT: Error code */
141179 int *pRc /* IN/OUT: Error code */
141607 char **ppOut /* OUT: Pointer to position list */
141842 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
141843 char **pzErr /* OUT: sqlite3_malloc'd error message */
142287 sqlite_int64 *pRowid /* OUT: Rowid value */
142513 Fts3Expr **ppExpr, /* OUT: expression */
142514 int *pnConsumed /* OUT: Number of bytes consumed */
142585 ** Enlarge a memory allocation. If an out-of-memory allocation occurs,
142604 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
142611 Fts3Expr **ppExpr /* OUT: expression */
142729 Fts3Expr **ppExpr, /* OUT: expression */
142730 int *pnConsumed /* OUT: Number of bytes consumed */
142808 /* Turns out that wasn't a keyword after all. This happens if the
142846 ** interface. Before doing so, figure out if there is an explicit
142942 ** (out of memory error) or SQLITE_ERROR (parse error) is returned.
142947 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
142948 int *pnConsumed /* OUT: Number of bytes consumed */
143187 /* If that was the last leaf node, break out of the loop */
143301 Fts3Expr **ppExpr /* OUT: Parsed query structure */
143338 ** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse
143364 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
143365 char **pzErr /* OUT: Error message (sqlite3_malloc) */
144123 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
144627 const char **pzToken, /* OUT: *pzToken is the token text */
144628 int *pnBytes, /* OUT: Number of bytes in token */
144629 int *piStartOffset, /* OUT: Starting offset of token */
144630 int *piEndOffset, /* OUT: Ending offset of token */
144631 int *piPosition /* OUT: Position integer of token */
144775 sqlite3_result_error(context, "out of memory", -1);
144847 sqlite3_tokenizer **ppTok, /* OUT: Tokenizer (if applicable) */
144848 char **pzErr /* OUT: Set to malloced error message */
145309 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
145352 const char **ppToken, /* OUT: *ppToken is the token text */
145353 int *pnBytes, /* OUT: Number of bytes in token */
145354 int *piStartOffset, /* OUT: Starting offset of token */
145355 int *piEndOffset, /* OUT: Ending offset of token */
145356 int *piPosition /* OUT: Position integer of token */
145593 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
145594 char **pzErr /* OUT: sqlite3_malloc'd error message */
145841 sqlite_int64 *pRowid /* OUT: Rowid value */
146099 ** the tree is assembled in memory and written out only once all leaves have
146177 sqlite3_stmt **pp, /* OUT: Statement handle */
146317 sqlite3_stmt **ppStmt /* OUT: Statement handle */
146341 sqlite3_stmt **ppStmt /* OUT: Statement handle */
146363 sqlite3_stmt **ppStmt /* OUT: Statement handle */
146484 sqlite3_stmt **ppStmt /* OUT: Compiled statement */
146527 PendingList **pp, /* IN/OUT: Pointer to PendingList struct */
146571 PendingList **pp, /* IN/OUT: PendingList structure */
146575 int *pRc /* OUT: Return code */
146675 u32 *pnWord /* IN/OUT: Incr. by number tokens inserted */
146840 sqlite3_int64 *piDocid /* OUT: Docid for row just inserted */
146951 int *pbFound /* OUT: Set to true if row really does exist */
147082 char **paBlob, /* OUT: Blob data in malloc'd buffer */
147083 int *pnBlob, /* OUT: Size of blob data */
147084 int *pnLoad /* OUT: Bytes actually loaded */
147339 char **ppOffsetList, /* OUT: Pointer to current position-list */
147340 int *pnOffsetList /* OUT: Length of *ppOffsetList in bytes */
147487 Fts3SegReader **ppReader /* OUT: Allocated Fts3SegReader */
147569 Fts3SegReader **ppReader /* OUT: SegReader for pending-terms */
147882 SegmentNode **ppTree, /* IN/OUT: SegmentNode handle */
148023 sqlite3_int64 *piLast, /* OUT: Block id of last entry written */
148024 char **paRoot, /* OUT: Data for root node */
148025 int *pnRoot /* OUT: Size of root node in bytes */
148088 SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */
148131 /* Figure out how many bytes are required by this new entry */
148141 /* The current leaf node is full. Write it out to the database. */
148465 int bZero, /* Zero out anything following *ppList */
148466 char **ppList, /* IN/OUT: Pointer to position list */
148467 int *pnList /* IN/OUT: Size of buffer *ppList in bytes */
148528 sqlite3_int64 *piDocid, /* OUT: Docid value */
148529 char **paPoslist, /* OUT: Pointer to position list */
148530 int *pnPoslist /* OUT: Size of position list in bytes */
149652 /* Figure out if this is a leaf or an internal node. */
149691 /* Figure out how much space the key will consume if it is written to
149849 ** bytes, write this block out to the database. */
149912 int *pRc /* IN/OUT: Error code */
150191 int *piIdx /* OUT: Next free index at iAbsLevel+1 */
150400 Blob *pNew, /* OUT: Write new node image here */
150403 sqlite3_int64 *piBlock /* OUT: Block number in next layer down */
150651 int *pRc /* IN/OUT: Error code */
150967 int *pRc /* OUT: Return code */
151354 int *pnChng, /* IN/OUT: Decrement if row is deleted */
151404 sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */
151882 int *pnPhrase, /* OUT: Number of phrases in query */
151883 int *pnToken /* OUT: Number of tokens in query */
151981 int *piToken, /* OUT: First token of proposed snippet */
151982 int *piScore, /* OUT: "Score" for this snippet */
151983 u64 *pmCover, /* OUT: Bitmask of phrases covered */
151984 u64 *pmHighlight /* OUT: Bitmask of terms to highlight */
152078 u64 *pmSeen, /* IN/OUT: Mask of phrases seen */
152079 SnippetFragment *pFragment, /* OUT: Best snippet found */
152080 int *piScore /* OUT: Score of snippet pFragment */
152217 int *piPos, /* IN/OUT: First token of snippet */
152218 u64 *pHlmask /* IN/OUT: Mask of tokens to highlight */
152339 ** Then break out of the loop. */
153036 ** one of the nSnippet snippet fragments, break out of the loop.
153496 sqlite3_tokenizer **pp /* OUT: New tokenizer handle */
153547 sqlite3_tokenizer_cursor **pp /* OUT: New cursor object */
153588 const char **paToken, /* OUT: Token text */
153589 int *pnToken, /* OUT: Number of bytes at *paToken */
153590 int *piStart, /* OUT: Starting offset of token */
153591 int *piEnd, /* OUT: Ending offset of token */
153592 int *piPos /* OUT: Position integer of token */
154528 ** node contents out to the database.
154551 RtreeNode **ppNode /* OUT: Acquired node */
154690 ** If the node is dirty, write it out to the database.
154761 RtreeCoord *pCoord /* OUT: Space to write result to */
154774 RtreeCell *pCell /* OUT: Write the cell contents here */
154993 sqlite3_rtree_dbl *prScore, /* OUT: score for the cell */
154994 int *peWithin /* OUT: visibility of the cell */
155900 RtreeNode **ppLeaf /* OUT: Selected leaf page */
156949 /* Figure out the rowid of the new row. */
157173 char **pzErr /* OUT: Error message, if any */
157217 sqlite3_vtab **ppVtab, /* OUT: New virtual table */
157218 char **pzErr, /* OUT: Error message, if any */
157260 /* Figure out the node size to use. */
157452 ** out which elements of the R-Tree should be returned by the query.
158116 sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */
158159 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
158240 const char **ppToken, /* OUT: *ppToken is the token text */
158241 int *pnBytes, /* OUT: Number of bytes in token */
158242 int *piStartOffset, /* OUT: Starting offset of token */
158243 int *piEndOffset, /* OUT: Ending offset of token */
158244 int *piPosition /* OUT: Position integer of token */
158390 ** wrong moment they might get out of sync. As the main database will be
158397 ** not really clear how to get out of this state. The system could just
158725 ** not work out of the box with zipvfs. Refer to the comment describing
159377 /* Figure out the size of the output */
159972 /* Figure out the type of table this step will deal with. */
160112 char **pzImposterCols, /* OUT: Columns for imposter table */
160113 char **pzImposterPk, /* OUT: Imposter PK clause */
160114 char **pzWhere, /* OUT: WHERE clause */
160115 int *pnBind /* OUT: Trbul number of columns */
160466 /* Figure out the name of the primary key index for the current table.
160838 sqlite3_stmt **ppStmt /* OUT: UPDATE statement handle */
163145 int *pnLocal /* OUT: Bytes stored locally */
163715 u8 oom; /* Set to true if out of memory */
163750 /* Report an out-of-memory (OOM) condition
166421 int *pi, /* IN/OUT: Offset within a[] */
166422 i64 *piOff /* IN/OUT: Current offset */
166477 Fts5IndexIter **ppIter /* OUT: New iterator object */
166652 const u8 **ppDoclist, /* OUT: Pointer to doclist for pTerm */
166653 int *pnDoclist /* OUT: Size of doclist in bytes */
166663 const char **pzTerm, /* OUT: term (nul-terminated) */
166664 const u8 **ppDoclist, /* OUT: pointer to doclist */
166665 int *pnDoclist /* OUT: size of doclist in bytes */
167033 ** If the index value fts5yy_shift_ofst[S]+X is out of range or if the value
167146 int fts5yyerrcnt; /* Shifts left before out of the error */
168439 Fts5Bm25Data **ppData /* OUT: bm25-data object for this query */
168542 /* Figure out the total size of the current row in tokens. */
168769 int *pi, /* IN/OUT: Offset within a[] */
168770 i64 *piOff /* IN/OUT: Current offset */
169109 char **pzErr /* OUT: Error message */
169138 *pzErr = sqlite3_mprintf("prefix length out of range: %d", nPre);
169258 int *pRc, /* IN/OUT: Error code */
169260 char **pzOut, /* OUT: malloc'd buffer containing str/bw */
169261 int *pbQuoted /* OUT: Set to true if dequoting required */
169361 Fts5Config **ppOut, /* OUT: Results of parse */
169362 char **pzErr /* OUT: Error message */
169595 char **pzRank, /* OUT: Rank function name */
169596 char **pzRankArgs /* OUT: Rank function arguments */
169905 const char **pz, /* IN/OUT: Pointer into buffer */
170071 int *pbDel, /* OUT: Caller should sqlite3_free(*pa) */
170163 int *pbMatch /* OUT: Set to true if really a match */
170289 ** If in/out parameter (*pRc) is set to other than SQLITE_OK when this
170465 i64 *piLast, /* IN/OUT: Lastest rowid seen so far */
170466 int *pRc, /* OUT: Error code */
170467 int *pbEof /* OUT: Set to true if EOF */
170491 i64 *piLast, /* IN/OUT: Lastest rowid seen so far */
170492 int *pRc /* OUT: Error code */
170529 ** phrase is not a match, break out of the loop early. */
172416 const u8 **ppDoclist, /* OUT: Pointer to doclist for pTerm */
172417 int *pnDoclist /* OUT: Size of doclist in bytes */
172456 const char **pzTerm, /* OUT: term (nul-terminated) */
172457 const u8 **ppDoclist, /* OUT: pointer to doclist */
172458 int *pnDoclist /* OUT: size of doclist in bytes */
173316 Fts5Structure **ppOut /* OUT: Deserialized object */
174186 int *pbNewTerm /* OUT: Set for new term */
174462 /* Figure out how many new bytes are in this term */
175448 ** writes it out to disk. Or, if it is too small to bother with, discards
175605 /* Write the page out to disk */
175782 int *pnLeaf /* OUT: Number of leaf pages in b-tree */
175920 Fts5Structure **ppStruct, /* IN/OUT: Stucture of index */
176050 Fts5Structure **ppStruct, /* IN/OUT: Current structure of index */
176107 Fts5Structure **ppStruct, /* IN/OUT: Current structure of index */
176128 Fts5Structure **ppStruct /* IN/OUT: Current structure of index */
176518 ** IN/OUT parameter (*pa) points to a position list n bytes in size. If
176525 const u8 **pa, /* IN/OUT: Pointer to poslist */
176673 i64 *piLastRowid, /* IN/OUT: Previous rowid written (if any) */
176705 Fts5Buffer out;
176707 memset(&out, 0, sizeof(out));
176710 sqlite3Fts5BufferGrow(&p->rc, &out, p1->n + p2->n);
176716 fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
176717 fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.nPoslist+i1.nSize);
176722 fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
176723 fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.nPoslist+i2.nSize);
176738 fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
176760 fts5BufferSafeAppendVarint(&out, tmp.n * 2);
176761 fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
176767 fts5BufferSet(&p->rc, p1, out.n, out.p);
176769 fts5BufferFree(&out);
176785 Fts5IndexIter **ppIter /* OUT: New iterator */
177063 Fts5IndexIter **ppIter /* OUT: New iterator object */
177217 const u8 **pp, /* OUT: Pointer to position-list data */
177218 int *pn, /* OUT: Size of position-list in bytes */
177219 i64 *piRowid /* OUT: Current rowid */
177428 u64 *pCksum /* IN/OUT: Checksum value */
177864 int *piSegid, /* OUT: Segment id */
177865 int *pbDlidx, /* OUT: Dlidx flag */
177866 int *piHeight, /* OUT: Height */
177867 int *piPgno /* OUT: Page number */
177900 int *pRc, /* IN/OUT: error code */
177929 int *pRc, /* IN/OUT: error code */
177954 int *pRc, /* IN/OUT: error code */
178625 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
178626 char **pzErr /* OUT: sqlite3_malloc'd error message */
178635 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
178636 char **pzErr /* OUT: sqlite3_malloc'd error message */
179395 ** routine to find out if it has reached the end of a result set.
179612 sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */
179664 /* Filter out attempts to run UPDATE or DELETE on contentless tables.
180348 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
180349 void **ppArg /* OUT: User data for *pxFunc */
180765 sqlite3_stmt **ppStmt, /* OUT: Prepared statement handle */
180766 char **pzErrMsg /* OUT: Error message (if any) */
180914 int *pRc, /* IN/OUT: Error code */
180951 char **pzErr /* OUT: Error message */
180982 char **pzErr /* OUT: Error message */
182237 ** a separator character. Or break out of the loop if it is not. */
182274 ** it is a token character, or break out of the loop if it is not. */
183967 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
183968 char **pzErr /* OUT: sqlite3_malloc'd error message */
183977 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
183978 char **pzErr /* OUT: sqlite3_malloc'd error message */
184172 ** routine to find out if it has reached the end of a result set.
