| blob | cc915987ddb30dd90da79950f161416400d0e8ad |
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
74 );
75 }
79 }
87 }
91 }
93 }
95 /*
96 ** Make a guess at all the possible datatypes of the result that could
97 ** be returned by an expression. Return a bitmask indicating the answer:
98 **
99 ** 0x01 Numeric
100 ** 0x02 Text
101 ** 0x04 Blob
102 **
103 ** If the expression must return NULL, then 0x00 is returned.
104 */
113 }
117 }
120 }
123 }
126 }
131 }
142 }
151 }
154 }
156 }
159 }
163 }
165 /*
166 ** Set the collating sequence for expression pExpr to be the collating
167 ** sequence named by pToken. Return a pointer to a new Expr node that
168 ** implements the COLLATE operator.
169 **
170 ** If a memory allocation error occurs, that fact is recorded in pParse->db
171 ** and the pExpr parameter is returned unchanged.
172 */
178 ){
185 }
186 }
188 }
193 ){
194 Token s;
198 }
200 /*
201 ** Skip over any TK_COLLATE operators.
202 */
207 }
209 }
211 /*
212 ** Skip over any TK_COLLATE operators and/or any unlikely()
213 ** or likelihood() or likely() functions at the root of an
214 ** expression.
215 */
227 }
228 }
230 }
232 /*
233 ** Return the collation sequence for the expression pExpr. If
234 ** there is no defined collating sequence, return NULL.
235 **
236 ** See also: sqlite3ExprNNCollSeq()
237 **
238 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
239 ** default collation if pExpr has no defined collation.
240 **
241 ** The collating sequence might be determined by a COLLATE operator
242 ** or by the presence of a column with a defined collating sequence.
243 ** COLLATE operators take first precedence. Left operands take
244 ** precedence over right operands.
245 */
255 ){
262 }
264 }
268 }
273 }
278 }
284 /* The Expr.x union is never used at the same time as Expr.pRight */
292 }
293 }
294 }
296 }
299 }
300 }
303 }
305 }
307 /*
308 ** Return the collation sequence for the expression pExpr. If
309 ** there is no defined collating sequence, return a pointer to the
310 ** default collation sequence.
311 **
312 ** See also: sqlite3ExprCollSeq()
313 **
314 ** The sqlite3ExprCollSeq() routine works the same except that it
315 ** returns NULL if there is no defined collation.
316 */
322 }
324 /*
325 ** Return TRUE if the two expressions have equivalent collating sequences.
326 */
331 }
333 /*
334 ** pExpr is an operand of a comparison operator. aff2 is the
335 ** type affinity of the other operand. This routine returns the
336 ** type affinity that should be used for the comparison operator.
337 */
341 /* Both sides of the comparison are columns. If one has numeric
342 ** affinity, use that. Otherwise use no affinity.
343 */
348 }
350 /* One side is a column, the other is not. Use the columns affinity. */
353 }
354 }
356 /*
357 ** pExpr is a comparison operator. Return the type affinity that should
358 ** be applied to both operands prior to doing the comparison.
359 */
373 }
375 }
377 /*
378 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
379 ** idx_affinity is the affinity of an indexed column. Return true
380 ** if the index with affinity idx_affinity may be used to implement
381 ** the comparison in pExpr.
382 */
387 }
390 }
392 }
394 /*
395 ** Return the P5 value that should be used for a binary comparison
396 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
397 */
402 ){
406 }
408 /*
409 ** Return a pointer to the collation sequence that should be used by
410 ** a binary comparison operator comparing pLeft and pRight.
411 **
412 ** If the left hand expression has a collating sequence type, then it is
413 ** used. Otherwise the collation sequence for the right hand expression
414 ** is used, or the default (BINARY) if neither expression has a collating
415 ** type.
416 **
417 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
418 ** it is not considered.
419 */
424 ){
435 }
436 }
438 }
440 /* Expression p is a comparison operator. Return a collation sequence
441 ** appropriate for the comparison operator.
442 **
443 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
444 ** However, if the OP_Commuted flag is set, then the order of the operands
445 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
446 ** correct collating sequence is found.
447 */
453 }
454 }
456 /*
457 ** Generate code for a comparison operator.
458 */
468 ){
478 }
484 }
486 /*
487 ** Return true if expression pExpr is a vector, or false otherwise.
488 **
489 ** A vector is defined as any expression that results in two or more
490 ** columns of result. Every TK_VECTOR node is an vector because the
491 ** parser will not generate a TK_VECTOR with fewer than two entries.
492 ** But a TK_SELECT might be either a vector or a scalar. It is only
493 ** considered a vector if it has two or more result columns.
494 */
497 }
499 /*
500 ** If the expression passed as the only argument is of type TK_VECTOR
501 ** return the number of expressions in the vector. Or, if the expression
502 ** is a sub-select, return the number of columns in the sub-select. For
503 ** any other type of expression, return 1.
504 */
516 }
517 }
519 /*
520 ** Return a pointer to a subexpression of pVector that is the i-th
521 ** column of the vector (numbered starting with 0). The caller must
522 ** ensure that i is within range.
523 **
524 ** If pVector is really a scalar (and "scalar" here includes subqueries
525 ** that return a single column!) then return pVector unmodified.
526 **
527 ** pVector retains ownership of the returned subexpression.
528 **
529 ** If the vector is a (SELECT ...) then the expression returned is
530 ** just the expression for the i-th term of the result set, and may
531 ** not be ready for evaluation because the table cursor has not yet
532 ** been positioned.
533 */
544 }
545 }
547 }
549 /*
550 ** Compute and return a new Expr object which when passed to
551 ** sqlite3ExprCode() will generate all necessary code to compute
552 ** the iField-th column of the vector expression pVector.
553 **
554 ** It is ok for pVector to be a scalar (as long as iField==0).
555 ** In that case, this routine works like sqlite3ExprDup().
556 **
557 ** The caller owns the returned Expr object and is responsible for
558 ** ensuring that the returned value eventually gets freed.
559 **
560 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
561 ** then the returned object will reference pVector and so pVector must remain
562 ** valid for the life of the returned object. If pVector is a TK_VECTOR
563 ** or a scalar expression, then it can be deleted as soon as this routine
564 ** returns.
565 **
566 ** A trick to cause a TK_SELECT pVector to be deleted together with
567 ** the returned Expr object is to attach the pVector to the pRight field
568 ** of the returned TK_SELECT_COLUMN Expr object.
569 */
575 ){
579 /* The TK_SELECT_COLUMN Expr node:
580 **
581 ** pLeft: pVector containing TK_SELECT. Not deleted.
582 ** pRight: not used. But recursively deleted.
583 ** iColumn: Index of a column in pVector
584 ** iTable: 0 or the number of columns on the LHS of an assignment
585 ** pLeft->iTable: First in an array of register holding result, or 0
586 ** if the result is not yet computed.
587 **
588 ** sqlite3ExprDelete() specifically skips the recursive delete of
589 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
590 ** can be attached to pRight to cause this node to take ownership of
591 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
592 ** with the same pLeft pointer to the pVector, but only one of them
593 ** will own the pVector.
594 */
601 }
609 /* This must be a vector UPDATE inside a trigger */
612 }
613 }
615 }
617 }
619 /*
620 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
621 ** it. Return the register in which the result is stored (or, if the
622 ** sub-select returns more than one column, the first in an array
623 ** of registers in which the result is stored).
624 **
625 ** If pExpr is not a TK_SELECT expression, return 0.
626 */
629 #ifndef SQLITE_OMIT_SUBQUERY
632 }
633 #endif
635 }
637 /*
638 ** Argument pVector points to a vector expression - either a TK_VECTOR
639 ** or TK_SELECT that returns more than one column. This function returns
640 ** the register number of a register that contains the value of
641 ** element iField of the vector.
642 **
643 ** If pVector is a TK_SELECT expression, then code for it must have
644 ** already been generated using the exprCodeSubselect() routine. In this
645 ** case parameter regSelect should be the first in an array of registers
646 ** containing the results of the sub-select.
647 **
648 ** If pVector is of type TK_VECTOR, then code for the requested field
649 ** is generated. In this case (*pRegFree) may be set to the number of
650 ** a temporary register to be freed by the caller before returning.
651 **
652 ** Before returning, output parameter (*ppExpr) is set to point to the
653 ** Expr object corresponding to element iElem of the vector.
654 */
662 ){
668 }
673 }
678 }
680 }
682 /*
683 ** Expression pExpr is a comparison between two vector values. Compute
684 ** the result of the comparison (1, 0, or NULL) and write that
685 ** result into register dest.
686 **
687 ** The caller must satisfy the following preconditions:
688 **
689 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
690 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
691 ** otherwise: op==pExpr->op and p5==0
692 */
698 u8 p5 /* SQLITE_NULLEQ or zero */
699 ){
717 }
722 );
758 }
763 }
766 }
773 }
774 }
779 }
780 }
782 #if SQLITE_MAX_EXPR_DEPTH>0
783 /*
784 ** Check that argument nHeight is less than or equal to the maximum
785 ** expression depth allowed. If it is not, leave an error message in
786 ** pParse.
787 */
794 );
796 }
798 }
800 /* The following three functions, heightOfExpr(), heightOfExprList()
801 ** and heightOfSelect(), are used to determine the maximum height
802 ** of any expression tree referenced by the structure passed as the
803 ** first argument.
804 **
805 ** If this maximum height is greater than the current value pointed
806 ** to by pnHeight, the second parameter, then set *pnHeight to that
807 ** value.
808 */
813 }
814 }
815 }
821 }
822 }
823 }
833 }
834 }
836 /*
837 ** Set the Expr.nHeight variable in the structure passed as an
838 ** argument. An expression with no children, Expr.pList or
839 ** Expr.pSelect member has a height of 1. Any other expression
840 ** has a height equal to the maximum height of any other
841 ** referenced Expr plus one.
842 **
843 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
844 ** if appropriate.
845 */
850 }
856 }
858 }
860 /*
861 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
862 ** the height is greater than the maximum allowed expression depth,
863 ** leave an error in pParse.
864 **
865 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
866 ** Expr.flags.
867 */
872 }
874 /*
875 ** Return the maximum height of any expression tree referenced
876 ** by the select statement passed as an argument.
877 */
882 }
884 /*
885 ** Propagate all EP_Propagate flags from the Expr.x.pList into
886 ** Expr.flags.
887 */
892 }
893 }
894 #define exprSetHeight(y)
897 /*
898 ** Set the error offset for an Expr node, if possible.
899 */
904 }
906 /*
907 ** This routine is the core allocator for Expr nodes.
908 **
909 ** Construct a new expression node and return a pointer to it. Memory
910 ** for this node and for the pToken argument is a single allocation
911 ** obtained from sqlite3DbMalloc(). The calling function
912 ** is responsible for making sure the node eventually gets freed.
913 **
914 ** If dequote is true, then the token (if it exists) is dequoted.
915 ** If dequote is false, no dequoting is performed. The deQuote
916 ** parameter is ignored if pToken is NULL or if the token does not
917 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
918 ** then the EP_DblQuoted flag is set on the expression node.
919 **
920 ** Special case (tag-20240227-a): If op==TK_INTEGER and pToken points to
921 ** a string that can be translated into a 32-bit integer, then the token is
922 ** not stored in u.zToken. Instead, the integer values is written
923 ** into u.iValue and the EP_IntValue flag is set. No extra storage
924 ** is allocated to hold the integer text and the dequote flag is ignored.
925 ** See also tag-20240227-b.
926 */
932 ){
943 }
944 }
961 }
962 }
963 }
964 #if SQLITE_MAX_EXPR_DEPTH>0
966 #endif
967 }
969 }
971 /*
972 ** Allocate a new expression node from a zero-terminated token that has
973 ** already been dequoted.
974 */
979 ){
980 Token x;
984 }
986 /*
987 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
988 **
989 ** If pRoot==NULL that means that a memory allocation error has occurred.
990 ** In that case, delete the subtrees pLeft and pRight.
991 */
996 Expr *pRight
997 ){
1008 #if SQLITE_MAX_EXPR_DEPTH>0
1012 #endif
1013 }
1017 #if SQLITE_MAX_EXPR_DEPTH>0
1020 }
1021 #endif
1022 }
1023 }
1024 }
1026 /*
1027 ** Allocate an Expr node which joins as many as two subtrees.
1028 **
1029 ** One or both of the subtrees can be NULL. Return a pointer to the new
1030 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
1031 ** free the subtrees and return NULL.
1032 */
1038 ){
1050 }
1052 }
1054 /*
1055 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
1056 ** do a memory allocation failure) then delete the pSelect object.
1057 */
1066 }
1067 }
1069 /*
1070 ** Expression list pEList is a list of vector values. This function
1071 ** converts the contents of pEList to a VALUES(...) Select statement
1072 ** returning 1 row for each element of the list. For example, the
1073 ** expression list:
1074 **
1075 ** ( (1,2), (3,4) (5,6) )
1076 **
1077 ** is translated to the equivalent of:
1078 **
1079 ** VALUES(1,2), (3,4), (5,6)
1080 **
1081 ** Each of the vector values in pEList must contain exactly nElem terms.
1082 ** If a list element that is not a vector or does not contain nElem terms,
1083 ** an error message is left in pParse.
1084 **
1085 ** This is used as part of processing IN(...) expressions with a list
1086 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
1087 */
1101 }
1105 );
1107 }
1115 }
1117 }
1118 }
1122 }
1125 }
1127 /*
1128 ** Join two expressions using an AND operator. If either expression is
1129 ** NULL, then just return the other expression.
1130 **
1131 ** If one side or the other of the AND is known to be false, and neither side
1132 ** is part of an ON clause, then instead of returning an AND expression,
1133 ** just return a constant expression with a value of false.
1134 */
1144 && !IN_RENAME_OBJECT
1145 ){
1151 }
1152 }
1153 }
1155 /*
1156 ** Construct a new expression node for a function with multiple
1157 ** arguments.
1158 */
1164 ){
1172 }
1178 ){
1180 }
1187 }
1189 /*
1190 ** Report an error when attempting to use an ORDER BY clause within
1191 ** the arguments of a non-aggregate function.
1192 */
1196 );
1197 }
1199 /*
1200 ** Attach an ORDER BY clause to a function call.
1201 **
1202 ** functionname( arguments ORDER BY sortlist )
1203 ** \_____________________/ \______/
1204 ** pExpr pOrderBy
1205 **
1206 ** The ORDER BY clause is inserted into a new Expr node of type TK_ORDER
1207 ** and added to the Expr.pLeft field of the parent TK_FUNCTION node.
1208 */
1213 ){
1219 }
1224 }
1229 /* Ignore ORDER BY on zero-argument aggregates */
1232 }
1237 }
1243 }
1248 }
1250 /*
1251 ** Check to see if a function is usable according to current access
1252 ** rules:
1253 **
1254 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1255 **
1256 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1257 ** top-level SQL
1258 **
1259 ** If the function is not usable, create an error.
1260 */
1265 ){
1271 ){
1272 /* Functions prohibited in triggers and views if:
1273 ** (1) tagged with SQLITE_DIRECTONLY
1274 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1275 ** is tagged with SQLITE_FUNC_UNSAFE) and
1276 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1277 ** that the schema is possibly tainted).
1278 */
1280 }
1281 }
1282 }
1284 /*
1285 ** Assign a variable number to an expression that encodes a wildcard
1286 ** in the original SQL statement.
1287 **
1288 ** Wildcards consisting of a single "?" are assigned the next sequential
1289 ** variable number.
1290 **
1291 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1292 ** sure "nnn" is not too big to avoid a denial of service attack when
1293 ** the SQL statement comes from an external source.
1294 **
1295 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1296 ** as the previous instance of the same wildcard. Or if this is the first
1297 ** instance of the wildcard, the next sequential variable number is
1298 ** assigned.
1299 */
1303 ynVar x;
1312 /* Wildcard of the form "?". Assign the next variable number */
1318 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1319 ** use it as the variable number */
1320 i64 i;
1327 }
1337 }
1344 }
1346 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1347 ** number as the prior appearance of the same name, or if the name
1348 ** has never appeared before, reuse the same variable number
1349 */
1354 }
1355 }
1358 }
1359 }
1364 }
1365 }
1367 /*
1368 ** Recursively delete an expression tree.
1369 */
1373 exprDeleteRestart:
1378 #ifdef SQLITE_DEBUG
1384 }
1385 #endif
1387 /* The Expr.x union is never used at the same time as Expr.pRight */
1397 #ifndef SQLITE_OMIT_WINDOWFUNC
1400 }
1401 #endif
1402 }
1407 ){
1408 /* Avoid unnecessary recursion on unary operators */
1414 }
1415 }
1416 }
1419 }
1420 }
1423 }
1426 }
1428 /*
1429 ** Clear both elements of an OnOrUsing object
1430 */
1433 /* Nothing to clear */
1438 }
1439 }
1441 /*
1442 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1443 ** This is similar to sqlite3ExprDelete() except that the delete is
1444 ** deferred until the pParse is deleted.
1445 **
1446 ** The pExpr might be deleted immediately on an OOM error.
1447 **
1448 ** Return 0 if the delete was successfully deferred. Return non-zero
1449 ** if the delete happened immediately because of an OOM.
1450 */
1453 }
1455 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1456 ** expression.
1457 */
1462 }
1464 }
1465 }
1467 /*
1468 ** Return the number of bytes allocated for the expression structure
1469 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1470 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1471 */
1476 }
1478 /*
1479 ** The dupedExpr*Size() routines each return the number of bytes required
1480 ** to store a copy of an expression or expression tree. They differ in
1481 ** how much of the tree is measured.
1482 **
1483 ** dupedExprStructSize() Size of only the Expr structure
1484 ** dupedExprNodeSize() Size of Expr + space for token
1485 ** dupedExprSize() Expr + token + subtree components
1486 **
1487 ***************************************************************************
1488 **
1489 ** The dupedExprStructSize() function returns two values OR-ed together:
1490 ** (1) the space required for a copy of the Expr structure only and
1491 ** (2) the EP_xxx flags that indicate what the structure size should be.
1492 ** The return values is always one of:
1493 **
1494 ** EXPR_FULLSIZE
1495 ** EXPR_REDUCEDSIZE | EP_Reduced
1496 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1497 **
1498 ** The size of the structure can be found by masking the return value
1499 ** of this routine with 0xfff. The flags can be found by masking the
1500 ** return value with EP_Reduced|EP_TokenOnly.
1501 **
1502 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1503 ** (unreduced) Expr objects as they or originally constructed by the parser.
1504 ** During expression analysis, extra information is computed and moved into
1505 ** later parts of the Expr object and that extra information might get chopped
1506 ** off if the expression is reduced. Note also that it does not work to
1507 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1508 ** to reduce a pristine expression tree from the parser. The implementation
1509 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1510 ** to enforce this constraint.
1511 */
1528 }
1529 }
1531 }
1533 /*
1534 ** This function returns the space in bytes required to store the copy
1535 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1536 ** string is defined.)
1537 */
1542 }
1544 }
1546 /*
1547 ** Return the number of bytes required to create a duplicate of the
1548 ** expression passed as the first argument.
1549 **
1550 ** The value returned includes space to create a copy of the Expr struct
1551 ** itself and the buffer referred to by Expr.u.zToken, if any.
1552 **
1553 ** The return value includes space to duplicate all Expr nodes in the
1554 ** tree formed by Expr.pLeft and Expr.pRight, but not any other
1555 ** substructure such as Expr.x.pList, Expr.x.pSelect, and Expr.y.pWin.
1556 */
1565 }
1567 /*
1568 ** An EdupBuf is a memory allocation used to stored multiple Expr objects
1569 ** together with their Expr.zToken content. This is used to help implement
1570 ** compression while doing sqlite3ExprDup(). The top-level Expr does the
1571 ** allocation for itself and many of its decendents, then passes an instance
1572 ** of the structure down into exprDup() so that they decendents can have
1573 ** access to that memory.
1574 */
1578 #ifdef SQLITE_DEBUG
1580 #endif
1581 };
1583 /*
1584 ** This function is similar to sqlite3ExprDup(), except that if pEdupBuf
1585 ** is not NULL then it points to memory that can be used to store a copy
1586 ** of the input Expr p together with its p->u.zToken (if any). pEdupBuf
1587 ** is updated with the new buffer tail prior to returning.
1588 */
1594 ){
1605 /* Figure out where to write the new Expr structure. */
1608 #ifdef SQLITE_DEBUG
1610 #endif
1624 }
1627 #ifdef SQLITE_DEBUG
1629 #endif
1632 }
1637 /* Set nNewSize to the size allocated for the structure pointed to
1638 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1639 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1640 ** by the copy of the p->u.zToken string (if any).
1641 */
1649 }
1650 }
1662 }
1664 }
1666 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1673 }
1675 /* Copy the p->u.zToken string, if any. */
1681 }
1686 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1692 }
1694 #ifndef SQLITE_OMIT_WINDOWFUNC
1698 }
1701 /* Fill in pNew->pLeft and pNew->pRight. */
1711 }
1722 }
1724 }
1725 }
1726 }
1730 }
1732 /*
1733 ** Create and return a deep copy of the object passed as the second
1734 ** argument. If an OOM condition is encountered, NULL is returned
1735 ** and the db->mallocFailed flag set.
1736 */
1737 #ifndef SQLITE_OMIT_CTE
1751 }
1752 }
1753 }
1755 }
1756 #else
1757 # define sqlite3WithDup(x,y) 0
1758 #endif
1760 #ifndef SQLITE_OMIT_WINDOWFUNC
1761 /*
1762 ** The gatherSelectWindows() procedure and its helper routine
1763 ** gatherSelectWindowsCallback() are used to scan all the expressions
1764 ** an a newly duplicated SELECT statement and gather all of the Window
1765 ** objects found there, assembling them onto the linked list at Select->pWin.
1766 */
1775 }
1777 }
1780 }
1782 Walker w;
1789 }
1790 #endif
1793 /*
1794 ** The following group of routines make deep copies of expressions,
1795 ** expression lists, ID lists, and select statements. The copies can
1796 ** be deleted (by being passed to their respective ...Delete() routines)
1797 ** without effecting the originals.
1798 **
1799 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1800 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1801 ** by subsequent calls to sqlite*ListAppend() routines.
1802 **
1803 ** Any tables that the SrcList might point to are not duplicated.
1804 **
1805 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1806 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1807 ** truncated version of the usual Expr structure that will be stored as
1808 ** part of the in-memory representation of the database schema.
1809 */
1813 }
1836 ){
1846 }
1848 }
1849 }
1854 }
1856 }
1858 /*
1859 ** If cursors, triggers, views and subqueries are all omitted from
1860 ** the build, then none of the following routines, except for
1861 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1862 ** called with a NULL argument.
1863 */
1864 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1865 || !defined(SQLITE_OMIT_SUBQUERY)
1893 }
1894 }
1900 }
1911 }
1915 }
1919 }
1925 }
1927 }
1929 }
1945 }
1947 }
1975 #ifndef SQLITE_OMIT_WINDOWFUNC
1979 #endif
1982 /* Any prior OOM might have left the Select object incomplete.
1983 ** Delete the whole thing rather than allow an incomplete Select
1984 ** to be used by the code generator. */
1988 }
1992 }
1994 }
1995 #else
1999 }
2000 #endif
2003 /*
2004 ** Add a new element to the end of an expression list. If pList is
2005 ** initially NULL, then create a new expression list.
2006 **
2007 ** The pList argument must be either NULL or a pointer to an ExprList
2008 ** obtained from a prior call to sqlite3ExprListAppend().
2009 **
2010 ** If a memory allocation error occurs, the entire list is freed and
2011 ** NULL is returned. If non-NULL is returned, then it is guaranteed
2012 ** that the new entry was successfully appended.
2013 */
2018 ){
2026 }
2033 }
2038 ){
2050 }
2055 }
2060 ){
2064 }
2067 }
2072 }
2074 /*
2075 ** pColumns and pExpr form a vector assignment which is part of the SET
2076 ** clause of an UPDATE statement. Like this:
2077 **
2078 ** (a,b,c) = (expr1,expr2,expr3)
2079 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
2080 **
2081 ** For each term of the vector assignment, append new entries to the
2082 ** expression list pList. In the case of a subquery on the RHS, append
2083 ** TK_SELECT_COLUMN expressions.
2084 */
2090 ){
2095 /* pColumns can only be NULL due to an OOM but an OOM will cause an
2096 ** exit prior to this routine being invoked */
2100 /* If the RHS is a vector, then we can immediately check to see that
2101 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
2102 ** wildcards ("*") in the result set of the SELECT must be expanded before
2103 ** we can do the size check, so defer the size check until code generation.
2104 */
2109 }
2120 }
2121 }
2128 /* Store the SELECT statement in pRight so it will be deleted when
2129 ** sqlite3ExprListDelete() is called */
2133 /* Remember the size of the LHS in iTable so that we can check that
2134 ** the RHS and LHS sizes match during code generation. */
2136 }
2138 vector_append_error:
2142 }
2144 /*
2145 ** Set the sort order for the last element on the given ExprList.
2146 */
2156 );
2160 );
2166 }
2173 }
2174 }
2175 }
2177 /*
2178 ** Set the ExprList.a[].zEName element of the most recently added item
2179 ** on the expression list.
2180 **
2181 ** pList might be NULL following an OOM error. But pName should never be
2182 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2183 ** is set.
2184 */
2190 ){
2201 /* If dequote==0, then pName->z does not point to part of a DDL
2202 ** statement handled by the parser. And so no token need be added
2203 ** to the token-map. */
2207 }
2208 }
2209 }
2210 }
2212 /*
2213 ** Set the ExprList.a[].zSpan element of the most recently added item
2214 ** on the expression list.
2215 **
2216 ** pList might be NULL following an OOM error. But pSpan should never be
2217 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2218 ** is set.
2219 */
2225 ){
2234 }
2235 }
2236 }
2238 /*
2239 ** If the expression list pEList contains more than iLimit elements,
2240 ** leave an error message in pParse.
2241 */
2246 ){
2252 }
2253 }
2255 /*
2256 ** Delete an entire expression list.
2257 */
2266 pItem++;
2269 }
2272 }
2275 }
2277 /*
2278 ** Return the bitwise-OR of all Expr.flags fields in the given
2279 ** ExprList.
2280 */
2289 }
2291 }
2293 /*
2294 ** This is a SELECT-node callback for the expression walker that
2295 ** always "fails". By "fail" in this case, we mean set
2296 ** pWalker->eCode to zero and abort.
2297 **
2298 ** This callback is used by multiple expression walkers.
2299 */
2304 }
2306 /*
2307 ** Check the input string to see if it is "true" or "false" (in any case).
2308 **
2309 ** If the string is.... Return
2310 ** "true" EP_IsTrue
2311 ** "false" EP_IsFalse
2312 ** anything else 0
2313 */
2318 }
2321 /*
2322 ** If the input expression is an ID with the name "true" or "false"
2323 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2324 ** the conversion happened, and zero if the expression is unaltered.
2325 */
2327 u32 v;
2331 ){
2335 }
2337 }
2339 /*
2340 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2341 ** and 0 if it is FALSE.
2342 */
2350 }
2352 /*
2353 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2354 ** terms that are always true or false. Return the simplified expression.
2355 ** Or return the original expression if no simplification is possible.
2356 **
2357 ** Examples:
2358 **
2359 ** (x<10) AND true => (x<10)
2360 ** (x<10) AND false => false
2361 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2362 ** (x<10) AND (y=22 OR true) => (x<10)
2363 ** (y=22) OR true => true
2364 */
2374 }
2375 }
2377 }
2379 /*
2380 ** pExpr is a TK_FUNCTION node. Try to determine whether or not the
2381 ** function is a constant function. A function is constant if all of
2382 ** the following are true:
2383 **
2384 ** (1) It is a scalar function (not an aggregate or window function)
2385 ** (2) It has either the SQLITE_FUNC_CONSTANT or SQLITE_FUNC_SLOCHNG
2386 ** property.
2387 ** (3) All of its arguments are constants
2388 **
2389 ** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
2390 ** It makes no changes to pWalker->eCode if pExpr is constant. In
2391 ** every case, it returns WRC_Abort.
2392 **
2393 ** Called as a service subroutine from exprNodeIsConstant().
2394 */
2397 Expr *pExpr
2398 ){
2407 ){;
2413 }
2420 ){
2423 }
2425 }
2428 /*
2429 ** These routines are Walker callbacks used to check expressions to
2430 ** see if they are "constant" for some definition of constant. The
2431 ** Walker.eCode value determines the type of "constant" we are looking
2432 ** for.
2433 **
2434 ** These callback routines are used to implement the following:
2435 **
2436 ** sqlite3ExprIsConstant() pWalker->eCode==1
2437 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2438 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2439 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2440 **
2441 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2442 ** is found to not be a constant.
2443 **
2444 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2445 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2446 ** when parsing an existing schema out of the sqlite_schema table and 4
2447 ** when processing a new CREATE TABLE statement. A bound parameter raises
2448 ** an error for new statements, but is silently converted
2449 ** to NULL for existing schemas. This allows sqlite_schema tables that
2450 ** contain a bound parameter because they were generated by older versions
2451 ** of SQLite to be parsed by newer versions of SQLite without raising a
2452 ** malformed schema error.
2453 */
2457 /* If pWalker->eCode is 2 then any term of the expression that comes from
2458 ** the ON or USING clauses of an outer join disqualifies the expression
2459 ** from being considered constant. */
2463 }
2466 /* Consider functions to be constant if all their arguments are constant
2467 ** and either pWalker->eCode==4 or 5 or the function has the
2468 ** SQLITE_FUNC_CONST flag. */
2472 ){
2480 }
2482 /* Convert "true" or "false" in a DEFAULT clause into the
2483 ** appropriate TK_TRUEFALSE operator */
2486 }
2487 /* no break */ deliberate_fall_through
2497 }
2500 }
2501 /* no break */ deliberate_fall_through
2514 /* Silently convert bound parameters that appear inside of CREATE
2515 ** statements into a NULL when parsing the CREATE statement text out
2516 ** of the sqlite_schema table */
2519 /* A bound parameter in a CREATE statement that originates from
2520 ** sqlite3_prepare() causes an error */
2523 }
2524 /* no break */ deliberate_fall_through
2529 }
2530 }
2532 Walker w;
2537 #ifdef SQLITE_DEBUG
2539 #endif
2542 }
2544 /*
2545 ** Walk an expression tree. Return non-zero if the expression is constant
2546 ** and 0 if it involves variables or function calls.
2547 **
2548 ** For the purposes of this function, a double-quoted string (ex: "abc")
2549 ** is considered a variable but a single-quoted string (ex: 'abc') is
2550 ** a constant.
2551 **
2552 ** The pParse parameter may be NULL. But if it is NULL, there is no way
2553 ** to determine if function calls are constant or not, and hence all
2554 ** function calls will be considered to be non-constant. If pParse is
2555 ** not NULL, then a function call might be constant, depending on the
2556 ** function and on its parameters.
2557 */
2560 }
2562 /*
2563 ** Walk an expression tree. Return non-zero if
2564 **
2565 ** (1) the expression is constant, and
2566 ** (2) the expression does originate in the ON or USING clause
2567 ** of a LEFT JOIN, and
2568 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2569 ** operands created by the constant propagation optimization.
2570 **
2571 ** When this routine returns true, it indicates that the expression
2572 ** can be added to the pParse->pConstExpr list and evaluated once when
2573 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2574 */
2577 }
2579 /*
2580 ** This routine examines sub-SELECT statements as an expression is being
2581 ** walked as part of sqlite3ExprIsTableConstant(). Sub-SELECTs are considered
2582 ** constant as long as they are uncorrelated - meaning that they do not
2583 ** contain any terms from outer contexts.
2584 */
2591 }
2593 }
2595 /*
2596 ** Walk an expression tree. Return non-zero if the expression is constant
2597 ** for any single row of the table with cursor iCur. In other words, the
2598 ** expression must not refer to any non-deterministic function nor any
2599 ** table other than iCur.
2600 **
2601 ** Consider uncorrelated subqueries to be constants if the bAllowSubq
2602 ** parameter is true.
2603 */
2605 Walker w;
2613 #ifdef SQLITE_DEBUG
2615 #endif
2616 }
2620 }
2622 /*
2623 ** Check pExpr to see if it is an constraint on the single data source
2624 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
2625 ** constrains pSrc but does not depend on any other tables or data
2626 ** sources anywhere else in the query. Return true (non-zero) if pExpr
2627 ** is a constraint on pSrc only.
2628 **
2629 ** This is an optimization. False negatives will perhaps cause slower
2630 ** queries, but false positives will yield incorrect answers. So when in
2631 ** doubt, return 0.
2632 **
2633 ** To be an single-source constraint, the following must be true:
2634 **
2635 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
2636 **
2637 ** (2a) pExpr cannot use subqueries unless the bAllowSubq parameter is
2638 ** true and the subquery is non-correlated
2639 **
2640 ** (2b) pExpr cannot use non-deterministic functions.
2641 **
2642 ** (3) pSrc cannot be part of the left operand for a RIGHT JOIN.
2643 ** (Is there some way to relax this constraint?)
2644 **
2645 ** (4) If pSrc is the right operand of a LEFT JOIN, then...
2646 ** (4a) pExpr must come from an ON clause..
2647 ** (4b) and specifically the ON clause associated with the LEFT JOIN.
2648 **
2649 ** (5) If pSrc is not the right operand of a LEFT JOIN or the left
2650 ** operand of a RIGHT JOIN, then pExpr must be from the WHERE
2651 ** clause, not an ON clause.
2652 **
2653 ** (6) Either:
2654 **
2655 ** (6a) pExpr does not originate in an ON or USING clause, or
2656 **
2657 ** (6b) The ON or USING clause from which pExpr is derived is
2658 ** not to the left of a RIGHT JOIN (or FULL JOIN).
2659 **
2660 ** Without this restriction, accepting pExpr as a single-table
2661 ** constraint might move the the ON/USING filter expression
2662 ** from the left side of a RIGHT JOIN over to the right side,
2663 ** which leads to incorrect answers. See also restriction (9)
2664 ** on push-down.
2665 */
2671 ){
2675 }
2681 }
2684 ){
2690 }
2692 }
2693 }
2694 }
2695 /* Rules (1), (2a), and (2b) handled by the following: */
2697 }
2700 /*
2701 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2702 */
2707 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2708 ** it constant. */
2715 }
2716 }
2717 }
2719 /* Check if pExpr is a sub-select. If so, consider it variable. */
2723 }
2726 }
2728 /*
2729 ** Walk the expression tree passed as the first argument. Return non-zero
2730 ** if the expression consists entirely of constants or copies of terms
2731 ** in pGroupBy that sort with the BINARY collation sequence.
2732 **
2733 ** This routine is used to determine if a term of the HAVING clause can
2734 ** be promoted into the WHERE clause. In order for such a promotion to work,
2735 ** the value of the HAVING clause term must be the same for all members of
2736 ** a "group". The requirement that the GROUP BY term must be BINARY
2737 ** assumes that no other collating sequence will have a finer-grained
2738 ** grouping than binary. In other words (A=B COLLATE binary) implies
2739 ** A=B in every other collating sequence. The requirement that the
2740 ** GROUP BY be BINARY is stricter than necessary. It would also work
2741 ** to promote HAVING clauses that use the same alternative collating
2742 ** sequence as the GROUP BY term, but that is much harder to check,
2743 ** alternative collating sequences are uncommon, and this is only an
2744 ** optimization, so we take the easy way out and simply require the
2745 ** GROUP BY to use the BINARY collating sequence.
2746 */
2748 Walker w;
2756 }
2758 /*
2759 ** Walk an expression tree for the DEFAULT field of a column definition
2760 ** in a CREATE TABLE statement. Return non-zero if the expression is
2761 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2762 ** the expression is constant or a function call with constant arguments.
2763 ** Return and 0 if there are any variables.
2764 **
2765 ** isInit is true when parsing from sqlite_schema. isInit is false when
2766 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2767 ** (such as ? or $abc) in the expression are converted into NULL. When
2768 ** isInit is false, parameters raise an error. Parameters should not be
2769 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2770 ** allowed it, so we need to support it when reading sqlite_schema for
2771 ** backwards compatibility.
2772 **
2773 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2774 **
2775 ** For the purposes of this function, a double-quoted string (ex: "abc")
2776 ** is considered a variable but a single-quoted string (ex: 'abc') is
2777 ** a constant.
2778 */
2782 }
2784 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2785 /*
2786 ** Walk an expression tree. Return 1 if the expression contains a
2787 ** subquery of some kind. Return 0 if there are no subqueries.
2788 */
2790 Walker w;
2794 #ifdef SQLITE_DEBUG
2796 #endif
2799 }
2800 #endif
2802 /*
2803 ** If the expression p codes a constant integer that is small enough
2804 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2805 ** in *pValue. If the expression is not an integer or if it is too big
2806 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2807 **
2808 ** If the pParse pointer is provided, then allow the expression p to be
2809 ** a parameter (TK_VARIABLE) that is bound to an integer.
2810 ** But if pParse is NULL, then p must be a pure integer literal.
2811 */
2816 /* If an expression is an integer literal that fits in a signed 32-bit
2817 ** integer, then the EP_IntValue flag will have already been set */
2824 }
2829 }
2836 }
2838 }
2846 SQLITE_AFF_BLOB);
2853 }
2854 }
2856 }
2858 }
2860 }
2862 }
2864 /*
2865 ** Return FALSE if there is no chance that the expression can be NULL.
2866 **
2867 ** If the expression might be NULL or if the expression is too complex
2868 ** to tell return TRUE.
2869 **
2870 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2871 ** when we know that a value cannot be NULL. Hence, a false positive
2872 ** (returning TRUE when in fact the expression can never be NULL) might
2873 ** be a small performance hit but is otherwise harmless. On the other
2874 ** hand, a false negative (returning FALSE when the result could be NULL)
2875 ** will likely result in an incorrect answer. So when in doubt, return
2876 ** TRUE.
2877 */
2879 u8 op;
2884 }
2897 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
2899 #endif
2906 }
2907 }
2909 /*
2910 ** Return TRUE if the given expression is a constant which would be
2911 ** unchanged by OP_Affinity with the affinity given in the second
2912 ** argument.
2913 **
2914 ** This routine is used to determine if the OP_Affinity operation
2915 ** can be omitted. When in doubt return FALSE. A false negative
2916 ** is harmless. A false positive, however, can result in the wrong
2917 ** answer.
2918 */
2920 u8 op;
2926 }
2932 }
2935 }
2938 }
2941 }
2945 }
2948 }
2949 }
2950 }
2952 /*
2953 ** Return TRUE if the given string is a row-id column name.
2954 */
2960 }
2962 /*
2963 ** Return a pointer to a buffer containing a usable rowid alias for table
2964 ** pTab. An alias is usable if there is not an explicit user-defined column
2965 ** of the same name.
2966 */
2975 }
2978 }
2979 }
2981 }
2983 /*
2984 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2985 ** that can be simplified to a direct table access, then return
2986 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2987 ** or if the SELECT statement needs to be materialized into a transient
2988 ** table, then return NULL.
2989 */
2990 #ifndef SQLITE_OMIT_SUBQUERY
3005 }
3019 /* All SELECT results must be columns. */
3024 }
3026 }
3029 #ifndef SQLITE_OMIT_SUBQUERY
3030 /*
3031 ** Generate code that checks the left-most column of index table iCur to see if
3032 ** it contains any NULL entries. Cause the register at regHasNull to be set
3033 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
3034 ** to be set to NULL if iCur contains one or more NULL values.
3035 */
3044 }
3045 #endif
3048 #ifndef SQLITE_OMIT_SUBQUERY
3049 /*
3050 ** The argument is an IN operator with a list (not a subquery) on the
3051 ** right-hand side. Return TRUE if that list is constant.
3052 */
3062 }
3063 #endif
3065 /*
3066 ** This function is used by the implementation of the IN (...) operator.
3067 ** The pX parameter is the expression on the RHS of the IN operator, which
3068 ** might be either a list of expressions or a subquery.
3069 **
3070 ** The job of this routine is to find or create a b-tree object that can
3071 ** be used either to test for membership in the RHS set or to iterate through
3072 ** all members of the RHS set, skipping duplicates.
3073 **
3074 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
3075 ** and the *piTab parameter is set to the index of that cursor.
3076 **
3077 ** The returned value of this function indicates the b-tree type, as follows:
3078 **
3079 ** IN_INDEX_ROWID - The cursor was opened on a database table.
3080 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
3081 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
3082 ** IN_INDEX_EPH - The cursor was opened on a specially created and
3083 ** populated ephemeral table.
3084 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
3085 ** implemented as a sequence of comparisons.
3086 **
3087 ** An existing b-tree might be used if the RHS expression pX is a simple
3088 ** subquery such as:
3089 **
3090 ** SELECT <column1>, <column2>... FROM <table>
3091 **
3092 ** If the RHS of the IN operator is a list or a more complex subquery, then
3093 ** an ephemeral table might need to be generated from the RHS and then
3094 ** pX->iTable made to point to the ephemeral table instead of an
3095 ** existing table. In this case, the creation and initialization of the
3096 ** ephemeral table might be put inside of a subroutine, the EP_Subrtn flag
3097 ** will be set on pX and the pX->y.sub fields will be set to show where
3098 ** the subroutine is coded.
3099 **
3100 ** The inFlags parameter must contain, at a minimum, one of the bits
3101 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
3102 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
3103 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
3104 ** be used to loop over all values of the RHS of the IN operator.
3105 **
3106 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
3107 ** through the set members) then the b-tree must not contain duplicates.
3108 ** An ephemeral table will be created unless the selected columns are guaranteed
3109 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
3110 ** a UNIQUE constraint or index.
3111 **
3112 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
3113 ** for fast set membership tests) then an ephemeral table must
3114 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
3115 ** index can be found with the specified <columns> as its left-most.
3116 **
3117 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
3118 ** if the RHS of the IN operator is a list (not a subquery) then this
3119 ** routine might decide that creating an ephemeral b-tree for membership
3120 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
3121 ** calling routine should implement the IN operator using a sequence
3122 ** of Eq or Ne comparison operations.
3123 **
3124 ** When the b-tree is being used for membership tests, the calling function
3125 ** might need to know whether or not the RHS side of the IN operator
3126 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
3127 ** if there is any chance that the (...) might contain a NULL value at
3128 ** runtime, then a register is allocated and the register number written
3129 ** to *prRhsHasNull. If there is no chance that the (...) contains a
3130 ** NULL value, then *prRhsHasNull is left unchanged.
3131 **
3132 ** If a register is allocated and its location stored in *prRhsHasNull, then
3133 ** the value in that register will be NULL if the b-tree contains one or more
3134 ** NULL values, and it will be some non-NULL value if the b-tree contains no
3135 ** NULL values.
3136 **
3137 ** If the aiMap parameter is not NULL, it must point to an array containing
3138 ** one element for each column returned by the SELECT statement on the RHS
3139 ** of the IN(...) operator. The i'th entry of the array is populated with the
3140 ** offset of the index column that matches the i'th column returned by the
3141 ** SELECT. For example, if the expression and selected index are:
3142 **
3143 ** (?,?,?) IN (SELECT a, b, c FROM t1)
3144 ** CREATE INDEX i1 ON t1(b, c, a);
3145 **
3146 ** then aiMap[] is populated with {2, 0, 1}.
3147 */
3148 #ifndef SQLITE_OMIT_SUBQUERY
3156 ){
3167 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
3168 ** whether or not the SELECT result contains NULL values, check whether
3169 ** or not NULL is actually possible (it may not be, for example, due
3170 ** to NOT NULL constraints in the schema). If no NULL values are possible,
3171 ** set prRhsHasNull to 0 before continuing. */
3177 }
3180 }
3181 }
3183 /* Check to see if an existing table or index can be used to
3184 ** satisfy the query. This is preferable to generating a new
3185 ** ephemeral table. */
3198 /* Code an OP_Transaction and OP_TableLock for <table>. */
3206 /* The "x IN (SELECT rowid FROM table)" case */
3220 /* Check that the affinity that will be used to perform each
3221 ** comparison is the same as the affinity of each column in table
3222 ** on the RHS of the IN operator. If it not, it is not possible to
3223 ** use any index of the RHS table. */
3235 /* sqlite3CompareAffinity() only returns TEXT if one side or the
3236 ** other has no affinity and the other side is TEXT. Hence,
3237 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
3238 ** and for the term on the LHS of the IN to have no affinity. */
3243 }
3244 }
3247 /* Search for an existing index that will work for this IN operator */
3253 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
3254 ** BITMASK(nExpr) without overflowing */
3261 ){
3263 }
3264 }
3278 }
3280 }
3286 }
3290 /* If we reach this point, that means the index pIdx is usable */
3301 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
3305 #endif
3309 }
3310 }
3312 }
3318 /* If no preexisting index is available for the IN clause
3319 ** and IN_INDEX_NOOP is an allowed reply
3320 ** and the RHS of the IN operator is a list, not a subquery
3321 ** and the RHS is not constant or has two or fewer terms,
3322 ** then it is not worth creating an ephemeral table to evaluate
3323 ** the IN operator so return IN_INDEX_NOOP.
3324 */
3329 ){
3333 }
3336 /* Could not find an existing table or index to use as the RHS b-tree.
3337 ** We will have to generate an ephemeral table to do the job.
3338 */
3346 }
3351 }
3353 }
3359 }
3362 }
3363 #endif
3365 #ifndef SQLITE_OMIT_SUBQUERY
3366 /*
3367 ** Argument pExpr is an (?, ?...) IN(...) expression. This
3368 ** function allocates and returns a nul-terminated string containing
3369 ** the affinities to be used for each column of the comparison.
3370 **
3371 ** It is the responsibility of the caller to ensure that the returned
3372 ** string is eventually freed using sqlite3DbFree().
3373 */
3391 }
3392 }
3394 }
3396 }
3397 #endif
3399 #ifndef SQLITE_OMIT_SUBQUERY
3400 /*
3401 ** Load the Parse object passed as the first argument with an error
3402 ** message of the form:
3403 **
3404 ** "sub-select returns N columns - expected M"
3405 */
3410 }
3411 }
3412 #endif
3414 /*
3415 ** Expression pExpr is a vector that has been used in a context where
3416 ** it is not permitted. If pExpr is a sub-select vector, this routine
3417 ** loads the Parse object with a message of the form:
3418 **
3419 ** "sub-select returns N columns - expected 1"
3420 **
3421 ** Or, if it is a regular scalar vector:
3422 **
3423 ** "row value misused"
3424 */
3426 #ifndef SQLITE_OMIT_SUBQUERY
3430 #endif
3431 {
3433 }
3434 }
3436 #ifndef SQLITE_OMIT_SUBQUERY
3437 /*
3438 ** Scan all previously generated bytecode looking for an OP_BeginSubrtn
3439 ** that is compatible with pExpr. If found, add the y.sub values
3440 ** to pExpr and return true. If not found, return false.
3441 */
3446 ){
3474 }
3476 }
3479 #ifndef SQLITE_OMIT_SUBQUERY
3480 /*
3481 ** Generate code that will construct an ephemeral table containing all terms
3482 ** in the RHS of an IN operator. The IN operator can be in either of two
3483 ** forms:
3484 **
3485 ** x IN (4,5,11) -- IN operator with list on right-hand side
3486 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
3487 **
3488 ** The pExpr parameter is the IN operator. The cursor number for the
3489 ** constructed ephemeral table is returned. The first time the ephemeral
3490 ** table is computed, the cursor number is also stored in pExpr->iTable,
3491 ** however the cursor number returned might not be the same, as it might
3492 ** have been duplicated using OP_OpenDup.
3493 **
3494 ** If the LHS expression ("x" in the examples) is a column value, or
3495 ** the SELECT statement returns a column value, then the affinity of that
3496 ** column is used to build the index keys. If both 'x' and the
3497 ** SELECT... statement are columns, then numeric affinity is used
3498 ** if either column has NUMERIC or INTEGER affinity. If neither
3499 ** 'x' nor the SELECT... statement are columns, then numeric affinity
3500 ** is used.
3501 */
3506 ){
3517 /* The evaluation of the IN must be repeated every time it
3518 ** is encountered if any of the following is true:
3519 **
3520 ** * The right-hand side is a correlated subquery
3521 ** * The right-hand side is an expression list containing variables
3522 ** * We are inside a trigger
3523 **
3524 ** If all of the above are false, then we can compute the RHS just once
3525 ** and reuse it many names.
3526 */
3528 /* Reuse of the RHS is allowed
3529 **
3530 ** Compute a signature for the RHS of the IN operator to facility
3531 ** finding and reusing prior instances of the same IN operator.
3532 */
3540 }
3541 }
3543 /* Check to see if there is a prior materialization of the RHS of
3544 ** this IN operator. If there is, then make use of that prior
3545 ** materialization rather than recomputing it.
3546 */
3549 ){
3554 }
3564 }
3566 }
3568 /* Begin coding the subroutine */
3581 }
3583 }
3585 /* Check to see if this is a vector IN operator */
3589 /* Construct the ephemeral table that will contain the content of
3590 ** RHS of the IN operator.
3591 */
3594 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3599 }
3600 #endif
3604 /* Case 1: expr IN (SELECT ...)
3605 **
3606 ** Generate code to write the results of the select into the temporary
3607 ** table allocated and opened above.
3608 */
3614 ));
3615 /* If the LHS and RHS of the IN operator do not match, that
3616 ** error will have been caught long before we reach this point. */
3619 SelectDest dest;
3631 }
3644 }
3645 }
3649 }
3658 );
3659 }
3660 }
3662 /* Case 2: expr IN (exprlist)
3663 **
3664 ** For each expression, build an index key from the evaluation and
3665 ** store it in the temporary table. If <expr> is a column, then use
3666 ** that columns affinity when building index keys. If <expr> is not
3667 ** a column, use numeric affinity.
3668 */
3679 }
3683 }
3685 /* Loop through each expression in <exprlist>. */
3691 /* If the expression is not constant then we will need to
3692 ** disable the test that was generated above that makes sure
3693 ** this code only executes once. Because for a non-constant
3694 ** expression we need to rerun this code each time.
3695 */
3701 }
3703 /* Evaluate the expression and insert it into the temp table */
3707 }
3710 }
3713 }
3717 /* Subroutine return */
3725 }
3726 }
3729 /*
3730 ** Generate code for scalar subqueries used as a subquery expression
3731 ** or EXISTS operator:
3732 **
3733 ** (SELECT a FROM b) -- subquery
3734 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3735 **
3736 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3737 **
3738 ** Return the register that holds the result. For a multi-column SELECT,
3739 ** the result is stored in a contiguous array of registers and the
3740 ** return value is the register of the left-most result column.
3741 ** Return 0 if an error occurs.
3742 */
3743 #ifndef SQLITE_OMIT_SUBQUERY
3751 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3753 #endif
3764 /* If this routine has already been coded, then invoke it as a
3765 ** subroutine. */
3772 }
3774 /* Begin coding the subroutine */
3782 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3783 ** is encountered if any of the following is true:
3784 **
3785 ** * The right-hand side is a correlated subquery
3786 ** * The right-hand side is an expression list containing variables
3787 ** * We are inside a trigger
3788 **
3789 ** If all of the above are false, then we can run this code just once
3790 ** save the results, and reuse the same result on subsequent invocations.
3791 */
3794 }
3796 /* For a SELECT, generate code to put the values for all columns of
3797 ** the first row into an array of registers and return the index of
3798 ** the first register.
3799 **
3800 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3801 ** into a register and return that register number.
3802 **
3803 ** In both cases, the query is augmented with "LIMIT 1". Any
3804 ** preexisting limit is discarded in place of the new LIMIT 1.
3805 */
3822 }
3824 /* The subquery already has a limit. If the pre-existing limit is X
3825 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3832 }
3836 /* If there is no pre-existing limit add a limit of 1 */
3839 }
3845 }
3850 }
3853 /* Subroutine return */
3862 }
3865 #ifndef SQLITE_OMIT_SUBQUERY
3866 /*
3867 ** Expr pIn is an IN(...) expression. This function checks that the
3868 ** sub-select on the RHS of the IN() operator has the same number of
3869 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3870 ** a sub-query, that the LHS is a vector of size 1.
3871 */
3878 }
3882 }
3884 }
3885 #endif
3887 #ifndef SQLITE_OMIT_SUBQUERY
3888 /*
3889 ** Generate code for an IN expression.
3890 **
3891 ** x IN (SELECT ...)
3892 ** x IN (value, value, ...)
3893 **
3894 ** The left-hand side (LHS) is a scalar or vector expression. The
3895 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3896 ** subquery. If the RHS is a subquery, the number of result columns must
3897 ** match the number of columns in the vector on the LHS. If the RHS is
3898 ** a list of values, the LHS must be a scalar.
3899 **
3900 ** The IN operator is true if the LHS value is contained within the RHS.
3901 ** The result is false if the LHS is definitely not in the RHS. The
3902 ** result is NULL if the presence of the LHS in the RHS cannot be
3903 ** determined due to NULLs.
3904 **
3905 ** This routine generates code that jumps to destIfFalse if the LHS is not
3906 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3907 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3908 ** within the RHS then fall through.
3909 **
3910 ** See the separate in-operator.md documentation file in the canonical
3911 ** SQLite source tree for additional information.
3912 */
3918 ){
3946 /* Attempt to compute the RHS. After this step, if anything other than
3947 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3948 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3949 ** the RHS has not yet been coded. */
3960 );
3961 #ifdef SQLITE_DEBUG
3962 /* Confirm that aiMap[] contains nVector integer values between 0 and
3963 ** nVector-1. */
3968 }
3969 #endif
3971 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3972 ** vector, then it is stored in an array of nVector registers starting
3973 ** at r1.
3974 **
3975 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3976 ** so that the fields are in the same order as an existing index. The
3977 ** aiMap[] array contains a mapping from the original LHS field order to
3978 ** the field order that matches the RHS index.
3979 **
3980 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3981 ** even if it is constant, as OP_Affinity may be used on the register
3982 ** by code generated below. */
3989 /* LHS fields are not reordered */
3992 /* Need to reorder the LHS fields according to aiMap */
3996 }
3997 }
3999 /* If sqlite3FindInIndex() did not find or create an index that is
4000 ** suitable for evaluating the IN operator, then evaluate using a
4001 ** sequence of comparisons.
4002 **
4003 ** This is step (1) in the in-operator.md optimized algorithm.
4004 */
4018 }
4023 }
4042 }
4043 }
4047 }
4051 }
4053 /* Step 2: Check to see if the LHS contains any NULL columns. If the
4054 ** LHS does contain NULLs then the result must be either FALSE or NULL.
4055 ** We will then skip the binary search of the RHS.
4056 */
4061 }
4068 }
4069 }
4071 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
4072 ** of the RHS using the LHS as a probe. If found, the result is
4073 ** true.
4074 */
4076 /* In this case, the RHS is the ROWID of table b-tree and so we also
4077 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
4078 ** into a single opcode. */
4085 /* Combine Step 3 and Step 5 into a single opcode */
4093 }
4094 }
4098 }
4099 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
4102 }
4104 /* Step 4. If the RHS is known to be non-NULL and we did not find
4105 ** an match on the search above, then the result must be FALSE.
4106 */
4110 }
4112 /* Step 5. If we do not care about the difference between NULL and
4113 ** FALSE, then just return false.
4114 */
4117 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
4118 ** If any comparison is NULL, then the result is NULL. If all
4119 ** comparisons are FALSE then the final result is FALSE.
4120 **
4121 ** For a scalar LHS, it is sufficient to check just the first row
4122 ** of the RHS.
4123 */
4130 /* For nVector==1, combine steps 6 and 7 by immediately returning
4131 ** FALSE if the first comparison is not NULL */
4133 }
4145 }
4152 /* Step 7: If we reach this point, we know that the result must
4153 ** be false. */
4155 }
4157 /* Jumps here in order to return true. */
4160 sqlite3ExprCodeIN_finished:
4163 sqlite3ExprCodeIN_oom_error:
4166 }
4169 #ifndef SQLITE_OMIT_FLOATING_POINT
4170 /*
4171 ** Generate an instruction that will put the floating point
4172 ** value described by z[0..n-1] into register iMem.
4173 **
4174 ** The z[] string will probably not be zero-terminated. But the
4175 ** z[n] character is guaranteed to be something that does not look
4176 ** like the continuation of the number.
4177 */
4185 }
4186 }
4187 #endif
4190 /*
4191 ** Generate an instruction that will put the integer describe by
4192 ** text z[0..n-1] into register iMem.
4193 **
4194 ** Expr.u.zToken is always UTF8 and zero-terminated.
4195 */
4205 i64 value;
4210 #ifdef SQLITE_OMIT_FLOATING_POINT
4212 #else
4213 #ifndef SQLITE_OMIT_HEX_INTEGER
4218 #endif
4219 {
4221 }
4222 #endif
4226 }
4227 }
4228 }
4231 /* Generate code that will load into register regOut a value that is
4232 ** appropriate for the iIdxCol-th column of index pIdx.
4233 */
4240 ){
4251 }
4252 }
4254 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4255 /*
4256 ** Generate code that will compute the value of generated column pCol
4257 ** and store the result in register regOut
4258 */
4264 ){
4274 }
4278 }
4281 }
4284 /*
4285 ** Generate code to extract the value of the iCol-th column of a table.
4286 */
4293 ){
4307 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4320 }
4322 #endif
4331 }
4334 }
4335 }
4337 /*
4338 ** Generate code that will extract the iColumn-th column from
4339 ** table pTab and store the column value in register iReg.
4340 **
4341 ** There must be an open cursor to pTab in iTable when this routine
4342 ** is called. If iColumn<0 then code is generated that extracts the rowid.
4343 */
4350 u8 p5 /* P5 value for OP_Column + FLAGS */
4351 ){
4360 }
4362 }
4364 /*
4365 ** Generate code to move content from registers iFrom...iFrom+nReg-1
4366 ** over to iTo..iTo+nReg-1.
4367 */
4370 }
4372 /*
4373 ** Convert a scalar expression node to a TK_REGISTER referencing
4374 ** register iReg. The caller must ensure that iReg already contains
4375 ** the correct value for the expression.
4376 */
4387 }
4388 }
4390 /*
4391 ** Evaluate an expression (either a vector or a scalar expression) and store
4392 ** the result in contiguous temporary registers. Return the index of
4393 ** the first register used to store the result.
4394 **
4395 ** If the returned result register is a temporary scalar, then also write
4396 ** that register number into *piFreeable. If the returned result register
4397 ** is not a temporary or if the expression is a vector set *piFreeable
4398 ** to 0.
4399 */
4408 #if SQLITE_OMIT_SUBQUERY
4410 #else
4412 #endif
4420 }
4421 }
4422 }
4424 }
4426 /*
4427 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
4428 ** so that a subsequent copy will not be merged into this one.
4429 */
4433 }
4434 }
4436 /*
4437 ** Generate code to implement special SQL functions that are implemented
4438 ** in-line rather than by using the usual callbacks.
4439 */
4445 ){
4454 /* Attempt a direct implementation of the built-in COALESCE() and
4455 ** IFNULL() functions. This avoids unnecessary evaluation of
4456 ** arguments past the first non-NULL argument.
4457 */
4466 }
4470 }
4472 Expr caseExpr;
4477 }
4478 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4485 }
4487 }
4488 #endif
4490 /* The UNLIKELY() function is a no-op. The result is the value
4491 ** of the first argument.
4492 */
4496 }
4498 /***********************************************************************
4499 ** Test-only SQL functions that are only usable if enabled
4500 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
4501 */
4502 #if !defined(SQLITE_UNTESTABLE)
4504 /* Compare two expressions using sqlite3ExprCompare() */
4508 target);
4510 }
4513 /* Compare two expressions using sqlite3ExprImpliesExpr() */
4517 target);
4519 }
4522 /* Result of sqlite3ExprImpliesNonNullRow() */
4529 target);
4532 }
4534 }
4537 /* The AFFINITY() function evaluates to a string that describes
4538 ** the type affinity of the argument. This is used for testing of
4539 ** the SQLite type logic.
4540 */
4551 }
4553 }
4555 }
4557 /*
4558 ** Expression Node callback for sqlite3ExprCanReturnSubtype().
4559 **
4560 ** Only a function call is able to return a subtype. So if the node
4561 ** is not a function call, return WRC_Prune immediately.
4562 **
4563 ** A function call is able to return a subtype if it has the
4564 ** SQLITE_RESULT_SUBTYPE property.
4565 **
4566 ** Assume that every function is able to pass-through a subtype from
4567 ** one of its argument (using sqlite3_result_value()). Most functions
4568 ** are not this way, but we don't have a mechanism to distinguish those
4569 ** that are from those that are not, so assume they all work this way.
4570 ** That means that if one of its arguments is another function and that
4571 ** other function is able to return a subtype, then this function is
4572 ** able to return a subtype.
4573 */
4580 }
4588 }
4590 }
4592 /*
4593 ** Return TRUE if expression pExpr is able to return a subtype.
4594 **
4595 ** A TRUE return does not guarantee that a subtype will be returned.
4596 ** It only indicates that a subtype return is possible. False positives
4597 ** are acceptable as they only disable an optimization. False negatives,
4598 ** on the other hand, can lead to incorrect answers.
4599 */
4601 Walker w;
4607 }
4610 /*
4611 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
4612 ** If it is, then resolve the expression by reading from the index and
4613 ** return the register into which the value has been read. If pExpr is
4614 ** not an indexed expression, then return negative.
4615 */
4620 ){
4624 u8 exprAff;
4630 }
4637 ){
4638 /* Affinity mismatch on a generated column */
4640 }
4643 /* Functions that might set a subtype should not be replaced by the
4644 ** value taken from an expression index if they are themselves an
4645 ** argument to another scalar function or aggregate.
4646 ** https://sqlite.org/forum/forumpost/68d284c86b082c3e */
4649 ){
4651 }
4656 /* If the index is on a NULL row due to an outer join, then we
4657 ** cannot extract the value from the index. The value must be
4658 ** computed using the original expression. */
4673 }
4675 }
4677 }
4680 /*
4681 ** Expresion pExpr is guaranteed to be a TK_COLUMN or equivalent. This
4682 ** function checks the Parse.pIdxPartExpr list to see if this column
4683 ** can be replaced with a constant value. If so, it generates code to
4684 ** put the constant value in a register (ideally, but not necessarily,
4685 ** register iTarget) and returns the register number.
4686 **
4687 ** Or, if the TK_COLUMN cannot be replaced by a constant, zero is
4688 ** returned.
4689 */
4700 }
4707 }
4709 }
4710 }
4712 }
4715 /*
4716 ** Generate code into the current Vdbe to evaluate the given
4717 ** expression. Attempt to store the results in register "target".
4718 ** Return the register where results are stored.
4719 **
4720 ** With this routine, there is no guarantee that results will
4721 ** be stored in target. The result might be stored in some other
4722 ** register if it is convenient to do so. The calling function
4723 ** must check the return code and move the results to the desired
4724 ** register.
4725 */
4739 expr_code_doover:
4745 ){
4750 }
4759 /* Happens when the left table of a RIGHT JOIN is null and
4760 ** is using an expression index */
4762 #ifdef SQLITE_VDBE_COVERAGE
4763 /* Verify that the OP_Null above is exercised by tests
4764 ** tag-20230325-2 */
4767 #endif
4769 }
4778 /* No comment added */
4786 }
4787 }
4790 /* This case happens when the argument to an aggregate function
4791 ** is rewritten by aggregateConvertIndexedExprRefToColumn() */
4794 }
4795 /* Otherwise, fall thru into the TK_COLUMN case */
4796 /* no break */ deliberate_fall_through
4797 }
4802 /* This COLUMN expression is really a constant due to WHERE clause
4803 ** constraints, and that constant is coded by the pExpr->pLeft
4804 ** expression. However, make sure the constant has the correct
4805 ** datatype by applying the Affinity of the table column to the
4806 ** constant.
4807 */
4819 }
4821 }
4824 /* Other columns in the same row for CHECK constraints or
4825 ** generated columns or for inserting into partial index.
4826 ** The row is unpacked into registers beginning at
4827 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4828 ** immediately prior to the first column.
4829 */
4841 }
4845 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4851 }
4855 }
4866 }
4868 /* Coding an expression that is part of an index where column names
4869 ** in the index refer to the table to which the index belongs */
4871 }
4872 }
4875 ){
4877 }
4884 }
4888 }
4892 }
4893 #ifndef SQLITE_OMIT_FLOATING_POINT
4898 }
4899 #endif
4904 }
4906 /* Make NULL the default case so that if a bug causes an illegal
4907 ** Expr node to be passed into this function, it will be handled
4908 ** sanely and not crash. But keep the assert() to bring the problem
4909 ** to the attention of the developers. */
4913 }
4914 #ifndef SQLITE_OMIT_BLOB_LITERAL
4928 }
4929 #endif
4936 }
4939 }
4940 #ifndef SQLITE_OMIT_CAST
4942 /* Expressions of the form: CAST(pLeft AS token) */
4949 }
4955 /* fall-through */
4982 }
4985 }
4987 }
5017 }
5024 #ifndef SQLITE_OMIT_FLOATING_POINT
5029 #endif
5039 }
5041 }
5050 }
5062 }
5077 }
5083 ){
5088 }
5090 }
5102 #ifndef SQLITE_OMIT_WINDOWFUNC
5105 }
5106 #endif
5110 ){
5111 /* SQL functions can be expensive. So try to avoid running them
5112 ** multiple times if we know they always give the same result */
5114 }
5122 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
5125 }
5126 #endif
5130 }
5138 }
5144 }
5147 }
5148 }
5155 }
5157 /* For length() and typeof() and octet_length() functions,
5158 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
5159 ** or OPFLAG_TYPEOFARG or OPFLAG_BYTELENARG respectively, to avoid
5160 ** unnecessary data loading.
5161 */
5163 u8 exprOp;
5176 }
5177 }
5182 }
5183 #ifndef SQLITE_OMIT_VIRTUALTABLE
5184 /* Possibly overload the function if the first argument is
5185 ** a virtual table column.
5186 **
5187 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
5188 ** second argument, not the first, as the argument to test to
5189 ** see if it is a column in a virtual table. This is done because
5190 ** the left operand of infix functions (the operand we want to
5191 ** control overloading) ends up as the second argument to the
5192 ** function. The expression "A glob B" is equivalent to
5193 ** "glob(B,A). We want to use the A in "A glob B" to test
5194 ** for function overloading. But we use the B term in "glob(B,A)".
5195 */
5200 }
5201 #endif
5205 }
5213 }
5214 }
5216 }
5217 #ifndef SQLITE_OMIT_SUBQUERY
5228 ){
5232 }
5234 }
5241 }
5247 }
5249 }
5260 }
5264 /*
5265 ** x BETWEEN y AND z
5266 **
5267 ** This is equivalent to
5268 **
5269 ** x>=y AND x<=z
5270 **
5271 ** X is stored in pExpr->pLeft.
5272 ** Y is stored in pExpr->pList->a[0].pExpr.
5273 ** Z is stored in pExpr->pList->a[1].pExpr.
5274 */
5278 }
5281 /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
5282 ** "SOFT-COLLATE" that is added to constraints that are pushed down
5283 ** from outer queries into sub-queries by the WHERE-clause push-down
5284 ** optimization. Clear subtypes as subtypes may not cross a subquery
5285 ** boundary.
5286 */
5294 }
5295 }
5300 }
5303 /* If the opcode is TK_TRIGGER, then the expression is a reference
5304 ** to a column in the new.* or old.* pseudo-tables available to
5305 ** trigger programs. In this case Expr.iTable is set to 1 for the
5306 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
5307 ** is set to the column of the pseudo-table to read, or to -1 to
5308 ** read the rowid field.
5309 **
5310 ** The expression is implemented using an OP_Param opcode. The p1
5311 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
5312 ** to reference another column of the old.* pseudo-table, where
5313 ** i is the index of the column. For a new.rowid reference, p1 is
5314 ** set to (n+1), where n is the number of columns in each pseudo-table.
5315 ** For a reference to any other column in the new.* pseudo-table, p1
5316 ** is set to (n+2+i), where n and i are as defined previously. For
5317 ** example, if the table on which triggers are being fired is
5318 ** declared as:
5319 **
5320 ** CREATE TABLE t1(a, b);
5321 **
5322 ** Then p1 is interpreted as follows:
5323 **
5324 ** p1==0 -> old.rowid p1==3 -> new.rowid
5325 ** p1==1 -> old.a p1==4 -> new.a
5326 ** p1==2 -> old.b p1==5 -> new.b
5327 */
5347 ));
5349 #ifndef SQLITE_OMIT_FLOATING_POINT
5350 /* If the column has REAL affinity, it may currently be stored as an
5351 ** integer. Use OP_RealAffinity to make sure it is really real.
5352 **
5353 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
5354 ** floating point when extracting it from the record. */
5357 }
5358 #endif
5360 }
5365 }
5367 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
5368 ** that derive from the right-hand table of a LEFT JOIN. The
5369 ** Expr.iTable value is the table number for the right-hand table.
5370 ** The expression is only evaluated if that table is not currently
5371 ** on a LEFT JOIN NULL row.
5372 */
5382 }
5386 target);
5389 }
5390 }
5392 /* The OP_IfNullRow opcode above can overwrite the result register with
5393 ** NULL. So we have to ensure that the result register is not a value
5394 ** that is suppose to be a constant. Two defenses are needed:
5395 ** (1) Temporarily disable factoring of constant expressions
5396 ** (2) Make sure the computed value really is stored in register
5397 ** "target" and not someplace else.
5398 */
5405 }
5407 /*
5408 ** Form A:
5409 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
5410 **
5411 ** Form B:
5412 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
5413 **
5414 ** Form A is can be transformed into the equivalent form B as follows:
5415 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
5416 ** WHEN x=eN THEN rN ELSE y END
5417 **
5418 ** X (if it exists) is in pExpr->pLeft.
5419 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
5420 ** odd. The Y is also optional. If the number of elements in x.pList
5421 ** is even, then Y is omitted and the "otherwise" result is NULL.
5422 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
5423 **
5424 ** The result of the expression is the Ri for the first matching Ei,
5425 ** or if there is no matching Ei, the ELSE term Y, or if there is
5426 ** no ELSE term, NULL.
5427 */
5452 }
5460 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
5461 ** The value in regFree1 might get SCopy-ed into the file result.
5462 ** So make sure that the regFree1 register is not reused for other
5463 ** purposes and possibly overwritten. */
5465 }
5472 }
5480 }
5485 }
5490 }
5491 #ifndef SQLITE_OMIT_TRIGGER
5497 );
5502 }
5505 }
5515 }
5517 }
5518 #endif
5519 }
5523 }
5525 /*
5526 ** Generate code that will evaluate expression pExpr just one time
5527 ** per prepared statement execution.
5528 **
5529 ** If the expression uses functions (that might throw an exception) then
5530 ** guard them with an OP_Once opcode to ensure that the code is only executed
5531 ** once. If no functions are involved, then factor the code out and put it at
5532 ** the end of the prepared statement in the initialization section.
5533 **
5534 ** If regDest>0 then the result is always stored in that register and the
5535 ** result is not reusable. If regDest<0 then this routine is free to
5536 ** store the value wherever it wants. The register where the expression
5537 ** is stored is returned. When regDest<0, two identical expressions might
5538 ** code to the same register, if they do not contain function calls and hence
5539 ** are factored out into the initialization section at the end of the
5540 ** prepared statement.
5541 */
5546 ){
5557 ){
5559 }
5560 }
5561 }
5572 }
5583 }
5585 }
5587 }
5589 /*
5590 ** Generate code to evaluate an expression and store the results
5591 ** into a register. Return the register number where the results
5592 ** are stored.
5593 **
5594 ** If the register is a temporary register that can be deallocated,
5595 ** then write its number into *pReg. If the result register is not
5596 ** a temporary, then set *pReg to zero.
5597 **
5598 ** If pExpr is a constant, then this routine might generate this
5599 ** code to fill the register in the initialization section of the
5600 ** VDBE program, in order to factor it out of the evaluation loop.
5601 */
5609 ){
5620 }
5621 }
5623 }
5625 /*
5626 ** Generate code that will evaluate expression pExpr and store the
5627 ** results in register target. The results are guaranteed to appear
5628 ** in register target.
5629 */
5639 u8 op;
5644 ){
5648 }
5650 }
5651 }
5653 /*
5654 ** Make a transient copy of expression pExpr and then code it using
5655 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
5656 ** except that the input expression is guaranteed to be unchanged.
5657 */
5663 }
5665 /*
5666 ** Generate code that will evaluate expression pExpr and store the
5667 ** results in register target. The results are guaranteed to appear
5668 ** in register target. If the expression is constant, then this routine
5669 ** might choose to code the expression at initialization time.
5670 */
5676 }
5677 }
5679 /*
5680 ** Generate code that pushes the value of every element of the given
5681 ** expression list into a sequence of registers beginning at target.
5682 **
5683 ** Return the number of elements evaluated. The number returned will
5684 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
5685 ** is defined.
5686 **
5687 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
5688 ** filled using OP_SCopy. OP_Copy must be used instead.
5689 **
5690 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
5691 ** factored out into initialization code.
5692 **
5693 ** The SQLITE_ECEL_REF flag means that expressions in the list with
5694 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
5695 ** in registers at srcReg, and so the value can be copied from there.
5696 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
5697 ** are simply omitted rather than being copied from srcReg.
5698 */
5704 u8 flags /* SQLITE_ECEL_* flags */
5705 ){
5717 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
5719 i--;
5720 n--;
5722 #endif
5725 i--;
5726 n--;
5729 }
5732 ){
5743 ){
5747 }
5748 }
5749 }
5750 }
5752 }
5754 /*
5755 ** Generate code for a BETWEEN operator.
5756 **
5757 ** x BETWEEN y AND z
5758 **
5759 ** The above is equivalent to
5760 **
5761 ** x>=y AND x<=z
5762 **
5763 ** Code it as such, taking care to do the common subexpression
5764 ** elimination of x.
5765 **
5766 ** The xJumpIf parameter determines details:
5767 **
5768 ** NULL: Store the boolean result in reg[dest]
5769 ** sqlite3ExprIfTrue: Jump to dest if true
5770 ** sqlite3ExprIfFalse: Jump to dest if false
5771 **
5772 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
5773 */
5780 ){
5808 /* Mark the expression is being from the ON or USING clause of a join
5809 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5810 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5811 ** for clarity, but we are out of bits in the Expr.flags field so we
5812 ** have to reuse the EP_OuterON bit. Bummer. */
5815 }
5817 }
5820 /* Ensure adequate test coverage */
5830 }
5832 /*
5833 ** Generate code for a boolean expression such that a jump is made
5834 ** to the label "dest" if the expression is true but execution
5835 ** continues straight thru if the expression is false.
5836 **
5837 ** If the expression evaluates to NULL (neither true nor false), then
5838 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5839 **
5840 ** This code depends on the fact that certain token values (ex: TK_EQ)
5841 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5842 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5843 ** the make process cause these values to align. Assert()s in the code
5844 ** below verify that the numbers are aligned correctly.
5845 */
5875 }
5877 }
5882 }
5897 }
5899 }
5906 /* no break */ deliberate_fall_through
5932 }
5944 }
5949 }
5950 #ifndef SQLITE_OMIT_SUBQUERY
5958 }
5959 #endif
5961 default_expr:
5965 /* No-op */
5972 }
5974 }
5975 }
5978 }
5980 /*
5981 ** Generate code for a boolean expression such that a jump is made
5982 ** to the label "dest" if the expression is false but execution
5983 ** continues straight thru if the expression is true.
5984 **
5985 ** If the expression evaluates to NULL (neither true nor false) then
5986 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5987 ** is 0.
5988 */
6001 /* The value of pExpr->op and op are related as follows:
6002 **
6003 ** pExpr->op op
6004 ** --------- ----------
6005 ** TK_ISNULL OP_NotNull
6006 ** TK_NOTNULL OP_IsNull
6007 ** TK_NE OP_Eq
6008 ** TK_EQ OP_Ne
6009 ** TK_GT OP_Le
6010 ** TK_LE OP_Gt
6011 ** TK_GE OP_Lt
6012 ** TK_LT OP_Ge
6013 **
6014 ** For other values of pExpr->op, op is undefined and unused.
6015 ** The value of TK_ and OP_ constants are arranged such that we
6016 ** can compute the mapping above using the following expression.
6017 ** Assert()s verify that the computation is correct.
6018 */
6021 /* Verify correct alignment of TK_ and OP_ constants
6022 */
6049 }
6051 }
6056 }
6066 /* IS TRUE and IS NOT FALSE */
6071 /* IS FALSE and IS NOT TRUE */
6074 }
6076 }
6083 /* no break */ deliberate_fall_through
6109 }
6119 }
6124 }
6125 #ifndef SQLITE_OMIT_SUBQUERY
6133 }
6135 }
6136 #endif
6138 default_expr:
6142 /* no-op */
6149 }
6151 }
6152 }
6155 }
6157 /*
6158 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
6159 ** code generation, and that copy is deleted after code generation. This
6160 ** ensures that the original pExpr is unchanged.
6161 */
6167 }
6169 }
6171 /*
6172 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
6173 ** type of expression.
6174 **
6175 ** If pExpr is a simple SQL value - an integer, real, string, blob
6176 ** or NULL value - then the VDBE currently being prepared is configured
6177 ** to re-prepare each time a new value is bound to variable pVar.
6178 **
6179 ** Additionally, if pExpr is a simple SQL value and the value is the
6180 ** same as that currently bound to variable pVar, non-zero is returned.
6181 ** Otherwise, if the values are not the same or if pExpr is not a simple
6182 ** SQL value, zero is returned.
6183 */
6188 ){
6201 }
6203 }
6206 }
6209 }
6211 /*
6212 ** Do a deep comparison of two expression trees. Return 0 if the two
6213 ** expressions are completely identical. Return 1 if they differ only
6214 ** by a COLLATE operator at the top level. Return 2 if there are differences
6215 ** other than the top-level COLLATE operator.
6216 **
6217 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
6218 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
6219 **
6220 ** The pA side might be using TK_REGISTER. If that is the case and pB is
6221 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
6222 **
6223 ** Sometimes this routine will return 2 even if the two expressions
6224 ** really are equivalent. If we cannot prove that the expressions are
6225 ** identical, we return 2 just to be safe. So if this routine
6226 ** returns 2, then you do not really know for certain if the two
6227 ** expressions are the same. But if you get a 0 or 1 return, then you
6228 ** can be sure the expressions are the same. In the places where
6229 ** this routine is used, it does not hurt to get an extra 2 - that
6230 ** just might result in some slightly slower code. But returning
6231 ** an incorrect 0 or 1 could lead to a malfunction.
6232 **
6233 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
6234 ** pParse->pReprepare can be matched against literals in pB. The
6235 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
6236 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
6237 ** Argument pParse should normally be NULL. If it is not NULL and pA or
6238 ** pB causes a return value of 2.
6239 */
6244 int iTab
6245 ){
6246 u32 combinedFlags;
6249 }
6252 }
6257 }
6259 }
6263 }
6266 }
6269 ){
6270 /* fall through */
6273 }
6274 }
6280 #ifndef SQLITE_OMIT_WINDOWFUNC
6284 }
6288 }
6289 }
6290 #endif
6300 ){
6302 }
6303 }
6315 ){
6320 }
6321 }
6322 }
6324 }
6326 /*
6327 ** Compare two ExprList objects. Return 0 if they are identical, 1
6328 ** if they are certainly different, or 2 if it is not possible to
6329 ** determine if they are identical or not.
6330 **
6331 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
6332 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
6333 **
6334 ** This routine might return non-zero for equivalent ExprLists. The
6335 ** only consequence will be disabled optimizations. But this routine
6336 ** must never return 0 if the two ExprList objects are different, or
6337 ** a malfunction will result.
6338 **
6339 ** Two NULL pointers are considered to be the same. But a NULL pointer
6340 ** always differs from a non-NULL pointer.
6341 */
6353 }
6355 }
6357 /*
6358 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
6359 ** are ignored.
6360 */
6365 iTab);
6366 }
6368 /*
6369 ** Return non-zero if Expr p can only be true if pNN is not NULL.
6370 **
6371 ** Or if seenNot is true, return non-zero if Expr p can only be
6372 ** non-NULL if pNN is not NULL
6373 */
6380 ){
6385 }
6391 }
6401 ){
6403 }
6405 }
6419 /* no break */ deliberate_fall_through
6425 /* no break */ deliberate_fall_through
6426 }
6432 }
6437 }
6441 }
6442 }
6444 }
6446 /*
6447 ** Return true if we can prove the pE2 will always be true if pE1 is
6448 ** true. Return false if we cannot complete the proof or if pE2 might
6449 ** be false. Examples:
6450 **
6451 ** pE1: x==5 pE2: x==5 Result: true
6452 ** pE1: x>0 pE2: x==5 Result: false
6453 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
6454 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
6455 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
6456 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
6457 ** pE1: x IS ?2 pE2: x IS NOT NULL Result: false
6458 **
6459 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
6460 ** Expr.iTable<0 then assume a table number given by iTab.
6461 **
6462 ** If pParse is not NULL, then the values of bound variables in pE1 are
6463 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
6464 ** modified to record which bound variables are referenced. If pParse
6465 ** is NULL, then false will be returned if pE1 contains any bound variables.
6466 **
6467 ** When in doubt, return false. Returning true might give a performance
6468 ** improvement. Returning false might cause a performance reduction, but
6469 ** it will always give the correct answer and is hence always safe.
6470 */
6475 int iTab
6476 ){
6479 }
6483 ){
6485 }
6488 ){
6490 }
6492 }
6494 /* This is a helper function to impliesNotNullRow(). In this routine,
6495 ** set pWalker->eCode to one only if *both* of the input expressions
6496 ** separately have the implies-not-null-row property.
6497 */
6504 }
6505 }
6506 }
6508 /*
6509 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
6510 ** If the expression node requires that the table at pWalker->iCur
6511 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
6512 **
6513 ** pWalker->mWFlags is non-zero if this inquiry is being undertaking on
6514 ** behalf of a RIGHT JOIN (or FULL JOIN). That makes a difference when
6515 ** evaluating terms in the ON clause of an inner join.
6516 **
6517 ** This routine controls an optimization. False positives (setting
6518 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
6519 ** (never setting pWalker->eCode) is a harmless missed optimization.
6520 */
6526 /* If iCur is used in an inner-join ON clause to the left of a
6527 ** RIGHT JOIN, that does *not* mean that the table must be non-null.
6528 ** But it is difficult to check for that condition precisely.
6529 ** To keep things simple, any use of iCur from any inner-join is
6530 ** ignored while attempting to simplify a RIGHT JOIN. */
6532 }
6556 }
6561 /* Both sides of an AND or OR must separately imply non-null-row.
6562 ** Consider these cases:
6563 ** 1. NOT (x AND y)
6564 ** 2. x OR y
6565 ** If only one of x or y is non-null-row, then the overall expression
6566 ** can be true if the other arm is false (case 1) or true (case 2).
6567 */
6574 /* Beware of "x NOT IN ()" and "x NOT IN (SELECT 1 WHERE false)",
6575 ** both of which can be true. But apart from these cases, if
6576 ** the left-hand side of the IN is NULL then the IN itself will be
6577 ** NULL. */
6580 }
6584 /* In "x NOT BETWEEN y AND z" either x must be non-null-row or else
6585 ** both y and z must be non-null row */
6593 /* Virtual tables are allowed to use constraints like x=NULL. So
6594 ** a term of the form x=y does not prove that y is not null if x
6595 ** is the column of a virtual table */
6610 /* The y.pTab=0 assignment in wherecode.c always happens after the
6611 ** impliesNotNullRow() test */
6620 ){
6622 }
6623 /* no break */ deliberate_fall_through
6624 }
6627 }
6628 }
6630 /*
6631 ** Return true (non-zero) if expression p can only be true if at least
6632 ** one column of table iTab is non-null. In other words, return true
6633 ** if expression p will always be NULL or false if every column of iTab
6634 ** is NULL.
6635 **
6636 ** False negatives are acceptable. In other words, it is ok to return
6637 ** zero even if expression p will never be true of every column of iTab
6638 ** is NULL. A false negative is merely a missed optimization opportunity.
6639 **
6640 ** False positives are not allowed, however. A false positive may result
6641 ** in an incorrect answer.
6642 **
6643 ** Terms of p that are marked with EP_OuterON (and hence that come from
6644 ** the ON or USING clauses of OUTER JOINS) are excluded from the analysis.
6645 **
6646 ** This routine is used to check if a LEFT JOIN can be converted into
6647 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
6648 ** clause requires that some column of the right table of the LEFT JOIN
6649 ** be non-NULL, then the LEFT JOIN can be safely converted into an
6650 ** ordinary join.
6651 */
6653 Walker w;
6662 }
6663 }
6672 }
6674 /*
6675 ** An instance of the following structure is used by the tree walker
6676 ** to determine if an expression can be evaluated by reference to the
6677 ** index only, without having to do a search for the corresponding
6678 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
6679 ** is the cursor for the table.
6680 */
6684 };
6686 /*
6687 ** Check to see if there are references to columns in table
6688 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
6689 ** pWalker->u.pIdxCover->pIdx.
6690 */
6695 ){
6698 }
6700 }
6702 /*
6703 ** Determine if an index pIdx on table with cursor iCur contains will
6704 ** the expression pExpr. Return true if the index does cover the
6705 ** expression and false if the pExpr expression references table columns
6706 ** that are not found in the index pIdx.
6707 **
6708 ** An index covering an expression means that the expression can be
6709 ** evaluated using only the index and without having to lookup the
6710 ** corresponding table entry.
6711 */
6716 ){
6717 Walker w;
6726 }
6729 /* Structure used to pass information throughout the Walker in order to
6730 ** implement sqlite3ReferencesSrcList().
6731 */
6737 };
6739 /*
6740 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
6741 **
6742 ** When entering a new subquery on the pExpr argument, add all FROM clause
6743 ** entries for that subquery to the exclude list.
6744 **
6745 ** When leaving the subquery, remove those entries from the exclude list.
6746 */
6761 }
6764 }
6766 }
6773 }
6774 }
6776 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
6777 **
6778 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
6779 ** of the tables shown in RefSrcList.pRef.
6780 **
6781 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
6782 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
6783 */
6787 ){
6796 }
6797 }
6801 }
6802 }
6804 }
6806 /*
6807 ** Check to see if pExpr references any tables in pSrcList.
6808 ** Possible return values:
6809 **
6810 ** 1 pExpr does references a table in pSrcList.
6811 **
6812 ** 0 pExpr references some table that is not defined in either
6813 ** pSrcList or in subqueries of pExpr itself.
6814 **
6815 ** -1 pExpr only references no tables at all, or it only
6816 ** references tables defined in subqueries of pExpr itself.
6817 **
6818 ** As currently used, pExpr is always an aggregate function call. That
6819 ** fact is exploited for efficiency.
6820 */
6822 Walker w;
6841 }
6842 #ifndef SQLITE_OMIT_WINDOWFUNC
6845 }
6846 #endif
6854 }
6855 }
6857 /*
6858 ** This is a Walker expression node callback.
6859 **
6860 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6861 ** object that is referenced does not refer directly to the Expr. If
6862 ** it does, make a copy. This is done because the pExpr argument is
6863 ** subject to change.
6864 **
6865 ** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete()
6866 ** which builds on the sqlite3ParserAddCleanup() mechanism.
6867 */
6871 ){
6880 ){
6884 }
6885 }
6890 ){
6894 }
6895 }
6896 }
6897 }
6899 }
6901 /*
6902 ** Initialize a Walker object so that will persist AggInfo entries referenced
6903 ** by the tree that is walked.
6904 */
6910 }
6912 /*
6913 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6914 ** the new element. Return a negative number if malloc fails.
6915 */
6919 db,
6923 &i
6924 );
6926 }
6928 /*
6929 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6930 ** the new element. Return a negative number if malloc fails.
6931 */
6935 db,
6939 &i
6940 );
6942 }
6944 /*
6945 ** Search the AggInfo object for an aCol[] entry that has iTable and iColumn.
6946 ** Return the index in aCol[] of the entry that describes that column.
6947 **
6948 ** If no prior entry is found, create a new one and return -1. The
6949 ** new column will have an index of pAggInfo->nColumn-1.
6950 */
6955 ){
6966 ){
6968 }
6969 }
6972 /* OOM on resize */
6975 }
6993 ){
6996 }
6997 }
6998 }
7001 }
7002 fix_up_expr:
7008 }
7010 }
7012 /*
7013 ** This is the xExprCallback for a tree walker. It is used to
7014 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
7015 ** for additional information.
7016 */
7029 Expr tmp;
7037 }
7042 }
7047 /* If we reach this point, it means that expression pExpr can be
7048 ** translated into a reference to an index column as described by
7049 ** pIEpr.
7050 */
7063 }
7070 /* Check to see if the column is in one of the tables in the FROM
7071 ** clause of the aggregate query */
7081 }
7083 }
7088 ){
7089 /* Check to see if pExpr is a duplicate of another aggregate
7090 ** function that is already in the pAggInfo structure
7091 */
7097 }
7098 }
7100 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
7101 */
7116 ){
7117 /* The NEEDCOLL test above causes any ORDER BY clause on
7118 ** aggregate min() or max() to be ignored. */
7131 ){
7136 }
7141 }
7146 }
7147 }
7148 }
7149 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
7150 */
7158 }
7159 }
7160 }
7162 }
7164 /*
7165 ** Analyze the pExpr expression looking for aggregate functions and
7166 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
7167 ** points to. Additional entries are made on the AggInfo object as
7168 ** necessary.
7169 **
7170 ** This routine should only be called after the expression has been
7171 ** analyzed by sqlite3ResolveExprNames().
7172 */
7174 Walker w;
7183 }
7185 /*
7186 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
7187 ** expression list. Return the number of errors.
7188 **
7189 ** If an error is found, the analysis is cut short.
7190 */
7197 }
7198 }
7199 }
7201 /*
7202 ** Allocate a single new register for use to hold some intermediate result.
7203 */
7207 }
7209 }
7211 /*
7212 ** Deallocate a register, making available for reuse for some other
7213 ** purpose.
7214 */
7220 }
7221 }
7222 }
7224 /*
7225 ** Allocate or deallocate a block of nReg consecutive registers.
7226 */
7238 }
7240 }
7245 }
7250 }
7251 }
7253 /*
7254 ** Mark all temporary registers as being unavailable for reuse.
7255 **
7256 ** Always invoke this procedure after coding a subroutine or co-routine
7257 ** that might be invoked from other parts of the code, to ensure that
7258 ** the sub/co-routine does not use registers in common with the code that
7259 ** invokes the sub/co-routine.
7260 */
7264 }
7266 /*
7267 ** Make sure sufficient registers have been allocated so that
7268 ** iReg is a valid register number.
7269 */
7272 }
7274 #if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG)
7275 /*
7276 ** Return the latest reusable register in the set of all registers.
7277 ** The value returned is no less than iMin. If any register iMin or
7278 ** greater is in permanent use, then return one more than that last
7279 ** permanent register.
7280 */
7288 }
7289 }
7290 }
7294 }
7297 /*
7298 ** Validate that no temporary register falls within the range of
7299 ** iFirst..iLast, inclusive. This routine is only call from within assert()
7300 ** statements.
7301 */
7302 #ifdef SQLITE_DEBUG
7308 ){
7310 }
7314 }
7315 }
7322 }
7323 }
7325 }