| blob | b64ea28bf5e953535e6d0880c76bd8760afcbaaa |
1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains routines used for analyzing expressions and
13 ** for generating VDBE code that evaluates expressions in SQLite.
14 */
17 /* Forward declarations */
21 /*
22 ** Return the affinity character for a single column of a table.
23 */
27 }
29 /*
30 ** Return the 'affinity' of the expression pExpr if any.
31 **
32 ** If pExpr is a column, a reference to a column via an 'AS' alias,
33 ** or a sub-select with a column as the return value, then the
34 ** affinity of that column is returned. Otherwise, 0x00 is returned,
35 ** indicating no affinity for the expression.
36 **
37 ** i.e. the WHERE clause expressions in the following statements all
38 ** have an affinity:
39 **
40 ** CREATE TABLE t1(a);
41 ** SELECT * FROM t1 WHERE a;
42 ** SELECT a AS b FROM t1 WHERE b;
43 ** SELECT * FROM t1 WHERE (select a from t1);
44 */
51 }
59 }
61 #ifndef SQLITE_OMIT_CAST
65 }
66 #endif
69 }
74 );
75 }
78 }
80 }
82 /*
83 ** Set the collating sequence for expression pExpr to be the collating
84 ** sequence named by pToken. Return a pointer to a new Expr node that
85 ** implements the COLLATE operator.
86 **
87 ** If a memory allocation error occurs, that fact is recorded in pParse->db
88 ** and the pExpr parameter is returned unchanged.
89 */
95 ){
102 }
103 }
105 }
107 Token s;
111 }
113 /*
114 ** Skip over any TK_COLLATE operators.
115 */
120 }
122 }
124 /*
125 ** Skip over any TK_COLLATE operators and/or any unlikely()
126 ** or likelihood() or likely() functions at the root of an
127 ** expression.
128 */
139 }
140 }
142 }
144 /*
145 ** Return the collation sequence for the expression pExpr. If
146 ** there is no defined collating sequence, return NULL.
147 **
148 ** See also: sqlite3ExprNNCollSeq()
149 **
150 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
151 ** default collation if pExpr has no defined collation.
152 **
153 ** The collating sequence might be determined by a COLLATE operator
154 ** or by the presence of a column with a defined collating sequence.
155 ** COLLATE operators take first precedence. Left operands take
156 ** precedence over right operands.
157 */
167 ){
168 /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally
169 ** a TK_COLUMN but was previously evaluated and cached in a register */
174 }
176 }
180 }
184 }
188 }
194 /* The Expr.x union is never used at the same time as Expr.pRight */
199 ){
205 }
206 }
207 }
209 }
212 }
213 }
216 }
218 }
220 /*
221 ** Return the collation sequence for the expression pExpr. If
222 ** there is no defined collating sequence, return a pointer to the
223 ** defautl collation sequence.
224 **
225 ** See also: sqlite3ExprCollSeq()
226 **
227 ** The sqlite3ExprCollSeq() routine works the same except that it
228 ** returns NULL if there is no defined collation.
229 */
235 }
237 /*
238 ** Return TRUE if the two expressions have equivalent collating sequences.
239 */
244 }
246 /*
247 ** pExpr is an operand of a comparison operator. aff2 is the
248 ** type affinity of the other operand. This routine returns the
249 ** type affinity that should be used for the comparison operator.
250 */
254 /* Both sides of the comparison are columns. If one has numeric
255 ** affinity, use that. Otherwise use no affinity.
256 */
261 }
263 /* One side is a column, the other is not. Use the columns affinity. */
266 }
267 }
269 /*
270 ** pExpr is a comparison operator. Return the type affinity that should
271 ** be applied to both operands prior to doing the comparison.
272 */
286 }
288 }
290 /*
291 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
292 ** idx_affinity is the affinity of an indexed column. Return true
293 ** if the index with affinity idx_affinity may be used to implement
294 ** the comparison in pExpr.
295 */
300 }
303 }
305 }
307 /*
308 ** Return the P5 value that should be used for a binary comparison
309 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
310 */
315 ){
319 }
321 /*
322 ** Return a pointer to the collation sequence that should be used by
323 ** a binary comparison operator comparing pLeft and pRight.
324 **
325 ** If the left hand expression has a collating sequence type, then it is
326 ** used. Otherwise the collation sequence for the right hand expression
327 ** is used, or the default (BINARY) if neither expression has a collating
328 ** type.
329 **
330 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
331 ** it is not considered.
332 */
337 ){
348 }
349 }
351 }
353 /* Expresssion p is a comparison operator. Return a collation sequence
354 ** appropriate for the comparison operator.
355 **
356 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
357 ** However, if the OP_Commuted flag is set, then the order of the operands
358 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
359 ** correct collating sequence is found.
360 */
366 }
367 }
369 /*
370 ** Generate code for a comparison operator.
371 */
381 ){
391 }
397 }
399 /*
400 ** Return true if expression pExpr is a vector, or false otherwise.
401 **
402 ** A vector is defined as any expression that results in two or more
403 ** columns of result. Every TK_VECTOR node is an vector because the
404 ** parser will not generate a TK_VECTOR with fewer than two entries.
405 ** But a TK_SELECT might be either a vector or a scalar. It is only
406 ** considered a vector if it has two or more result columns.
407 */
410 }
412 /*
413 ** If the expression passed as the only argument is of type TK_VECTOR
414 ** return the number of expressions in the vector. Or, if the expression
415 ** is a sub-select, return the number of columns in the sub-select. For
416 ** any other type of expression, return 1.
417 */
427 }
428 }
430 /*
431 ** Return a pointer to a subexpression of pVector that is the i-th
432 ** column of the vector (numbered starting with 0). The caller must
433 ** ensure that i is within range.
434 **
435 ** If pVector is really a scalar (and "scalar" here includes subqueries
436 ** that return a single column!) then return pVector unmodified.
437 **
438 ** pVector retains ownership of the returned subexpression.
439 **
440 ** If the vector is a (SELECT ...) then the expression returned is
441 ** just the expression for the i-th term of the result set, and may
442 ** not be ready for evaluation because the table cursor has not yet
443 ** been positioned.
444 */
453 }
454 }
456 }
458 /*
459 ** Compute and return a new Expr object which when passed to
460 ** sqlite3ExprCode() will generate all necessary code to compute
461 ** the iField-th column of the vector expression pVector.
462 **
463 ** It is ok for pVector to be a scalar (as long as iField==0).
464 ** In that case, this routine works like sqlite3ExprDup().
465 **
466 ** The caller owns the returned Expr object and is responsible for
467 ** ensuring that the returned value eventually gets freed.
468 **
469 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
470 ** then the returned object will reference pVector and so pVector must remain
471 ** valid for the life of the returned object. If pVector is a TK_VECTOR
472 ** or a scalar expression, then it can be deleted as soon as this routine
473 ** returns.
474 **
475 ** A trick to cause a TK_SELECT pVector to be deleted together with
476 ** the returned Expr object is to attach the pVector to the pRight field
477 ** of the returned TK_SELECT_COLUMN Expr object.
478 */
483 ){
487 /* The TK_SELECT_COLUMN Expr node:
488 **
489 ** pLeft: pVector containing TK_SELECT. Not deleted.
490 ** pRight: not used. But recursively deleted.
491 ** iColumn: Index of a column in pVector
492 ** iTable: 0 or the number of columns on the LHS of an assignment
493 ** pLeft->iTable: First in an array of register holding result, or 0
494 ** if the result is not yet computed.
495 **
496 ** sqlite3ExprDelete() specifically skips the recursive delete of
497 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
498 ** can be attached to pRight to cause this node to take ownership of
499 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
500 ** with the same pLeft pointer to the pVector, but only one of them
501 ** will own the pVector.
502 */
507 }
513 }
515 }
517 /*
518 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
519 ** it. Return the register in which the result is stored (or, if the
520 ** sub-select returns more than one column, the first in an array
521 ** of registers in which the result is stored).
522 **
523 ** If pExpr is not a TK_SELECT expression, return 0.
524 */
527 #ifndef SQLITE_OMIT_SUBQUERY
530 }
531 #endif
533 }
535 /*
536 ** Argument pVector points to a vector expression - either a TK_VECTOR
537 ** or TK_SELECT that returns more than one column. This function returns
538 ** the register number of a register that contains the value of
539 ** element iField of the vector.
540 **
541 ** If pVector is a TK_SELECT expression, then code for it must have
542 ** already been generated using the exprCodeSubselect() routine. In this
543 ** case parameter regSelect should be the first in an array of registers
544 ** containing the results of the sub-select.
545 **
546 ** If pVector is of type TK_VECTOR, then code for the requested field
547 ** is generated. In this case (*pRegFree) may be set to the number of
548 ** a temporary register to be freed by the caller before returning.
549 **
550 ** Before returning, output parameter (*ppExpr) is set to point to the
551 ** Expr object corresponding to element iElem of the vector.
552 */
560 ){
566 }
570 }
573 }
575 /*
576 ** Expression pExpr is a comparison between two vector values. Compute
577 ** the result of the comparison (1, 0, or NULL) and write that
578 ** result into register dest.
579 **
580 ** The caller must satisfy the following preconditions:
581 **
582 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
583 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
584 ** otherwise: op==pExpr->op and p5==0
585 */
591 u8 p5 /* SQLITE_NULLEQ or zero */
592 ){
609 }
614 );
645 }
660 }
661 }
663 }
665 #if SQLITE_MAX_EXPR_DEPTH>0
666 /*
667 ** Check that argument nHeight is less than or equal to the maximum
668 ** expression depth allowed. If it is not, leave an error message in
669 ** pParse.
670 */
677 );
679 }
681 }
683 /* The following three functions, heightOfExpr(), heightOfExprList()
684 ** and heightOfSelect(), are used to determine the maximum height
685 ** of any expression tree referenced by the structure passed as the
686 ** first argument.
687 **
688 ** If this maximum height is greater than the current value pointed
689 ** to by pnHeight, the second parameter, then set *pnHeight to that
690 ** value.
691 */
696 }
697 }
698 }
704 }
705 }
706 }
716 }
717 }
719 /*
720 ** Set the Expr.nHeight variable in the structure passed as an
721 ** argument. An expression with no children, Expr.pList or
722 ** Expr.pSelect member has a height of 1. Any other expression
723 ** has a height equal to the maximum height of any other
724 ** referenced Expr plus one.
725 **
726 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
727 ** if appropriate.
728 */
738 }
740 }
742 /*
743 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
744 ** the height is greater than the maximum allowed expression depth,
745 ** leave an error in pParse.
746 **
747 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
748 ** Expr.flags.
749 */
754 }
756 /*
757 ** Return the maximum height of any expression tree referenced
758 ** by the select statement passed as an argument.
759 */
764 }
766 /*
767 ** Propagate all EP_Propagate flags from the Expr.x.pList into
768 ** Expr.flags.
769 */
773 }
774 }
775 #define exprSetHeight(y)
778 /*
779 ** This routine is the core allocator for Expr nodes.
780 **
781 ** Construct a new expression node and return a pointer to it. Memory
782 ** for this node and for the pToken argument is a single allocation
783 ** obtained from sqlite3DbMalloc(). The calling function
784 ** is responsible for making sure the node eventually gets freed.
785 **
786 ** If dequote is true, then the token (if it exists) is dequoted.
787 ** If dequote is false, no dequoting is performed. The deQuote
788 ** parameter is ignored if pToken is NULL or if the token does not
789 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
790 ** then the EP_DblQuoted flag is set on the expression node.
791 **
792 ** Special case: If op==TK_INTEGER and pToken points to a string that
793 ** can be translated into a 32-bit integer, then the token is not
794 ** stored in u.zToken. Instead, the integer values is written
795 ** into u.iValue and the EP_IntValue flag is set. No extra storage
796 ** is allocated to hold the integer text and the dequote flag is ignored.
797 */
803 ){
814 }
815 }
832 }
833 }
834 }
835 #if SQLITE_MAX_EXPR_DEPTH>0
837 #endif
838 }
840 }
842 /*
843 ** Allocate a new expression node from a zero-terminated token that has
844 ** already been dequoted.
845 */
850 ){
851 Token x;
855 }
857 /*
858 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
859 **
860 ** If pRoot==NULL that means that a memory allocation error has occurred.
861 ** In that case, delete the subtrees pLeft and pRight.
862 */
867 Expr *pRight
868 ){
877 }
881 }
883 }
884 }
886 /*
887 ** Allocate an Expr node which joins as many as two subtrees.
888 **
889 ** One or both of the subtrees can be NULL. Return a pointer to the new
890 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
891 ** free the subtrees and return NULL.
892 */
898 ){
910 }
912 }
914 /*
915 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
916 ** do a memory allocation failure) then delete the pSelect object.
917 */
926 }
927 }
930 /*
931 ** Join two expressions using an AND operator. If either expression is
932 ** NULL, then just return the other expression.
933 **
934 ** If one side or the other of the AND is known to be false, then instead
935 ** of returning an AND expression, just return a constant expression with
936 ** a value of false.
937 */
945 && !IN_RENAME_OBJECT
946 ){
952 }
953 }
955 /*
956 ** Construct a new expression node for a function with multiple
957 ** arguments.
958 */
964 ){
972 }
975 }
982 }
984 /*
985 ** Check to see if a function is usable according to current access
986 ** rules:
987 **
988 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
989 **
990 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
991 ** top-level SQL
992 **
993 ** If the function is not usable, create an error.
994 */
999 ){
1005 ){
1006 /* Functions prohibited in triggers and views if:
1007 ** (1) tagged with SQLITE_DIRECTONLY
1008 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1009 ** is tagged with SQLITE_FUNC_UNSAFE) and
1010 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1011 ** that the schema is possibly tainted).
1012 */
1014 }
1015 }
1016 }
1018 /*
1019 ** Assign a variable number to an expression that encodes a wildcard
1020 ** in the original SQL statement.
1021 **
1022 ** Wildcards consisting of a single "?" are assigned the next sequential
1023 ** variable number.
1024 **
1025 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1026 ** sure "nnn" is not too big to avoid a denial of service attack when
1027 ** the SQL statement comes from an external source.
1028 **
1029 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1030 ** as the previous instance of the same wildcard. Or if this is the first
1031 ** instance of the wildcard, the next sequential variable number is
1032 ** assigned.
1033 */
1037 ynVar x;
1046 /* Wildcard of the form "?". Assign the next variable number */
1052 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1053 ** use it as the variable number */
1054 i64 i;
1061 }
1070 }
1077 }
1079 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1080 ** number as the prior appearance of the same name, or if the name
1081 ** has never appeared before, reuse the same variable number
1082 */
1087 }
1088 }
1091 }
1092 }
1096 }
1097 }
1099 /*
1100 ** Recursively delete an expression tree.
1101 */
1104 /* Sanity check: Assert that the IntValue is non-negative if it exists */
1110 #ifdef SQLITE_DEBUG
1115 }
1116 #endif
1118 /* The Expr.x union is never used at the same time as Expr.pRight */
1129 #ifndef SQLITE_OMIT_WINDOWFUNC
1132 }
1133 #endif
1134 }
1135 }
1139 }
1140 }
1143 }
1145 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1146 ** expression.
1147 */
1152 }
1154 }
1155 }
1157 /*
1158 ** Return the number of bytes allocated for the expression structure
1159 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1160 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1161 */
1166 }
1168 /*
1169 ** The dupedExpr*Size() routines each return the number of bytes required
1170 ** to store a copy of an expression or expression tree. They differ in
1171 ** how much of the tree is measured.
1172 **
1173 ** dupedExprStructSize() Size of only the Expr structure
1174 ** dupedExprNodeSize() Size of Expr + space for token
1175 ** dupedExprSize() Expr + token + subtree components
1176 **
1177 ***************************************************************************
1178 **
1179 ** The dupedExprStructSize() function returns two values OR-ed together:
1180 ** (1) the space required for a copy of the Expr structure only and
1181 ** (2) the EP_xxx flags that indicate what the structure size should be.
1182 ** The return values is always one of:
1183 **
1184 ** EXPR_FULLSIZE
1185 ** EXPR_REDUCEDSIZE | EP_Reduced
1186 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1187 **
1188 ** The size of the structure can be found by masking the return value
1189 ** of this routine with 0xfff. The flags can be found by masking the
1190 ** return value with EP_Reduced|EP_TokenOnly.
1191 **
1192 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1193 ** (unreduced) Expr objects as they or originally constructed by the parser.
1194 ** During expression analysis, extra information is computed and moved into
1195 ** later parts of the Expr object and that extra information might get chopped
1196 ** off if the expression is reduced. Note also that it does not work to
1197 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1198 ** to reduce a pristine expression tree from the parser. The implementation
1199 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1200 ** to enforce this constraint.
1201 */
1208 #ifndef SQLITE_OMIT_WINDOWFUNC
1210 #endif
1211 ){
1223 }
1224 }
1226 }
1228 /*
1229 ** This function returns the space in bytes required to store the copy
1230 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1231 ** string is defined.)
1232 */
1237 }
1239 }
1241 /*
1242 ** Return the number of bytes required to create a duplicate of the
1243 ** expression passed as the first argument. The second argument is a
1244 ** mask containing EXPRDUP_XXX flags.
1245 **
1246 ** The value returned includes space to create a copy of the Expr struct
1247 ** itself and the buffer referred to by Expr.u.zToken, if any.
1248 **
1249 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1250 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1251 ** and Expr.pRight variables (but not for any structures pointed to or
1252 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1253 */
1260 }
1261 }
1263 }
1265 /*
1266 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1267 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1268 ** to store the copy of expression p, the copies of p->u.zToken
1269 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1270 ** if any. Before returning, *pzBuffer is set to the first byte past the
1271 ** portion of the buffer copied into by this function.
1272 */
1283 /* Figure out where to write the new Expr structure. */
1290 }
1294 /* Set nNewSize to the size allocated for the structure pointed to
1295 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1296 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1297 ** by the copy of the p->u.zToken string (if any).
1298 */
1306 }
1315 }
1316 }
1318 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1325 }
1327 /* Copy the p->u.zToken string, if any. */
1331 }
1334 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1339 }
1340 }
1342 /* Fill in pNew->pLeft and pNew->pRight. */
1350 }
1351 #ifndef SQLITE_OMIT_WINDOWFUNC
1355 }
1359 }
1368 }
1370 }
1371 }
1372 }
1374 }
1376 /*
1377 ** Create and return a deep copy of the object passed as the second
1378 ** argument. If an OOM condition is encountered, NULL is returned
1379 ** and the db->mallocFailed flag set.
1380 */
1381 #ifndef SQLITE_OMIT_CTE
1394 }
1395 }
1396 }
1398 }
1399 #else
1400 # define withDup(x,y) 0
1401 #endif
1403 #ifndef SQLITE_OMIT_WINDOWFUNC
1404 /*
1405 ** The gatherSelectWindows() procedure and its helper routine
1406 ** gatherSelectWindowsCallback() are used to scan all the expressions
1407 ** an a newly duplicated SELECT statement and gather all of the Window
1408 ** objects found there, assembling them onto the linked list at Select->pWin.
1409 */
1418 }
1420 }
1423 }
1425 Walker w;
1432 }
1433 #endif
1436 /*
1437 ** The following group of routines make deep copies of expressions,
1438 ** expression lists, ID lists, and select statements. The copies can
1439 ** be deleted (by being passed to their respective ...Delete() routines)
1440 ** without effecting the originals.
1441 **
1442 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1443 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1444 ** by subsequent calls to sqlite*ListAppend() routines.
1445 **
1446 ** Any tables that the SrcList might point to are not duplicated.
1447 **
1448 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1449 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1450 ** truncated version of the usual Expr structure that will be stored as
1451 ** part of the in-memory representation of the database schema.
1452 */
1456 }
1476 ){
1487 }
1488 }
1496 }
1498 }
1500 /*
1501 ** If cursors, triggers, views and subqueries are all omitted from
1502 ** the build, then none of the following routines, except for
1503 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1504 ** called with a NULL argument.
1505 */
1506 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1507 || !defined(SQLITE_OMIT_SUBQUERY)
1532 }
1537 }
1541 }
1546 }
1548 }
1561 }
1562 /* Note that because the size of the allocation for p->a[] is not
1563 ** necessarily a power of two, sqlite3IdListAppend() may not be called
1564 ** on the duplicate created by this function. */
1570 }
1572 }
1600 #ifndef SQLITE_OMIT_WINDOWFUNC
1604 #endif
1609 }
1612 }
1613 #else
1617 }
1618 #endif
1621 /*
1622 ** Add a new element to the end of an expression list. If pList is
1623 ** initially NULL, then create a new expression list.
1624 **
1625 ** The pList argument must be either NULL or a pointer to an ExprList
1626 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1627 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1628 ** Reason: This routine assumes that the number of slots in pList->a[]
1629 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1630 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1631 **
1632 ** If a memory allocation error occurs, the entire list is freed and
1633 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1634 ** that the new entry was successfully appended.
1635 */
1640 ){
1648 }
1656 }
1658 }
1666 no_mem:
1667 /* Avoid leaking memory if malloc has failed. */
1671 }
1673 /*
1674 ** pColumns and pExpr form a vector assignment which is part of the SET
1675 ** clause of an UPDATE statement. Like this:
1676 **
1677 ** (a,b,c) = (expr1,expr2,expr3)
1678 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1679 **
1680 ** For each term of the vector assignment, append new entries to the
1681 ** expression list pList. In the case of a subquery on the RHS, append
1682 ** TK_SELECT_COLUMN expressions.
1683 */
1689 ){
1694 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1695 ** exit prior to this routine being invoked */
1699 /* If the RHS is a vector, then we can immediately check to see that
1700 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1701 ** wildcards ("*") in the result set of the SELECT must be expanded before
1702 ** we can do the size check, so defer the size check until code generation.
1703 */
1708 }
1721 }
1722 }
1729 /* Store the SELECT statement in pRight so it will be deleted when
1730 ** sqlite3ExprListDelete() is called */
1734 /* Remember the size of the LHS in iTable so that we can check that
1735 ** the RHS and LHS sizes match during code generation. */
1737 }
1739 vector_append_error:
1743 }
1745 /*
1746 ** Set the sort order for the last element on the given ExprList.
1747 */
1757 );
1761 );
1767 }
1774 }
1775 }
1776 }
1778 /*
1779 ** Set the ExprList.a[].zEName element of the most recently added item
1780 ** on the expression list.
1781 **
1782 ** pList might be NULL following an OOM error. But pName should never be
1783 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1784 ** is set.
1785 */
1791 ){
1802 /* If dequote==0, then pName->z does not point to part of a DDL
1803 ** statement handled by the parser. And so no token need be added
1804 ** to the token-map. */
1808 }
1809 }
1810 }
1811 }
1813 /*
1814 ** Set the ExprList.a[].zSpan element of the most recently added item
1815 ** on the expression list.
1816 **
1817 ** pList might be NULL following an OOM error. But pSpan should never be
1818 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1819 ** is set.
1820 */
1826 ){
1835 }
1836 }
1837 }
1839 /*
1840 ** If the expression list pEList contains more than iLimit elements,
1841 ** leave an error message in pParse.
1842 */
1847 ){
1853 }
1854 }
1856 /*
1857 ** Delete an entire expression list.
1858 */
1866 pItem++;
1869 }
1872 }
1874 /*
1875 ** Return the bitwise-OR of all Expr.flags fields in the given
1876 ** ExprList.
1877 */
1886 }
1888 }
1890 /*
1891 ** This is a SELECT-node callback for the expression walker that
1892 ** always "fails". By "fail" in this case, we mean set
1893 ** pWalker->eCode to zero and abort.
1894 **
1895 ** This callback is used by multiple expression walkers.
1896 */
1901 }
1903 /*
1904 ** Check the input string to see if it is "true" or "false" (in any case).
1905 **
1906 ** If the string is.... Return
1907 ** "true" EP_IsTrue
1908 ** "false" EP_IsFalse
1909 ** anything else 0
1910 */
1915 }
1918 /*
1919 ** If the input expression is an ID with the name "true" or "false"
1920 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
1921 ** the conversion happened, and zero if the expression is unaltered.
1922 */
1924 u32 v;
1928 ){
1932 }
1934 }
1936 /*
1937 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
1938 ** and 0 if it is FALSE.
1939 */
1946 }
1948 /*
1949 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
1950 ** terms that are always true or false. Return the simplified expression.
1951 ** Or return the original expression if no simplification is possible.
1952 **
1953 ** Examples:
1954 **
1955 ** (x<10) AND true => (x<10)
1956 ** (x<10) AND false => false
1957 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
1958 ** (x<10) AND (y=22 OR true) => (x<10)
1959 ** (y=22) OR true => true
1960 */
1970 }
1971 }
1973 }
1976 /*
1977 ** These routines are Walker callbacks used to check expressions to
1978 ** see if they are "constant" for some definition of constant. The
1979 ** Walker.eCode value determines the type of "constant" we are looking
1980 ** for.
1981 **
1982 ** These callback routines are used to implement the following:
1983 **
1984 ** sqlite3ExprIsConstant() pWalker->eCode==1
1985 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
1986 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
1987 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
1988 **
1989 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
1990 ** is found to not be a constant.
1991 **
1992 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
1993 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
1994 ** when parsing an existing schema out of the sqlite_schema table and 4
1995 ** when processing a new CREATE TABLE statement. A bound parameter raises
1996 ** an error for new statements, but is silently converted
1997 ** to NULL for existing schemas. This allows sqlite_schema tables that
1998 ** contain a bound parameter because they were generated by older versions
1999 ** of SQLite to be parsed by newer versions of SQLite without raising a
2000 ** malformed schema error.
2001 */
2004 /* If pWalker->eCode is 2 then any term of the expression that comes from
2005 ** the ON or USING clauses of a left join disqualifies the expression
2006 ** from being considered constant. */
2010 }
2013 /* Consider functions to be constant if all their arguments are constant
2014 ** and either pWalker->eCode==4 or 5 or the function has the
2015 ** SQLITE_FUNC_CONST flag. */
2019 ){
2025 }
2027 /* Convert "true" or "false" in a DEFAULT clause into the
2028 ** appropriate TK_TRUEFALSE operator */
2031 }
2032 /* no break */ deliberate_fall_through
2042 }
2045 }
2046 /* no break */ deliberate_fall_through
2057 /* Silently convert bound parameters that appear inside of CREATE
2058 ** statements into a NULL when parsing the CREATE statement text out
2059 ** of the sqlite_schema table */
2062 /* A bound parameter in a CREATE statement that originates from
2063 ** sqlite3_prepare() causes an error */
2066 }
2067 /* no break */ deliberate_fall_through
2072 }
2073 }
2075 Walker w;
2079 #ifdef SQLITE_DEBUG
2081 #endif
2085 }
2087 /*
2088 ** Walk an expression tree. Return non-zero if the expression is constant
2089 ** and 0 if it involves variables or function calls.
2090 **
2091 ** For the purposes of this function, a double-quoted string (ex: "abc")
2092 ** is considered a variable but a single-quoted string (ex: 'abc') is
2093 ** a constant.
2094 */
2097 }
2099 /*
2100 ** Walk an expression tree. Return non-zero if
2101 **
2102 ** (1) the expression is constant, and
2103 ** (2) the expression does originate in the ON or USING clause
2104 ** of a LEFT JOIN, and
2105 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2106 ** operands created by the constant propagation optimization.
2107 **
2108 ** When this routine returns true, it indicates that the expression
2109 ** can be added to the pParse->pConstExpr list and evaluated once when
2110 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2111 */
2114 }
2116 /*
2117 ** Walk an expression tree. Return non-zero if the expression is constant
2118 ** for any single row of the table with cursor iCur. In other words, the
2119 ** expression must not refer to any non-deterministic function nor any
2120 ** table other than iCur.
2121 */
2124 }
2127 /*
2128 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2129 */
2134 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2135 ** it constant. */
2142 }
2143 }
2144 }
2146 /* Check if pExpr is a sub-select. If so, consider it variable. */
2150 }
2153 }
2155 /*
2156 ** Walk the expression tree passed as the first argument. Return non-zero
2157 ** if the expression consists entirely of constants or copies of terms
2158 ** in pGroupBy that sort with the BINARY collation sequence.
2159 **
2160 ** This routine is used to determine if a term of the HAVING clause can
2161 ** be promoted into the WHERE clause. In order for such a promotion to work,
2162 ** the value of the HAVING clause term must be the same for all members of
2163 ** a "group". The requirement that the GROUP BY term must be BINARY
2164 ** assumes that no other collating sequence will have a finer-grained
2165 ** grouping than binary. In other words (A=B COLLATE binary) implies
2166 ** A=B in every other collating sequence. The requirement that the
2167 ** GROUP BY be BINARY is stricter than necessary. It would also work
2168 ** to promote HAVING clauses that use the same alternative collating
2169 ** sequence as the GROUP BY term, but that is much harder to check,
2170 ** alternative collating sequences are uncommon, and this is only an
2171 ** optimization, so we take the easy way out and simply require the
2172 ** GROUP BY to use the BINARY collating sequence.
2173 */
2175 Walker w;
2183 }
2185 /*
2186 ** Walk an expression tree for the DEFAULT field of a column definition
2187 ** in a CREATE TABLE statement. Return non-zero if the expression is
2188 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2189 ** the expression is constant or a function call with constant arguments.
2190 ** Return and 0 if there are any variables.
2191 **
2192 ** isInit is true when parsing from sqlite_schema. isInit is false when
2193 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2194 ** (such as ? or $abc) in the expression are converted into NULL. When
2195 ** isInit is false, parameters raise an error. Parameters should not be
2196 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2197 ** allowed it, so we need to support it when reading sqlite_schema for
2198 ** backwards compatibility.
2199 **
2200 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2201 **
2202 ** For the purposes of this function, a double-quoted string (ex: "abc")
2203 ** is considered a variable but a single-quoted string (ex: 'abc') is
2204 ** a constant.
2205 */
2209 }
2211 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2212 /*
2213 ** Walk an expression tree. Return 1 if the expression contains a
2214 ** subquery of some kind. Return 0 if there are no subqueries.
2215 */
2217 Walker w;
2221 #ifdef SQLITE_DEBUG
2223 #endif
2226 }
2227 #endif
2229 /*
2230 ** If the expression p codes a constant integer that is small enough
2231 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2232 ** in *pValue. If the expression is not an integer or if it is too big
2233 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2234 */
2239 /* If an expression is an integer literal that fits in a signed 32-bit
2240 ** integer, then the EP_IntValue flag will have already been set */
2247 }
2252 }
2259 }
2261 }
2263 }
2265 }
2267 /*
2268 ** Return FALSE if there is no chance that the expression can be NULL.
2269 **
2270 ** If the expression might be NULL or if the expression is too complex
2271 ** to tell return TRUE.
2272 **
2273 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2274 ** when we know that a value cannot be NULL. Hence, a false positive
2275 ** (returning TRUE when in fact the expression can never be NULL) might
2276 ** be a small performance hit but is otherwise harmless. On the other
2277 ** hand, a false negative (returning FALSE when the result could be NULL)
2278 ** will likely result in an incorrect answer. So when in doubt, return
2279 ** TRUE.
2280 */
2282 u8 op;
2285 }
2302 }
2303 }
2305 /*
2306 ** Return TRUE if the given expression is a constant which would be
2307 ** unchanged by OP_Affinity with the affinity given in the second
2308 ** argument.
2309 **
2310 ** This routine is used to determine if the OP_Affinity operation
2311 ** can be omitted. When in doubt return FALSE. A false negative
2312 ** is harmless. A false positive, however, can result in the wrong
2313 ** answer.
2314 */
2316 u8 op;
2322 }
2328 }
2331 }
2334 }
2337 }
2341 }
2344 }
2345 }
2346 }
2348 /*
2349 ** Return TRUE if the given string is a row-id column name.
2350 */
2356 }
2358 /*
2359 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2360 ** that can be simplified to a direct table access, then return
2361 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2362 ** or if the SELECT statement needs to be manifested into a transient
2363 ** table, then return NULL.
2364 */
2365 #ifndef SQLITE_OMIT_SUBQUERY
2380 }
2394 /* All SELECT results must be columns. */
2399 }
2401 }
2404 #ifndef SQLITE_OMIT_SUBQUERY
2405 /*
2406 ** Generate code that checks the left-most column of index table iCur to see if
2407 ** it contains any NULL entries. Cause the register at regHasNull to be set
2408 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2409 ** to be set to NULL if iCur contains one or more NULL values.
2410 */
2419 }
2420 #endif
2423 #ifndef SQLITE_OMIT_SUBQUERY
2424 /*
2425 ** The argument is an IN operator with a list (not a subquery) on the
2426 ** right-hand side. Return TRUE if that list is constant.
2427 */
2437 }
2438 #endif
2440 /*
2441 ** This function is used by the implementation of the IN (...) operator.
2442 ** The pX parameter is the expression on the RHS of the IN operator, which
2443 ** might be either a list of expressions or a subquery.
2444 **
2445 ** The job of this routine is to find or create a b-tree object that can
2446 ** be used either to test for membership in the RHS set or to iterate through
2447 ** all members of the RHS set, skipping duplicates.
2448 **
2449 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2450 ** and pX->iTable is set to the index of that cursor.
2451 **
2452 ** The returned value of this function indicates the b-tree type, as follows:
2453 **
2454 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2455 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2456 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2457 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2458 ** populated epheremal table.
2459 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2460 ** implemented as a sequence of comparisons.
2461 **
2462 ** An existing b-tree might be used if the RHS expression pX is a simple
2463 ** subquery such as:
2464 **
2465 ** SELECT <column1>, <column2>... FROM <table>
2466 **
2467 ** If the RHS of the IN operator is a list or a more complex subquery, then
2468 ** an ephemeral table might need to be generated from the RHS and then
2469 ** pX->iTable made to point to the ephemeral table instead of an
2470 ** existing table.
2471 **
2472 ** The inFlags parameter must contain, at a minimum, one of the bits
2473 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2474 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2475 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2476 ** be used to loop over all values of the RHS of the IN operator.
2477 **
2478 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2479 ** through the set members) then the b-tree must not contain duplicates.
2480 ** An epheremal table will be created unless the selected columns are guaranteed
2481 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2482 ** a UNIQUE constraint or index.
2483 **
2484 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2485 ** for fast set membership tests) then an epheremal table must
2486 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2487 ** index can be found with the specified <columns> as its left-most.
2488 **
2489 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2490 ** if the RHS of the IN operator is a list (not a subquery) then this
2491 ** routine might decide that creating an ephemeral b-tree for membership
2492 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2493 ** calling routine should implement the IN operator using a sequence
2494 ** of Eq or Ne comparison operations.
2495 **
2496 ** When the b-tree is being used for membership tests, the calling function
2497 ** might need to know whether or not the RHS side of the IN operator
2498 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2499 ** if there is any chance that the (...) might contain a NULL value at
2500 ** runtime, then a register is allocated and the register number written
2501 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2502 ** NULL value, then *prRhsHasNull is left unchanged.
2503 **
2504 ** If a register is allocated and its location stored in *prRhsHasNull, then
2505 ** the value in that register will be NULL if the b-tree contains one or more
2506 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2507 ** NULL values.
2508 **
2509 ** If the aiMap parameter is not NULL, it must point to an array containing
2510 ** one element for each column returned by the SELECT statement on the RHS
2511 ** of the IN(...) operator. The i'th entry of the array is populated with the
2512 ** offset of the index column that matches the i'th column returned by the
2513 ** SELECT. For example, if the expression and selected index are:
2514 **
2515 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2516 ** CREATE INDEX i1 ON t1(b, c, a);
2517 **
2518 ** then aiMap[] is populated with {2, 0, 1}.
2519 */
2520 #ifndef SQLITE_OMIT_SUBQUERY
2528 ){
2538 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2539 ** whether or not the SELECT result contains NULL values, check whether
2540 ** or not NULL is actually possible (it may not be, for example, due
2541 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2542 ** set prRhsHasNull to 0 before continuing. */
2548 }
2551 }
2552 }
2554 /* Check to see if an existing table or index can be used to
2555 ** satisfy the query. This is preferable to generating a new
2556 ** ephemeral table. */
2569 /* Code an OP_Transaction and OP_TableLock for <table>. */
2577 /* The "x IN (SELECT rowid FROM table)" case */
2591 /* Check that the affinity that will be used to perform each
2592 ** comparison is the same as the affinity of each column in table
2593 ** on the RHS of the IN operator. If it not, it is not possible to
2594 ** use any index of the RHS table. */
2606 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2607 ** other has no affinity and the other side is TEXT. Hence,
2608 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2609 ** and for the term on the LHS of the IN to have no affinity. */
2614 }
2615 }
2618 /* Search for an existing index that will work for this IN operator */
2624 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2625 ** BITMASK(nExpr) without overflowing */
2632 ){
2634 }
2635 }
2650 }
2652 }
2658 }
2662 /* If we reach this point, that means the index pIdx is usable */
2673 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
2677 #endif
2681 }
2682 }
2684 }
2690 /* If no preexisting index is available for the IN clause
2691 ** and IN_INDEX_NOOP is an allowed reply
2692 ** and the RHS of the IN operator is a list, not a subquery
2693 ** and the RHS is not constant or has two or fewer terms,
2694 ** then it is not worth creating an ephemeral table to evaluate
2695 ** the IN operator so return IN_INDEX_NOOP.
2696 */
2701 ){
2703 }
2706 /* Could not find an existing table or index to use as the RHS b-tree.
2707 ** We will have to generate an ephemeral table to do the job.
2708 */
2716 }
2721 }
2723 }
2729 }
2732 }
2733 #endif
2735 #ifndef SQLITE_OMIT_SUBQUERY
2736 /*
2737 ** Argument pExpr is an (?, ?...) IN(...) expression. This
2738 ** function allocates and returns a nul-terminated string containing
2739 ** the affinities to be used for each column of the comparison.
2740 **
2741 ** It is the responsibility of the caller to ensure that the returned
2742 ** string is eventually freed using sqlite3DbFree().
2743 */
2761 }
2762 }
2764 }
2766 }
2767 #endif
2769 #ifndef SQLITE_OMIT_SUBQUERY
2770 /*
2771 ** Load the Parse object passed as the first argument with an error
2772 ** message of the form:
2773 **
2774 ** "sub-select returns N columns - expected M"
2775 */
2780 }
2781 }
2782 #endif
2784 /*
2785 ** Expression pExpr is a vector that has been used in a context where
2786 ** it is not permitted. If pExpr is a sub-select vector, this routine
2787 ** loads the Parse object with a message of the form:
2788 **
2789 ** "sub-select returns N columns - expected 1"
2790 **
2791 ** Or, if it is a regular scalar vector:
2792 **
2793 ** "row value misused"
2794 */
2796 #ifndef SQLITE_OMIT_SUBQUERY
2800 #endif
2801 {
2803 }
2804 }
2806 #ifndef SQLITE_OMIT_SUBQUERY
2807 /*
2808 ** Generate code that will construct an ephemeral table containing all terms
2809 ** in the RHS of an IN operator. The IN operator can be in either of two
2810 ** forms:
2811 **
2812 ** x IN (4,5,11) -- IN operator with list on right-hand side
2813 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
2814 **
2815 ** The pExpr parameter is the IN operator. The cursor number for the
2816 ** constructed ephermeral table is returned. The first time the ephemeral
2817 ** table is computed, the cursor number is also stored in pExpr->iTable,
2818 ** however the cursor number returned might not be the same, as it might
2819 ** have been duplicated using OP_OpenDup.
2820 **
2821 ** If the LHS expression ("x" in the examples) is a column value, or
2822 ** the SELECT statement returns a column value, then the affinity of that
2823 ** column is used to build the index keys. If both 'x' and the
2824 ** SELECT... statement are columns, then numeric affinity is used
2825 ** if either column has NUMERIC or INTEGER affinity. If neither
2826 ** 'x' nor the SELECT... statement are columns, then numeric affinity
2827 ** is used.
2828 */
2833 ){
2844 /* The evaluation of the IN must be repeated every time it
2845 ** is encountered if any of the following is true:
2846 **
2847 ** * The right-hand side is a correlated subquery
2848 ** * The right-hand side is an expression list containing variables
2849 ** * We are inside a trigger
2850 **
2851 ** If all of the above are false, then we can compute the RHS just once
2852 ** and reuse it many names.
2853 */
2855 /* Reuse of the RHS is allowed */
2856 /* If this routine has already been coded, but the previous code
2857 ** might not have been invoked yet, so invoke it now as a subroutine.
2858 */
2864 }
2870 }
2872 /* Begin coding the subroutine */
2881 }
2883 /* Check to see if this is a vector IN operator */
2887 /* Construct the ephemeral table that will contain the content of
2888 ** RHS of the IN operator.
2889 */
2892 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
2897 }
2898 #endif
2902 /* Case 1: expr IN (SELECT ...)
2903 **
2904 ** Generate code to write the results of the select into the temporary
2905 ** table allocated and opened above.
2906 */
2912 ));
2913 /* If the LHS and RHS of the IN operator do not match, that
2914 ** error will have been caught long before we reach this point. */
2916 SelectDest dest;
2927 }
2937 );
2938 }
2939 }
2941 /* Case 2: expr IN (exprlist)
2942 **
2943 ** For each expression, build an index key from the evaluation and
2944 ** store it in the temporary table. If <expr> is a column, then use
2945 ** that columns affinity when building index keys. If <expr> is not
2946 ** a column, use numeric affinity.
2947 */
2958 }
2962 }
2964 /* Loop through each expression in <exprlist>. */
2970 /* If the expression is not constant then we will need to
2971 ** disable the test that was generated above that makes sure
2972 ** this code only executes once. Because for a non-constant
2973 ** expression we need to rerun this code each time.
2974 */
2979 }
2981 /* Evaluate the expression and insert it into the temp table */
2985 }
2988 }
2991 }
2994 /* Subroutine return */
2998 }
2999 }
3002 /*
3003 ** Generate code for scalar subqueries used as a subquery expression
3004 ** or EXISTS operator:
3005 **
3006 ** (SELECT a FROM b) -- subquery
3007 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3008 **
3009 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3010 **
3011 ** Return the register that holds the result. For a multi-column SELECT,
3012 ** the result is stored in a contiguous array of registers and the
3013 ** return value is the register of the left-most result column.
3014 ** Return 0 if an error occurs.
3015 */
3016 #ifndef SQLITE_OMIT_SUBQUERY
3033 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3034 ** is encountered if any of the following is true:
3035 **
3036 ** * The right-hand side is a correlated subquery
3037 ** * The right-hand side is an expression list containing variables
3038 ** * We are inside a trigger
3039 **
3040 ** If all of the above are false, then we can run this code just once
3041 ** save the results, and reuse the same result on subsequent invocations.
3042 */
3044 /* If this routine has already been coded, then invoke it as a
3045 ** subroutine. */
3051 }
3053 /* Begin coding the subroutine */
3061 }
3063 /* For a SELECT, generate code to put the values for all columns of
3064 ** the first row into an array of registers and return the index of
3065 ** the first register.
3066 **
3067 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3068 ** into a register and return that register number.
3069 **
3070 ** In both cases, the query is augmented with "LIMIT 1". Any
3071 ** preexisting limit is discarded in place of the new LIMIT 1.
3072 */
3088 }
3090 /* The subquery already has a limit. If the pre-existing limit is X
3091 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3098 }
3102 /* If there is no pre-existing limit add a limit of 1 */
3105 }
3109 }
3115 /* Subroutine return */
3119 }
3122 }
3125 #ifndef SQLITE_OMIT_SUBQUERY
3126 /*
3127 ** Expr pIn is an IN(...) expression. This function checks that the
3128 ** sub-select on the RHS of the IN() operator has the same number of
3129 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3130 ** a sub-query, that the LHS is a vector of size 1.
3131 */
3138 }
3142 }
3144 }
3145 #endif
3147 #ifndef SQLITE_OMIT_SUBQUERY
3148 /*
3149 ** Generate code for an IN expression.
3150 **
3151 ** x IN (SELECT ...)
3152 ** x IN (value, value, ...)
3153 **
3154 ** The left-hand side (LHS) is a scalar or vector expression. The
3155 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3156 ** subquery. If the RHS is a subquery, the number of result columns must
3157 ** match the number of columns in the vector on the LHS. If the RHS is
3158 ** a list of values, the LHS must be a scalar.
3159 **
3160 ** The IN operator is true if the LHS value is contained within the RHS.
3161 ** The result is false if the LHS is definitely not in the RHS. The
3162 ** result is NULL if the presence of the LHS in the RHS cannot be
3163 ** determined due to NULLs.
3164 **
3165 ** This routine generates code that jumps to destIfFalse if the LHS is not
3166 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3167 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3168 ** within the RHS then fall through.
3169 **
3170 ** See the separate in-operator.md documentation file in the canonical
3171 ** SQLite source tree for additional information.
3172 */
3178 ){
3205 );
3208 /* Attempt to compute the RHS. After this step, if anything other than
3209 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3210 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3211 ** the RHS has not yet been coded. */
3222 );
3223 #ifdef SQLITE_DEBUG
3224 /* Confirm that aiMap[] contains nVector integer values between 0 and
3225 ** nVector-1. */
3230 }
3231 #endif
3233 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3234 ** vector, then it is stored in an array of nVector registers starting
3235 ** at r1.
3236 **
3237 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3238 ** so that the fields are in the same order as an existing index. The
3239 ** aiMap[] array contains a mapping from the original LHS field order to
3240 ** the field order that matches the RHS index.
3241 **
3242 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3243 ** even if it is constant, as OP_Affinity may be used on the register
3244 ** by code generated below. */
3251 /* LHS fields are not reordered */
3254 /* Need to reorder the LHS fields according to aiMap */
3258 }
3259 }
3261 /* If sqlite3FindInIndex() did not find or create an index that is
3262 ** suitable for evaluating the IN operator, then evaluate using a
3263 ** sequence of comparisons.
3264 **
3265 ** This is step (1) in the in-operator.md optimized algorithm.
3266 */
3278 }
3283 }
3302 }
3303 }
3307 }
3311 }
3313 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3314 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3315 ** We will then skip the binary search of the RHS.
3316 */
3321 }
3328 }
3329 }
3331 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3332 ** of the RHS using the LHS as a probe. If found, the result is
3333 ** true.
3334 */
3336 /* In this case, the RHS is the ROWID of table b-tree and so we also
3337 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3338 ** into a single opcode. */
3345 /* Combine Step 3 and Step 5 into a single opcode */
3349 }
3350 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3353 }
3355 /* Step 4. If the RHS is known to be non-NULL and we did not find
3356 ** an match on the search above, then the result must be FALSE.
3357 */
3361 }
3363 /* Step 5. If we do not care about the difference between NULL and
3364 ** FALSE, then just return false.
3365 */
3368 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3369 ** If any comparison is NULL, then the result is NULL. If all
3370 ** comparisons are FALSE then the final result is FALSE.
3371 **
3372 ** For a scalar LHS, it is sufficient to check just the first row
3373 ** of the RHS.
3374 */
3381 /* For nVector==1, combine steps 6 and 7 by immediately returning
3382 ** FALSE if the first comparison is not NULL */
3384 }
3396 }
3403 /* Step 7: If we reach this point, we know that the result must
3404 ** be false. */
3406 }
3408 /* Jumps here in order to return true. */
3411 sqlite3ExprCodeIN_finished:
3414 sqlite3ExprCodeIN_oom_error:
3417 }
3420 #ifndef SQLITE_OMIT_FLOATING_POINT
3421 /*
3422 ** Generate an instruction that will put the floating point
3423 ** value described by z[0..n-1] into register iMem.
3424 **
3425 ** The z[] string will probably not be zero-terminated. But the
3426 ** z[n] character is guaranteed to be something that does not look
3427 ** like the continuation of the number.
3428 */
3436 }
3437 }
3438 #endif
3441 /*
3442 ** Generate an instruction that will put the integer describe by
3443 ** text z[0..n-1] into register iMem.
3444 **
3445 ** Expr.u.zToken is always UTF8 and zero-terminated.
3446 */
3456 i64 value;
3461 #ifdef SQLITE_OMIT_FLOATING_POINT
3463 #else
3464 #ifndef SQLITE_OMIT_HEX_INTEGER
3468 #endif
3469 {
3471 }
3472 #endif
3476 }
3477 }
3478 }
3481 /* Generate code that will load into register regOut a value that is
3482 ** appropriate for the iIdxCol-th column of index pIdx.
3483 */
3490 ){
3501 }
3502 }
3504 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3505 /*
3506 ** Generate code that will compute the value of generated column pCol
3507 ** and store the result in register regOut
3508 */
3512 int regOut
3513 ){
3522 }
3526 }
3528 }
3531 /*
3532 ** Generate code to extract the value of the iCol-th column of a table.
3533 */
3540 ){
3546 }
3555 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3567 }
3569 #endif
3578 }
3581 }
3582 }
3584 /*
3585 ** Generate code that will extract the iColumn-th column from
3586 ** table pTab and store the column value in register iReg.
3587 **
3588 ** There must be an open cursor to pTab in iTable when this routine
3589 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3590 */
3597 u8 p5 /* P5 value for OP_Column + FLAGS */
3598 ){
3604 }
3606 }
3608 /*
3609 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3610 ** over to iTo..iTo+nReg-1.
3611 */
3614 }
3616 /*
3617 ** Convert a scalar expression node to a TK_REGISTER referencing
3618 ** register iReg. The caller must ensure that iReg already contains
3619 ** the correct value for the expression.
3620 */
3627 }
3629 /*
3630 ** Evaluate an expression (either a vector or a scalar expression) and store
3631 ** the result in continguous temporary registers. Return the index of
3632 ** the first register used to store the result.
3633 **
3634 ** If the returned result register is a temporary scalar, then also write
3635 ** that register number into *piFreeable. If the returned result register
3636 ** is not a temporary or if the expression is a vector set *piFreeable
3637 ** to 0.
3638 */
3647 #if SQLITE_OMIT_SUBQUERY
3649 #else
3651 #endif
3658 }
3659 }
3660 }
3662 }
3664 /*
3665 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
3666 ** so that a subsequent copy will not be merged into this one.
3667 */
3671 }
3672 }
3674 /*
3675 ** Generate code to implement special SQL functions that are implemented
3676 ** in-line rather than by using the usual callbacks.
3677 */
3683 ){
3692 /* Attempt a direct implementation of the built-in COALESCE() and
3693 ** IFNULL() functions. This avoids unnecessary evaluation of
3694 ** arguments past the first non-NULL argument.
3695 */
3704 }
3708 }
3710 Expr caseExpr;
3715 }
3718 /* The UNLIKELY() function is a no-op. The result is the value
3719 ** of the first argument.
3720 */
3724 }
3726 /***********************************************************************
3727 ** Test-only SQL functions that are only usable if enabled
3728 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
3729 */
3731 /* Compare two expressions using sqlite3ExprCompare() */
3735 target);
3737 }
3740 /* Compare two expressions using sqlite3ExprImpliesExpr() */
3744 target);
3746 }
3749 /* REsult of sqlite3ExprImpliesNonNullRow() */
3756 target);
3759 }
3761 }
3763 #ifdef SQLITE_DEBUG
3765 /* The AFFINITY() function evaluates to a string that describes
3766 ** the type affinity of the argument. This is used for testing of
3767 ** the SQLite type logic.
3768 */
3776 }
3777 #endif
3778 }
3780 }
3783 /*
3784 ** Generate code into the current Vdbe to evaluate the given
3785 ** expression. Attempt to store the results in register "target".
3786 ** Return the register where results are stored.
3787 **
3788 ** With this routine, there is no guarantee that results will
3789 ** be stored in target. The result might be stored in some other
3790 ** register if it is convenient to do so. The calling function
3791 ** must check the return code and move the results to the desired
3792 ** register.
3793 */
3807 expr_code_doover:
3813 }
3834 }
3835 }
3837 }
3838 /* Otherwise, fall thru into the TK_COLUMN case */
3839 /* no break */ deliberate_fall_through
3840 }
3845 /* This COLUMN expression is really a constant due to WHERE clause
3846 ** constraints, and that constant is coded by the pExpr->pLeft
3847 ** expresssion. However, make sure the constant has the correct
3848 ** datatype by applying the Affinity of the table column to the
3849 ** constant.
3850 */
3857 }
3864 }
3866 }
3869 /* Other columns in the same row for CHECK constraints or
3870 ** generated columns or for inserting into partial index.
3871 ** The row is unpacked into registers beginning at
3872 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
3873 ** immediately prior to the first column.
3874 */
3884 }
3888 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3894 }
3898 }
3909 }
3911 /* Coding an expression that is part of an index where column names
3912 ** in the index refer to the table to which the index belongs */
3914 }
3915 }
3921 }
3923 }
3927 }
3931 }
3932 #ifndef SQLITE_OMIT_FLOATING_POINT
3937 }
3938 #endif
3943 }
3945 /* Make NULL the default case so that if a bug causes an illegal
3946 ** Expr node to be passed into this function, it will be handled
3947 ** sanely and not crash. But keep the assert() to bring the problem
3948 ** to the attention of the developers. */
3952 }
3953 #ifndef SQLITE_OMIT_BLOB_LITERAL
3967 }
3968 #endif
3979 }
3981 }
3984 }
3985 #ifndef SQLITE_OMIT_CAST
3987 /* Expressions of the form: CAST(pLeft AS token) */
3992 }
3996 }
4002 /* fall-through */
4026 }
4028 }
4058 }
4065 #ifndef SQLITE_OMIT_FLOATING_POINT
4070 #endif
4080 }
4082 }
4091 }
4103 }
4118 }
4124 ){
4129 }
4131 }
4143 #ifndef SQLITE_OMIT_WINDOWFUNC
4146 }
4147 #endif
4150 /* SQL functions can be expensive. So try to avoid running them
4151 ** multiple times if we know they always give the same result */
4153 }
4161 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4164 }
4165 #endif
4169 }
4177 }
4183 }
4186 }
4187 }
4194 }
4196 /* For length() and typeof() functions with a column argument,
4197 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4198 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
4199 ** loading.
4200 */
4202 u8 exprOp;
4212 }
4213 }
4219 }
4220 #ifndef SQLITE_OMIT_VIRTUALTABLE
4221 /* Possibly overload the function if the first argument is
4222 ** a virtual table column.
4223 **
4224 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4225 ** second argument, not the first, as the argument to test to
4226 ** see if it is a column in a virtual table. This is done because
4227 ** the left operand of infix functions (the operand we want to
4228 ** control overloading) ends up as the second argument to the
4229 ** function. The expression "A glob B" is equivalent to
4230 ** "glob(B,A). We want to use the A in "A glob B" to test
4231 ** for function overloading. But we use the B term in "glob(B,A)".
4232 */
4237 }
4238 #endif
4242 }
4243 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4250 }
4252 #endif
4253 {
4256 }
4262 }
4263 }
4265 }
4266 #ifndef SQLITE_OMIT_SUBQUERY
4278 }
4280 }
4285 }
4289 ){
4292 }
4294 }
4305 }
4309 /*
4310 ** x BETWEEN y AND z
4311 **
4312 ** This is equivalent to
4313 **
4314 ** x>=y AND x<=z
4315 **
4316 ** X is stored in pExpr->pLeft.
4317 ** Y is stored in pExpr->pList->a[0].pExpr.
4318 ** Z is stored in pExpr->pList->a[1].pExpr.
4319 */
4323 }
4329 }
4332 /* If the opcode is TK_TRIGGER, then the expression is a reference
4333 ** to a column in the new.* or old.* pseudo-tables available to
4334 ** trigger programs. In this case Expr.iTable is set to 1 for the
4335 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4336 ** is set to the column of the pseudo-table to read, or to -1 to
4337 ** read the rowid field.
4338 **
4339 ** The expression is implemented using an OP_Param opcode. The p1
4340 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4341 ** to reference another column of the old.* pseudo-table, where
4342 ** i is the index of the column. For a new.rowid reference, p1 is
4343 ** set to (n+1), where n is the number of columns in each pseudo-table.
4344 ** For a reference to any other column in the new.* pseudo-table, p1
4345 ** is set to (n+2+i), where n and i are as defined previously. For
4346 ** example, if the table on which triggers are being fired is
4347 ** declared as:
4348 **
4349 ** CREATE TABLE t1(a, b);
4350 **
4351 ** Then p1 is interpreted as follows:
4352 **
4353 ** p1==0 -> old.rowid p1==3 -> new.rowid
4354 ** p1==1 -> old.a p1==4 -> new.a
4355 ** p1==2 -> old.b p1==5 -> new.b
4356 */
4371 ));
4373 #ifndef SQLITE_OMIT_FLOATING_POINT
4374 /* If the column has REAL affinity, it may currently be stored as an
4375 ** integer. Use OP_RealAffinity to make sure it is really real.
4376 **
4377 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4378 ** floating point when extracting it from the record. */
4381 }
4382 #endif
4384 }
4389 }
4391 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
4392 ** that derive from the right-hand table of a LEFT JOIN. The
4393 ** Expr.iTable value is the table number for the right-hand table.
4394 ** The expression is only evaluated if that table is not currently
4395 ** on a LEFT JOIN NULL row.
4396 */
4401 /* Temporarily disable factoring of constant expressions, since
4402 ** even though expressions may appear to be constant, they are not
4403 ** really constant because they originate from the right-hand side
4404 ** of a LEFT JOIN. */
4411 }
4413 /*
4414 ** Form A:
4415 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4416 **
4417 ** Form B:
4418 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4419 **
4420 ** Form A is can be transformed into the equivalent form B as follows:
4421 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4422 ** WHEN x=eN THEN rN ELSE y END
4423 **
4424 ** X (if it exists) is in pExpr->pLeft.
4425 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4426 ** odd. The Y is also optional. If the number of elements in x.pList
4427 ** is even, then Y is omitted and the "otherwise" result is NULL.
4428 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4429 **
4430 ** The result of the expression is the Ri for the first matching Ei,
4431 ** or if there is no matching Ei, the ELSE term Y, or if there is
4432 ** no ELSE term, NULL.
4433 */
4458 }
4466 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4467 ** The value in regFree1 might get SCopy-ed into the file result.
4468 ** So make sure that the regFree1 register is not reused for other
4469 ** purposes and possibly overwritten. */
4471 }
4478 }
4486 }
4491 }
4496 }
4497 #ifndef SQLITE_OMIT_TRIGGER
4503 );
4508 }
4511 }
4521 }
4524 }
4525 #endif
4526 }
4530 }
4532 /*
4533 ** Generate code that will evaluate expression pExpr just one time
4534 ** per prepared statement execution.
4535 **
4536 ** If the expression uses functions (that might throw an exception) then
4537 ** guard them with an OP_Once opcode to ensure that the code is only executed
4538 ** once. If no functions are involved, then factor the code out and put it at
4539 ** the end of the prepared statement in the initialization section.
4540 **
4541 ** If regDest>=0 then the result is always stored in that register and the
4542 ** result is not reusable. If regDest<0 then this routine is free to
4543 ** store the value whereever it wants. The register where the expression
4544 ** is stored is returned. When regDest<0, two identical expressions might
4545 ** code to the same register, if they do not contain function calls and hence
4546 ** are factored out into the initialization section at the end of the
4547 ** prepared statement.
4548 */
4553 ){
4563 }
4564 }
4565 }
4576 }
4587 }
4589 }
4591 }
4593 /*
4594 ** Generate code to evaluate an expression and store the results
4595 ** into a register. Return the register number where the results
4596 ** are stored.
4597 **
4598 ** If the register is a temporary register that can be deallocated,
4599 ** then write its number into *pReg. If the result register is not
4600 ** a temporary, then set *pReg to zero.
4601 **
4602 ** If pExpr is a constant, then this routine might generate this
4603 ** code to fill the register in the initialization section of the
4604 ** VDBE program, in order to factor it out of the evaluation loop.
4605 */
4612 ){
4623 }
4624 }
4626 }
4628 /*
4629 ** Generate code that will evaluate expression pExpr and store the
4630 ** results in register target. The results are guaranteed to appear
4631 ** in register target.
4632 */
4642 u8 op;
4647 }
4649 }
4650 }
4652 /*
4653 ** Make a transient copy of expression pExpr and then code it using
4654 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
4655 ** except that the input expression is guaranteed to be unchanged.
4656 */
4662 }
4664 /*
4665 ** Generate code that will evaluate expression pExpr and store the
4666 ** results in register target. The results are guaranteed to appear
4667 ** in register target. If the expression is constant, then this routine
4668 ** might choose to code the expression at initialization time.
4669 */
4675 }
4676 }
4678 /*
4679 ** Generate code that pushes the value of every element of the given
4680 ** expression list into a sequence of registers beginning at target.
4681 **
4682 ** Return the number of elements evaluated. The number returned will
4683 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
4684 ** is defined.
4685 **
4686 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
4687 ** filled using OP_SCopy. OP_Copy must be used instead.
4688 **
4689 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
4690 ** factored out into initialization code.
4691 **
4692 ** The SQLITE_ECEL_REF flag means that expressions in the list with
4693 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
4694 ** in registers at srcReg, and so the value can be copied from there.
4695 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
4696 ** are simply omitted rather than being copied from srcReg.
4697 */
4703 u8 flags /* SQLITE_ECEL_* flags */
4704 ){
4716 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
4718 i--;
4719 n--;
4721 #endif
4724 i--;
4725 n--;
4728 }
4731 ){
4742 ){
4746 }
4747 }
4748 }
4749 }
4751 }
4753 /*
4754 ** Generate code for a BETWEEN operator.
4755 **
4756 ** x BETWEEN y AND z
4757 **
4758 ** The above is equivalent to
4759 **
4760 ** x>=y AND x<=z
4761 **
4762 ** Code it as such, taking care to do the common subexpression
4763 ** elimination of x.
4764 **
4765 ** The xJumpIf parameter determines details:
4766 **
4767 ** NULL: Store the boolean result in reg[dest]
4768 ** sqlite3ExprIfTrue: Jump to dest if true
4769 ** sqlite3ExprIfFalse: Jump to dest if false
4770 **
4771 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
4772 */
4779 ){
4807 /* Mark the expression is being from the ON or USING clause of a join
4808 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
4809 ** it into the Parse.pConstExpr list. We should use a new bit for this,
4810 ** for clarity, but we are out of bits in the Expr.flags field so we
4811 ** have to reuse the EP_FromJoin bit. Bummer. */
4814 }
4816 }
4819 /* Ensure adequate test coverage */
4829 }
4831 /*
4832 ** Generate code for a boolean expression such that a jump is made
4833 ** to the label "dest" if the expression is true but execution
4834 ** continues straight thru if the expression is false.
4835 **
4836 ** If the expression evaluates to NULL (neither true nor false), then
4837 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
4838 **
4839 ** This code depends on the fact that certain token values (ex: TK_EQ)
4840 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
4841 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
4842 ** the make process cause these values to align. Assert()s in the code
4843 ** below verify that the numbers are aligned correctly.
4844 */
4874 }
4876 }
4881 }
4896 }
4898 }
4905 /* no break */ deliberate_fall_through
4931 }
4942 }
4947 }
4948 #ifndef SQLITE_OMIT_SUBQUERY
4956 }
4957 #endif
4959 default_expr:
4963 /* No-op */
4970 }
4972 }
4973 }
4976 }
4978 /*
4979 ** Generate code for a boolean expression such that a jump is made
4980 ** to the label "dest" if the expression is false but execution
4981 ** continues straight thru if the expression is true.
4982 **
4983 ** If the expression evaluates to NULL (neither true nor false) then
4984 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
4985 ** is 0.
4986 */
4999 /* The value of pExpr->op and op are related as follows:
5000 **
5001 ** pExpr->op op
5002 ** --------- ----------
5003 ** TK_ISNULL OP_NotNull
5004 ** TK_NOTNULL OP_IsNull
5005 ** TK_NE OP_Eq
5006 ** TK_EQ OP_Ne
5007 ** TK_GT OP_Le
5008 ** TK_LE OP_Gt
5009 ** TK_GE OP_Lt
5010 ** TK_LT OP_Ge
5011 **
5012 ** For other values of pExpr->op, op is undefined and unused.
5013 ** The value of TK_ and OP_ constants are arranged such that we
5014 ** can compute the mapping above using the following expression.
5015 ** Assert()s verify that the computation is correct.
5016 */
5019 /* Verify correct alignment of TK_ and OP_ constants
5020 */
5047 }
5049 }
5054 }
5064 /* IS TRUE and IS NOT FALSE */
5069 /* IS FALSE and IS NOT TRUE */
5072 }
5074 }
5081 /* no break */ deliberate_fall_through
5107 }
5116 }
5121 }
5122 #ifndef SQLITE_OMIT_SUBQUERY
5130 }
5132 }
5133 #endif
5135 default_expr:
5139 /* no-op */
5146 }
5148 }
5149 }
5152 }
5154 /*
5155 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5156 ** code generation, and that copy is deleted after code generation. This
5157 ** ensures that the original pExpr is unchanged.
5158 */
5164 }
5166 }
5168 /*
5169 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5170 ** type of expression.
5171 **
5172 ** If pExpr is a simple SQL value - an integer, real, string, blob
5173 ** or NULL value - then the VDBE currently being prepared is configured
5174 ** to re-prepare each time a new value is bound to variable pVar.
5175 **
5176 ** Additionally, if pExpr is a simple SQL value and the value is the
5177 ** same as that currently bound to variable pVar, non-zero is returned.
5178 ** Otherwise, if the values are not the same or if pExpr is not a simple
5179 ** SQL value, zero is returned.
5180 */
5194 }
5196 }
5199 }
5202 }
5204 /*
5205 ** Do a deep comparison of two expression trees. Return 0 if the two
5206 ** expressions are completely identical. Return 1 if they differ only
5207 ** by a COLLATE operator at the top level. Return 2 if there are differences
5208 ** other than the top-level COLLATE operator.
5209 **
5210 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5211 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5212 **
5213 ** The pA side might be using TK_REGISTER. If that is the case and pB is
5214 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
5215 **
5216 ** Sometimes this routine will return 2 even if the two expressions
5217 ** really are equivalent. If we cannot prove that the expressions are
5218 ** identical, we return 2 just to be safe. So if this routine
5219 ** returns 2, then you do not really know for certain if the two
5220 ** expressions are the same. But if you get a 0 or 1 return, then you
5221 ** can be sure the expressions are the same. In the places where
5222 ** this routine is used, it does not hurt to get an extra 2 - that
5223 ** just might result in some slightly slower code. But returning
5224 ** an incorrect 0 or 1 could lead to a malfunction.
5225 **
5226 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
5227 ** pParse->pReprepare can be matched against literals in pB. The
5228 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
5229 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
5230 ** Argument pParse should normally be NULL. If it is not NULL and pA or
5231 ** pB causes a return value of 2.
5232 */
5234 u32 combinedFlags;
5237 }
5240 }
5245 }
5247 }
5251 }
5254 }
5256 }
5260 #ifndef SQLITE_OMIT_WINDOWFUNC
5264 }
5268 }
5269 }
5270 #endif
5277 }
5278 }
5290 ){
5295 }
5296 }
5297 }
5299 }
5301 /*
5302 ** Compare two ExprList objects. Return 0 if they are identical, 1
5303 ** if they are certainly different, or 2 if it is not possible to
5304 ** determine if they are identical or not.
5305 **
5306 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5307 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5308 **
5309 ** This routine might return non-zero for equivalent ExprLists. The
5310 ** only consequence will be disabled optimizations. But this routine
5311 ** must never return 0 if the two ExprList objects are different, or
5312 ** a malfunction will result.
5313 **
5314 ** Two NULL pointers are considered to be the same. But a NULL pointer
5315 ** always differs from a non-NULL pointer.
5316 */
5328 }
5330 }
5332 /*
5333 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
5334 ** are ignored.
5335 */
5340 iTab);
5341 }
5343 /*
5344 ** Return non-zero if Expr p can only be true if pNN is not NULL.
5345 **
5346 ** Or if seenNot is true, return non-zero if Expr p can only be
5347 ** non-NULL if pNN is not NULL
5348 */
5355 ){
5360 }
5367 }
5375 ){
5377 }
5379 }
5393 /* no break */ deliberate_fall_through
5399 /* no break */ deliberate_fall_through
5400 }
5406 }
5411 }
5415 }
5416 }
5418 }
5420 /*
5421 ** Return true if we can prove the pE2 will always be true if pE1 is
5422 ** true. Return false if we cannot complete the proof or if pE2 might
5423 ** be false. Examples:
5424 **
5425 ** pE1: x==5 pE2: x==5 Result: true
5426 ** pE1: x>0 pE2: x==5 Result: false
5427 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
5428 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
5429 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
5430 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
5431 ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false
5432 **
5433 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
5434 ** Expr.iTable<0 then assume a table number given by iTab.
5435 **
5436 ** If pParse is not NULL, then the values of bound variables in pE1 are
5437 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
5438 ** modified to record which bound variables are referenced. If pParse
5439 ** is NULL, then false will be returned if pE1 contains any bound variables.
5440 **
5441 ** When in doubt, return false. Returning true might give a performance
5442 ** improvement. Returning false might cause a performance reduction, but
5443 ** it will always give the correct answer and is hence always safe.
5444 */
5448 }
5452 ){
5454 }
5457 ){
5459 }
5461 }
5463 /*
5464 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
5465 ** If the expression node requires that the table at pWalker->iCur
5466 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
5467 **
5468 ** This routine controls an optimization. False positives (setting
5469 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
5470 ** (never setting pWalker->eCode) is a harmless missed optimization.
5471 */
5502 }
5511 }
5512 }
5519 }
5522 /* Virtual tables are allowed to use constraints like x=NULL. So
5523 ** a term of the form x=y does not prove that y is not null if x
5524 ** is the column of a virtual table */
5539 /* The y.pTab=0 assignment in wherecode.c always happens after the
5540 ** impliesNotNullRow() test */
5545 ){
5547 }
5548 /* no break */ deliberate_fall_through
5549 }
5552 }
5553 }
5555 /*
5556 ** Return true (non-zero) if expression p can only be true if at least
5557 ** one column of table iTab is non-null. In other words, return true
5558 ** if expression p will always be NULL or false if every column of iTab
5559 ** is NULL.
5560 **
5561 ** False negatives are acceptable. In other words, it is ok to return
5562 ** zero even if expression p will never be true of every column of iTab
5563 ** is NULL. A false negative is merely a missed optimization opportunity.
5564 **
5565 ** False positives are not allowed, however. A false positive may result
5566 ** in an incorrect answer.
5567 **
5568 ** Terms of p that are marked with EP_FromJoin (and hence that come from
5569 ** the ON or USING clauses of LEFT JOINS) are excluded from the analysis.
5570 **
5571 ** This routine is used to check if a LEFT JOIN can be converted into
5572 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
5573 ** clause requires that some column of the right table of the LEFT JOIN
5574 ** be non-NULL, then the LEFT JOIN can be safely converted into an
5575 ** ordinary join.
5576 */
5578 Walker w;
5587 }
5588 }
5596 }
5598 /*
5599 ** An instance of the following structure is used by the tree walker
5600 ** to determine if an expression can be evaluated by reference to the
5601 ** index only, without having to do a search for the corresponding
5602 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
5603 ** is the cursor for the table.
5604 */
5608 };
5610 /*
5611 ** Check to see if there are references to columns in table
5612 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
5613 ** pWalker->u.pIdxCover->pIdx.
5614 */
5619 ){
5622 }
5624 }
5626 /*
5627 ** Determine if an index pIdx on table with cursor iCur contains will
5628 ** the expression pExpr. Return true if the index does cover the
5629 ** expression and false if the pExpr expression references table columns
5630 ** that are not found in the index pIdx.
5631 **
5632 ** An index covering an expression means that the expression can be
5633 ** evaluated using only the index and without having to lookup the
5634 ** corresponding table entry.
5635 */
5640 ){
5641 Walker w;
5650 }
5653 /*
5654 ** An instance of the following structure is used by the tree walker
5655 ** to count references to table columns in the arguments of an
5656 ** aggregate function, in order to implement the
5657 ** sqlite3FunctionThisSrc() routine.
5658 */
5664 };
5666 /*
5667 ** xSelect callback for sqlite3FunctionUsesThisSrc(). If this is the first
5668 ** SELECT with a FROM clause encountered during this iteration, set
5669 ** SrcCount.iSrcInner to the cursor number of the leftmost object in
5670 ** the FROM cause.
5671 */
5676 }
5678 }
5680 /*
5681 ** Count the number of references to columns.
5682 */
5684 /* There was once a NEVER() on the second term on the grounds that
5685 ** sqlite3FunctionUsesThisSrc() was always called before
5686 ** sqlite3ExprAnalyzeAggregates() and so the TK_COLUMNs have not yet
5687 ** been converted into TK_AGG_COLUMN. But this is no longer true due
5688 ** to window functions - sqlite3WindowRewrite() may now indirectly call
5689 ** FunctionUsesThisSrc() when creating a new sub-select. */
5697 }
5701 /* In a well-formed parse tree (no name resolution errors),
5702 ** TK_COLUMN nodes with smaller Expr.iTable values are in an
5703 ** outer context. Those are the only ones to count as "other" */
5705 }
5706 }
5708 }
5710 /*
5711 ** Determine if any of the arguments to the pExpr Function reference
5712 ** pSrcList. Return true if they do. Also return true if the function
5713 ** has no arguments or has only constant arguments. Return false if pExpr
5714 ** references columns but not columns of tables found in pSrcList.
5715 */
5717 Walker w;
5729 #ifndef SQLITE_OMIT_WINDOWFUNC
5732 }
5733 #endif
5735 }
5737 /*
5738 ** This is a Walker expression node callback.
5739 **
5740 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
5741 ** object that is referenced does not refer directly to the Expr. If
5742 ** it does, make a copy. This is done because the pExpr argument is
5743 ** subject to change.
5744 **
5745 ** The copy is stored on pParse->pConstExpr with a register number of 0.
5746 ** This will cause the expression to be deleted automatically when the
5747 ** Parse object is destroyed, but the zero register number means that it
5748 ** will not generate any code in the preamble.
5749 */
5753 ){
5767 }
5768 }
5777 }
5778 }
5779 }
5780 }
5782 }
5784 /*
5785 ** Initialize a Walker object so that will persist AggInfo entries referenced
5786 ** by the tree that is walked.
5787 */
5793 }
5795 /*
5796 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
5797 ** the new element. Return a negative number if malloc fails.
5798 */
5802 db,
5806 &i
5807 );
5809 }
5811 /*
5812 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
5813 ** the new element. Return a negative number if malloc fails.
5814 */
5818 db,
5822 &i
5823 );
5825 }
5827 /*
5828 ** This is the xExprCallback for a tree walker. It is used to
5829 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
5830 ** for additional information.
5831 */
5845 /* Check to see if the column is in one of the tables in the FROM
5846 ** clause of the aggregate query */
5853 /* If we reach this point, it means that pExpr refers to a table
5854 ** that is in the FROM clause of the aggregate query.
5855 **
5856 ** Make an entry for the column in pAggInfo->aCol[] if there
5857 ** is not an entry there already.
5858 */
5865 }
5866 }
5869 ){
5888 }
5889 }
5890 }
5893 }
5894 }
5895 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
5896 ** because it was there before or because we just created it).
5897 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
5898 ** pAggInfo->aCol[] entry.
5899 */
5907 }
5909 }
5913 ){
5914 /* Check to see if pExpr is a duplicate of another aggregate
5915 ** function that is already in the pAggInfo structure
5916 */
5921 }
5922 }
5924 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
5925 */
5941 }
5942 }
5943 }
5944 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
5945 */
5953 }
5954 }
5955 }
5957 }
5959 /*
5960 ** Analyze the pExpr expression looking for aggregate functions and
5961 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
5962 ** points to. Additional entries are made on the AggInfo object as
5963 ** necessary.
5964 **
5965 ** This routine should only be called after the expression has been
5966 ** analyzed by sqlite3ResolveExprNames().
5967 */
5969 Walker w;
5978 }
5980 /*
5981 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
5982 ** expression list. Return the number of errors.
5983 **
5984 ** If an error is found, the analysis is cut short.
5985 */
5992 }
5993 }
5994 }
5996 /*
5997 ** Allocate a single new register for use to hold some intermediate result.
5998 */
6002 }
6004 }
6006 /*
6007 ** Deallocate a register, making available for reuse for some other
6008 ** purpose.
6009 */
6015 }
6016 }
6017 }
6019 /*
6020 ** Allocate or deallocate a block of nReg consecutive registers.
6021 */
6033 }
6035 }
6040 }
6045 }
6046 }
6048 /*
6049 ** Mark all temporary registers as being unavailable for reuse.
6050 **
6051 ** Always invoke this procedure after coding a subroutine or co-routine
6052 ** that might be invoked from other parts of the code, to ensure that
6053 ** the sub/co-routine does not use registers in common with the code that
6054 ** invokes the sub/co-routine.
6055 */
6059 }
6061 /*
6062 ** Validate that no temporary register falls within the range of
6063 ** iFirst..iLast, inclusive. This routine is only call from within assert()
6064 ** statements.
6065 */
6066 #ifdef SQLITE_DEBUG
6072 ){
6074 }
6078 }
6079 }
6081 }