| blob | 6135da786c2dd222bd0dd68a543ae4eedd70ed10 |
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 */
53 }
60 }
61 #ifndef SQLITE_OMIT_CAST
65 }
66 #endif
73 );
74 }
78 }
86 }
88 }
90 }
92 /*
93 ** Make a guess at all the possible datatypes of the result that could
94 ** be returned by an expression. Return a bitmask indicating the answer:
95 **
96 ** 0x01 Numeric
97 ** 0x02 Text
98 ** 0x04 Blob
99 **
100 ** If the expression must return NULL, then 0x00 is returned.
101 */
110 }
114 }
117 }
120 }
123 }
128 }
139 }
148 }
151 }
153 }
156 }
160 }
162 /*
163 ** Set the collating sequence for expression pExpr to be the collating
164 ** sequence named by pToken. Return a pointer to a new Expr node that
165 ** implements the COLLATE operator.
166 **
167 ** If a memory allocation error occurs, that fact is recorded in pParse->db
168 ** and the pExpr parameter is returned unchanged.
169 */
175 ){
182 }
183 }
185 }
190 ){
191 Token s;
195 }
197 /*
198 ** Skip over any TK_COLLATE operators.
199 */
204 }
206 }
208 /*
209 ** Skip over any TK_COLLATE operators and/or any unlikely()
210 ** or likelihood() or likely() functions at the root of an
211 ** expression.
212 */
223 }
224 }
226 }
228 /*
229 ** Return the collation sequence for the expression pExpr. If
230 ** there is no defined collating sequence, return NULL.
231 **
232 ** See also: sqlite3ExprNNCollSeq()
233 **
234 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
235 ** default collation if pExpr has no defined collation.
236 **
237 ** The collating sequence might be determined by a COLLATE operator
238 ** or by the presence of a column with a defined collating sequence.
239 ** COLLATE operators take first precedence. Left operands take
240 ** precedence over right operands.
241 */
251 ){
258 }
260 }
264 }
269 }
274 }
280 /* The Expr.x union is never used at the same time as Expr.pRight */
289 }
290 }
291 }
293 }
296 }
297 }
300 }
302 }
304 /*
305 ** Return the collation sequence for the expression pExpr. If
306 ** there is no defined collating sequence, return a pointer to the
307 ** defautl collation sequence.
308 **
309 ** See also: sqlite3ExprCollSeq()
310 **
311 ** The sqlite3ExprCollSeq() routine works the same except that it
312 ** returns NULL if there is no defined collation.
313 */
319 }
321 /*
322 ** Return TRUE if the two expressions have equivalent collating sequences.
323 */
328 }
330 /*
331 ** pExpr is an operand of a comparison operator. aff2 is the
332 ** type affinity of the other operand. This routine returns the
333 ** type affinity that should be used for the comparison operator.
334 */
338 /* Both sides of the comparison are columns. If one has numeric
339 ** affinity, use that. Otherwise use no affinity.
340 */
345 }
347 /* One side is a column, the other is not. Use the columns affinity. */
350 }
351 }
353 /*
354 ** pExpr is a comparison operator. Return the type affinity that should
355 ** be applied to both operands prior to doing the comparison.
356 */
370 }
372 }
374 /*
375 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
376 ** idx_affinity is the affinity of an indexed column. Return true
377 ** if the index with affinity idx_affinity may be used to implement
378 ** the comparison in pExpr.
379 */
384 }
387 }
389 }
391 /*
392 ** Return the P5 value that should be used for a binary comparison
393 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
394 */
399 ){
403 }
405 /*
406 ** Return a pointer to the collation sequence that should be used by
407 ** a binary comparison operator comparing pLeft and pRight.
408 **
409 ** If the left hand expression has a collating sequence type, then it is
410 ** used. Otherwise the collation sequence for the right hand expression
411 ** is used, or the default (BINARY) if neither expression has a collating
412 ** type.
413 **
414 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
415 ** it is not considered.
416 */
421 ){
432 }
433 }
435 }
437 /* Expresssion p is a comparison operator. Return a collation sequence
438 ** appropriate for the comparison operator.
439 **
440 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
441 ** However, if the OP_Commuted flag is set, then the order of the operands
442 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
443 ** correct collating sequence is found.
444 */
450 }
451 }
453 /*
454 ** Generate code for a comparison operator.
455 */
465 ){
475 }
481 }
483 /*
484 ** Return true if expression pExpr is a vector, or false otherwise.
485 **
486 ** A vector is defined as any expression that results in two or more
487 ** columns of result. Every TK_VECTOR node is an vector because the
488 ** parser will not generate a TK_VECTOR with fewer than two entries.
489 ** But a TK_SELECT might be either a vector or a scalar. It is only
490 ** considered a vector if it has two or more result columns.
491 */
494 }
496 /*
497 ** If the expression passed as the only argument is of type TK_VECTOR
498 ** return the number of expressions in the vector. Or, if the expression
499 ** is a sub-select, return the number of columns in the sub-select. For
500 ** any other type of expression, return 1.
501 */
513 }
514 }
516 /*
517 ** Return a pointer to a subexpression of pVector that is the i-th
518 ** column of the vector (numbered starting with 0). The caller must
519 ** ensure that i is within range.
520 **
521 ** If pVector is really a scalar (and "scalar" here includes subqueries
522 ** that return a single column!) then return pVector unmodified.
523 **
524 ** pVector retains ownership of the returned subexpression.
525 **
526 ** If the vector is a (SELECT ...) then the expression returned is
527 ** just the expression for the i-th term of the result set, and may
528 ** not be ready for evaluation because the table cursor has not yet
529 ** been positioned.
530 */
541 }
542 }
544 }
546 /*
547 ** Compute and return a new Expr object which when passed to
548 ** sqlite3ExprCode() will generate all necessary code to compute
549 ** the iField-th column of the vector expression pVector.
550 **
551 ** It is ok for pVector to be a scalar (as long as iField==0).
552 ** In that case, this routine works like sqlite3ExprDup().
553 **
554 ** The caller owns the returned Expr object and is responsible for
555 ** ensuring that the returned value eventually gets freed.
556 **
557 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
558 ** then the returned object will reference pVector and so pVector must remain
559 ** valid for the life of the returned object. If pVector is a TK_VECTOR
560 ** or a scalar expression, then it can be deleted as soon as this routine
561 ** returns.
562 **
563 ** A trick to cause a TK_SELECT pVector to be deleted together with
564 ** the returned Expr object is to attach the pVector to the pRight field
565 ** of the returned TK_SELECT_COLUMN Expr object.
566 */
572 ){
576 /* The TK_SELECT_COLUMN Expr node:
577 **
578 ** pLeft: pVector containing TK_SELECT. Not deleted.
579 ** pRight: not used. But recursively deleted.
580 ** iColumn: Index of a column in pVector
581 ** iTable: 0 or the number of columns on the LHS of an assignment
582 ** pLeft->iTable: First in an array of register holding result, or 0
583 ** if the result is not yet computed.
584 **
585 ** sqlite3ExprDelete() specifically skips the recursive delete of
586 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
587 ** can be attached to pRight to cause this node to take ownership of
588 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
589 ** with the same pLeft pointer to the pVector, but only one of them
590 ** will own the pVector.
591 */
597 }
605 /* This must be a vector UPDATE inside a trigger */
608 }
609 }
611 }
613 }
615 /*
616 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
617 ** it. Return the register in which the result is stored (or, if the
618 ** sub-select returns more than one column, the first in an array
619 ** of registers in which the result is stored).
620 **
621 ** If pExpr is not a TK_SELECT expression, return 0.
622 */
625 #ifndef SQLITE_OMIT_SUBQUERY
628 }
629 #endif
631 }
633 /*
634 ** Argument pVector points to a vector expression - either a TK_VECTOR
635 ** or TK_SELECT that returns more than one column. This function returns
636 ** the register number of a register that contains the value of
637 ** element iField of the vector.
638 **
639 ** If pVector is a TK_SELECT expression, then code for it must have
640 ** already been generated using the exprCodeSubselect() routine. In this
641 ** case parameter regSelect should be the first in an array of registers
642 ** containing the results of the sub-select.
643 **
644 ** If pVector is of type TK_VECTOR, then code for the requested field
645 ** is generated. In this case (*pRegFree) may be set to the number of
646 ** a temporary register to be freed by the caller before returning.
647 **
648 ** Before returning, output parameter (*ppExpr) is set to point to the
649 ** Expr object corresponding to element iElem of the vector.
650 */
658 ){
664 }
669 }
674 }
676 }
678 /*
679 ** Expression pExpr is a comparison between two vector values. Compute
680 ** the result of the comparison (1, 0, or NULL) and write that
681 ** result into register dest.
682 **
683 ** The caller must satisfy the following preconditions:
684 **
685 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
686 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
687 ** otherwise: op==pExpr->op and p5==0
688 */
694 u8 p5 /* SQLITE_NULLEQ or zero */
695 ){
713 }
718 );
754 }
759 }
762 }
769 }
770 }
775 }
776 }
778 #if SQLITE_MAX_EXPR_DEPTH>0
779 /*
780 ** Check that argument nHeight is less than or equal to the maximum
781 ** expression depth allowed. If it is not, leave an error message in
782 ** pParse.
783 */
790 );
792 }
794 }
796 /* The following three functions, heightOfExpr(), heightOfExprList()
797 ** and heightOfSelect(), are used to determine the maximum height
798 ** of any expression tree referenced by the structure passed as the
799 ** first argument.
800 **
801 ** If this maximum height is greater than the current value pointed
802 ** to by pnHeight, the second parameter, then set *pnHeight to that
803 ** value.
804 */
809 }
810 }
811 }
817 }
818 }
819 }
829 }
830 }
832 /*
833 ** Set the Expr.nHeight variable in the structure passed as an
834 ** argument. An expression with no children, Expr.pList or
835 ** Expr.pSelect member has a height of 1. Any other expression
836 ** has a height equal to the maximum height of any other
837 ** referenced Expr plus one.
838 **
839 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
840 ** if appropriate.
841 */
846 }
852 }
854 }
856 /*
857 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
858 ** the height is greater than the maximum allowed expression depth,
859 ** leave an error in pParse.
860 **
861 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
862 ** Expr.flags.
863 */
868 }
870 /*
871 ** Return the maximum height of any expression tree referenced
872 ** by the select statement passed as an argument.
873 */
878 }
880 /*
881 ** Propagate all EP_Propagate flags from the Expr.x.pList into
882 ** Expr.flags.
883 */
888 }
889 }
890 #define exprSetHeight(y)
893 /*
894 ** This routine is the core allocator for Expr nodes.
895 **
896 ** Construct a new expression node and return a pointer to it. Memory
897 ** for this node and for the pToken argument is a single allocation
898 ** obtained from sqlite3DbMalloc(). The calling function
899 ** is responsible for making sure the node eventually gets freed.
900 **
901 ** If dequote is true, then the token (if it exists) is dequoted.
902 ** If dequote is false, no dequoting is performed. The deQuote
903 ** parameter is ignored if pToken is NULL or if the token does not
904 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
905 ** then the EP_DblQuoted flag is set on the expression node.
906 **
907 ** Special case: If op==TK_INTEGER and pToken points to a string that
908 ** can be translated into a 32-bit integer, then the token is not
909 ** stored in u.zToken. Instead, the integer values is written
910 ** into u.iValue and the EP_IntValue flag is set. No extra storage
911 ** is allocated to hold the integer text and the dequote flag is ignored.
912 */
918 ){
929 }
930 }
947 }
948 }
949 }
950 #if SQLITE_MAX_EXPR_DEPTH>0
952 #endif
953 }
955 }
957 /*
958 ** Allocate a new expression node from a zero-terminated token that has
959 ** already been dequoted.
960 */
965 ){
966 Token x;
970 }
972 /*
973 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
974 **
975 ** If pRoot==NULL that means that a memory allocation error has occurred.
976 ** In that case, delete the subtrees pLeft and pRight.
977 */
982 Expr *pRight
983 ){
994 #if SQLITE_MAX_EXPR_DEPTH>0
998 #endif
999 }
1003 #if SQLITE_MAX_EXPR_DEPTH>0
1006 }
1007 #endif
1008 }
1009 }
1010 }
1012 /*
1013 ** Allocate an Expr node which joins as many as two subtrees.
1014 **
1015 ** One or both of the subtrees can be NULL. Return a pointer to the new
1016 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
1017 ** free the subtrees and return NULL.
1018 */
1024 ){
1036 }
1038 }
1040 /*
1041 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
1042 ** do a memory allocation failure) then delete the pSelect object.
1043 */
1052 }
1053 }
1055 /*
1056 ** Expression list pEList is a list of vector values. This function
1057 ** converts the contents of pEList to a VALUES(...) Select statement
1058 ** returning 1 row for each element of the list. For example, the
1059 ** expression list:
1060 **
1061 ** ( (1,2), (3,4) (5,6) )
1062 **
1063 ** is translated to the equivalent of:
1064 **
1065 ** VALUES(1,2), (3,4), (5,6)
1066 **
1067 ** Each of the vector values in pEList must contain exactly nElem terms.
1068 ** If a list element that is not a vector or does not contain nElem terms,
1069 ** an error message is left in pParse.
1070 **
1071 ** This is used as part of processing IN(...) expressions with a list
1072 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
1073 */
1087 }
1091 );
1093 }
1101 }
1103 }
1104 }
1108 }
1111 }
1113 /*
1114 ** Join two expressions using an AND operator. If either expression is
1115 ** NULL, then just return the other expression.
1116 **
1117 ** If one side or the other of the AND is known to be false, then instead
1118 ** of returning an AND expression, just return a constant expression with
1119 ** a value of false.
1120 */
1128 && !IN_RENAME_OBJECT
1129 ){
1135 }
1136 }
1138 /*
1139 ** Construct a new expression node for a function with multiple
1140 ** arguments.
1141 */
1147 ){
1155 }
1161 ){
1163 }
1170 }
1172 /*
1173 ** Check to see if a function is usable according to current access
1174 ** rules:
1175 **
1176 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1177 **
1178 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1179 ** top-level SQL
1180 **
1181 ** If the function is not usable, create an error.
1182 */
1187 ){
1193 ){
1194 /* Functions prohibited in triggers and views if:
1195 ** (1) tagged with SQLITE_DIRECTONLY
1196 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1197 ** is tagged with SQLITE_FUNC_UNSAFE) and
1198 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1199 ** that the schema is possibly tainted).
1200 */
1202 }
1203 }
1204 }
1206 /*
1207 ** Assign a variable number to an expression that encodes a wildcard
1208 ** in the original SQL statement.
1209 **
1210 ** Wildcards consisting of a single "?" are assigned the next sequential
1211 ** variable number.
1212 **
1213 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1214 ** sure "nnn" is not too big to avoid a denial of service attack when
1215 ** the SQL statement comes from an external source.
1216 **
1217 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1218 ** as the previous instance of the same wildcard. Or if this is the first
1219 ** instance of the wildcard, the next sequential variable number is
1220 ** assigned.
1221 */
1225 ynVar x;
1234 /* Wildcard of the form "?". Assign the next variable number */
1240 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1241 ** use it as the variable number */
1242 i64 i;
1249 }
1259 }
1266 }
1268 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1269 ** number as the prior appearance of the same name, or if the name
1270 ** has never appeared before, reuse the same variable number
1271 */
1276 }
1277 }
1280 }
1281 }
1286 }
1287 }
1289 /*
1290 ** Recursively delete an expression tree.
1291 */
1299 #ifdef SQLITE_DEBUG
1305 }
1306 #endif
1308 /* The Expr.x union is never used at the same time as Expr.pRight */
1319 #ifndef SQLITE_OMIT_WINDOWFUNC
1322 }
1323 #endif
1324 }
1325 }
1328 }
1329 }
1332 }
1334 /*
1335 ** Clear both elements of an OnOrUsing object
1336 */
1339 /* Nothing to clear */
1344 }
1345 }
1347 /*
1348 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1349 ** This is similar to sqlite3ExprDelete() except that the delete is
1350 ** deferred untilthe pParse is deleted.
1351 **
1352 ** The pExpr might be deleted immediately on an OOM error.
1353 **
1354 ** The deferred delete is (currently) implemented by adding the
1355 ** pExpr to the pParse->pConstExpr list with a register number of 0.
1356 */
1360 pExpr);
1361 }
1363 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1364 ** expression.
1365 */
1370 }
1372 }
1373 }
1375 /*
1376 ** Return the number of bytes allocated for the expression structure
1377 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1378 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1379 */
1384 }
1386 /*
1387 ** The dupedExpr*Size() routines each return the number of bytes required
1388 ** to store a copy of an expression or expression tree. They differ in
1389 ** how much of the tree is measured.
1390 **
1391 ** dupedExprStructSize() Size of only the Expr structure
1392 ** dupedExprNodeSize() Size of Expr + space for token
1393 ** dupedExprSize() Expr + token + subtree components
1394 **
1395 ***************************************************************************
1396 **
1397 ** The dupedExprStructSize() function returns two values OR-ed together:
1398 ** (1) the space required for a copy of the Expr structure only and
1399 ** (2) the EP_xxx flags that indicate what the structure size should be.
1400 ** The return values is always one of:
1401 **
1402 ** EXPR_FULLSIZE
1403 ** EXPR_REDUCEDSIZE | EP_Reduced
1404 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1405 **
1406 ** The size of the structure can be found by masking the return value
1407 ** of this routine with 0xfff. The flags can be found by masking the
1408 ** return value with EP_Reduced|EP_TokenOnly.
1409 **
1410 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1411 ** (unreduced) Expr objects as they or originally constructed by the parser.
1412 ** During expression analysis, extra information is computed and moved into
1413 ** later parts of the Expr object and that extra information might get chopped
1414 ** off if the expression is reduced. Note also that it does not work to
1415 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1416 ** to reduce a pristine expression tree from the parser. The implementation
1417 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1418 ** to enforce this constraint.
1419 */
1426 #ifndef SQLITE_OMIT_WINDOWFUNC
1428 #endif
1429 ){
1440 }
1441 }
1443 }
1445 /*
1446 ** This function returns the space in bytes required to store the copy
1447 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1448 ** string is defined.)
1449 */
1454 }
1456 }
1458 /*
1459 ** Return the number of bytes required to create a duplicate of the
1460 ** expression passed as the first argument. The second argument is a
1461 ** mask containing EXPRDUP_XXX flags.
1462 **
1463 ** The value returned includes space to create a copy of the Expr struct
1464 ** itself and the buffer referred to by Expr.u.zToken, if any.
1465 **
1466 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1467 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1468 ** and Expr.pRight variables (but not for any structures pointed to or
1469 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1470 */
1477 }
1478 }
1480 }
1482 /*
1483 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1484 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1485 ** to store the copy of expression p, the copies of p->u.zToken
1486 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1487 ** if any. Before returning, *pzBuffer is set to the first byte past the
1488 ** portion of the buffer copied into by this function.
1489 */
1500 /* Figure out where to write the new Expr structure. */
1508 }
1512 /* Set nNewSize to the size allocated for the structure pointed to
1513 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1514 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1515 ** by the copy of the p->u.zToken string (if any).
1516 */
1524 }
1533 }
1534 }
1536 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1543 }
1545 /* Copy the p->u.zToken string, if any. */
1549 }
1552 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1557 }
1558 }
1560 /* Fill in pNew->pLeft and pNew->pRight. */
1568 }
1569 #ifndef SQLITE_OMIT_WINDOWFUNC
1573 }
1577 }
1586 }
1588 }
1589 }
1590 }
1592 }
1594 /*
1595 ** Create and return a deep copy of the object passed as the second
1596 ** argument. If an OOM condition is encountered, NULL is returned
1597 ** and the db->mallocFailed flag set.
1598 */
1599 #ifndef SQLITE_OMIT_CTE
1613 }
1614 }
1615 }
1617 }
1618 #else
1619 # define sqlite3WithDup(x,y) 0
1620 #endif
1622 #ifndef SQLITE_OMIT_WINDOWFUNC
1623 /*
1624 ** The gatherSelectWindows() procedure and its helper routine
1625 ** gatherSelectWindowsCallback() are used to scan all the expressions
1626 ** an a newly duplicated SELECT statement and gather all of the Window
1627 ** objects found there, assembling them onto the linked list at Select->pWin.
1628 */
1637 }
1639 }
1642 }
1644 Walker w;
1651 }
1652 #endif
1655 /*
1656 ** The following group of routines make deep copies of expressions,
1657 ** expression lists, ID lists, and select statements. The copies can
1658 ** be deleted (by being passed to their respective ...Delete() routines)
1659 ** without effecting the originals.
1660 **
1661 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1662 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1663 ** by subsequent calls to sqlite*ListAppend() routines.
1664 **
1665 ** Any tables that the SrcList might point to are not duplicated.
1666 **
1667 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1668 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1669 ** truncated version of the usual Expr structure that will be stored as
1670 ** part of the in-memory representation of the database schema.
1671 */
1675 }
1698 ){
1708 }
1710 }
1711 }
1716 }
1718 }
1720 /*
1721 ** If cursors, triggers, views and subqueries are all omitted from
1722 ** the build, then none of the following routines, except for
1723 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1724 ** called with a NULL argument.
1725 */
1726 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1727 || !defined(SQLITE_OMIT_SUBQUERY)
1752 }
1756 }
1760 }
1764 }
1771 }
1773 }
1775 }
1791 }
1793 }
1821 #ifndef SQLITE_OMIT_WINDOWFUNC
1825 #endif
1828 /* Any prior OOM might have left the Select object incomplete.
1829 ** Delete the whole thing rather than allow an incomplete Select
1830 ** to be used by the code generator. */
1834 }
1838 }
1841 }
1842 #else
1846 }
1847 #endif
1850 /*
1851 ** Add a new element to the end of an expression list. If pList is
1852 ** initially NULL, then create a new expression list.
1853 **
1854 ** The pList argument must be either NULL or a pointer to an ExprList
1855 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1856 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1857 ** Reason: This routine assumes that the number of slots in pList->a[]
1858 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1859 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1860 **
1861 ** If a memory allocation error occurs, the entire list is freed and
1862 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1863 ** that the new entry was successfully appended.
1864 */
1869 ){
1877 }
1884 }
1889 ){
1901 }
1906 }
1911 ){
1915 }
1918 }
1923 }
1925 /*
1926 ** pColumns and pExpr form a vector assignment which is part of the SET
1927 ** clause of an UPDATE statement. Like this:
1928 **
1929 ** (a,b,c) = (expr1,expr2,expr3)
1930 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1931 **
1932 ** For each term of the vector assignment, append new entries to the
1933 ** expression list pList. In the case of a subquery on the RHS, append
1934 ** TK_SELECT_COLUMN expressions.
1935 */
1941 ){
1946 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1947 ** exit prior to this routine being invoked */
1951 /* If the RHS is a vector, then we can immediately check to see that
1952 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1953 ** wildcards ("*") in the result set of the SELECT must be expanded before
1954 ** we can do the size check, so defer the size check until code generation.
1955 */
1960 }
1971 }
1972 }
1979 /* Store the SELECT statement in pRight so it will be deleted when
1980 ** sqlite3ExprListDelete() is called */
1984 /* Remember the size of the LHS in iTable so that we can check that
1985 ** the RHS and LHS sizes match during code generation. */
1987 }
1989 vector_append_error:
1993 }
1995 /*
1996 ** Set the sort order for the last element on the given ExprList.
1997 */
2007 );
2011 );
2017 }
2024 }
2025 }
2026 }
2028 /*
2029 ** Set the ExprList.a[].zEName element of the most recently added item
2030 ** on the expression list.
2031 **
2032 ** pList might be NULL following an OOM error. But pName should never be
2033 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2034 ** is set.
2035 */
2041 ){
2052 /* If dequote==0, then pName->z does not point to part of a DDL
2053 ** statement handled by the parser. And so no token need be added
2054 ** to the token-map. */
2058 }
2059 }
2060 }
2061 }
2063 /*
2064 ** Set the ExprList.a[].zSpan element of the most recently added item
2065 ** on the expression list.
2066 **
2067 ** pList might be NULL following an OOM error. But pSpan should never be
2068 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2069 ** is set.
2070 */
2076 ){
2085 }
2086 }
2087 }
2089 /*
2090 ** If the expression list pEList contains more than iLimit elements,
2091 ** leave an error message in pParse.
2092 */
2097 ){
2103 }
2104 }
2106 /*
2107 ** Delete an entire expression list.
2108 */
2117 pItem++;
2120 }
2123 }
2125 /*
2126 ** Return the bitwise-OR of all Expr.flags fields in the given
2127 ** ExprList.
2128 */
2137 }
2139 }
2141 /*
2142 ** This is a SELECT-node callback for the expression walker that
2143 ** always "fails". By "fail" in this case, we mean set
2144 ** pWalker->eCode to zero and abort.
2145 **
2146 ** This callback is used by multiple expression walkers.
2147 */
2152 }
2154 /*
2155 ** Check the input string to see if it is "true" or "false" (in any case).
2156 **
2157 ** If the string is.... Return
2158 ** "true" EP_IsTrue
2159 ** "false" EP_IsFalse
2160 ** anything else 0
2161 */
2166 }
2169 /*
2170 ** If the input expression is an ID with the name "true" or "false"
2171 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2172 ** the conversion happened, and zero if the expression is unaltered.
2173 */
2175 u32 v;
2179 ){
2183 }
2185 }
2187 /*
2188 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2189 ** and 0 if it is FALSE.
2190 */
2198 }
2200 /*
2201 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2202 ** terms that are always true or false. Return the simplified expression.
2203 ** Or return the original expression if no simplification is possible.
2204 **
2205 ** Examples:
2206 **
2207 ** (x<10) AND true => (x<10)
2208 ** (x<10) AND false => false
2209 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2210 ** (x<10) AND (y=22 OR true) => (x<10)
2211 ** (y=22) OR true => true
2212 */
2222 }
2223 }
2225 }
2228 /*
2229 ** These routines are Walker callbacks used to check expressions to
2230 ** see if they are "constant" for some definition of constant. The
2231 ** Walker.eCode value determines the type of "constant" we are looking
2232 ** for.
2233 **
2234 ** These callback routines are used to implement the following:
2235 **
2236 ** sqlite3ExprIsConstant() pWalker->eCode==1
2237 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2238 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2239 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2240 **
2241 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2242 ** is found to not be a constant.
2243 **
2244 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2245 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2246 ** when parsing an existing schema out of the sqlite_schema table and 4
2247 ** when processing a new CREATE TABLE statement. A bound parameter raises
2248 ** an error for new statements, but is silently converted
2249 ** to NULL for existing schemas. This allows sqlite_schema tables that
2250 ** contain a bound parameter because they were generated by older versions
2251 ** of SQLite to be parsed by newer versions of SQLite without raising a
2252 ** malformed schema error.
2253 */
2256 /* If pWalker->eCode is 2 then any term of the expression that comes from
2257 ** the ON or USING clauses of an outer join disqualifies the expression
2258 ** from being considered constant. */
2262 }
2265 /* Consider functions to be constant if all their arguments are constant
2266 ** and either pWalker->eCode==4 or 5 or the function has the
2267 ** SQLITE_FUNC_CONST flag. */
2271 ){
2277 }
2279 /* Convert "true" or "false" in a DEFAULT clause into the
2280 ** appropriate TK_TRUEFALSE operator */
2283 }
2284 /* no break */ deliberate_fall_through
2294 }
2297 }
2298 /* no break */ deliberate_fall_through
2309 /* Silently convert bound parameters that appear inside of CREATE
2310 ** statements into a NULL when parsing the CREATE statement text out
2311 ** of the sqlite_schema table */
2314 /* A bound parameter in a CREATE statement that originates from
2315 ** sqlite3_prepare() causes an error */
2318 }
2319 /* no break */ deliberate_fall_through
2324 }
2325 }
2327 Walker w;
2331 #ifdef SQLITE_DEBUG
2333 #endif
2337 }
2339 /*
2340 ** Walk an expression tree. Return non-zero if the expression is constant
2341 ** and 0 if it involves variables or function calls.
2342 **
2343 ** For the purposes of this function, a double-quoted string (ex: "abc")
2344 ** is considered a variable but a single-quoted string (ex: 'abc') is
2345 ** a constant.
2346 */
2349 }
2351 /*
2352 ** Walk an expression tree. Return non-zero if
2353 **
2354 ** (1) the expression is constant, and
2355 ** (2) the expression does originate in the ON or USING clause
2356 ** of a LEFT JOIN, and
2357 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2358 ** operands created by the constant propagation optimization.
2359 **
2360 ** When this routine returns true, it indicates that the expression
2361 ** can be added to the pParse->pConstExpr list and evaluated once when
2362 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2363 */
2366 }
2368 /*
2369 ** Walk an expression tree. Return non-zero if the expression is constant
2370 ** for any single row of the table with cursor iCur. In other words, the
2371 ** expression must not refer to any non-deterministic function nor any
2372 ** table other than iCur.
2373 */
2376 }
2378 /*
2379 ** Check pExpr to see if it is an invariant constraint on data source pSrc.
2380 ** This is an optimization. False negatives will perhaps cause slower
2381 ** queries, but false positives will yield incorrect answers. So when in
2382 ** doubt, return 0.
2383 **
2384 ** To be an invariant constraint, the following must be true:
2385 **
2386 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
2387 **
2388 ** (2) pExpr cannot use subqueries or non-deterministic functions.
2389 **
2390 ** (3) pSrc cannot be part of the left operand for a RIGHT JOIN.
2391 ** (Is there some way to relax this constraint?)
2392 **
2393 ** (4) If pSrc is the right operand of a LEFT JOIN, then...
2394 ** (4a) pExpr must come from an ON clause..
2395 (4b) and specifically the ON clause associated with the LEFT JOIN.
2396 **
2397 ** (5) If pSrc is not the right operand of a LEFT JOIN or the left
2398 ** operand of a RIGHT JOIN, then pExpr must be from the WHERE
2399 ** clause, not an ON clause.
2400 */
2404 }
2410 }
2412 }
2415 /*
2416 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2417 */
2422 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2423 ** it constant. */
2430 }
2431 }
2432 }
2434 /* Check if pExpr is a sub-select. If so, consider it variable. */
2438 }
2441 }
2443 /*
2444 ** Walk the expression tree passed as the first argument. Return non-zero
2445 ** if the expression consists entirely of constants or copies of terms
2446 ** in pGroupBy that sort with the BINARY collation sequence.
2447 **
2448 ** This routine is used to determine if a term of the HAVING clause can
2449 ** be promoted into the WHERE clause. In order for such a promotion to work,
2450 ** the value of the HAVING clause term must be the same for all members of
2451 ** a "group". The requirement that the GROUP BY term must be BINARY
2452 ** assumes that no other collating sequence will have a finer-grained
2453 ** grouping than binary. In other words (A=B COLLATE binary) implies
2454 ** A=B in every other collating sequence. The requirement that the
2455 ** GROUP BY be BINARY is stricter than necessary. It would also work
2456 ** to promote HAVING clauses that use the same alternative collating
2457 ** sequence as the GROUP BY term, but that is much harder to check,
2458 ** alternative collating sequences are uncommon, and this is only an
2459 ** optimization, so we take the easy way out and simply require the
2460 ** GROUP BY to use the BINARY collating sequence.
2461 */
2463 Walker w;
2471 }
2473 /*
2474 ** Walk an expression tree for the DEFAULT field of a column definition
2475 ** in a CREATE TABLE statement. Return non-zero if the expression is
2476 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2477 ** the expression is constant or a function call with constant arguments.
2478 ** Return and 0 if there are any variables.
2479 **
2480 ** isInit is true when parsing from sqlite_schema. isInit is false when
2481 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2482 ** (such as ? or $abc) in the expression are converted into NULL. When
2483 ** isInit is false, parameters raise an error. Parameters should not be
2484 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2485 ** allowed it, so we need to support it when reading sqlite_schema for
2486 ** backwards compatibility.
2487 **
2488 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2489 **
2490 ** For the purposes of this function, a double-quoted string (ex: "abc")
2491 ** is considered a variable but a single-quoted string (ex: 'abc') is
2492 ** a constant.
2493 */
2497 }
2499 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2500 /*
2501 ** Walk an expression tree. Return 1 if the expression contains a
2502 ** subquery of some kind. Return 0 if there are no subqueries.
2503 */
2505 Walker w;
2509 #ifdef SQLITE_DEBUG
2511 #endif
2514 }
2515 #endif
2517 /*
2518 ** If the expression p codes a constant integer that is small enough
2519 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2520 ** in *pValue. If the expression is not an integer or if it is too big
2521 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2522 */
2527 /* If an expression is an integer literal that fits in a signed 32-bit
2528 ** integer, then the EP_IntValue flag will have already been set */
2535 }
2540 }
2547 }
2549 }
2551 }
2553 }
2555 /*
2556 ** Return FALSE if there is no chance that the expression can be NULL.
2557 **
2558 ** If the expression might be NULL or if the expression is too complex
2559 ** to tell return TRUE.
2560 **
2561 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2562 ** when we know that a value cannot be NULL. Hence, a false positive
2563 ** (returning TRUE when in fact the expression can never be NULL) might
2564 ** be a small performance hit but is otherwise harmless. On the other
2565 ** hand, a false negative (returning FALSE when the result could be NULL)
2566 ** will likely result in an incorrect answer. So when in doubt, return
2567 ** TRUE.
2568 */
2570 u8 op;
2575 }
2593 }
2594 }
2596 /*
2597 ** Return TRUE if the given expression is a constant which would be
2598 ** unchanged by OP_Affinity with the affinity given in the second
2599 ** argument.
2600 **
2601 ** This routine is used to determine if the OP_Affinity operation
2602 ** can be omitted. When in doubt return FALSE. A false negative
2603 ** is harmless. A false positive, however, can result in the wrong
2604 ** answer.
2605 */
2607 u8 op;
2613 }
2619 }
2622 }
2625 }
2628 }
2632 }
2635 }
2636 }
2637 }
2639 /*
2640 ** Return TRUE if the given string is a row-id column name.
2641 */
2647 }
2649 /*
2650 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2651 ** that can be simplified to a direct table access, then return
2652 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2653 ** or if the SELECT statement needs to be manifested into a transient
2654 ** table, then return NULL.
2655 */
2656 #ifndef SQLITE_OMIT_SUBQUERY
2671 }
2685 /* All SELECT results must be columns. */
2690 }
2692 }
2695 #ifndef SQLITE_OMIT_SUBQUERY
2696 /*
2697 ** Generate code that checks the left-most column of index table iCur to see if
2698 ** it contains any NULL entries. Cause the register at regHasNull to be set
2699 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2700 ** to be set to NULL if iCur contains one or more NULL values.
2701 */
2710 }
2711 #endif
2714 #ifndef SQLITE_OMIT_SUBQUERY
2715 /*
2716 ** The argument is an IN operator with a list (not a subquery) on the
2717 ** right-hand side. Return TRUE if that list is constant.
2718 */
2728 }
2729 #endif
2731 /*
2732 ** This function is used by the implementation of the IN (...) operator.
2733 ** The pX parameter is the expression on the RHS of the IN operator, which
2734 ** might be either a list of expressions or a subquery.
2735 **
2736 ** The job of this routine is to find or create a b-tree object that can
2737 ** be used either to test for membership in the RHS set or to iterate through
2738 ** all members of the RHS set, skipping duplicates.
2739 **
2740 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2741 ** and the *piTab parameter is set to the index of that cursor.
2742 **
2743 ** The returned value of this function indicates the b-tree type, as follows:
2744 **
2745 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2746 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2747 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2748 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2749 ** populated epheremal table.
2750 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2751 ** implemented as a sequence of comparisons.
2752 **
2753 ** An existing b-tree might be used if the RHS expression pX is a simple
2754 ** subquery such as:
2755 **
2756 ** SELECT <column1>, <column2>... FROM <table>
2757 **
2758 ** If the RHS of the IN operator is a list or a more complex subquery, then
2759 ** an ephemeral table might need to be generated from the RHS and then
2760 ** pX->iTable made to point to the ephemeral table instead of an
2761 ** existing table. In this case, the creation and initialization of the
2762 ** ephmeral table might be put inside of a subroutine, the EP_Subrtn flag
2763 ** will be set on pX and the pX->y.sub fields will be set to show where
2764 ** the subroutine is coded.
2765 **
2766 ** The inFlags parameter must contain, at a minimum, one of the bits
2767 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2768 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2769 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2770 ** be used to loop over all values of the RHS of the IN operator.
2771 **
2772 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2773 ** through the set members) then the b-tree must not contain duplicates.
2774 ** An epheremal table will be created unless the selected columns are guaranteed
2775 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2776 ** a UNIQUE constraint or index.
2777 **
2778 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2779 ** for fast set membership tests) then an epheremal table must
2780 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2781 ** index can be found with the specified <columns> as its left-most.
2782 **
2783 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2784 ** if the RHS of the IN operator is a list (not a subquery) then this
2785 ** routine might decide that creating an ephemeral b-tree for membership
2786 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2787 ** calling routine should implement the IN operator using a sequence
2788 ** of Eq or Ne comparison operations.
2789 **
2790 ** When the b-tree is being used for membership tests, the calling function
2791 ** might need to know whether or not the RHS side of the IN operator
2792 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2793 ** if there is any chance that the (...) might contain a NULL value at
2794 ** runtime, then a register is allocated and the register number written
2795 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2796 ** NULL value, then *prRhsHasNull is left unchanged.
2797 **
2798 ** If a register is allocated and its location stored in *prRhsHasNull, then
2799 ** the value in that register will be NULL if the b-tree contains one or more
2800 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2801 ** NULL values.
2802 **
2803 ** If the aiMap parameter is not NULL, it must point to an array containing
2804 ** one element for each column returned by the SELECT statement on the RHS
2805 ** of the IN(...) operator. The i'th entry of the array is populated with the
2806 ** offset of the index column that matches the i'th column returned by the
2807 ** SELECT. For example, if the expression and selected index are:
2808 **
2809 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2810 ** CREATE INDEX i1 ON t1(b, c, a);
2811 **
2812 ** then aiMap[] is populated with {2, 0, 1}.
2813 */
2814 #ifndef SQLITE_OMIT_SUBQUERY
2822 ){
2833 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2834 ** whether or not the SELECT result contains NULL values, check whether
2835 ** or not NULL is actually possible (it may not be, for example, due
2836 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2837 ** set prRhsHasNull to 0 before continuing. */
2843 }
2846 }
2847 }
2849 /* Check to see if an existing table or index can be used to
2850 ** satisfy the query. This is preferable to generating a new
2851 ** ephemeral table. */
2864 /* Code an OP_Transaction and OP_TableLock for <table>. */
2872 /* The "x IN (SELECT rowid FROM table)" case */
2886 /* Check that the affinity that will be used to perform each
2887 ** comparison is the same as the affinity of each column in table
2888 ** on the RHS of the IN operator. If it not, it is not possible to
2889 ** use any index of the RHS table. */
2901 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2902 ** other has no affinity and the other side is TEXT. Hence,
2903 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2904 ** and for the term on the LHS of the IN to have no affinity. */
2909 }
2910 }
2913 /* Search for an existing index that will work for this IN operator */
2919 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2920 ** BITMASK(nExpr) without overflowing */
2927 ){
2929 }
2930 }
2945 }
2947 }
2953 }
2957 /* If we reach this point, that means the index pIdx is usable */
2968 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
2972 #endif
2976 }
2977 }
2979 }
2985 /* If no preexisting index is available for the IN clause
2986 ** and IN_INDEX_NOOP is an allowed reply
2987 ** and the RHS of the IN operator is a list, not a subquery
2988 ** and the RHS is not constant or has two or fewer terms,
2989 ** then it is not worth creating an ephemeral table to evaluate
2990 ** the IN operator so return IN_INDEX_NOOP.
2991 */
2996 ){
3000 }
3003 /* Could not find an existing table or index to use as the RHS b-tree.
3004 ** We will have to generate an ephemeral table to do the job.
3005 */
3013 }
3018 }
3020 }
3026 }
3029 }
3030 #endif
3032 #ifndef SQLITE_OMIT_SUBQUERY
3033 /*
3034 ** Argument pExpr is an (?, ?...) IN(...) expression. This
3035 ** function allocates and returns a nul-terminated string containing
3036 ** the affinities to be used for each column of the comparison.
3037 **
3038 ** It is the responsibility of the caller to ensure that the returned
3039 ** string is eventually freed using sqlite3DbFree().
3040 */
3058 }
3059 }
3061 }
3063 }
3064 #endif
3066 #ifndef SQLITE_OMIT_SUBQUERY
3067 /*
3068 ** Load the Parse object passed as the first argument with an error
3069 ** message of the form:
3070 **
3071 ** "sub-select returns N columns - expected M"
3072 */
3077 }
3078 }
3079 #endif
3081 /*
3082 ** Expression pExpr is a vector that has been used in a context where
3083 ** it is not permitted. If pExpr is a sub-select vector, this routine
3084 ** loads the Parse object with a message of the form:
3085 **
3086 ** "sub-select returns N columns - expected 1"
3087 **
3088 ** Or, if it is a regular scalar vector:
3089 **
3090 ** "row value misused"
3091 */
3093 #ifndef SQLITE_OMIT_SUBQUERY
3097 #endif
3098 {
3100 }
3101 }
3103 #ifndef SQLITE_OMIT_SUBQUERY
3104 /*
3105 ** Generate code that will construct an ephemeral table containing all terms
3106 ** in the RHS of an IN operator. The IN operator can be in either of two
3107 ** forms:
3108 **
3109 ** x IN (4,5,11) -- IN operator with list on right-hand side
3110 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
3111 **
3112 ** The pExpr parameter is the IN operator. The cursor number for the
3113 ** constructed ephermeral table is returned. The first time the ephemeral
3114 ** table is computed, the cursor number is also stored in pExpr->iTable,
3115 ** however the cursor number returned might not be the same, as it might
3116 ** have been duplicated using OP_OpenDup.
3117 **
3118 ** If the LHS expression ("x" in the examples) is a column value, or
3119 ** the SELECT statement returns a column value, then the affinity of that
3120 ** column is used to build the index keys. If both 'x' and the
3121 ** SELECT... statement are columns, then numeric affinity is used
3122 ** if either column has NUMERIC or INTEGER affinity. If neither
3123 ** 'x' nor the SELECT... statement are columns, then numeric affinity
3124 ** is used.
3125 */
3130 ){
3141 /* The evaluation of the IN must be repeated every time it
3142 ** is encountered if any of the following is true:
3143 **
3144 ** * The right-hand side is a correlated subquery
3145 ** * The right-hand side is an expression list containing variables
3146 ** * We are inside a trigger
3147 **
3148 ** If all of the above are false, then we can compute the RHS just once
3149 ** and reuse it many names.
3150 */
3152 /* Reuse of the RHS is allowed */
3153 /* If this routine has already been coded, but the previous code
3154 ** might not have been invoked yet, so invoke it now as a subroutine.
3155 */
3161 }
3169 }
3171 /* Begin coding the subroutine */
3180 }
3182 /* Check to see if this is a vector IN operator */
3186 /* Construct the ephemeral table that will contain the content of
3187 ** RHS of the IN operator.
3188 */
3191 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3196 }
3197 #endif
3201 /* Case 1: expr IN (SELECT ...)
3202 **
3203 ** Generate code to write the results of the select into the temporary
3204 ** table allocated and opened above.
3205 */
3211 ));
3212 /* If the LHS and RHS of the IN operator do not match, that
3213 ** error will have been caught long before we reach this point. */
3216 SelectDest dest;
3231 }
3240 );
3241 }
3242 }
3244 /* Case 2: expr IN (exprlist)
3245 **
3246 ** For each expression, build an index key from the evaluation and
3247 ** store it in the temporary table. If <expr> is a column, then use
3248 ** that columns affinity when building index keys. If <expr> is not
3249 ** a column, use numeric affinity.
3250 */
3261 }
3265 }
3267 /* Loop through each expression in <exprlist>. */
3273 /* If the expression is not constant then we will need to
3274 ** disable the test that was generated above that makes sure
3275 ** this code only executes once. Because for a non-constant
3276 ** expression we need to rerun this code each time.
3277 */
3283 }
3285 /* Evaluate the expression and insert it into the temp table */
3289 }
3292 }
3295 }
3299 /* Subroutine return */
3307 }
3308 }
3311 /*
3312 ** Generate code for scalar subqueries used as a subquery expression
3313 ** or EXISTS operator:
3314 **
3315 ** (SELECT a FROM b) -- subquery
3316 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3317 **
3318 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3319 **
3320 ** Return the register that holds the result. For a multi-column SELECT,
3321 ** the result is stored in a contiguous array of registers and the
3322 ** return value is the register of the left-most result column.
3323 ** Return 0 if an error occurs.
3324 */
3325 #ifndef SQLITE_OMIT_SUBQUERY
3333 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3335 #endif
3346 /* If this routine has already been coded, then invoke it as a
3347 ** subroutine. */
3354 }
3356 /* Begin coding the subroutine */
3364 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3365 ** is encountered if any of the following is true:
3366 **
3367 ** * The right-hand side is a correlated subquery
3368 ** * The right-hand side is an expression list containing variables
3369 ** * We are inside a trigger
3370 **
3371 ** If all of the above are false, then we can run this code just once
3372 ** save the results, and reuse the same result on subsequent invocations.
3373 */
3376 }
3378 /* For a SELECT, generate code to put the values for all columns of
3379 ** the first row into an array of registers and return the index of
3380 ** the first register.
3381 **
3382 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3383 ** into a register and return that register number.
3384 **
3385 ** In both cases, the query is augmented with "LIMIT 1". Any
3386 ** preexisting limit is discarded in place of the new LIMIT 1.
3387 */
3404 }
3406 /* The subquery already has a limit. If the pre-existing limit is X
3407 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3414 }
3418 /* If there is no pre-existing limit add a limit of 1 */
3421 }
3427 }
3432 }
3435 /* Subroutine return */
3444 }
3447 #ifndef SQLITE_OMIT_SUBQUERY
3448 /*
3449 ** Expr pIn is an IN(...) expression. This function checks that the
3450 ** sub-select on the RHS of the IN() operator has the same number of
3451 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3452 ** a sub-query, that the LHS is a vector of size 1.
3453 */
3460 }
3464 }
3466 }
3467 #endif
3469 #ifndef SQLITE_OMIT_SUBQUERY
3470 /*
3471 ** Generate code for an IN expression.
3472 **
3473 ** x IN (SELECT ...)
3474 ** x IN (value, value, ...)
3475 **
3476 ** The left-hand side (LHS) is a scalar or vector expression. The
3477 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3478 ** subquery. If the RHS is a subquery, the number of result columns must
3479 ** match the number of columns in the vector on the LHS. If the RHS is
3480 ** a list of values, the LHS must be a scalar.
3481 **
3482 ** The IN operator is true if the LHS value is contained within the RHS.
3483 ** The result is false if the LHS is definitely not in the RHS. The
3484 ** result is NULL if the presence of the LHS in the RHS cannot be
3485 ** determined due to NULLs.
3486 **
3487 ** This routine generates code that jumps to destIfFalse if the LHS is not
3488 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3489 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3490 ** within the RHS then fall through.
3491 **
3492 ** See the separate in-operator.md documentation file in the canonical
3493 ** SQLite source tree for additional information.
3494 */
3500 ){
3527 );
3530 /* Attempt to compute the RHS. After this step, if anything other than
3531 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3532 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3533 ** the RHS has not yet been coded. */
3544 );
3545 #ifdef SQLITE_DEBUG
3546 /* Confirm that aiMap[] contains nVector integer values between 0 and
3547 ** nVector-1. */
3552 }
3553 #endif
3555 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3556 ** vector, then it is stored in an array of nVector registers starting
3557 ** at r1.
3558 **
3559 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3560 ** so that the fields are in the same order as an existing index. The
3561 ** aiMap[] array contains a mapping from the original LHS field order to
3562 ** the field order that matches the RHS index.
3563 **
3564 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3565 ** even if it is constant, as OP_Affinity may be used on the register
3566 ** by code generated below. */
3573 /* LHS fields are not reordered */
3576 /* Need to reorder the LHS fields according to aiMap */
3580 }
3581 }
3583 /* If sqlite3FindInIndex() did not find or create an index that is
3584 ** suitable for evaluating the IN operator, then evaluate using a
3585 ** sequence of comparisons.
3586 **
3587 ** This is step (1) in the in-operator.md optimized algorithm.
3588 */
3602 }
3607 }
3626 }
3627 }
3631 }
3635 }
3637 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3638 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3639 ** We will then skip the binary search of the RHS.
3640 */
3645 }
3652 }
3653 }
3655 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3656 ** of the RHS using the LHS as a probe. If found, the result is
3657 ** true.
3658 */
3660 /* In this case, the RHS is the ROWID of table b-tree and so we also
3661 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3662 ** into a single opcode. */
3669 /* Combine Step 3 and Step 5 into a single opcode */
3673 }
3674 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3677 }
3679 /* Step 4. If the RHS is known to be non-NULL and we did not find
3680 ** an match on the search above, then the result must be FALSE.
3681 */
3685 }
3687 /* Step 5. If we do not care about the difference between NULL and
3688 ** FALSE, then just return false.
3689 */
3692 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3693 ** If any comparison is NULL, then the result is NULL. If all
3694 ** comparisons are FALSE then the final result is FALSE.
3695 **
3696 ** For a scalar LHS, it is sufficient to check just the first row
3697 ** of the RHS.
3698 */
3705 /* For nVector==1, combine steps 6 and 7 by immediately returning
3706 ** FALSE if the first comparison is not NULL */
3708 }
3720 }
3727 /* Step 7: If we reach this point, we know that the result must
3728 ** be false. */
3730 }
3732 /* Jumps here in order to return true. */
3735 sqlite3ExprCodeIN_finished:
3738 sqlite3ExprCodeIN_oom_error:
3741 }
3744 #ifndef SQLITE_OMIT_FLOATING_POINT
3745 /*
3746 ** Generate an instruction that will put the floating point
3747 ** value described by z[0..n-1] into register iMem.
3748 **
3749 ** The z[] string will probably not be zero-terminated. But the
3750 ** z[n] character is guaranteed to be something that does not look
3751 ** like the continuation of the number.
3752 */
3760 }
3761 }
3762 #endif
3765 /*
3766 ** Generate an instruction that will put the integer describe by
3767 ** text z[0..n-1] into register iMem.
3768 **
3769 ** Expr.u.zToken is always UTF8 and zero-terminated.
3770 */
3780 i64 value;
3785 #ifdef SQLITE_OMIT_FLOATING_POINT
3787 #else
3788 #ifndef SQLITE_OMIT_HEX_INTEGER
3793 #endif
3794 {
3796 }
3797 #endif
3801 }
3802 }
3803 }
3806 /* Generate code that will load into register regOut a value that is
3807 ** appropriate for the iIdxCol-th column of index pIdx.
3808 */
3815 ){
3826 }
3827 }
3829 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3830 /*
3831 ** Generate code that will compute the value of generated column pCol
3832 ** and store the result in register regOut
3833 */
3839 ){
3848 }
3852 }
3854 }
3857 /*
3858 ** Generate code to extract the value of the iCol-th column of a table.
3859 */
3866 ){
3879 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3892 }
3894 #endif
3903 }
3906 }
3907 }
3909 /*
3910 ** Generate code that will extract the iColumn-th column from
3911 ** table pTab and store the column value in register iReg.
3912 **
3913 ** There must be an open cursor to pTab in iTable when this routine
3914 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3915 */
3922 u8 p5 /* P5 value for OP_Column + FLAGS */
3923 ){
3929 }
3931 }
3933 /*
3934 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3935 ** over to iTo..iTo+nReg-1.
3936 */
3939 }
3941 /*
3942 ** Convert a scalar expression node to a TK_REGISTER referencing
3943 ** register iReg. The caller must ensure that iReg already contains
3944 ** the correct value for the expression.
3945 */
3953 }
3955 /*
3956 ** Evaluate an expression (either a vector or a scalar expression) and store
3957 ** the result in continguous temporary registers. Return the index of
3958 ** the first register used to store the result.
3959 **
3960 ** If the returned result register is a temporary scalar, then also write
3961 ** that register number into *piFreeable. If the returned result register
3962 ** is not a temporary or if the expression is a vector set *piFreeable
3963 ** to 0.
3964 */
3973 #if SQLITE_OMIT_SUBQUERY
3975 #else
3977 #endif
3985 }
3986 }
3987 }
3989 }
3991 /*
3992 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
3993 ** so that a subsequent copy will not be merged into this one.
3994 */
3998 }
3999 }
4001 /*
4002 ** Generate code to implement special SQL functions that are implemented
4003 ** in-line rather than by using the usual callbacks.
4004 */
4010 ){
4019 /* Attempt a direct implementation of the built-in COALESCE() and
4020 ** IFNULL() functions. This avoids unnecessary evaluation of
4021 ** arguments past the first non-NULL argument.
4022 */
4031 }
4035 }
4037 Expr caseExpr;
4042 }
4043 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4050 }
4052 }
4053 #endif
4055 /* The UNLIKELY() function is a no-op. The result is the value
4056 ** of the first argument.
4057 */
4061 }
4063 /***********************************************************************
4064 ** Test-only SQL functions that are only usable if enabled
4065 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
4066 */
4067 #if !defined(SQLITE_UNTESTABLE)
4069 /* Compare two expressions using sqlite3ExprCompare() */
4073 target);
4075 }
4078 /* Compare two expressions using sqlite3ExprImpliesExpr() */
4082 target);
4084 }
4087 /* REsult of sqlite3ExprImpliesNonNullRow() */
4094 target);
4097 }
4099 }
4102 /* The AFFINITY() function evaluates to a string that describes
4103 ** the type affinity of the argument. This is used for testing of
4104 ** the SQLite type logic.
4105 */
4116 }
4118 }
4120 }
4122 /*
4123 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
4124 ** If it is, then resolve the expression by reading from the index and
4125 ** return the register into which the value has been read. If pExpr is
4126 ** not an indexed expression, then return negative.
4127 */
4132 ){
4136 u8 exprAff;
4142 }
4149 ){
4150 /* Affinity mismatch on a generated column */
4152 }
4157 /* If the index is on a NULL row due to an outer join, then we
4158 ** cannot extract the value from the index. The value must be
4159 ** computed using the original expression. */
4174 }
4176 }
4178 }
4181 /*
4182 ** Generate code into the current Vdbe to evaluate the given
4183 ** expression. Attempt to store the results in register "target".
4184 ** Return the register where results are stored.
4185 **
4186 ** With this routine, there is no guarantee that results will
4187 ** be stored in target. The result might be stored in some other
4188 ** register if it is convenient to do so. The calling function
4189 ** must check the return code and move the results to the desired
4190 ** register.
4191 */
4205 expr_code_doover:
4211 ){
4216 }
4231 /* No comment added */
4239 }
4240 }
4243 /* This case happens when the argument to an aggregate function
4244 ** is rewritten by aggregateConvertIndexedExprRefToColumn() */
4247 }
4248 /* Otherwise, fall thru into the TK_COLUMN case */
4249 /* no break */ deliberate_fall_through
4250 }
4255 /* This COLUMN expression is really a constant due to WHERE clause
4256 ** constraints, and that constant is coded by the pExpr->pLeft
4257 ** expresssion. However, make sure the constant has the correct
4258 ** datatype by applying the Affinity of the table column to the
4259 ** constant.
4260 */
4272 }
4274 }
4277 /* Other columns in the same row for CHECK constraints or
4278 ** generated columns or for inserting into partial index.
4279 ** The row is unpacked into registers beginning at
4280 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4281 ** immediately prior to the first column.
4282 */
4294 }
4298 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4304 }
4308 }
4319 }
4321 /* Coding an expression that is part of an index where column names
4322 ** in the index refer to the table to which the index belongs */
4324 }
4325 }
4332 }
4336 }
4340 }
4341 #ifndef SQLITE_OMIT_FLOATING_POINT
4346 }
4347 #endif
4352 }
4354 /* Make NULL the default case so that if a bug causes an illegal
4355 ** Expr node to be passed into this function, it will be handled
4356 ** sanely and not crash. But keep the assert() to bring the problem
4357 ** to the attention of the developers. */
4361 }
4362 #ifndef SQLITE_OMIT_BLOB_LITERAL
4376 }
4377 #endif
4388 }
4390 }
4393 }
4394 #ifndef SQLITE_OMIT_CAST
4396 /* Expressions of the form: CAST(pLeft AS token) */
4401 }
4406 }
4412 /* fall-through */
4439 }
4442 }
4444 }
4474 }
4481 #ifndef SQLITE_OMIT_FLOATING_POINT
4486 #endif
4496 }
4498 }
4507 }
4519 }
4534 }
4540 ){
4545 }
4547 }
4559 #ifndef SQLITE_OMIT_WINDOWFUNC
4562 }
4563 #endif
4566 /* SQL functions can be expensive. So try to avoid running them
4567 ** multiple times if we know they always give the same result */
4569 }
4577 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4580 }
4581 #endif
4585 }
4593 }
4599 }
4602 }
4603 }
4610 }
4612 /* For length() and typeof() functions with a column argument,
4613 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4614 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
4615 ** loading.
4616 */
4618 u8 exprOp;
4628 }
4629 }
4635 }
4636 #ifndef SQLITE_OMIT_VIRTUALTABLE
4637 /* Possibly overload the function if the first argument is
4638 ** a virtual table column.
4639 **
4640 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4641 ** second argument, not the first, as the argument to test to
4642 ** see if it is a column in a virtual table. This is done because
4643 ** the left operand of infix functions (the operand we want to
4644 ** control overloading) ends up as the second argument to the
4645 ** function. The expression "A glob B" is equivalent to
4646 ** "glob(B,A). We want to use the A in "A glob B" to test
4647 ** for function overloading. But we use the B term in "glob(B,A)".
4648 */
4653 }
4654 #endif
4658 }
4666 }
4667 }
4669 }
4670 #ifndef SQLITE_OMIT_SUBQUERY
4681 ){
4685 }
4687 }
4694 }
4700 }
4702 }
4713 }
4717 /*
4718 ** x BETWEEN y AND z
4719 **
4720 ** This is equivalent to
4721 **
4722 ** x>=y AND x<=z
4723 **
4724 ** X is stored in pExpr->pLeft.
4725 ** Y is stored in pExpr->pList->a[0].pExpr.
4726 ** Z is stored in pExpr->pList->a[1].pExpr.
4727 */
4731 }
4734 /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
4735 ** "SOFT-COLLATE" that is added to constraints that are pushed down
4736 ** from outer queries into sub-queries by the push-down optimization.
4737 ** Clear subtypes as subtypes may not cross a subquery boundary.
4738 */
4744 }
4750 }
4751 }
4756 }
4759 /* If the opcode is TK_TRIGGER, then the expression is a reference
4760 ** to a column in the new.* or old.* pseudo-tables available to
4761 ** trigger programs. In this case Expr.iTable is set to 1 for the
4762 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4763 ** is set to the column of the pseudo-table to read, or to -1 to
4764 ** read the rowid field.
4765 **
4766 ** The expression is implemented using an OP_Param opcode. The p1
4767 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4768 ** to reference another column of the old.* pseudo-table, where
4769 ** i is the index of the column. For a new.rowid reference, p1 is
4770 ** set to (n+1), where n is the number of columns in each pseudo-table.
4771 ** For a reference to any other column in the new.* pseudo-table, p1
4772 ** is set to (n+2+i), where n and i are as defined previously. For
4773 ** example, if the table on which triggers are being fired is
4774 ** declared as:
4775 **
4776 ** CREATE TABLE t1(a, b);
4777 **
4778 ** Then p1 is interpreted as follows:
4779 **
4780 ** p1==0 -> old.rowid p1==3 -> new.rowid
4781 ** p1==1 -> old.a p1==4 -> new.a
4782 ** p1==2 -> old.b p1==5 -> new.b
4783 */
4803 ));
4805 #ifndef SQLITE_OMIT_FLOATING_POINT
4806 /* If the column has REAL affinity, it may currently be stored as an
4807 ** integer. Use OP_RealAffinity to make sure it is really real.
4808 **
4809 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4810 ** floating point when extracting it from the record. */
4813 }
4814 #endif
4816 }
4821 }
4823 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
4824 ** that derive from the right-hand table of a LEFT JOIN. The
4825 ** Expr.iTable value is the table number for the right-hand table.
4826 ** The expression is only evaluated if that table is not currently
4827 ** on a LEFT JOIN NULL row.
4828 */
4838 }
4842 target);
4845 }
4846 }
4848 /* The OP_IfNullRow opcode above can overwrite the result register with
4849 ** NULL. So we have to ensure that the result register is not a value
4850 ** that is suppose to be a constant. Two defenses are needed:
4851 ** (1) Temporarily disable factoring of constant expressions
4852 ** (2) Make sure the computed value really is stored in register
4853 ** "target" and not someplace else.
4854 */
4861 }
4864 }
4866 /*
4867 ** Form A:
4868 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4869 **
4870 ** Form B:
4871 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4872 **
4873 ** Form A is can be transformed into the equivalent form B as follows:
4874 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4875 ** WHEN x=eN THEN rN ELSE y END
4876 **
4877 ** X (if it exists) is in pExpr->pLeft.
4878 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4879 ** odd. The Y is also optional. If the number of elements in x.pList
4880 ** is even, then Y is omitted and the "otherwise" result is NULL.
4881 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4882 **
4883 ** The result of the expression is the Ri for the first matching Ei,
4884 ** or if there is no matching Ei, the ELSE term Y, or if there is
4885 ** no ELSE term, NULL.
4886 */
4911 }
4919 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4920 ** The value in regFree1 might get SCopy-ed into the file result.
4921 ** So make sure that the regFree1 register is not reused for other
4922 ** purposes and possibly overwritten. */
4924 }
4931 }
4939 }
4944 }
4949 }
4950 #ifndef SQLITE_OMIT_TRIGGER
4956 );
4961 }
4964 }
4974 }
4977 }
4978 #endif
4979 }
4983 }
4985 /*
4986 ** Generate code that will evaluate expression pExpr just one time
4987 ** per prepared statement execution.
4988 **
4989 ** If the expression uses functions (that might throw an exception) then
4990 ** guard them with an OP_Once opcode to ensure that the code is only executed
4991 ** once. If no functions are involved, then factor the code out and put it at
4992 ** the end of the prepared statement in the initialization section.
4993 **
4994 ** If regDest>=0 then the result is always stored in that register and the
4995 ** result is not reusable. If regDest<0 then this routine is free to
4996 ** store the value whereever it wants. The register where the expression
4997 ** is stored is returned. When regDest<0, two identical expressions might
4998 ** code to the same register, if they do not contain function calls and hence
4999 ** are factored out into the initialization section at the end of the
5000 ** prepared statement.
5001 */
5006 ){
5016 ){
5018 }
5019 }
5020 }
5031 }
5042 }
5044 }
5046 }
5048 /*
5049 ** Generate code to evaluate an expression and store the results
5050 ** into a register. Return the register number where the results
5051 ** are stored.
5052 **
5053 ** If the register is a temporary register that can be deallocated,
5054 ** then write its number into *pReg. If the result register is not
5055 ** a temporary, then set *pReg to zero.
5056 **
5057 ** If pExpr is a constant, then this routine might generate this
5058 ** code to fill the register in the initialization section of the
5059 ** VDBE program, in order to factor it out of the evaluation loop.
5060 */
5068 ){
5079 }
5080 }
5082 }
5084 /*
5085 ** Generate code that will evaluate expression pExpr and store the
5086 ** results in register target. The results are guaranteed to appear
5087 ** in register target.
5088 */
5098 u8 op;
5103 }
5105 }
5106 }
5108 /*
5109 ** Make a transient copy of expression pExpr and then code it using
5110 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
5111 ** except that the input expression is guaranteed to be unchanged.
5112 */
5118 }
5120 /*
5121 ** Generate code that will evaluate expression pExpr and store the
5122 ** results in register target. The results are guaranteed to appear
5123 ** in register target. If the expression is constant, then this routine
5124 ** might choose to code the expression at initialization time.
5125 */
5131 }
5132 }
5134 /*
5135 ** Generate code that pushes the value of every element of the given
5136 ** expression list into a sequence of registers beginning at target.
5137 **
5138 ** Return the number of elements evaluated. The number returned will
5139 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
5140 ** is defined.
5141 **
5142 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
5143 ** filled using OP_SCopy. OP_Copy must be used instead.
5144 **
5145 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
5146 ** factored out into initialization code.
5147 **
5148 ** The SQLITE_ECEL_REF flag means that expressions in the list with
5149 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
5150 ** in registers at srcReg, and so the value can be copied from there.
5151 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
5152 ** are simply omitted rather than being copied from srcReg.
5153 */
5159 u8 flags /* SQLITE_ECEL_* flags */
5160 ){
5172 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
5174 i--;
5175 n--;
5177 #endif
5180 i--;
5181 n--;
5184 }
5187 ){
5198 ){
5202 }
5203 }
5204 }
5205 }
5207 }
5209 /*
5210 ** Generate code for a BETWEEN operator.
5211 **
5212 ** x BETWEEN y AND z
5213 **
5214 ** The above is equivalent to
5215 **
5216 ** x>=y AND x<=z
5217 **
5218 ** Code it as such, taking care to do the common subexpression
5219 ** elimination of x.
5220 **
5221 ** The xJumpIf parameter determines details:
5222 **
5223 ** NULL: Store the boolean result in reg[dest]
5224 ** sqlite3ExprIfTrue: Jump to dest if true
5225 ** sqlite3ExprIfFalse: Jump to dest if false
5226 **
5227 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
5228 */
5235 ){
5263 /* Mark the expression is being from the ON or USING clause of a join
5264 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5265 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5266 ** for clarity, but we are out of bits in the Expr.flags field so we
5267 ** have to reuse the EP_OuterON bit. Bummer. */
5270 }
5272 }
5275 /* Ensure adequate test coverage */
5285 }
5287 /*
5288 ** Generate code for a boolean expression such that a jump is made
5289 ** to the label "dest" if the expression is true but execution
5290 ** continues straight thru if the expression is false.
5291 **
5292 ** If the expression evaluates to NULL (neither true nor false), then
5293 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5294 **
5295 ** This code depends on the fact that certain token values (ex: TK_EQ)
5296 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5297 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5298 ** the make process cause these values to align. Assert()s in the code
5299 ** below verify that the numbers are aligned correctly.
5300 */
5330 }
5332 }
5337 }
5352 }
5354 }
5361 /* no break */ deliberate_fall_through
5387 }
5399 }
5404 }
5405 #ifndef SQLITE_OMIT_SUBQUERY
5413 }
5414 #endif
5416 default_expr:
5420 /* No-op */
5427 }
5429 }
5430 }
5433 }
5435 /*
5436 ** Generate code for a boolean expression such that a jump is made
5437 ** to the label "dest" if the expression is false but execution
5438 ** continues straight thru if the expression is true.
5439 **
5440 ** If the expression evaluates to NULL (neither true nor false) then
5441 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5442 ** is 0.
5443 */
5456 /* The value of pExpr->op and op are related as follows:
5457 **
5458 ** pExpr->op op
5459 ** --------- ----------
5460 ** TK_ISNULL OP_NotNull
5461 ** TK_NOTNULL OP_IsNull
5462 ** TK_NE OP_Eq
5463 ** TK_EQ OP_Ne
5464 ** TK_GT OP_Le
5465 ** TK_LE OP_Gt
5466 ** TK_GE OP_Lt
5467 ** TK_LT OP_Ge
5468 **
5469 ** For other values of pExpr->op, op is undefined and unused.
5470 ** The value of TK_ and OP_ constants are arranged such that we
5471 ** can compute the mapping above using the following expression.
5472 ** Assert()s verify that the computation is correct.
5473 */
5476 /* Verify correct alignment of TK_ and OP_ constants
5477 */
5504 }
5506 }
5511 }
5521 /* IS TRUE and IS NOT FALSE */
5526 /* IS FALSE and IS NOT TRUE */
5529 }
5531 }
5538 /* no break */ deliberate_fall_through
5564 }
5574 }
5579 }
5580 #ifndef SQLITE_OMIT_SUBQUERY
5588 }
5590 }
5591 #endif
5593 default_expr:
5597 /* no-op */
5604 }
5606 }
5607 }
5610 }
5612 /*
5613 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5614 ** code generation, and that copy is deleted after code generation. This
5615 ** ensures that the original pExpr is unchanged.
5616 */
5622 }
5624 }
5626 /*
5627 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5628 ** type of expression.
5629 **
5630 ** If pExpr is a simple SQL value - an integer, real, string, blob
5631 ** or NULL value - then the VDBE currently being prepared is configured
5632 ** to re-prepare each time a new value is bound to variable pVar.
5633 **
5634 ** Additionally, if pExpr is a simple SQL value and the value is the
5635 ** same as that currently bound to variable pVar, non-zero is returned.
5636 ** Otherwise, if the values are not the same or if pExpr is not a simple
5637 ** SQL value, zero is returned.
5638 */
5643 ){
5656 }
5658 }
5661 }
5664 }
5666 /*
5667 ** Do a deep comparison of two expression trees. Return 0 if the two
5668 ** expressions are completely identical. Return 1 if they differ only
5669 ** by a COLLATE operator at the top level. Return 2 if there are differences
5670 ** other than the top-level COLLATE operator.
5671 **
5672 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5673 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5674 **
5675 ** The pA side might be using TK_REGISTER. If that is the case and pB is
5676 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
5677 **
5678 ** Sometimes this routine will return 2 even if the two expressions
5679 ** really are equivalent. If we cannot prove that the expressions are
5680 ** identical, we return 2 just to be safe. So if this routine
5681 ** returns 2, then you do not really know for certain if the two
5682 ** expressions are the same. But if you get a 0 or 1 return, then you
5683 ** can be sure the expressions are the same. In the places where
5684 ** this routine is used, it does not hurt to get an extra 2 - that
5685 ** just might result in some slightly slower code. But returning
5686 ** an incorrect 0 or 1 could lead to a malfunction.
5687 **
5688 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
5689 ** pParse->pReprepare can be matched against literals in pB. The
5690 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
5691 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
5692 ** Argument pParse should normally be NULL. If it is not NULL and pA or
5693 ** pB causes a return value of 2.
5694 */
5699 int iTab
5700 ){
5701 u32 combinedFlags;
5704 }
5707 }
5712 }
5714 }
5718 }
5721 }
5724 ){
5725 /* fall through */
5728 }
5729 }
5735 #ifndef SQLITE_OMIT_WINDOWFUNC
5739 }
5743 }
5744 }
5745 #endif
5755 ){
5757 }
5758 }
5770 ){
5775 }
5776 }
5777 }
5779 }
5781 /*
5782 ** Compare two ExprList objects. Return 0 if they are identical, 1
5783 ** if they are certainly different, or 2 if it is not possible to
5784 ** determine if they are identical or not.
5785 **
5786 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5787 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5788 **
5789 ** This routine might return non-zero for equivalent ExprLists. The
5790 ** only consequence will be disabled optimizations. But this routine
5791 ** must never return 0 if the two ExprList objects are different, or
5792 ** a malfunction will result.
5793 **
5794 ** Two NULL pointers are considered to be the same. But a NULL pointer
5795 ** always differs from a non-NULL pointer.
5796 */
5808 }
5810 }
5812 /*
5813 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
5814 ** are ignored.
5815 */
5820 iTab);
5821 }
5823 /*
5824 ** Return non-zero if Expr p can only be true if pNN is not NULL.
5825 **
5826 ** Or if seenNot is true, return non-zero if Expr p can only be
5827 ** non-NULL if pNN is not NULL
5828 */
5835 ){
5840 }
5846 }
5856 ){
5858 }
5860 }
5874 /* no break */ deliberate_fall_through
5880 /* no break */ deliberate_fall_through
5881 }
5887 }
5892 }
5896 }
5897 }
5899 }
5901 /*
5902 ** Return true if we can prove the pE2 will always be true if pE1 is
5903 ** true. Return false if we cannot complete the proof or if pE2 might
5904 ** be false. Examples:
5905 **
5906 ** pE1: x==5 pE2: x==5 Result: true
5907 ** pE1: x>0 pE2: x==5 Result: false
5908 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
5909 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
5910 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
5911 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
5912 ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false
5913 **
5914 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
5915 ** Expr.iTable<0 then assume a table number given by iTab.
5916 **
5917 ** If pParse is not NULL, then the values of bound variables in pE1 are
5918 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
5919 ** modified to record which bound variables are referenced. If pParse
5920 ** is NULL, then false will be returned if pE1 contains any bound variables.
5921 **
5922 ** When in doubt, return false. Returning true might give a performance
5923 ** improvement. Returning false might cause a performance reduction, but
5924 ** it will always give the correct answer and is hence always safe.
5925 */
5930 int iTab
5931 ){
5934 }
5938 ){
5940 }
5943 ){
5945 }
5947 }
5949 /*
5950 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
5951 ** If the expression node requires that the table at pWalker->iCur
5952 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
5953 **
5954 ** This routine controls an optimization. False positives (setting
5955 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
5956 ** (never setting pWalker->eCode) is a harmless missed optimization.
5957 */
5988 }
5997 }
5998 }
6005 }
6008 /* Virtual tables are allowed to use constraints like x=NULL. So
6009 ** a term of the form x=y does not prove that y is not null if x
6010 ** is the column of a virtual table */
6025 /* The y.pTab=0 assignment in wherecode.c always happens after the
6026 ** impliesNotNullRow() test */
6035 ){
6037 }
6038 /* no break */ deliberate_fall_through
6039 }
6042 }
6043 }
6045 /*
6046 ** Return true (non-zero) if expression p can only be true if at least
6047 ** one column of table iTab is non-null. In other words, return true
6048 ** if expression p will always be NULL or false if every column of iTab
6049 ** is NULL.
6050 **
6051 ** False negatives are acceptable. In other words, it is ok to return
6052 ** zero even if expression p will never be true of every column of iTab
6053 ** is NULL. A false negative is merely a missed optimization opportunity.
6054 **
6055 ** False positives are not allowed, however. A false positive may result
6056 ** in an incorrect answer.
6057 **
6058 ** Terms of p that are marked with EP_OuterON (and hence that come from
6059 ** the ON or USING clauses of OUTER JOINS) are excluded from the analysis.
6060 **
6061 ** This routine is used to check if a LEFT JOIN can be converted into
6062 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
6063 ** clause requires that some column of the right table of the LEFT JOIN
6064 ** be non-NULL, then the LEFT JOIN can be safely converted into an
6065 ** ordinary join.
6066 */
6068 Walker w;
6077 }
6078 }
6086 }
6088 /*
6089 ** An instance of the following structure is used by the tree walker
6090 ** to determine if an expression can be evaluated by reference to the
6091 ** index only, without having to do a search for the corresponding
6092 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
6093 ** is the cursor for the table.
6094 */
6098 };
6100 /*
6101 ** Check to see if there are references to columns in table
6102 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
6103 ** pWalker->u.pIdxCover->pIdx.
6104 */
6109 ){
6112 }
6114 }
6116 /*
6117 ** Determine if an index pIdx on table with cursor iCur contains will
6118 ** the expression pExpr. Return true if the index does cover the
6119 ** expression and false if the pExpr expression references table columns
6120 ** that are not found in the index pIdx.
6121 **
6122 ** An index covering an expression means that the expression can be
6123 ** evaluated using only the index and without having to lookup the
6124 ** corresponding table entry.
6125 */
6130 ){
6131 Walker w;
6140 }
6143 /* Structure used to pass information throught the Walker in order to
6144 ** implement sqlite3ReferencesSrcList().
6145 */
6151 };
6153 /*
6154 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
6155 **
6156 ** When entering a new subquery on the pExpr argument, add all FROM clause
6157 ** entries for that subquery to the exclude list.
6158 **
6159 ** When leaving the subquery, remove those entries from the exclude list.
6160 */
6175 }
6178 }
6180 }
6187 }
6188 }
6190 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
6191 **
6192 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
6193 ** of the tables shown in RefSrcList.pRef.
6194 **
6195 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
6196 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
6197 */
6201 ){
6210 }
6211 }
6215 }
6216 }
6218 }
6220 /*
6221 ** Check to see if pExpr references any tables in pSrcList.
6222 ** Possible return values:
6223 **
6224 ** 1 pExpr does references a table in pSrcList.
6225 **
6226 ** 0 pExpr references some table that is not defined in either
6227 ** pSrcList or in subqueries of pExpr itself.
6228 **
6229 ** -1 pExpr only references no tables at all, or it only
6230 ** references tables defined in subqueries of pExpr itself.
6231 **
6232 ** As currently used, pExpr is always an aggregate function call. That
6233 ** fact is exploited for efficiency.
6234 */
6236 Walker w;
6250 #ifndef SQLITE_OMIT_WINDOWFUNC
6253 }
6254 #endif
6262 }
6263 }
6265 /*
6266 ** This is a Walker expression node callback.
6267 **
6268 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6269 ** object that is referenced does not refer directly to the Expr. If
6270 ** it does, make a copy. This is done because the pExpr argument is
6271 ** subject to change.
6272 **
6273 ** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete()
6274 ** which builds on the sqlite3ParserAddCleanup() mechanism.
6275 */
6279 ){
6291 }
6292 }
6301 }
6302 }
6303 }
6304 }
6306 }
6308 /*
6309 ** Initialize a Walker object so that will persist AggInfo entries referenced
6310 ** by the tree that is walked.
6311 */
6317 }
6319 /*
6320 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6321 ** the new element. Return a negative number if malloc fails.
6322 */
6326 db,
6330 &i
6331 );
6333 }
6335 /*
6336 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6337 ** the new element. Return a negative number if malloc fails.
6338 */
6342 db,
6346 &i
6347 );
6349 }
6351 /*
6352 ** Search the AggInfo object for an aCol[] entry that has iTable and iColumn.
6353 ** Return the index in aCol[] of the entry that describes that column.
6354 **
6355 ** If no prior entry is found, create a new one and return -1. The
6356 ** new column will have an idex of pAggInfo->nColumn-1.
6357 */
6362 ){
6372 ){
6374 }
6375 }
6378 /* OOM on resize */
6381 }
6399 ){
6402 }
6403 }
6404 }
6407 }
6408 fix_up_expr:
6414 }
6416 }
6418 /*
6419 ** This is the xExprCallback for a tree walker. It is used to
6420 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
6421 ** for additional information.
6422 */
6435 Expr tmp;
6443 }
6448 /* If we reach this point, it means that expression pExpr can be
6449 ** translated into a reference to an index column as described by
6450 ** pIEpr.
6451 */
6461 }
6468 /* Check to see if the column is in one of the tables in the FROM
6469 ** clause of the aggregate query */
6479 }
6481 }
6485 ){
6486 /* Check to see if pExpr is a duplicate of another aggregate
6487 ** function that is already in the pAggInfo structure
6488 */
6494 }
6495 }
6497 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
6498 */
6513 }
6514 }
6515 }
6516 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
6517 */
6525 }
6526 }
6527 }
6529 }
6531 /*
6532 ** Analyze the pExpr expression looking for aggregate functions and
6533 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
6534 ** points to. Additional entries are made on the AggInfo object as
6535 ** necessary.
6536 **
6537 ** This routine should only be called after the expression has been
6538 ** analyzed by sqlite3ResolveExprNames().
6539 */
6541 Walker w;
6550 }
6552 /*
6553 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
6554 ** expression list. Return the number of errors.
6555 **
6556 ** If an error is found, the analysis is cut short.
6557 */
6564 }
6565 }
6566 }
6568 /*
6569 ** Allocate a single new register for use to hold some intermediate result.
6570 */
6574 }
6576 }
6578 /*
6579 ** Deallocate a register, making available for reuse for some other
6580 ** purpose.
6581 */
6587 }
6588 }
6589 }
6591 /*
6592 ** Allocate or deallocate a block of nReg consecutive registers.
6593 */
6605 }
6607 }
6612 }
6617 }
6618 }
6620 /*
6621 ** Mark all temporary registers as being unavailable for reuse.
6622 **
6623 ** Always invoke this procedure after coding a subroutine or co-routine
6624 ** that might be invoked from other parts of the code, to ensure that
6625 ** the sub/co-routine does not use registers in common with the code that
6626 ** invokes the sub/co-routine.
6627 */
6631 }
6633 /*
6634 ** Validate that no temporary register falls within the range of
6635 ** iFirst..iLast, inclusive. This routine is only call from within assert()
6636 ** statements.
6637 */
6638 #ifdef SQLITE_DEBUG
6644 ){
6646 }
6650 }
6651 }
6653 }