Lines Matching defs:result
686 ** sqlite3_exec() is not NULL, then it is invoked for each result row
690 ** is NULL, then no callback is ever invoked and result rows are
710 ** number of columns in the result. ^The 3rd argument to the sqlite3_exec()
713 ** result row is NULL then the corresponding string pointer for the
716 ** entry represents the name of corresponding result column as obtained
745 ** KEYWORDS: {result code definitions}
747 ** Many SQLite functions return an integer result code from the set shown
752 ** See also: [extended result code definitions]
754 #define SQLITE_OK 0 /* Successful result */
790 ** KEYWORDS: {extended result code definitions}
793 ** [result codes]. However, experience has shown that many of
794 ** these result codes are too coarse-grained. They do not provide as
798 ** support for additional result codes that provide more detailed information
799 ** about errors. These [extended result codes] are enabled or disabled
922 #define SQLITE_OPEN_EXRESCODE 0x02000000 /* Extended result codes */
1301 ** [sqlite3_malloc()] and the result is stored in the char* variable
1328 ** or the equivalent and that string will become the result of the pragma or
1334 ** prepared statement if result string is NULL, or that returns a copy
1335 ** of the result string if the string is non-NULL.
1337 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
1362 ** invoke [sqlite3_free()] on the result to avoid a memory leak.
2295 ** [sqlite3_log()] call and is intended to be a [result code] or an
2296 ** [extended result code]. ^The third parameter passed to the logger is
2775 ** [extended result codes] feature of SQLite. ^The extended result
3058 ** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]
3083 ** result in undefined behavior.
3120 ** Definition: A <b>result table</b> is memory data structure created by the
3121 ** [sqlite3_get_table()] interface. A result table records the
3125 ** these numbers are not part of the result table itself. These
3129 ** A result table is an array of pointers to zero-terminated UTF-8 strings.
3132 ** The remaining entries all point to query results. NULL values result
3136 ** A result table might consist of one or more memory allocations.
3137 ** It is not safe to pass a result table directly to [sqlite3_free()].
3138 ** A result table should be deallocated using [sqlite3_free_table()].
3140 ** ^(As an example of the result table format, suppose a query result
3152 ** result table has 8 entries. Suppose the result table is stored
3168 ** string of its 2nd parameter and returns a result table to the
3171 ** After the application has finished with the result from sqlite3_get_table(),
3172 ** it must pass the result table pointer to sqlite3_free_table() in order to
3190 int *pnRow, /* Number of result rows written here */
3191 int *pnColumn, /* Number of result columns written here */
3194 SQLITE_API void sqlite3_free_table(char **result);
3214 ** the standard C library. The result is written into the
3266 ** memory might result in a segmentation fault or other severe error.
3268 ** might result if sqlite3_free() is called with a non-NULL pointer that
3615 ** statement generates a single row of result.
3788 ** <dd>The database connection comes up in "extended result code mode".
3792 ** the extended result code mode, this flag also causes [sqlite3_open_v2()]
3793 ** to return an extended result code.</dd>
3902 ** support locking. Caution: Database corruption might result if two
3912 ** property on a database file that does in fact change can result
4084 ** return value from [sqlite3_db_filename()], then the result is
4118 ** with N URI parameters key/values pairs in the array P. The result from
4170 ** returns the numeric [result code] or [extended result code] for that
4174 ** [extended result code] even when extended result codes are
4194 ** The application does not need to worry about freeing the result.
4199 ** that describes the [result code], as UTF-8.
4214 ** interfaces always report the most recent result. To avoid
4317 ** result set of a [SELECT] or the maximum number of columns in an index
4482 ** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
4576 ** is available to hold the result, or if the result would exceed the
4637 ** makes it a no-op, but the sqlite3_stmt_readonly() result would still
4779 ** is ignored and the end result is the same as sqlite3_bind_null().
4813 ** contain embedded NULs. The result of expressions involving strings
4863 ** result is undefined and probably harmful.
4976 ** ^Return the number of columns in the result set returned by the
4993 ** in the result set of a [SELECT] statement. ^The sqlite3_column_name()
5010 ** ^The name of a result column is the value of the "AS" clause for
5023 ** table column that is the origin of a particular result column in
5039 ** ^These functions return information about the Nth result column returned by
5047 ** or column that query result column was extracted from.
5057 ** for the same [prepared statement] and result column
5073 ** returned result set of that [SELECT] is a table column (not an
5075 ** column is returned.)^ ^If the Nth column of the result set is an
5087 ** this routine would return the string "VARIANT" for the second result
5088 ** column (i==1), and a NULL pointer for the first result column (i==0).)^
5120 ** ^With the "v2" interface, any of the other [result codes] or
5121 ** [extended result codes] might be returned as well.
5160 ** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from
5188 ** CAPI3REF: Number of columns in a result set
5192 ** current row of the result set of [prepared statement] P.
5247 ** <tr><td><b>sqlite3_column_blob</b><td>→<td>BLOB result
5248 ** <tr><td><b>sqlite3_column_double</b><td>→<td>REAL result
5249 ** <tr><td><b>sqlite3_column_int</b><td>→<td>32-bit INTEGER result
5250 ** <tr><td><b>sqlite3_column_int64</b><td>→<td>64-bit INTEGER result
5251 ** <tr><td><b>sqlite3_column_text</b><td>→<td>UTF-8 TEXT result
5252 ** <tr><td><b>sqlite3_column_text16</b><td>→<td>UTF-16 TEXT result
5253 ** <tr><td><b>sqlite3_column_value</b><td>→<td>The result as an
5257 ** or a UTF-8 TEXT result in bytes
5262 ** datatype of the result
5268 ** result row of a query. ^In every case the first argument is a pointer
5272 ** should be returned. ^The leftmost column of the result set has the index 0.
5273 ** ^The number of columns in the result can be determined using
5277 ** column index is out of range, the result is undefined.
5289 ** each return the value of a result column in a specific data format. If
5290 ** the result column is not initially in the requested format (for example,
5296 ** of the result column. ^The returned value is one of [SQLITE_INTEGER],
5302 ** After a type conversion, the result of calling sqlite3_column_type()
5307 ** If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes()
5311 ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
5313 ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
5315 ** ^If the result is a numeric value then sqlite3_column_bytes() uses
5318 ** ^If the result is NULL, then sqlite3_column_bytes() returns zero.
5320 ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
5322 ** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
5324 ** ^If the result is a numeric value then sqlite3_column_bytes16() uses
5327 ** ^If the result is NULL, then sqlite3_column_bytes16() returns zero.
5356 ** These routines may attempt to convert the datatype of the result.
5357 ** ^For example, if the internal representation is FLOAT and a text result
5419 ** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
5421 ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls
5487 ** statement after it has been finalized can result in undefined and
5544 ** will result in [SQLITE_MISUSE] being returned.
5568 ** to signal that the function will always return the same result given
5883 ** the value for that column returned without setting a result (probably
5964 ** memory allocation fails. ^If V is a [pointer value], then the result
6138 ** ^The sqlite3_result_blob() interface sets the result from
6144 ** interfaces set the result of the application-defined function to be
6147 ** ^The sqlite3_result_double() interface sets the result from
6170 ** returned by SQLite as a result of an error in a function. ^By default,
6199 ** ^SQLite takes the text result from the application from
6208 ** function result. If the 3rd parameter is non-negative, then it
6213 ** result of expressions operating on strings with embedded NULs is undefined.
6216 ** function as the destructor on the text or BLOB result when it has
6217 ** finished using that result.
6220 ** assumes that the text or BLOB result is in constant space and does not
6222 ** when it has finished using that result.
6225 ** then SQLite makes a copy of the result into space obtained
6247 ** ^The sqlite3_result_value() interface sets the result of
6257 ** ^The sqlite3_result_pointer(C,P,T,D) interface sets the result to an
6301 ** the result from the [application-defined SQL function] with
6591 ** open can result in a corrupt database.
6704 ** private copy of the result prior to releasing the mutex.
6890 ** does some arithmetic on its input parameters and returns a result.
7158 ** sqlite3_table_column_metadata(X,D,T,C,...) is NULL then the result is
7312 ** arguments and expects an integer result as if the signature of the
8453 ** sqlite3_keyword_name(N,Z,L) result in undefined behavior.
8460 ** a keyword as an identifier as long as such use does not result in a
8575 ** These methods do not return a result code. ^If an error occurs, that fact
8893 ** the number of table searches or result rows, that would tend to indicate
9472 ** crash or deadlock may be the result.
9528 ** or "DROP INDEX" query, an infinite loop might be the result.
9957 ** method can optionally return without setting a result, without calling
10010 ** of a [virtual table] implementation. The result of calling this
10062 ** [sqlite3_index_info] object or an incorrect answer may result.
10083 ** The result of invoking this interface from any other context is
10156 ** The result of invoking these interfaces from any other context
10205 ** of a [virtual table] implementation. The result of calling this interface
10219 ** can return an result code other than SQLITE_OK or SQLITE_NOTFOUND if
10252 ** [SQLITE_ABORT] is also a [result code].
10472 ** callback was invoked as a result of a direct insert, update, or delete
10665 ** file, the result of the comparison is undefined.
10667 ** Additionally, the result of the comparison is only valid if both of the
11115 ** instead of directly as a result of a users SQL statement.
11332 ** a useful result, the sqlite3_session object must have been configured
11811 ** single changeset. The result is a changeset equivalent to applying
11874 ** <li> The result of combining all input changesets together is obtained
12245 ** handler while processing an INSERT change if the operation would result
12736 sqlite3_context *pCtx, /* Context for returning result/error */
13323 ** * Terms in the result set of a SELECT statement
13361 ** level of recursion for each term. A stack overflow can result
17025 int errMask; /* & result codes with this before returning */
17189 /* result set is empty */
18031 i8 default_rc; /* Comparison result if keys are equal */
18271 ** expression is used as a result in an aggregate SELECT, then the
18280 ** register number containing the result of the subquery. If the
18281 ** subquery gives a constant result, then iTable is -1. If the subquery
18322 ** access them will result in a segfault or malfunction.
18334 ** access them will result in a segfault or malfunction.
18346 ** TK_SELECT: 1st register of result vector */
18349 ** TK_SELECT_COLUMN: column of the result vector */
18491 ** ENAME_NAME (1) the AS of result set column
18497 ** ENAME_SPAN Text of the original result set
18520 u16 iOrderByCol; /* For ORDER BY, column number in result set */
18532 #define ENAME_NAME 0 /* The AS clause of a result set */
18533 #define ENAME_SPAN 1 /* Complete text of the result set expression */
18534 #define ENAME_TAB 2 /* "DB.TABLE.NAME" for the result set */
18707 ** pEList corresponds to the result set of a SELECT and is NULL for
18726 ExprList *pEList; /* Optional list of result-set columns */
18820 ** for the result set. The KeyInfo for addrOpenEphm[2] contains collating
18825 LogEst nSelectRow; /* Estimated number of result rows */
18830 ExprList *pEList; /* The fields of the result */
18898 ** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result
18906 ** opcode) for each row in the result set.
18908 ** SRT_Mem Only valid if the result is a single column.
18909 ** Store the first column of the first result row
18913 ** SRT_Set The result must be a single column. Store each
18914 ** row of result as the key in table pDest->iSDParm.
18919 ** the result there. The cursor is left open after
18927 ** and the result row is stored in pDest->nDest registers
18957 #define SRT_Union 1 /* Store result as keys in an index */
18958 #define SRT_Except 2 /* Remove result from a UNION index */
18959 #define SRT_Exists 3 /* Store 1 if the result is not empty */
18968 #define SRT_Queue 7 /* Store result in an queue */
18969 #define SRT_Fifo 8 /* Store result as data with an automatic rowid */
18974 #define SRT_Output 9 /* Output each row of result */
18975 #define SRT_Mem 10 /* Store result in a memory cell */
18978 #define SRT_Coroutine 13 /* Generate a single row of result */
18979 #define SRT_Table 14 /* Store result as data with an automatic rowid */
18980 #define SRT_Upfrom 15 /* Store result as data with rowid */
19026 ** accessed (or set to 0 for triggers fired as a result of INSERT
19734 int regResult; /* Interim result */
22055 ** sqlite3aGTb[opcode] depending on whether the result of compare(A,B)
22303 ** result in TSAN warnings. But as the variable does not exist in
22332 ** Changing the pending byte during operation will result in undefined
22867 u16 nResColumn; /* Number of columns in one row of the result set */
23800 ** Write the result into the DateTime structure and return 0
24207 ** SQLite (0..5373484.5) then the result will be NULL.
28413 ** are not met, then the mutexes will fail and problems will result.
28456 ** are not met, then the mutexes will fail and problems will result.
31042 ** as the result of an SQL function.
31621 sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set");
34014 ** Return TRUE if the result is a valid real number (or integer) and FALSE
34033 ** returns FALSE but it still converts the prefix and writes the result
34050 double result;
34156 result = sign<0 ? -(double)0 : (double)0;
34179 result = (double)s;
34186 result = s / scale;
34187 result /= 1.0e+308;
34189 result = s * scale;
34190 result *= 1.0e+308;
34194 result = 0.0*s;
34197 result = INFINITY*s;
34199 result = 1e308*1e308*s; /* Infinity */
34206 result = s / scale;
34208 result = s * scale;
34214 /* store the result */
34215 *pResult = result;
34234 ** Render an signed 64-bit integer as text. Store the result in zOut[].
35031 ** the other 64-bit signed integer at *pA and store the result in *pA.
35969 /* Expand the key name with an appropriate prefix and put the result
41466 ** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
42134 ** recreated as a result of outstanding references) or an SQLite error
43317 int *pResOut /* Write result boolean here */
43650 ** the number of seconds since 1970 and is used to set the result of
45407 * data will almost certainly result in an immediate access violation.
47209 ** result in the failing I/O operation being retried by the caller. If
47730 ** fail. This is a very unreasonable result, but Windows is notorious
47993 ** This can result in incremental vacuum not truncating the file,
48262 OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res));
48286 OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res));
48367 OSTRACE(("LOCK-PENDING-FAIL file=%p, count=%d, result=%d\n",
48438 ** return the appropriate result code.
48469 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res));
48476 OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res));
49485 ** recreated as a result of outstanding references) or an SQLite error
49741 ** supports for filenames into UTF-8. Space to hold the result is
49761 ** operating system wants filenames in. Space to hold the result
51008 ** the number of seconds since 1970 and is used to set the result of
53024 pcacheTrace(("%p.FETCH %d%s (result: %p) ",pCache,pgno,
53044 sqlite3_pcache_page **ppPage /* Write result here */
53121 ** result.
53342 PgHdr result, *pTail;
53343 pTail = &result;
53364 return result.pDirty;
57975 ** database active. However such a page may be rolled back as a result
58465 /* If this playback is happening automatically as a result of an IO or
58807 ** integer multiple of the page-size, round up the result.
59667 ** result in a coredump.
63599 ** the correct result. There may be entries in the hash table with
63939 u32 iPrior; /* Last result returned from the iterator */
63984 ** Three possible result scenarios:
64850 ** of these constants would result in an incompatible on-disk format
65468 /* If the database may grow as a result of this checkpoint, hint
65673 ** read it, which might result in inconsistency. A dirty read is detected
66584 ** result obtained using the hash indexes above. */
66743 ** committed. As a result, the call to xUndo may not fail.
67059 ** an out-of-order write following a WAL restart could result in
69743 ** way will result in an incompatible file format.
71203 ** the right size. This is to guard against size changes that result
72989 ** a tripped cursor will result in an error.
73372 ** is invalid, the result of this routine is undefined.
74188 ** An integer is written into *pRes which is the result of
74416 ** An integer is written into *pRes which is the result of
74649 ** as well as the boolean result value.
75414 ** STore the result code (SQLITE_OK or some error code) in rc.
75859 ** entries, shift down. The end result is that each ixNx[] entry should
77901 ** fails. Internal data structure corruption will result otherwise.
78710 ** number of entries in the b-tree and write the result to *pnEntry.
80998 ** result of the aggregate is stored back into pMem.
81784 ** The result is written into the pMem element.
81890 ** If that is the case, then the result must be aligned on an even byte
81993 ** object containing the result before returning SQLITE_OK.
81995 ** Affinity aff is applied to the result of the function before returning.
81996 ** If the result is a text value, the sqlite3_value object uses encoding
82437 Mem *pMem = *ppVal; /* Write result into this Mem object */
83315 ** Assert if an Abort at this point in time might result in a corrupt
84779 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
84789 ** the result, result columns may become dynamic if the user calls
84803 /* The first 8 memory cells are used for the result set. So we will
85237 ** Set the number of result columns that will be returned by this SQL
85652 ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
85689 ** transaction will be committed or rolled back as a result of the
85887 ** Each VDBE holds the result of the most recent sqlite3_step() call
85888 ** in p->rc. This routine sets that result back to SQLITE_OK.
85943 ** Write any error messages into *pzErrMsg. Return the result code.
86039 ** the result code. Write any error message text into *pzErrMsg.
86369 ** upper 4 bytes. Return the result.
86428 ** and store the result in pMem.
86648 ** Return true if the result of comparison is equivalent to desiredResult.
86723 rc = -rc; /* Invert the result for DESC sort order. */
87592 int *res /* Write the comparison result here */
87703 ** to sqlite3_reoptimize() that re-preparing the statement may result
87955 ** success/failure code that describes the result of executing the virtual
88232 ** the function result.
88235 ** result as a string or blob. Appropriate errors are set if the string/blob
88460 /* Force the INT64 value currently stored as the result to be
88636 /* There are only a limited number of result codes allowed from the
88774 ** performance by substituting a NULL result, or some other light-weight
89004 ** Return the number of columns in the result set for the statement pStmt.
89085 ** malloc() has failed, the threads mallocFailed flag is cleared and the result
89117 ** in the result set.
89123 ** need to call malloc() to expand the result of a zeroblob()
89192 ** 4 The name of the table column that the result column derives from
89194 ** If the result is not a simple column reference (if it is an expression
89243 ** Return the name of the Nth column of the result set returned by SQL
89267 ** of the result set of SQL statement pStmt.
89281 ** Return the name of the database from which a result column derives.
89282 ** NULL is returned if the result column is an expression or constant or
89295 ** Return the name of the table from which a result column derives.
89296 ** NULL is returned if the result column is an expression or constant or
89309 ** Return the name of the table column from which a result column derives.
89310 ** NULL is returned if the result column is an expression or constant or
89597 ** The result is always UTF-8.
90425 ** if the result of comparison is NULL. For M=3, I=2 the jump may or
90608 ** point or exponential notation, the result is only MEM_Real, even
90685 ** Try to convert the type of a function argument or a result column
91447 ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
91901 ** to returning results such as a row change count or the result of a
91918 ** the result row.
91972 /* The registers in the result will not be used again when the
91994 ** register P2 and store the result in register P3.
92065 ** and store the result in register P3.
92066 ** If either input is NULL, the result is NULL.
92073 ** and store the result in register P3.
92074 ** If either input is NULL, the result is NULL.
92080 ** and store the result in register P3.
92081 ** If either input is NULL, the result is NULL.
92087 ** and store the result in register P3 (P3=P2/P1). If the value in
92088 ** register P1 is zero, then the result is NULL. If either input is
92089 ** NULL, the result is NULL.
92095 ** register P1 and store the result in register P3.
92096 ** If the value in register P1 is zero the result is NULL.
92097 ** If either operand is NULL, the result is NULL.
92212 ** store the result in register P3.
92213 ** If either input is NULL, the result is NULL.
92219 ** store the result in register P3.
92220 ** If either input is NULL, the result is NULL.
92227 ** Store the result in register P3.
92228 ** If either input is NULL, the result is NULL.
92235 ** Store the result in register P3.
92236 ** If either input is NULL, the result is NULL.
92294 ** The result is always an integer.
92413 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
92414 ** true or false and is never NULL. If both operands are NULL then the result
92415 ** of comparison is true. If either operand is NULL then the result is false.
92416 ** If neither operand is NULL the result is the same as it would be if
92419 ** This opcode saves the result of comparison for use by the new
92457 ** This opcode saves the result of comparison for use by the new
92540 ** then the result is always NULL.
92625 ** If result of an OP_Eq comparison on the same two operands as the
92627 ** If the result of an OP_Eq comparison on the two previous
92671 ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
92785 ** write the result into register P3.
92787 ** If either P1 or P2 is 0 (false) then the result is 0 even if
92797 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
93161 ** the result.
93163 ** If the OPFLAG_LENGTHARG bit is set in P5 then the result is guaranteed
93166 ** OPFLAG_TYPEOFARG bit is set then the result will only be used by the
93358 ** columns. So the result will be either the default value or a NULL.
93521 /* When applying REAL affinity, if the result is still an MEM_Int
93584 /* When applying REAL affinity, if the result is still an MEM_Int
93634 ** only used inside an assert() and does not affect the end result.
93863 ** the output register to hold the full result */
94979 int res; /* Comparison result */
96014 ** the next Next instruction will be a no-op. As a result, in this case
97953 ** for an aggregate and store the result in P1.
97965 ** Invoke the xValue() function and store the result in register P3.
98152 ** the file into which the result of vacuum should be written. When
98422 ** the filtered result set is empty.
98435 ** A jump is made to P2 if the result set after filtering would be empty.
98545 ** Advance virtual table P1 to the next row in its result set and
98547 ** the end of its result set, then fall through to the next instruction.
98748 ** The result of the function is stored
98767 ** The result of the function is stored
99805 ** the ORDER BY key columns and result columns
99986 ** pairs of PMA keys together. Element i contains the result of
100550 ** used by the comparison. Return the result of the comparison.
101412 /* Compare pReadr1 and pReadr2. Store the result in variable iRes. */
101810 int iOut /* Store the result in pMerger->aTree[iOut] */
103338 ** case none of the code in this module is executed as a result of calls
103726 ** result set in pEList.
103745 ExprList *pEList, /* A result set */
103746 int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
103747 Expr *pExpr, /* Transform this into an alias to the result set */
103750 Expr *pOrig; /* The iCol-th column of the result set */
103783 ** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN".
104226 ** might refer to an result-set alias. This happens, for example, when
104232 ** forms the result set entry ("a+b" in the example) and return immediately.
104233 ** Note that the expression in the result set should have already been
104236 ** The ability to use an output result-set column in the WHERE, GROUP BY,
104978 ** pEList is a list of expressions which are really the result set of the
105019 ** ORDER BY term is not an integer index into the result set. That
105022 ** Attempt to match pE against result set columns in the left-most
105037 ExprList *pEList; /* The columns of the result set */
105062 ** in the result set. Return an 1-based index of the matching
105063 ** result-set entry.
105099 ** are matched against result set expressions of compound SELECT
105202 "column in the result set", i+1);
105212 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
105213 ** field) then convert that term into a copy of the corresponding result set
105286 ** number of columns in the result set of the SELECT) then the expression
105287 ** in the resolution is a copy of the I-th result-set expression. If
105289 ** a result-set expression, then the term resolves to a copy of the
105290 ** result-set expression. Otherwise, the expression is resolved in
105307 int nResult; /* Number of terms in the result set */
105320 ** a copy of the iCol-th result-set column. The subsequent call to
105322 ** copy of the iCol-th result-set expression. */
105330 ** order-by term to a copy of the result-set expression */
105347 ** to an identical expression in the result set, remove all Window
105455 ** resolve the result-set expression list.
105461 /* Resolve names in the result set. */
105465 /* If there are no aggregate functions in the result-set, and no GROUP BY
105481 ** aliases in the result set.
105530 ** These integers will be replaced by copies of the corresponding result
105540 ** below, after all of the result-sets for all of the elements of
105602 ** table columns and result-set columns. At the same time, do error
105625 ** To resolve result-set references, look for expression nodes of the
105627 ** size of an AS clause in the result-set of a SELECT. The Z expression
105628 ** is replaced by a copy of the left-hand side of the result-set expression.
106225 ** columns of result. Every TK_VECTOR node is an vector because the
106228 ** considered a vector if it has two or more result columns.
106265 ** just the expression for the i-th term of the result set, and may
106320 ** pLeft->iTable: First in an array of register holding result, or 0
106321 ** if the result is not yet computed.
106355 ** it. Return the register in which the result is stored (or, if the
106357 ** of registers in which the result is stored).
106418 ** the result of the comparison (1, 0, or NULL) and write that
106419 ** result into register dest.
107691 ** wildcards ("*") in the result set of the SELECT must be expanded before
108303 ** hand, a false negative (returning FALSE when the result could be NULL)
108304 ** will likely result in an incorrect answer. So when in doubt, return
108341 ** is harmless. A false positive, however, can result in the wrong
108572 ** whether or not the SELECT result contains NULL values, check whether
109058 ** Return the register that holds the result. For a multi-column SELECT,
109059 ** the result is stored in a contiguous array of registers and the
109060 ** return value is the register of the left-most result column.
109068 SelectDest dest; /* How to deal with SELECT result */
109107 ** save the results, and reuse the same result on subsequent invocations.
109133 VdbeComment((v, "Init subquery result"));
109137 VdbeComment((v, "Init EXISTS result"));
109211 ** subquery. If the RHS is a subquery, the number of result columns must
109216 ** The result is false if the LHS is definitely not in the RHS. The
109217 ** result is NULL if the presence of the LHS in the RHS cannot be
109371 ** LHS does contain NULLs then the result must be either FALSE or NULL.
109389 ** of the RHS using the LHS as a probe. If found, the result is
109413 ** an match on the search above, then the result must be FALSE.
109426 ** If any comparison is NULL, then the result is NULL. If all
109427 ** comparisons are FALSE then the final result is FALSE.
109460 /* Step 7: If we reach this point, we know that the result must
109565 ** and store the result in register regOut
109571 int regOut /* Put the result in this register */
109690 ** the result in continguous temporary registers. Return the index of
109691 ** the first register used to store the result.
109693 ** If the returned result register is a temporary scalar, then also write
109694 ** that register number into *piFreeable. If the returned result register
109742 int target /* Store function result in this register */
109788 /* The UNLIKELY() function is a no-op. The result is the value
109861 int target /* Where to store the result of the expression */
109906 ** be stored in target. The result might be stored in some other
110280 ** multiple times if we know they always give the same result */
110584 ** is even, then Y is omitted and the "otherwise" result is NULL.
110587 ** The result of the expression is the Ri for the first matching Ei,
110624 ** The value in regFree1 might get SCopy-ed into the file result.
110698 ** If regDest>=0 then the result is always stored in that register and the
110699 ** result is not reusable. If regDest<0 then this routine is free to
110758 ** then write its number into *pReg. If the result register is not
110927 ** NULL: Store the boolean result in reg[dest]
111389 ** just might result in some slightly slower code. But returning
111496 ** a malfunction will result.
111759 ** False positives are not allowed, however. A false positive may result
112238 ** Allocate a single new register for use to hold some intermediate result.
113500 ** true, then zNew is always quoted first. If no error occurs, the result
113501 ** is loaded into context object pCtx as the result.
113507 sqlite3_context *pCtx, /* Return result here */
117772 /* This can result either from an OOM or because the formatted string
118908 ** statement with a result set that is the argument of the RETURNING clause.
120086 ** the new table will match the result set of the SELECT.
120523 Table *pSelTab; /* A fake table from which we get the result set */
120855 ** move as a result of the drop (can happen in auto-vacuum mode).
121752 ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
121770 ** considered distinct and both result in separate indices.
122216 ** If the iStart argument had been 1 instead of 2, then the result
122218 ** the iStart value would be 0. The result then would
123831 ** Evaluate a view and store its result in an ephemeral table. The
124919 ** If both haystack and needle are BLOBs, then the result is one more than
125250 ** 2s complement of that positive value. The end result can
125654 ** Implementation of the NULLIF(x,y) function. The result is the first
125655 ** argument if the arguments are different. The result is NULL if the
125671 ** Implementation of the sqlite_version() function. The result is the version
125686 ** Implementation of the sqlite_source_id() function. The result is a string
125718 ** The result is an integer that identifies if the compiler option
125742 ** The result is a string that identifies the compiler options
125964 ** them A, B, and C. The result is also a string which is derived
126480 ** stored as actually incorporated into presently accumulated result.
129255 ** insert the select result into <table> from R..R+n
129534 /* Set useTempTable to TRUE if the result of the SELECT statement
129715 ** insert the select result into <table> from R..R+n
130567 ** triggers or FK resolution actions) might run as a result of deletes
131390 ExprList *pEList; /* The result set of the SELECT */
131451 return 0; /* The result set must have exactly one column */
131455 return 0; /* The result set must be the special operator "*" */
131788 ** If the SQL is a query, then for each row in the query result
131803 char **azCols = 0; /* Names of result columns */
132029 void (*free_table)(char**result);
133631 /* Names of columns for pragmas that return multi-column result
133633 ** result column is different from the name of the pragma
134406 ** Set result column names for a pragma.
134591 ** Generate code to output a single-column result row with a value of the
134592 ** string held in register 3. Decrement the result count in register 1
134593 ** and halt if the maximum number of result rows have been issued.
134735 /* Register the result column names for pragmas that return results */
135756 int x; /* result variable */
135757 int regResult; /* 3 registers to hold a result row */
138334 ExprList *pEList, /* which columns to include in the result */
138443 ** type and returns a result. Examples of accepted nonsense join types
138534 ** Mark a subquery result column as having been used.
138682 ** * ON and USING clauses result in extra terms being added to the
138839 ** needed to load the next result row that is to be added to the sorter.
138874 ** Return the register in which the result is stored.
139078 ** in an array of registers used to store the previous result row so that
139314 int nResultCol; /* Number of result columns */
139319 ** containing the current result row. In this case regOrig is set to the
139324 int regOrig; /* Start of memory holding full result (or 0) */
139366 /* This is an error condition that can result, for example, when a SELECT
139367 ** on the right-hand side of an INSERT contains more result columns than
139469 ** part of the result.
139493 /* In this mode, write each query result to the key of the temporary
139506 /* Construct a record from the query result, but instead of
139516 /* Store the result as data using a unique key.
139608 /* If any row exist in the result set, record that fact and abort.
139780 ** implement that clause. If the ExprList is the result set of a SELECT
139829 ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
140085 ** result-set expression in all of the following SELECT statements is
140169 ** data for the result-set column of the sub-select.
140221 ** origin info for the single column in the result set of the SELECT
140252 ** in the result set.
140257 ExprList *pEList /* Expressions defining the result set */
140310 ** other words, the zSpan of the result expression.
140312 ** short=ON, full=OFF: (This is the default setting). If the result
140314 ** result column name is just the table column
140317 ** full=ON, short=ANY: If the result refers directly to a table column,
140318 ** then the result column name with the table name
140394 ** that form the result set of a SELECT statement) compute appropriate
140423 Column *aCol, *pCol; /* For looping over result columns */
140424 int nCol; /* Number of columns in the result set */
140583 ** the result set of that SELECT.
140705 ** the result set for the compound-select statement "p". Return NULL if
141096 ** in their result sets.
141167 int unionTab; /* Cursor number of the temp table holding result */
141354 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
141357 int nCol; /* Number of columns in result set */
141406 ** size result sets.
141413 " do not have the same number of result columns",
141444 int regPrev, /* Previous result register. No uniqueness if 0 */
141476 /* Store the result as data using a unique key.
141531 /* If none of the above, then the result destination must be
141537 ** return the next row of result.
141686 u32 *aPermute; /* Mapping from ORDER BY terms to result set columns */
141706 ** the ORDER BY clause covers every term of the result set. Add
141751 ** for the logic that removes duplicate result rows when the
142020 ** whose result set is defined by pEList appears as entry in the
142024 ** of the subquery rather the result set of the subquery.
142325 ** The code generated for this simplification gives the same result
142405 ** (17h) The corresponding result set expressions in all arms of the
142416 ** of result columns. This is actually a requirement for any compound
142431 ** appear as unmodified result columns in the outer query. But we
142488 int iParent; /* VDBE cursor number of the pSub result set temp table */
142822 /* Now begin substituting subquery result set expressions for
143457 ** result in incorrect answers and/or crashes. So, when in doubt, return NULL.
143533 ** result columns as on the ORDER BY clause. See ticket
143557 ** to a result column of the SELECT statement. This occurs when the
143967 ** (4) Scan the list of columns in the result set (pEList) looking
144123 ** If we get here it means the result set contains one or more "*"
144125 ** in the result set and expand them one by one.
144220 ** result-set list unless the SELECT has the SF_IncludeHidden
144313 sqlite3ErrorMsg(pParse, "too many columns in result set");
144322 SELECTTRACE(0x100,pParse,p,("After result-set wildcard expansion:\n"));
144374 ** information to the Table structure that represents the result set
144377 ** The Table structure that represents the result set was constructed
144436 ** * Wildcards "*" and "TABLE.*" in result sets are expanded.
144796 if( p->pEList->nExpr!=1 ) return 0; /* Single result column */
145107 /* If the outer query contains a "complex" result set (that is,
145108 ** if the result set of the outer query uses functions or subqueries)
145119 ** The requirement that the outer query have a complex result set
145284 /* Implement a co-routine that will return a single row of the result
145306 ** holds the result of the materialization. */
145448 /* Delete or NULL-out result columns that will never be used */
145576 /* Remove any and all aliases between the result set and the
145713 int addrOutputRow; /* Start of subroutine that outputs a result row */
145844 ** This is an optimization - the correct answer should result regardless.
145914 /* Output the final row of result
145923 /* Generate a subroutine that outputs a single row of the result
145938 VdbeComment((v, "Groupby result generator entry point"));
145946 VdbeComment((v, "end groupby result generator"));
146186 ** to the callback function is uses to build the result.
146192 u32 nRow; /* Number of rows in the result */
146193 u32 nColumn; /* Number of columns in the result */
146199 ** This routine is called once for each row in the result table. Its job
146207 char *z; /* A single column of result */
146269 ** malloc() for space to hold the result and return the entire results
146272 ** The result that is written to ***pazResult is held in memory obtained
146280 char ***pazResult, /* Write the result table here */
146281 int *pnRow, /* Write the number of rows in the result here */
146282 int *pnColumn, /* Write the number of columns of result here */
147267 /* The input list pList is the list of result set terms from a RETURNING
147930 ** performance degradation, but false-negatives can result in a corrupt
147960 ** performance degradation, but false-negatives can result in a corrupt
148570 ** be deleted as a result of REPLACE conflict handling. Any of these
149035 int ephemTab; /* Table holding the result of the SELECT */
149537 ** Take each row of result and call execSql() again recursively.
150243 ** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously
152449 ** result-set. Since the result-set of the SELECT statement may
152476 ** of which is returned. An attempt is made store the result in iTarget but
152934 ** expression, as the result of the expression must be stored in a
153116 ** result in register iReg.
154242 ** the row has already been included in the result set and
155608 ** returned when it should not be, then incorrect answers might result.
156641 ** inner-most loop, in the sense that a correct answer will result.
157141 ExprList *pDistinct /* The result set that needs to be DISTINCT */
157938 ** not result in a valid plan.
158047 ** smaller than sample 1, so the binary search would not work. As a result,
160599 ** result (if the xBestIndex() implementation is sane). */
161408 ** -1, indicating that the result set may or may not be ordered,
161868 /* Attempt to omit tables from a join that do not affect the result.
161869 ** For a table to not affect the result, the following must be true:
162112 ** the WHERE clause, it might result in additional nested loops for
162176 ExprList *pResultSet, /* Query result set. Req'd for DISTINCT */
162332 ** generated code if the result is not true.
162360 /* Try to ORDER BY the result set to make distinct processing easier */
162458 /* Attempt to omit tables from a join that do not affect the result.
162992 ** the co-routine into OP_Copy of result contained in a register.
164015 ** expression list pList. Return a pointer to the result list.
164235 ** result-set or ORDER BY clause of the SELECT statement p. */
164597 ** evaluated and the result left in register reg. This function generates VM
165217 ** a numeric type (real or integer), then the result of the addition
172324 ** end result.
177376 ** Enable or disable the extended result codes.
181565 int cmp; /* memcmp() result */
182809 char **ppOut /* OUT: Malloced result buffer */
183058 ** routine to find out if it has reached the end of a result set.
183071 ** retrieve the rowid for the current row of the result set. fts3
184695 ** Then, for each token, defer it if loading the doclist would result in
186897 ** of pNew and the existing nodes of the tree. This may result in the head
189456 ** statement and returns one row for each token in the result. With
190096 ** When a b+tree is written to the database (either as a result of a merge
193002 ** iAbsLevel. Promote any segments that should be promoted as a result.
193325 int *pRC, /* The result code */
195300 ** Argument pVal contains the result of <expr>. Currently the only
197578 ** sqlite3FtsUnicodeIsalnum() function already returns the desired result.
198583 /* Make the JSON in p the result of the SQL function.
199768 ** always return a JSON representation of the result. If JSON_SQL is set,
199769 ** then always return an SQL representation of the result. If neither flag
199773 ** When multiple PATH arguments are supplied, the result is a JSON array
199774 ** containing the result of each PATH.
199941 ** object that is the result of running the RFC 7396 MergePatch() algorithm
199951 JsonNode *pResult; /* The result of the merge */
200015 ** Remove the named elements from JSON and return the result. malformed
200016 ** JSON or PATH arguments result in an error.
201884 RtreeCoord *pCoord /* OUT: Space to write result to */
202343 ** SearchPoints, then iLevel becomes the deciding factor and the result
202551 ** contains an entry suitable for returning as a result-set row,
207611 ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
207635 ** then the result is also NULL.
208238 ** pass unnoticed, or result in SQLITE_CONSTRAINT errors (due to UNIQUE
208442 ** user-defined SQL function "rbu_delta()" is invoked and the result stored in
208460 ** It is replaced by the result of applying the specified fossil delta to
208470 ** causes a result similar to:
209322 ** Compute a 32-bit checksum on the N-byte buffer. Return the result.
209842 ** the printf() style substitutions and executes the result as an SQL
211846 ** As a result, unless an error (i.e. OOM or SQLITE_BUSY) occurs, the
212080 ** one of the following values to indicate the result:
214389 ** Compute the best query strategy and return the result in idxNum.
215315 /* Default setting is no rows of result */
219989 ** the result will be SQLITE_OK with 0 rows modified. */
221397 sqlite3_context *pCtx, /* Context for returning result/error */
224488 sqlite3_context *pCtx, /* Context for returning result/error */
224660 sqlite3_context *pCtx, /* Context for returning result/error */
224919 sqlite3_context *pCtx, /* Context for returning result/error */
230499 ** even number, is stored in aFirst[(nSeg+N)/2]. The "result" of the
231273 ** as a result. Segments are promoted in two scenarios:
232587 ** fts5AssertMultiIterSetup(). It ensures that the result currently stored
232588 ** in *pRes is the correct result of comparing the current positions of the
236981 ** then this variable contains the result of the query.
238224 ** routine to find out if it has reached the end of a result set.
238248 ** retrieve the rowid for the current row of the result set. fts5
244137 ** routine to find out if it has reached the end of a result set.
244213 ** retrieve the rowid for the current row of the result set. The
244316 ** over rows of the result
244336 ** result set of queries against stmt will look like.
244350 #define STMT_COLUMN_NCOL 1 /* Number of result columns */
244983 // You should clear key derive result of output before you call this function