Lines Matching defs:out
182 ** that we have taken it all out and gone back to using simple
274 ** returning the N-th compile time option string. ^If N is out of range,
446 ** coming out of the evaluated SQL statements. ^The 4th argument to
539 #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */
1510 ** memory allocator that simulates memory out-of-memory conditions in
2978 sqlite3 **ppDb /* OUT: SQLite db handle */
2982 sqlite3 **ppDb /* OUT: SQLite db handle */
2986 sqlite3 **ppDb, /* OUT: SQLite db handle */
3295 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3296 const char **pzTail /* OUT: Pointer to unused portion of zSql */
3302 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3303 const char **pzTail /* OUT: Pointer to unused portion of zSql */
3309 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3310 const void **pzTail /* OUT: Pointer to unused portion of zSql */
3316 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3317 const void **pzTail /* OUT: Pointer to unused portion of zSql */
3522 ** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails.
3572 ** ^If the value N is out of range or if the N-th parameter is
3880 ** column index is out of range, the result is undefined.
4328 ** allocates N of memory, zeroes out that memory, and returns a pointer
4910 ** find out whether SQLite automatically rolled back the transaction after
5805 ** out to disk and so if any I/O errors occur, they will likely occur
6236 ** ^The sqlite3_test_control() interface is used to read out internal
6326 ** <dd>This parameter is the current amount of memory checked out
6344 ** currently checked out.</dd>)^
6347 ** <dd>This parameter returns the number of pages used out of the
6369 ** <dd>This parameter returns the number of allocations used out of the
6450 ** checked out.</dd>)^
6972 ** ^If an out-of-memory condition or IO error occurred during any prior
7377 int *pnLog, /* OUT: Size of WAL log in frames */
7378 int *pnCkpt /* OUT: Total number of frames checkpointed */
7592 int eWithin; /* OUT: Visiblity */
7593 sqlite3_rtree_dbl rScore; /* OUT: Write the score here */
7990 ** is set. Thus NDEBUG becomes an opt-in rather than an opt-out
8442 ** not, there are still machines out there that use EBCDIC.)
10009 ** Figure out if we are dealing with Unix, Windows, or some other operating
10082 ** anybody smart enough to figure out the code is also likely smart
10122 ** byte out of a specific range of bytes. The lock byte is obtained at
10136 ** But a single Win95 reader will lock out all WinNT readers and a single
10137 ** WinNT reader will lock out all other Win95 readers.
10251 ** to all source files. We break it out in an effort to keep the code
10261 ** Figure out what version of the code to use. The choices are
10373 ** have been filled out. If the schema changes, these column names might
10410 int nOut; /* Number of buffers currently checked out */
10985 ** done as a macro so that it will be optimized out when virtual
11049 ** fails and any prior changes from that one operation are backed out,
11052 ** changes due to the same operation are not backed out and no rollback
11071 #define OE_Abort 2 /* Back out changes but do no rollback transaction */
11105 ** single index record that has already been parsed out into individual
11214 ** Each token coming out of the lexer is an instance of
11552 ** The jointype starts out showing the join type between the current table
11919 u8 okConstFactor; /* OK to factor out constants */
11929 int iFixedOp; /* Never back out opcodes iFixedOp-1 or earlier */
12630 #define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */
13828 ** Return the N-th compile-time option string. If N is out of range,
13874 ** this header information was factored out.
13951 ** the cache is out of date.
15071 int *pRc /* OUT: Error code. SQLITE_OK or ERROR */
15885 void volatile **pp /* OUT: Pointer to mapping */
16148 ** is completely recoverable simply by not carrying out the resize. The
17049 FILE *out;
17053 out = fopen(zFilename, "w");
17054 if( out==0 ){
17062 fprintf(out, "**** %lld bytes at %p from %s ****\n",
17065 fflush(out);
17068 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
17069 fprintf(out, "\n");
17072 fprintf(out, "COUNTS:\n");
17075 fprintf(out, " %5d: %10d %10d %10d\n",
17080 fprintf(out, " %5d: %10d %10d %10d\n",
17084 fclose(out);
17155 ** A chunk is two or more blocks that is either checked out or
17158 ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
17160 ** is true if the previous chunk is checked out and false if the
17163 ** freelist. If the previous chunk is checked out, then
17179 ** out. If a chunk is checked out, the user data may extend into
17211 ** True if we are evaluating an out-of-memory callback.
17351 ** size parameters for check-out and return a pointer to the
17473 ** successful most of the time (about 9 times out of 10).
17577 ** works for chunks that are currently checked out.
17603 assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */
17693 FILE *out;
17697 out = stdout;
17699 out = fopen(zFilename, "w");
17700 if( out==0 ){
17707 fprintf(out, "CHUNKS:\n");
17711 fprintf(out, "%p size error\n", &mem3.aPool[i]);
17716 fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
17721 fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
17726 fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
17728 fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
17734 fprintf(out, "small(%2d):", i);
17736 fprintf(out, " %p(%d)", &mem3.aPool[j],
17739 fprintf(out, "\n");
17743 fprintf(out, "hash(%2d):", i);
17745 fprintf(out, " %p(%d)", &mem3.aPool[j],
17748 fprintf(out, "\n");
17750 fprintf(out, "master=%d\n", mem3.iMaster);
17751 fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8);
17752 fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8);
17754 if( out==stdout ){
17757 fclose(out);
17875 #define CTRL_FREE 0x20 /* True if not checked out */
17916 ** Space for tracking which blocks are checked out and the size
17991 ** works for chunks that are currently checked out.
18311 FILE *out;
18316 out = stdout;
18318 out = fopen(zFilename, "w");
18319 if( out==0 ){
18329 fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
18331 fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc);
18332 fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc);
18333 fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess);
18334 fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut);
18335 fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
18336 fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut);
18337 fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount);
18338 fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest);
18340 if( out==stdout ){
18343 fclose(out);
19186 ** It uses the RDTSC opcode to read the cycle count value out of the
19959 ** Return the amount of memory currently checked out.
19971 ** checked out since either the beginning of this process
20534 ** completeness. They are very out-of-date but might be useful as
20536 ** out so that the functionality is now the same as standard printf().
20764 /* Find out what flags are present */
21898 ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
22723 ** case is broken out because while 9223372036854775808 cannot be a
24400 ** It uses the RDTSC opcode to read the cycle count value out of the
24904 ** Helper function for printing out trace information from debugging
24922 ** Print out information about all locking operations.
25002 /* At one point this code was not commented out. In theory, this branch
25010 ** propagated back to the caller. Commenting this branch out means errno==0
26782 /* lock semaphore now but bail out when already locked. */
27496 int *piErrno /* OUT: Error number if error occurs */
28508 /* Call fstat() to figure out the permissions on the database file. If
28634 void volatile **pp /* OUT: Mapped memory */
28819 /* Find out which shared locks are already held by sibling connections.
29807 mode_t *pMode, /* OUT: Permissions to open file with */
29808 uid_t *pUid, /* OUT: uid to set on the file */
29809 gid_t *pGid /* OUT: gid to set on the file */
30907 /* write it out to the temporary break file */
31872 ** It uses the RDTSC opcode to read the cycle count value out of the
32154 ** Two of the file mapping APIs are different under WinRT. Figure out which
33980 /* out of memory */
35678 /* Find out which shared locks are already held by sibling connections.
35771 void volatile **pp /* OUT: Mapped memory */
36182 /* caller will handle out of memory */
36203 /* caller will handle out of memory */
36258 /* Figure out the effective temporary directory. First, check if one
36893 int *pResOut /* OUT: Result */
37642 ** i is out of range, then return false.
38194 /* Find a dirty page to write-out and recycle. First try to find a
38881 ** The pointer is allowed to be NULL, which is prudent. But it turns out
39578 int *pnCurrent, /* OUT: Total number of pages cached */
39579 int *pnMax, /* OUT: Global maximum cache size */
39580 int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */
39581 int *pnRecyclable /* OUT: Total number of pages available for recycling */
40236 int *pnLog, /* OUT: Number of frames in WAL */
40237 int *pnCkpt /* OUT: Number of backfilled frames in WAL */
40354 ** content out of the database file.
40371 ** to print out file-descriptors.
41020 ** out code that would never execute.
41741 u32 *pNRec, /* OUT: Value read from the nRec field */
41742 u32 *pDbSize /* OUT: Value of original database size field */
42027 ** out from under us.
42583 ** as clean, since there will be no need to write it out to the
42595 ** be written out into the database file before its journal file
42873 ** (7) zero padding out to the next sector size.
42925 /* Figure out how many records are in the journal. Abort early if
43015 /* Copy original pages out of the journal and back into the
43111 ** Read the content for page pPg out of the database file and into
43234 ** updated as data is copied out of the rollback journal and into the
43569 /* Continue rolling back records out of the main journal starting at
43571 ** of the main journal file. Continue to skip out-of-range pages and
43599 ** previously rolled back out of the main journal (and are hence in pDone)
43600 ** will be skipped. Out-of-range pages are also skipped.
44043 ** be necessary to write the current content out to the sub-journal
44136 PgHdr **ppPage /* OUT: Acquired page object */
44345 ** out-of-date data that follows it. Database corruption.
44440 ** written out.
44443 ** the pages are written out to the database file in list order. Writing
44449 ** If writing out a page causes the database file to grow, Pager.dbFileSize
44450 ** is updated accordingly. If page 1 is written out, then the value cached
44496 ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
44509 /* Write out the page data. */
44622 ** out to the database file, if possible. This may involve syncing the
44699 ** out to the database file, but will be dropped from the cache. Then,
44716 /* Write the contents of the page out to the database file. */
44765 Pager **ppPager, /* OUT: Return the Pager structure here */
44787 /* Figure out how much space is required for each journal file-handle
44963 ** database is the same as a temp-file that is never written out to
45058 /* Verify that the database file has not be deleted or renamed out from
46106 ** before any of them can be written out to the database file.
46465 ** last page is never written out to disk, leaving the database file
46610 ** cache. So call pager_error() on the way out to make any error persistent.
46800 /* Figure out how many savepoints will still be active after this
47026 ** need to rollback later. Just move the page out of the way. */
47388 int *pbOpen /* OUT: Set to true if call is a no-op */
47909 u8 padToSectorBoundary; /* Pad transactions out to the next sector */
48079 u32 *aOut /* OUT: Final checksum value output */
48154 u8 *aFrame /* OUT: Write encoded frame here */
48178 u32 *piPage, /* OUT: Database page number for frame */
48179 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
48320 volatile ht_slot **paHash, /* OUT: Pointer to hash index */
48321 volatile u32 **paPgno, /* OUT: Pointer to page number array */
48322 u32 *piZero /* OUT: Frame associated with *paPgno[0] */
48509 ** via the hash table. This turns out to be a really, really expensive
48739 Wal **ppWal /* OUT: Allocated Wal handle */
48808 ** Find the smallest page number out of all pages held in the WAL that
48819 u32 *piPage, /* OUT: The page number of the next page */
48820 u32 *piFrame /* OUT: Wal frame index of next page */
48874 ht_slot **paRight, /* IN/OUT: Right hand input list */
48875 int *pnRight, /* IN/OUT: Elements in *paRight */
48930 ht_slot *aList, /* IN/OUT: List to sort */
48931 int *pnList /* IN/OUT: Number of elements in aList[] */
49119 ** Fsync is called on the WAL before writing content out of the WAL and
49571 ** paged out or take a page-fault that is time-consuming to resolve,
49782 u32 *piRead /* OUT: Frame number (or zero) */
49821 ** This condition filters out normal hash-table collisions.
49824 ** This condition filters out entries that were added to the hash
50168 ** Write out a single frame of the WAL
50267 ** an out-of-order write following a WAL restart could result in
50397 int *pnLog, /* OUT: Number of frames in WAL */
50398 int *pnCkpt /* OUT: Number of backfilled frames in WAL */
50463 ** out of date. So zero the cached wal-index header to ensure that
50493 ** This function is called to change the WAL subsystem into or out
50500 ** transition out of exclusive-mode is successful, return 1. This
51249 BtShared *pBt; /* The tree being checked out */
51428 ** reset out from under us.
51708 /* Figure out the root-page that the lock should be held on. For table
52279 ** at is deleted out from under them.
52290 ** been deleted out from under the cursor.
53662 ** Clean out and delete the BtShared object.
53933 ** is returned if we run out of memory.
54789 ** the journal. Then the contents of the journal are flushed out to
54879 ** routine did all the work of writing information out to disk and flushing the
55215 ** to zero. But it turns out that the apPage[] and aiIdx[] arrays
55379 MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */
55380 Pgno *pPgnoNext /* OUT: Next overflow page number */
55393 ** out to be wrong, fall back to loading the data of page
55478 ** or be scattered out on multiple overflow pages.
56628 /* Value of k is out of range. Database corruption */
57766 ** buffer. It will be copied out again as soon as the aSpace[] buffer
57887 ** Figure out the number of pages needed to hold all nCell cells.
57926 ** be so out of balance as to be illegal. For example, the right-most
58352 ** some way. This function figures out if this modification means the
58534 ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
58792 ** out to be an overflow page, delete all overflow page-map caches
59147 ** Read the meta-information out of a database file. Meta[0]
59526 /* Check out all the cells.
59548 "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
59605 "Rowid %lld out of order (max larger than parent min of %lld)",
59611 "Rowid %lld out of order (min less than parent min of %lld)",
59616 "Rowid %lld out of order (max larger than parent max of %lld)",
59625 "Rowid %lld out of order (min less than parent max of %lld)",
60160 sqlite3Error(pErrorDb, SQLITE_NOMEM, "out of memory");
61158 ** If the double is out of range of a 64-bit signed integer then
61606 ** Move data out of a btree key or data field and into a Mem structure.
61623 Mem *pMem /* OUT: Return data in this Mem structure. */
61997 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
62069 UnpackedRecord **ppRec, /* IN/OUT: Probe record */
62073 int *pbOk /* OUT: True if value was extracted */
62104 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
62122 sqlite3_value **ppVal /* OUT: Extracted value */
62231 ** But that file was getting too big so this subroutines were split out.
62305 ** If an out-of-memory error occurs while resizing the array, return
62442 ** Add an OP_ParseSchema opcode. This routine is broken out from
63590 /* We are currently listing subprograms. Figure out which one and
63764 u8 **ppFrom, /* IN/OUT: Allocate from *ppFrom */
64790 FILE *out = fopen("vdbe_profile.out", "a");
64791 if( out ){
64793 fprintf(out, "---- ");
64795 fprintf(out, "%02x", p->aOp[i].opcode);
64797 fprintf(out, "\n");
64800 fprintf(out, "-- ");
64802 if( pc=='\n' ) fprintf(out, "-- ");
64803 putc(c, out);
64806 if( pc!='\n' ) fprintf(out, "\n");
64815 fprintf(out, "%s", zHdr);
64816 sqlite3VdbePrintOp(out, i, &p->aOp[i]);
64818 fclose(out);
64937 ** deleted out from under the cursor and if it has, mark the row as
64941 ** not been deleted out from under the cursor, then this routine is a no-op.
65025 /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
65097 ** the necessary byte swapping is carried out using a 64-bit integer
65293 char **ppFree /* OUT: Caller should free this pointer */
65444 /* rc==0 here means that one of the keys ran out of fields and
65815 /* rc==0 here means that one or both of the keys ran out of fields and
67123 ** xFunc() then return that string. If N is out of range, return 0.
67266 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
67466 ** is out of range or if the wildcard is unnamed.
67684 StrAccum out; /* Accumulate the output here */
67688 sqlite3StrAccumInit(&out, zBase, sizeof(zBase),
67690 out.db = db;
67695 sqlite3StrAccumAppend(&out, "-- ", 3);
67697 sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
67703 sqlite3StrAccumAppend(&out, zRawSql, n);
67727 sqlite3StrAccumAppend(&out, "NULL", 4);
67729 sqlite3XPrintf(&out, 0, "%lld", pVar->u.i);
67731 sqlite3XPrintf(&out, 0, "%!.15g", pVar->r);
67752 sqlite3XPrintf(&out, 0, "'%.*q'", nOut, pVar->z);
67755 sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
67762 sqlite3XPrintf(&out, 0, "zeroblob(%d)", pVar->u.nZero);
67766 sqlite3StrAccumAppend(&out, "x'", 2);
67772 sqlite3XPrintf(&out, 0, "%02x", pVar->z[i]&0xff);
67774 sqlite3StrAccumAppend(&out, "'", 1);
67777 sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
67783 return sqlite3StrAccumFinish(&out);
67932 ** be changed out from under the copy. This macro verifies that nothing
68074 ** if we run out of memory.
68394 ** It uses the RDTSC opcode to read the cycle count value out of the
68602 ** external allocations out of mem[p2] and set mem[p2] to be
68858 ** then back out all changes that have occurred during this execution of the
69382 char bIntint; /* Started out as two integer operands */
70665 ** out how much space is required for the new record.
71104 ** prepared queries. If such a query is out-of-date, we do not want to
72522 ** correctly optimizing out sorts.
73771 ** If changing into or out of WAL mode the procedure is more complicated.
73822 (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
74449 ** the evaluator loop. So we can leave it out when NDEBUG is defined.
74484 /* This is the only way out of this procedure. We have to
74506 sqlite3SetString(&p->zErrMsg, db, "out of memory");
74904 /* Request is out of range. Return a transient error. */
75181 u8 **ppOut /* OUT: Pointer to buffer containing data */
75321 i64 *pnByte /* IN/OUT: Increment this value by PMA size */
75390 int *pRes /* OUT: Result of comparison */
75566 SorterRecord **ppOut /* OUT: Head of merged list */
75797 /* See if the contents of the sorter should now be written out. They
75798 ** are written out when either of the following are true:
75907 ** initialize an iterator for each of them and break out of the loop.
76039 int *pnKey /* OUT: Size of current key in bytes */
76086 int *pRes /* OUT: Result of comparison */
77203 ** we have a match (cnt>0) or when we run out of name contexts.
77658 ** Generate an ORDER BY or GROUP BY term out-of-range error.
77663 int i, /* The index (1-based) of the term out of range */
77667 "%r %s BY term out of range - should be "
79056 /* Figure out where to write the new Expr structure. */
80214 /* Figure out the affinity to use to create a key from the results
80346 char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
80347 if( out ){
80348 memcpy(out, in, 8);
80350 return out;
81336 ** Factor out the code of the given expression to initialization time.
81368 ** VDBE program, in order to factor it out of the evaluation loop.
81743 ** factored out into initialization code.
82642 /* Ran out of input before finding an opening bracket. Return NULL. */
82765 /* Ran out of input before finding the table name. Return NULL. */
83079 /* figure out how many UTF-8 characters are in zName */
84011 ** be out of order. */
85234 /* Load new statistics out of the sqlite_stat1 table */
85487 zErrDyn = sqlite3MPrintf(db, "out of memory");
85712 ** checks out, these routines return 0.
85990 /* An attempt to read a column out of a subquery or other
86292 /* Code constant expressions that where factored out of inner loops */
89047 ** key out of the last column added to the table under construction.
89058 /* Figure out how many bytes of space are required to store explicitly
89607 ** out of the way */
91105 /* Figure out if we have any triggers and if the table being
91616 int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */
93607 Index **ppIdx, /* OUT: Unique index on parent table */
93608 int **paiCol /* OUT: Map of index columns in pFKey */
93677 ** unusable. Bail out early in this case. */
95303 /* Figure out if we have any triggers and if the table being
95413 /* Figure out how many columns of data are supplied. If the data
95881 ** any ABORT Back out changes from the current command
95921 int *pbMayReplace /* OUT: Set to true if constraint may cause a replace */
96041 /* Figure out what action to take in case of a rowid collision */
96200 /* Find out what action to take in case there is a uniqueness conflict */
98174 /* Common case: early out without every having to acquire a mutex */
100043 addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
100097 addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
100883 /* Read the schema information out of the schema tables
101011 ** Check schema cookies in all databases. If any cookie is out
101109 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
101110 const char **pzTail /* OUT: End of parsed string */
101269 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
101270 const char **pzTail /* OUT: End of parsed string */
101340 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
101341 const char **pzTail /* OUT: End of parsed string */
101352 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
101353 const char **pzTail /* OUT: End of parsed string */
101371 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
101372 const void **pzTail /* OUT: End of parsed string */
101376 ** tricky bit is figuring out the pointer to return in *pzTail.
101426 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
101427 const void **pzTail /* OUT: End of parsed string */
101438 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
101439 const void **pzTail /* OUT: End of parsed string */
101734 Expr **ppWhere /* IN/OUT: The WHERE clause to add to */
102069 int iBreak /* Jump here to break out of the inner loop */
102249 /* At first glance you would think we could optimize out the
102273 ** store the results in the appropriate memory cell and break out
102282 /* The LIMIT clause will jump out of the loop for us */
103961 ** store the results in the appropriate memory cell and break out
103967 /* The LIMIT clause will jump out of the loop for us */
104908 ** block of code will expand the out query to 4 slots. The middle
105188 With **ppContext /* OUT: WITH clause return value belongs to */
106198 ** we figure out that the sorting index is not needed. The addrSortIndex
106317 ** on the grounds that the GROUP BY will cause elements to come out
106371 ** implement it. Allocate that sorting index now. If it turns out
106416 /* Rows are coming out in undetermined order. We have to push
106659 ** add vdbe code to break out of the processing loop after the
107172 /* Figure out the db that the trigger will be created in */
107448 ** Build a trigger step out of an INSERT statement. Return a pointer
107705 int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
107774 /* Figure out the ON CONFLICT policy that will be used for this step
108306 int labelBreak; /* Jump here to break out of UPDATE loop */
108341 /* Figure out if we have any triggers and if the table being
108882 ** it out of the ephemeral table before calling VUpdate.
109703 ** created now instead of just being read out of sqlite_master) then
110464 ** planner logic in "where.c". These definitions are broken out into
110516 int addrBrk; /* Jump here to break out of the loop */
110681 ** spread out over the non-negative integers. For example, the cursor
110782 WhereClause wc; /* The subexpression broken out */
110859 int iBreak; /* Jump here to break out of the loop */
110950 ** out of a WHERE loop.
112537 ** if they go out of sync.
112676 sqlite3ErrorMsg(pParse, "out of memory");
112792 tRowcnt *aStat /* OUT: stats written here */
113507 char **pzAff /* OUT: Set to point to affinity string */
113528 /* Figure out how many memory cells we will need then allocate them.
113793 int addrBrk; /* Jump here to break out of the loop */
113813 ** for the current loop. Jump to addrBrk to break out of a loop.
114308 WhereClause *pOrWc; /* The OR-clause broken out into subterms */
115335 if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */
116023 Bitmask *pRevMask /* OUT: Mask of WhereLoops to run in reverse order */
116314 ** terms are out of order, then block-sorting will reduce the
117529 /* This routine constructs a binary expression node out of two ExprSpan
117711 ** If the index value yy_shift_ofst[S]+X is out of range or if the value
118305 int yyerrcnt; /* Shifts left before out of the error */
121806 ** separating it out, the code will be automatically omitted from
123341 /* SQLITE_NOMEM */ "out of memory",
123355 /* SQLITE_MISUSE */ "library routine called out of sequence",
123359 /* SQLITE_RANGE */ "bind or column index out of range",
123648 goto out;
123660 out:
123892 int *pnLog, /* OUT: Size of WAL log in frames */
123893 int *pnCkpt /* OUT: Total number of frames checkpointed */
124355 unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */
124356 sqlite3_vfs **ppVfs, /* OUT: VFS to use */
124357 char **pzFile, /* OUT: Filename component of URI */
124358 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
124568 sqlite3 **ppDb, /* OUT: Returned database handle */
124845 sqlite3 **ppDb, /* OUT: SQLite db handle */
126244 ** will eventually overtake the earlier data and knock it out. The
126245 ** query logic likewise merges doclists so that newer data knocks out
126366 sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */
126383 sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */
126395 ** "OUT" variables identified below, or SQLITE_DONE to indicate that
126418 const char **ppToken, int *pnBytes, /* OUT: Normalized text for token */
126419 int *piStartOffset, /* OUT: Byte offset of token in input buffer */
126420 int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */
126421 int *piPosition /* OUT: Number of tokens returned before this one */
127579 int *pRc, /* IN/OUT: Error code */
127580 char **pz, /* IN/OUT: Pointer to string buffer */
127777 int *pnIndex, /* OUT: size of *apIndex[] array */
127778 struct Fts3Index **apIndex /* OUT: Array of indexes for this table */
127842 const char ***pazCol, /* OUT: Malloc'd array of column names */
127843 int *pnCol, /* OUT: Size of array *pazCol */
127844 int *pnStr /* OUT: Bytes of string content */
127973 ** + Figures out the number of columns the FTSX table will have, and
128251 /* Figure out the page-size for the database. This is required in order to
128291 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
128292 char **pzErr /* OUT: sqlite3_malloc'd error message */
128301 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
128302 char **pzErr /* OUT: sqlite3_malloc'd error message */
128564 sqlite3_int64 *piFirst, /* OUT: Selected child node */
128565 sqlite3_int64 *piLast /* OUT: Selected child node */
128729 char **pp, /* IN/OUT: Output pointer */
128730 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
128845 char **pp, /* IN/OUT: Pointer into position-list buffer */
128846 sqlite3_int64 *pi /* IN/OUT: Value read from position-list */
128974 char **pp, /* IN/OUT: Preallocated output buffer */
128978 char **pp1, /* IN/OUT: Left input list */
128979 char **pp2 /* IN/OUT: Right input list */
129102 char **pp1, /* IN/OUT: Left input list */
129103 char **pp2 /* IN/OUT: Right input list */
129156 char **pp, /* IN/OUT: Point to read varint from */
129159 sqlite3_int64 *pVal /* IN/OUT: Integer value */
129190 char **pp, /* IN/OUT: Output pointer */
129192 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
129193 int *pbFirst, /* IN/OUT: True after first int written */
129239 char **paOut, int *pnOut /* OUT: Malloc'd doclist */
129331 char *aRight, int *pnRight /* IN/OUT: Right/output doclist */
129594 ** calls out here. */
129710 Fts3MultiSegReader **ppSegcsr /* OUT: Allocated seg-reader cursor */
129775 int *pnOut, /* OUT: Size of buffer at *ppOut */
129776 char **ppOut /* OUT: Malloced result buffer */
130022 ** routine to find out if it has reached the end of a result set.
130105 sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */
130261 Fts3Cursor **ppCsr /* OUT: Store cursor handle here */
130405 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
130712 int *pnToken, /* OUT: Total number of tokens in phrase. */
130713 int *pnOr, /* OUT: Total number of OR nodes in expr. */
130714 int *pRc /* IN/OUT: Error code */
131019 char **ppIter, /* IN/OUT: Iterator pointer */
131020 sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */
131021 int *pnList, /* OUT: List length pointer */
131022 u8 *pbEof /* OUT: End-of-file flag */
131075 char **ppIter, /* IN/OUT: Iterator pointer */
131076 sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */
131077 u8 *pbEof /* OUT: End-of-file flag */
131174 TokenDoclist *p, /* OUT: Docid and doclist for new entry */
131175 u8 *pbEof /* OUT: True if iterator is at EOF */
131225 u8 *pbEof /* OUT: Set to 1 if EOF */
131325 u8 *pbEof /* OUT: Set to 1 if EOF */
131364 int *pRc /* IN/OUT: Error code */
131418 int *pRc /* IN/OUT: Error code */
131740 char **paPoslist, /* IN/OUT: Position list */
131741 int *pnToken, /* IN/OUT: Tokens in phrase of *paPoslist */
131814 int *pRc /* IN/OUT: Error code */
132025 int *pRc /* IN/OUT: Error code */
132453 char **ppOut /* OUT: Pointer to position list */
132696 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
132697 char **pzErr /* OUT: sqlite3_malloc'd error message */
133141 sqlite_int64 *pRowid /* OUT: Rowid value */
133366 Fts3Expr **ppExpr, /* OUT: expression */
133367 int *pnConsumed /* OUT: Number of bytes consumed */
133438 ** Enlarge a memory allocation. If an out-of-memory allocation occurs,
133457 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
133464 Fts3Expr **ppExpr /* OUT: expression */
133582 Fts3Expr **ppExpr, /* OUT: expression */
133583 int *pnConsumed /* OUT: Number of bytes consumed */
133661 /* Turns out that wasn't a keyword after all. This happens if the
133699 ** interface. Before doing so, figure out if there is an explicit
133795 ** (out of memory error) or SQLITE_ERROR (parse error) is returned.
133800 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
133801 int *pnConsumed /* OUT: Number of bytes consumed */
134039 /* If that was the last leaf node, break out of the loop */
134128 Fts3Expr **ppExpr /* OUT: Parsed query structure */
134165 ** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse
134191 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
134192 char **pzErr /* OUT: Error message (sqlite3_malloc) */
134946 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
135450 const char **pzToken, /* OUT: *pzToken is the token text */
135451 int *pnBytes, /* OUT: Number of bytes in token */
135452 int *piStartOffset, /* OUT: Starting offset of token */
135453 int *piEndOffset, /* OUT: Ending offset of token */
135454 int *piPosition /* OUT: Position integer of token */
135597 sqlite3_result_error(context, "out of memory", -1);
135667 sqlite3_tokenizer **ppTok, /* OUT: Tokenizer (if applicable) */
135668 char **pzErr /* OUT: Set to malloced error message */
136123 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
136166 const char **ppToken, /* OUT: *ppToken is the token text */
136167 int *pnBytes, /* OUT: Number of bytes in token */
136168 int *piStartOffset, /* OUT: Starting offset of token */
136169 int *piEndOffset, /* OUT: Ending offset of token */
136170 int *piPosition /* OUT: Position integer of token */
136406 sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
136407 char **pzErr /* OUT: sqlite3_malloc'd error message */
136654 sqlite_int64 *pRowid /* OUT: Rowid value */
136911 ** the tree is assembled in memory and written out only once all leaves have
136989 sqlite3_stmt **pp, /* OUT: Statement handle */
137129 sqlite3_stmt **ppStmt /* OUT: Statement handle */
137153 sqlite3_stmt **ppStmt /* OUT: Statement handle */
137175 sqlite3_stmt **ppStmt /* OUT: Statement handle */
137296 sqlite3_stmt **ppStmt /* OUT: Compiled statement */
137339 PendingList **pp, /* IN/OUT: Pointer to PendingList struct */
137383 PendingList **pp, /* IN/OUT: PendingList structure */
137387 int *pRc /* OUT: Return code */
137487 u32 *pnWord /* IN/OUT: Incr. by number tokens inserted */
137648 sqlite3_int64 *piDocid /* OUT: Docid for row just inserted */
137759 int *pbFound /* OUT: Set to true if row really does exist */
137889 char **paBlob, /* OUT: Blob data in malloc'd buffer */
137890 int *pnBlob, /* OUT: Size of blob data */
137891 int *pnLoad /* OUT: Bytes actually loaded */
138141 char **ppOffsetList, /* OUT: Pointer to current position-list */
138142 int *pnOffsetList /* OUT: Length of *ppOffsetList in bytes */
138287 Fts3SegReader **ppReader /* OUT: Allocated Fts3SegReader */
138366 Fts3SegReader **ppReader /* OUT: SegReader for pending-terms */
138679 SegmentNode **ppTree, /* IN/OUT: SegmentNode handle */
138820 sqlite3_int64 *piLast, /* OUT: Block id of last entry written */
138821 char **paRoot, /* OUT: Data for root node */
138822 int *pnRoot /* OUT: Size of root node in bytes */
138885 SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */
138928 /* Figure out how many bytes are required by this new entry */
138938 /* The current leaf node is full. Write it out to the database. */
139262 int bZero, /* Zero out anything following *ppList */
139263 char **ppList, /* IN/OUT: Pointer to position list */
139264 int *pnList /* IN/OUT: Size of buffer *ppList in bytes */
139325 sqlite3_int64 *piDocid, /* OUT: Docid value */
139326 char **paPoslist, /* OUT: Pointer to position list */
139327 int *pnPoslist /* OUT: Size of position list in bytes */
140448 /* Figure out if this is a leaf or an internal node. */
140487 /* Figure out how much space the key will consume if it is written to
140645 ** bytes, write this block out to the database. */
140708 int *pRc /* IN/OUT: Error code */
140987 int *piIdx /* OUT: Next free index at iAbsLevel+1 */
141196 Blob *pNew, /* OUT: Write new node image here */
141199 sqlite3_int64 *piBlock /* OUT: Block number in next layer down */
141447 int *pRc /* IN/OUT: Error code */
141763 int *pRc /* OUT: Return code */
142150 int *pnChng, /* IN/OUT: Decrement if row is deleted */
142200 sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */
142570 int *pnPhrase, /* OUT: Number of phrases in query */
142571 int *pnToken /* OUT: Number of tokens in query */
142670 int *piToken, /* OUT: First token of proposed snippet */
142671 int *piScore, /* OUT: "Score" for this snippet */
142672 u64 *pmCover, /* OUT: Bitmask of phrases covered */
142673 u64 *pmHighlight /* OUT: Bitmask of terms to highlight */
142767 u64 *pmSeen, /* IN/OUT: Mask of phrases seen */
142768 SnippetFragment *pFragment, /* OUT: Best snippet found */
142769 int *piScore /* OUT: Score of snippet pFragment */
142904 int *piPos, /* IN/OUT: First token of snippet */
142905 u64 *pHlmask /* IN/OUT: Mask of tokens to highlight */
143026 ** Then break out of the loop. */
143629 ** one of the nSnippet snippet fragments, break out of the loop.
144104 sqlite3_tokenizer **pp /* OUT: New tokenizer handle */
144155 sqlite3_tokenizer_cursor **pp /* OUT: New cursor object */
144196 const char **paToken, /* OUT: Token text */
144197 int *pnToken, /* OUT: Number of bytes at *paToken */
144198 int *piStart, /* OUT: Starting offset of token */
144199 int *piEnd, /* OUT: Ending offset of token */
144200 int *piPos /* OUT: Position integer of token */
145134 ** node contents out to the database.
145157 RtreeNode **ppNode /* OUT: Acquired node */
145296 ** If the node is dirty, write it out to the database.
145367 RtreeCoord *pCoord /* OUT: Space to write result to */
145380 RtreeCell *pCell /* OUT: Write the cell contents here */
145600 sqlite3_rtree_dbl *prScore, /* OUT: score for the cell */
145601 int *peWithin /* OUT: visibility of the cell */
146494 RtreeNode **ppLeaf /* OUT: Selected leaf page */
147533 /* Figure out the rowid of the new row. */
147757 char **pzErr /* OUT: Error message, if any */
147801 sqlite3_vtab **ppVtab, /* OUT: New virtual table */
147802 char **pzErr, /* OUT: Error message, if any */
147844 /* Figure out the node size to use. */
148024 ** out which elements of the R-Tree should be returned by the query.
148674 sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */
148717 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
148798 const char **ppToken, /* OUT: *ppToken is the token text */
148799 int *pnBytes, /* OUT: Number of bytes in token */
148800 int *piStartOffset, /* OUT: Starting offset of token */
148801 int *piEndOffset, /* OUT: Ending offset of token */
148802 int *piPosition /* OUT: Position integer of token */
