| blob | 27f89d659dd9380c9e7b98643642efbd6c4bf18d |
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 }
89 }
91 }
93 /*
94 ** Make a guess at all the possible datatypes of the result that could
95 ** be returned by an expression. Return a bitmask indicating the answer:
96 **
97 ** 0x01 Numeric
98 ** 0x02 Text
99 ** 0x04 Blob
100 **
101 ** If the expression must return NULL, then 0x00 is returned.
102 */
111 }
115 }
118 }
121 }
124 }
129 }
140 }
149 }
152 }
154 }
157 }
161 }
163 /*
164 ** Set the collating sequence for expression pExpr to be the collating
165 ** sequence named by pToken. Return a pointer to a new Expr node that
166 ** implements the COLLATE operator.
167 **
168 ** If a memory allocation error occurs, that fact is recorded in pParse->db
169 ** and the pExpr parameter is returned unchanged.
170 */
176 ){
183 }
184 }
186 }
191 ){
192 Token s;
196 }
198 /*
199 ** Skip over any TK_COLLATE operators.
200 */
205 }
207 }
209 /*
210 ** Skip over any TK_COLLATE operators and/or any unlikely()
211 ** or likelihood() or likely() functions at the root of an
212 ** expression.
213 */
225 }
226 }
228 }
230 /*
231 ** Return the collation sequence for the expression pExpr. If
232 ** there is no defined collating sequence, return NULL.
233 **
234 ** See also: sqlite3ExprNNCollSeq()
235 **
236 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
237 ** default collation if pExpr has no defined collation.
238 **
239 ** The collating sequence might be determined by a COLLATE operator
240 ** or by the presence of a column with a defined collating sequence.
241 ** COLLATE operators take first precedence. Left operands take
242 ** precedence over right operands.
243 */
253 ){
260 }
262 }
266 }
271 }
276 }
282 /* The Expr.x union is never used at the same time as Expr.pRight */
290 }
291 }
292 }
294 }
297 }
298 }
301 }
303 }
305 /*
306 ** Return the collation sequence for the expression pExpr. If
307 ** there is no defined collating sequence, return a pointer to the
308 ** default collation sequence.
309 **
310 ** See also: sqlite3ExprCollSeq()
311 **
312 ** The sqlite3ExprCollSeq() routine works the same except that it
313 ** returns NULL if there is no defined collation.
314 */
320 }
322 /*
323 ** Return TRUE if the two expressions have equivalent collating sequences.
324 */
329 }
331 /*
332 ** pExpr is an operand of a comparison operator. aff2 is the
333 ** type affinity of the other operand. This routine returns the
334 ** type affinity that should be used for the comparison operator.
335 */
339 /* Both sides of the comparison are columns. If one has numeric
340 ** affinity, use that. Otherwise use no affinity.
341 */
346 }
348 /* One side is a column, the other is not. Use the columns affinity. */
351 }
352 }
354 /*
355 ** pExpr is a comparison operator. Return the type affinity that should
356 ** be applied to both operands prior to doing the comparison.
357 */
371 }
373 }
375 /*
376 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
377 ** idx_affinity is the affinity of an indexed column. Return true
378 ** if the index with affinity idx_affinity may be used to implement
379 ** the comparison in pExpr.
380 */
385 }
388 }
390 }
392 /*
393 ** Return the P5 value that should be used for a binary comparison
394 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
395 */
400 ){
404 }
406 /*
407 ** Return a pointer to the collation sequence that should be used by
408 ** a binary comparison operator comparing pLeft and pRight.
409 **
410 ** If the left hand expression has a collating sequence type, then it is
411 ** used. Otherwise the collation sequence for the right hand expression
412 ** is used, or the default (BINARY) if neither expression has a collating
413 ** type.
414 **
415 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
416 ** it is not considered.
417 */
422 ){
433 }
434 }
436 }
438 /* Expression p is a comparison operator. Return a collation sequence
439 ** appropriate for the comparison operator.
440 **
441 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
442 ** However, if the OP_Commuted flag is set, then the order of the operands
443 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
444 ** correct collating sequence is found.
445 */
451 }
452 }
454 /*
455 ** Generate code for a comparison operator.
456 */
466 ){
476 }
482 }
484 /*
485 ** Return true if expression pExpr is a vector, or false otherwise.
486 **
487 ** A vector is defined as any expression that results in two or more
488 ** columns of result. Every TK_VECTOR node is an vector because the
489 ** parser will not generate a TK_VECTOR with fewer than two entries.
490 ** But a TK_SELECT might be either a vector or a scalar. It is only
491 ** considered a vector if it has two or more result columns.
492 */
495 }
497 /*
498 ** If the expression passed as the only argument is of type TK_VECTOR
499 ** return the number of expressions in the vector. Or, if the expression
500 ** is a sub-select, return the number of columns in the sub-select. For
501 ** any other type of expression, return 1.
502 */
514 }
515 }
517 /*
518 ** Return a pointer to a subexpression of pVector that is the i-th
519 ** column of the vector (numbered starting with 0). The caller must
520 ** ensure that i is within range.
521 **
522 ** If pVector is really a scalar (and "scalar" here includes subqueries
523 ** that return a single column!) then return pVector unmodified.
524 **
525 ** pVector retains ownership of the returned subexpression.
526 **
527 ** If the vector is a (SELECT ...) then the expression returned is
528 ** just the expression for the i-th term of the result set, and may
529 ** not be ready for evaluation because the table cursor has not yet
530 ** been positioned.
531 */
542 }
543 }
545 }
547 /*
548 ** Compute and return a new Expr object which when passed to
549 ** sqlite3ExprCode() will generate all necessary code to compute
550 ** the iField-th column of the vector expression pVector.
551 **
552 ** It is ok for pVector to be a scalar (as long as iField==0).
553 ** In that case, this routine works like sqlite3ExprDup().
554 **
555 ** The caller owns the returned Expr object and is responsible for
556 ** ensuring that the returned value eventually gets freed.
557 **
558 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
559 ** then the returned object will reference pVector and so pVector must remain
560 ** valid for the life of the returned object. If pVector is a TK_VECTOR
561 ** or a scalar expression, then it can be deleted as soon as this routine
562 ** returns.
563 **
564 ** A trick to cause a TK_SELECT pVector to be deleted together with
565 ** the returned Expr object is to attach the pVector to the pRight field
566 ** of the returned TK_SELECT_COLUMN Expr object.
567 */
573 ){
577 /* The TK_SELECT_COLUMN Expr node:
578 **
579 ** pLeft: pVector containing TK_SELECT. Not deleted.
580 ** pRight: not used. But recursively deleted.
581 ** iColumn: Index of a column in pVector
582 ** iTable: 0 or the number of columns on the LHS of an assignment
583 ** pLeft->iTable: First in an array of register holding result, or 0
584 ** if the result is not yet computed.
585 **
586 ** sqlite3ExprDelete() specifically skips the recursive delete of
587 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
588 ** can be attached to pRight to cause this node to take ownership of
589 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
590 ** with the same pLeft pointer to the pVector, but only one of them
591 ** will own the pVector.
592 */
599 }
607 /* This must be a vector UPDATE inside a trigger */
610 }
611 }
613 }
615 }
617 /*
618 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
619 ** it. Return the register in which the result is stored (or, if the
620 ** sub-select returns more than one column, the first in an array
621 ** of registers in which the result is stored).
622 **
623 ** If pExpr is not a TK_SELECT expression, return 0.
624 */
627 #ifndef SQLITE_OMIT_SUBQUERY
630 }
631 #endif
633 }
635 /*
636 ** Argument pVector points to a vector expression - either a TK_VECTOR
637 ** or TK_SELECT that returns more than one column. This function returns
638 ** the register number of a register that contains the value of
639 ** element iField of the vector.
640 **
641 ** If pVector is a TK_SELECT expression, then code for it must have
642 ** already been generated using the exprCodeSubselect() routine. In this
643 ** case parameter regSelect should be the first in an array of registers
644 ** containing the results of the sub-select.
645 **
646 ** If pVector is of type TK_VECTOR, then code for the requested field
647 ** is generated. In this case (*pRegFree) may be set to the number of
648 ** a temporary register to be freed by the caller before returning.
649 **
650 ** Before returning, output parameter (*ppExpr) is set to point to the
651 ** Expr object corresponding to element iElem of the vector.
652 */
660 ){
666 }
671 }
676 }
678 }
680 /*
681 ** Expression pExpr is a comparison between two vector values. Compute
682 ** the result of the comparison (1, 0, or NULL) and write that
683 ** result into register dest.
684 **
685 ** The caller must satisfy the following preconditions:
686 **
687 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
688 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
689 ** otherwise: op==pExpr->op and p5==0
690 */
696 u8 p5 /* SQLITE_NULLEQ or zero */
697 ){
715 }
720 );
756 }
761 }
764 }
771 }
772 }
777 }
778 }
780 #if SQLITE_MAX_EXPR_DEPTH>0
781 /*
782 ** Check that argument nHeight is less than or equal to the maximum
783 ** expression depth allowed. If it is not, leave an error message in
784 ** pParse.
785 */
792 );
794 }
796 }
798 /* The following three functions, heightOfExpr(), heightOfExprList()
799 ** and heightOfSelect(), are used to determine the maximum height
800 ** of any expression tree referenced by the structure passed as the
801 ** first argument.
802 **
803 ** If this maximum height is greater than the current value pointed
804 ** to by pnHeight, the second parameter, then set *pnHeight to that
805 ** value.
806 */
811 }
812 }
813 }
819 }
820 }
821 }
831 }
832 }
834 /*
835 ** Set the Expr.nHeight variable in the structure passed as an
836 ** argument. An expression with no children, Expr.pList or
837 ** Expr.pSelect member has a height of 1. Any other expression
838 ** has a height equal to the maximum height of any other
839 ** referenced Expr plus one.
840 **
841 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
842 ** if appropriate.
843 */
848 }
854 }
856 }
858 /*
859 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
860 ** the height is greater than the maximum allowed expression depth,
861 ** leave an error in pParse.
862 **
863 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
864 ** Expr.flags.
865 */
870 }
872 /*
873 ** Return the maximum height of any expression tree referenced
874 ** by the select statement passed as an argument.
875 */
880 }
882 /*
883 ** Propagate all EP_Propagate flags from the Expr.x.pList into
884 ** Expr.flags.
885 */
890 }
891 }
892 #define exprSetHeight(y)
895 /*
896 ** Set the error offset for an Expr node, if possible.
897 */
902 }
904 /*
905 ** This routine is the core allocator for Expr nodes.
906 **
907 ** Construct a new expression node and return a pointer to it. Memory
908 ** for this node and for the pToken argument is a single allocation
909 ** obtained from sqlite3DbMalloc(). The calling function
910 ** is responsible for making sure the node eventually gets freed.
911 **
912 ** If dequote is true, then the token (if it exists) is dequoted.
913 ** If dequote is false, no dequoting is performed. The deQuote
914 ** parameter is ignored if pToken is NULL or if the token does not
915 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
916 ** then the EP_DblQuoted flag is set on the expression node.
917 **
918 ** Special case (tag-20240227-a): If op==TK_INTEGER and pToken points to
919 ** a string that can be translated into a 32-bit integer, then the token is
920 ** not stored in u.zToken. Instead, the integer values is written
921 ** into u.iValue and the EP_IntValue flag is set. No extra storage
922 ** is allocated to hold the integer text and the dequote flag is ignored.
923 ** See also tag-20240227-b.
924 */
930 ){
941 }
942 }
959 }
960 }
961 }
962 #if SQLITE_MAX_EXPR_DEPTH>0
964 #endif
965 }
967 }
969 /*
970 ** Allocate a new expression node from a zero-terminated token that has
971 ** already been dequoted.
972 */
977 ){
978 Token x;
982 }
984 /*
985 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
986 **
987 ** If pRoot==NULL that means that a memory allocation error has occurred.
988 ** In that case, delete the subtrees pLeft and pRight.
989 */
994 Expr *pRight
995 ){
1006 #if SQLITE_MAX_EXPR_DEPTH>0
1010 #endif
1011 }
1015 #if SQLITE_MAX_EXPR_DEPTH>0
1018 }
1019 #endif
1020 }
1021 }
1022 }
1024 /*
1025 ** Allocate an Expr node which joins as many as two subtrees.
1026 **
1027 ** One or both of the subtrees can be NULL. Return a pointer to the new
1028 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
1029 ** free the subtrees and return NULL.
1030 */
1036 ){
1048 }
1050 }
1052 /*
1053 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
1054 ** do a memory allocation failure) then delete the pSelect object.
1055 */
1064 }
1065 }
1067 /*
1068 ** Expression list pEList is a list of vector values. This function
1069 ** converts the contents of pEList to a VALUES(...) Select statement
1070 ** returning 1 row for each element of the list. For example, the
1071 ** expression list:
1072 **
1073 ** ( (1,2), (3,4) (5,6) )
1074 **
1075 ** is translated to the equivalent of:
1076 **
1077 ** VALUES(1,2), (3,4), (5,6)
1078 **
1079 ** Each of the vector values in pEList must contain exactly nElem terms.
1080 ** If a list element that is not a vector or does not contain nElem terms,
1081 ** an error message is left in pParse.
1082 **
1083 ** This is used as part of processing IN(...) expressions with a list
1084 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
1085 */
1099 }
1103 );
1105 }
1113 }
1115 }
1116 }
1120 }
1123 }
1125 /*
1126 ** Join two expressions using an AND operator. If either expression is
1127 ** NULL, then just return the other expression.
1128 **
1129 ** If one side or the other of the AND is known to be false, and neither side
1130 ** is part of an ON clause, then instead of returning an AND expression,
1131 ** just return a constant expression with a value of false.
1132 */
1142 && !IN_RENAME_OBJECT
1143 ){
1149 }
1150 }
1151 }
1153 /*
1154 ** Construct a new expression node for a function with multiple
1155 ** arguments.
1156 */
1162 ){
1170 }
1176 ){
1178 }
1185 }
1187 /*
1188 ** Report an error when attempting to use an ORDER BY clause within
1189 ** the arguments of a non-aggregate function.
1190 */
1194 );
1195 }
1197 /*
1198 ** Attach an ORDER BY clause to a function call.
1199 **
1200 ** functionname( arguments ORDER BY sortlist )
1201 ** \_____________________/ \______/
1202 ** pExpr pOrderBy
1203 **
1204 ** The ORDER BY clause is inserted into a new Expr node of type TK_ORDER
1205 ** and added to the Expr.pLeft field of the parent TK_FUNCTION node.
1206 */
1211 ){
1217 }
1222 }
1227 /* Ignore ORDER BY on zero-argument aggregates */
1230 }
1235 }
1241 }
1246 }
1248 /*
1249 ** Check to see if a function is usable according to current access
1250 ** rules:
1251 **
1252 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1253 **
1254 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1255 ** top-level SQL
1256 **
1257 ** If the function is not usable, create an error.
1258 */
1263 ){
1269 ){
1270 /* Functions prohibited in triggers and views if:
1271 ** (1) tagged with SQLITE_DIRECTONLY
1272 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1273 ** is tagged with SQLITE_FUNC_UNSAFE) and
1274 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1275 ** that the schema is possibly tainted).
1276 */
1278 }
1279 }
1280 }
1282 /*
1283 ** Assign a variable number to an expression that encodes a wildcard
1284 ** in the original SQL statement.
1285 **
1286 ** Wildcards consisting of a single "?" are assigned the next sequential
1287 ** variable number.
1288 **
1289 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1290 ** sure "nnn" is not too big to avoid a denial of service attack when
1291 ** the SQL statement comes from an external source.
1292 **
1293 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1294 ** as the previous instance of the same wildcard. Or if this is the first
1295 ** instance of the wildcard, the next sequential variable number is
1296 ** assigned.
1297 */
1301 ynVar x;
1310 /* Wildcard of the form "?". Assign the next variable number */
1316 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1317 ** use it as the variable number */
1318 i64 i;
1325 }
1335 }
1342 }
1344 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1345 ** number as the prior appearance of the same name, or if the name
1346 ** has never appeared before, reuse the same variable number
1347 */
1352 }
1353 }
1356 }
1357 }
1362 }
1363 }
1365 /*
1366 ** Recursively delete an expression tree.
1367 */
1371 exprDeleteRestart:
1376 #ifdef SQLITE_DEBUG
1382 }
1383 #endif
1385 /* The Expr.x union is never used at the same time as Expr.pRight */
1395 #ifndef SQLITE_OMIT_WINDOWFUNC
1398 }
1399 #endif
1400 }
1405 ){
1406 /* Avoid unnecessary recursion on unary operators */
1412 }
1413 }
1414 }
1417 }
1418 }
1421 }
1424 }
1426 /*
1427 ** Clear both elements of an OnOrUsing object
1428 */
1431 /* Nothing to clear */
1436 }
1437 }
1439 /*
1440 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1441 ** This is similar to sqlite3ExprDelete() except that the delete is
1442 ** deferred until the pParse is deleted.
1443 **
1444 ** The pExpr might be deleted immediately on an OOM error.
1445 **
1446 ** Return 0 if the delete was successfully deferred. Return non-zero
1447 ** if the delete happened immediately because of an OOM.
1448 */
1451 }
1453 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1454 ** expression.
1455 */
1460 }
1462 }
1463 }
1465 /*
1466 ** Return the number of bytes allocated for the expression structure
1467 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1468 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1469 */
1474 }
1476 /*
1477 ** The dupedExpr*Size() routines each return the number of bytes required
1478 ** to store a copy of an expression or expression tree. They differ in
1479 ** how much of the tree is measured.
1480 **
1481 ** dupedExprStructSize() Size of only the Expr structure
1482 ** dupedExprNodeSize() Size of Expr + space for token
1483 ** dupedExprSize() Expr + token + subtree components
1484 **
1485 ***************************************************************************
1486 **
1487 ** The dupedExprStructSize() function returns two values OR-ed together:
1488 ** (1) the space required for a copy of the Expr structure only and
1489 ** (2) the EP_xxx flags that indicate what the structure size should be.
1490 ** The return values is always one of:
1491 **
1492 ** EXPR_FULLSIZE
1493 ** EXPR_REDUCEDSIZE | EP_Reduced
1494 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1495 **
1496 ** The size of the structure can be found by masking the return value
1497 ** of this routine with 0xfff. The flags can be found by masking the
1498 ** return value with EP_Reduced|EP_TokenOnly.
1499 **
1500 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1501 ** (unreduced) Expr objects as they or originally constructed by the parser.
1502 ** During expression analysis, extra information is computed and moved into
1503 ** later parts of the Expr object and that extra information might get chopped
1504 ** off if the expression is reduced. Note also that it does not work to
1505 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1506 ** to reduce a pristine expression tree from the parser. The implementation
1507 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1508 ** to enforce this constraint.
1509 */
1526 }
1527 }
1529 }
1531 /*
1532 ** This function returns the space in bytes required to store the copy
1533 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1534 ** string is defined.)
1535 */
1540 }
1542 }
1544 /*
1545 ** Return the number of bytes required to create a duplicate of the
1546 ** expression passed as the first argument.
1547 **
1548 ** The value returned includes space to create a copy of the Expr struct
1549 ** itself and the buffer referred to by Expr.u.zToken, if any.
1550 **
1551 ** The return value includes space to duplicate all Expr nodes in the
1552 ** tree formed by Expr.pLeft and Expr.pRight, but not any other
1553 ** substructure such as Expr.x.pList, Expr.x.pSelect, and Expr.y.pWin.
1554 */
1563 }
1565 /*
1566 ** An EdupBuf is a memory allocation used to stored multiple Expr objects
1567 ** together with their Expr.zToken content. This is used to help implement
1568 ** compression while doing sqlite3ExprDup(). The top-level Expr does the
1569 ** allocation for itself and many of its decendents, then passes an instance
1570 ** of the structure down into exprDup() so that they decendents can have
1571 ** access to that memory.
1572 */
1576 #ifdef SQLITE_DEBUG
1578 #endif
1579 };
1581 /*
1582 ** This function is similar to sqlite3ExprDup(), except that if pEdupBuf
1583 ** is not NULL then it points to memory that can be used to store a copy
1584 ** of the input Expr p together with its p->u.zToken (if any). pEdupBuf
1585 ** is updated with the new buffer tail prior to returning.
1586 */
1592 ){
1603 /* Figure out where to write the new Expr structure. */
1606 #ifdef SQLITE_DEBUG
1608 #endif
1622 }
1625 #ifdef SQLITE_DEBUG
1627 #endif
1630 }
1635 /* Set nNewSize to the size allocated for the structure pointed to
1636 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1637 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1638 ** by the copy of the p->u.zToken string (if any).
1639 */
1647 }
1648 }
1660 }
1662 }
1664 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1671 }
1673 /* Copy the p->u.zToken string, if any. */
1679 }
1684 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1690 }
1692 #ifndef SQLITE_OMIT_WINDOWFUNC
1696 }
1699 /* Fill in pNew->pLeft and pNew->pRight. */
1709 }
1720 }
1722 }
1723 }
1724 }
1728 }
1730 /*
1731 ** Create and return a deep copy of the object passed as the second
1732 ** argument. If an OOM condition is encountered, NULL is returned
1733 ** and the db->mallocFailed flag set.
1734 */
1735 #ifndef SQLITE_OMIT_CTE
1749 }
1750 }
1751 }
1753 }
1754 #else
1755 # define sqlite3WithDup(x,y) 0
1756 #endif
1758 #ifndef SQLITE_OMIT_WINDOWFUNC
1759 /*
1760 ** The gatherSelectWindows() procedure and its helper routine
1761 ** gatherSelectWindowsCallback() are used to scan all the expressions
1762 ** an a newly duplicated SELECT statement and gather all of the Window
1763 ** objects found there, assembling them onto the linked list at Select->pWin.
1764 */
1773 }
1775 }
1778 }
1780 Walker w;
1787 }
1788 #endif
1791 /*
1792 ** The following group of routines make deep copies of expressions,
1793 ** expression lists, ID lists, and select statements. The copies can
1794 ** be deleted (by being passed to their respective ...Delete() routines)
1795 ** without effecting the originals.
1796 **
1797 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1798 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1799 ** by subsequent calls to sqlite*ListAppend() routines.
1800 **
1801 ** Any tables that the SrcList might point to are not duplicated.
1802 **
1803 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1804 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1805 ** truncated version of the usual Expr structure that will be stored as
1806 ** part of the in-memory representation of the database schema.
1807 */
1811 }
1834 ){
1844 }
1846 }
1847 }
1852 }
1854 }
1856 /*
1857 ** If cursors, triggers, views and subqueries are all omitted from
1858 ** the build, then none of the following routines, except for
1859 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1860 ** called with a NULL argument.
1861 */
1862 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1863 || !defined(SQLITE_OMIT_SUBQUERY)
1894 }
1898 }
1902 }
1909 }
1911 }
1913 }
1929 }
1931 }
1959 #ifndef SQLITE_OMIT_WINDOWFUNC
1963 #endif
1966 /* Any prior OOM might have left the Select object incomplete.
1967 ** Delete the whole thing rather than allow an incomplete Select
1968 ** to be used by the code generator. */
1972 }
1976 }
1979 }
1980 #else
1984 }
1985 #endif
1988 /*
1989 ** Add a new element to the end of an expression list. If pList is
1990 ** initially NULL, then create a new expression list.
1991 **
1992 ** The pList argument must be either NULL or a pointer to an ExprList
1993 ** obtained from a prior call to sqlite3ExprListAppend().
1994 **
1995 ** If a memory allocation error occurs, the entire list is freed and
1996 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1997 ** that the new entry was successfully appended.
1998 */
2003 ){
2011 }
2018 }
2023 ){
2035 }
2040 }
2045 ){
2049 }
2052 }
2057 }
2059 /*
2060 ** pColumns and pExpr form a vector assignment which is part of the SET
2061 ** clause of an UPDATE statement. Like this:
2062 **
2063 ** (a,b,c) = (expr1,expr2,expr3)
2064 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
2065 **
2066 ** For each term of the vector assignment, append new entries to the
2067 ** expression list pList. In the case of a subquery on the RHS, append
2068 ** TK_SELECT_COLUMN expressions.
2069 */
2075 ){
2080 /* pColumns can only be NULL due to an OOM but an OOM will cause an
2081 ** exit prior to this routine being invoked */
2085 /* If the RHS is a vector, then we can immediately check to see that
2086 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
2087 ** wildcards ("*") in the result set of the SELECT must be expanded before
2088 ** we can do the size check, so defer the size check until code generation.
2089 */
2094 }
2105 }
2106 }
2113 /* Store the SELECT statement in pRight so it will be deleted when
2114 ** sqlite3ExprListDelete() is called */
2118 /* Remember the size of the LHS in iTable so that we can check that
2119 ** the RHS and LHS sizes match during code generation. */
2121 }
2123 vector_append_error:
2127 }
2129 /*
2130 ** Set the sort order for the last element on the given ExprList.
2131 */
2141 );
2145 );
2151 }
2158 }
2159 }
2160 }
2162 /*
2163 ** Set the ExprList.a[].zEName element of the most recently added item
2164 ** on the expression list.
2165 **
2166 ** pList might be NULL following an OOM error. But pName should never be
2167 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2168 ** is set.
2169 */
2175 ){
2186 /* If dequote==0, then pName->z does not point to part of a DDL
2187 ** statement handled by the parser. And so no token need be added
2188 ** to the token-map. */
2192 }
2193 }
2194 }
2195 }
2197 /*
2198 ** Set the ExprList.a[].zSpan element of the most recently added item
2199 ** on the expression list.
2200 **
2201 ** pList might be NULL following an OOM error. But pSpan should never be
2202 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2203 ** is set.
2204 */
2210 ){
2219 }
2220 }
2221 }
2223 /*
2224 ** If the expression list pEList contains more than iLimit elements,
2225 ** leave an error message in pParse.
2226 */
2231 ){
2237 }
2238 }
2240 /*
2241 ** Delete an entire expression list.
2242 */
2251 pItem++;
2254 }
2257 }
2260 }
2262 /*
2263 ** Return the bitwise-OR of all Expr.flags fields in the given
2264 ** ExprList.
2265 */
2274 }
2276 }
2278 /*
2279 ** This is a SELECT-node callback for the expression walker that
2280 ** always "fails". By "fail" in this case, we mean set
2281 ** pWalker->eCode to zero and abort.
2282 **
2283 ** This callback is used by multiple expression walkers.
2284 */
2289 }
2291 /*
2292 ** Check the input string to see if it is "true" or "false" (in any case).
2293 **
2294 ** If the string is.... Return
2295 ** "true" EP_IsTrue
2296 ** "false" EP_IsFalse
2297 ** anything else 0
2298 */
2303 }
2306 /*
2307 ** If the input expression is an ID with the name "true" or "false"
2308 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2309 ** the conversion happened, and zero if the expression is unaltered.
2310 */
2312 u32 v;
2316 ){
2320 }
2322 }
2324 /*
2325 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2326 ** and 0 if it is FALSE.
2327 */
2335 }
2337 /*
2338 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2339 ** terms that are always true or false. Return the simplified expression.
2340 ** Or return the original expression if no simplification is possible.
2341 **
2342 ** Examples:
2343 **
2344 ** (x<10) AND true => (x<10)
2345 ** (x<10) AND false => false
2346 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2347 ** (x<10) AND (y=22 OR true) => (x<10)
2348 ** (y=22) OR true => true
2349 */
2359 }
2360 }
2362 }
2364 /*
2365 ** pExpr is a TK_FUNCTION node. Try to determine whether or not the
2366 ** function is a constant function. A function is constant if all of
2367 ** the following are true:
2368 **
2369 ** (1) It is a scalar function (not an aggregate or window function)
2370 ** (2) It has either the SQLITE_FUNC_CONSTANT or SQLITE_FUNC_SLOCHNG
2371 ** property.
2372 ** (3) All of its arguments are constants
2373 **
2374 ** This routine sets pWalker->eCode to 0 if pExpr is not a constant.
2375 ** It makes no changes to pWalker->eCode if pExpr is constant. In
2376 ** every case, it returns WRC_Abort.
2377 **
2378 ** Called as a service subroutine from exprNodeIsConstant().
2379 */
2382 Expr *pExpr
2383 ){
2392 ){;
2398 }
2405 ){
2408 }
2410 }
2413 /*
2414 ** These routines are Walker callbacks used to check expressions to
2415 ** see if they are "constant" for some definition of constant. The
2416 ** Walker.eCode value determines the type of "constant" we are looking
2417 ** for.
2418 **
2419 ** These callback routines are used to implement the following:
2420 **
2421 ** sqlite3ExprIsConstant() pWalker->eCode==1
2422 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2423 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2424 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2425 **
2426 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2427 ** is found to not be a constant.
2428 **
2429 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2430 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2431 ** when parsing an existing schema out of the sqlite_schema table and 4
2432 ** when processing a new CREATE TABLE statement. A bound parameter raises
2433 ** an error for new statements, but is silently converted
2434 ** to NULL for existing schemas. This allows sqlite_schema tables that
2435 ** contain a bound parameter because they were generated by older versions
2436 ** of SQLite to be parsed by newer versions of SQLite without raising a
2437 ** malformed schema error.
2438 */
2442 /* If pWalker->eCode is 2 then any term of the expression that comes from
2443 ** the ON or USING clauses of an outer join disqualifies the expression
2444 ** from being considered constant. */
2448 }
2451 /* Consider functions to be constant if all their arguments are constant
2452 ** and either pWalker->eCode==4 or 5 or the function has the
2453 ** SQLITE_FUNC_CONST flag. */
2457 ){
2465 }
2467 /* Convert "true" or "false" in a DEFAULT clause into the
2468 ** appropriate TK_TRUEFALSE operator */
2471 }
2472 /* no break */ deliberate_fall_through
2482 }
2485 }
2486 /* no break */ deliberate_fall_through
2499 /* Silently convert bound parameters that appear inside of CREATE
2500 ** statements into a NULL when parsing the CREATE statement text out
2501 ** of the sqlite_schema table */
2504 /* A bound parameter in a CREATE statement that originates from
2505 ** sqlite3_prepare() causes an error */
2508 }
2509 /* no break */ deliberate_fall_through
2514 }
2515 }
2517 Walker w;
2522 #ifdef SQLITE_DEBUG
2524 #endif
2527 }
2529 /*
2530 ** Walk an expression tree. Return non-zero if the expression is constant
2531 ** and 0 if it involves variables or function calls.
2532 **
2533 ** For the purposes of this function, a double-quoted string (ex: "abc")
2534 ** is considered a variable but a single-quoted string (ex: 'abc') is
2535 ** a constant.
2536 **
2537 ** The pParse parameter may be NULL. But if it is NULL, there is no way
2538 ** to determine if function calls are constant or not, and hence all
2539 ** function calls will be considered to be non-constant. If pParse is
2540 ** not NULL, then a function call might be constant, depending on the
2541 ** function and on its parameters.
2542 */
2545 }
2547 /*
2548 ** Walk an expression tree. Return non-zero if
2549 **
2550 ** (1) the expression is constant, and
2551 ** (2) the expression does originate in the ON or USING clause
2552 ** of a LEFT JOIN, and
2553 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2554 ** operands created by the constant propagation optimization.
2555 **
2556 ** When this routine returns true, it indicates that the expression
2557 ** can be added to the pParse->pConstExpr list and evaluated once when
2558 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2559 */
2562 }
2564 /*
2565 ** This routine examines sub-SELECT statements as an expression is being
2566 ** walked as part of sqlite3ExprIsTableConstant(). Sub-SELECTs are considered
2567 ** constant as long as they are uncorrelated - meaning that they do not
2568 ** contain any terms from outer contexts.
2569 */
2576 }
2578 }
2580 /*
2581 ** Walk an expression tree. Return non-zero if the expression is constant
2582 ** for any single row of the table with cursor iCur. In other words, the
2583 ** expression must not refer to any non-deterministic function nor any
2584 ** table other than iCur.
2585 **
2586 ** Consider uncorrelated subqueries to be constants if the bAllowSubq
2587 ** parameter is true.
2588 */
2590 Walker w;
2598 #ifdef SQLITE_DEBUG
2600 #endif
2601 }
2605 }
2607 /*
2608 ** Check pExpr to see if it is an constraint on the single data source
2609 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
2610 ** constrains pSrc but does not depend on any other tables or data
2611 ** sources anywhere else in the query. Return true (non-zero) if pExpr
2612 ** is a constraint on pSrc only.
2613 **
2614 ** This is an optimization. False negatives will perhaps cause slower
2615 ** queries, but false positives will yield incorrect answers. So when in
2616 ** doubt, return 0.
2617 **
2618 ** To be an single-source constraint, the following must be true:
2619 **
2620 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
2621 **
2622 ** (2a) pExpr cannot use subqueries unless the bAllowSubq parameter is
2623 ** true and the subquery is non-correlated
2624 **
2625 ** (2b) pExpr cannot use non-deterministic functions.
2626 **
2627 ** (3) pSrc cannot be part of the left operand for a RIGHT JOIN.
2628 ** (Is there some way to relax this constraint?)
2629 **
2630 ** (4) If pSrc is the right operand of a LEFT JOIN, then...
2631 ** (4a) pExpr must come from an ON clause..
2632 ** (4b) and specifically the ON clause associated with the LEFT JOIN.
2633 **
2634 ** (5) If pSrc is not the right operand of a LEFT JOIN or the left
2635 ** operand of a RIGHT JOIN, then pExpr must be from the WHERE
2636 ** clause, not an ON clause.
2637 **
2638 ** (6) Either:
2639 **
2640 ** (6a) pExpr does not originate in an ON or USING clause, or
2641 **
2642 ** (6b) The ON or USING clause from which pExpr is derived is
2643 ** not to the left of a RIGHT JOIN (or FULL JOIN).
2644 **
2645 ** Without this restriction, accepting pExpr as a single-table
2646 ** constraint might move the the ON/USING filter expression
2647 ** from the left side of a RIGHT JOIN over to the right side,
2648 ** which leads to incorrect answers. See also restriction (9)
2649 ** on push-down.
2650 */
2656 ){
2660 }
2666 }
2669 ){
2675 }
2677 }
2678 }
2679 }
2680 /* Rules (1), (2a), and (2b) handled by the following: */
2682 }
2685 /*
2686 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2687 */
2692 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2693 ** it constant. */
2700 }
2701 }
2702 }
2704 /* Check if pExpr is a sub-select. If so, consider it variable. */
2708 }
2711 }
2713 /*
2714 ** Walk the expression tree passed as the first argument. Return non-zero
2715 ** if the expression consists entirely of constants or copies of terms
2716 ** in pGroupBy that sort with the BINARY collation sequence.
2717 **
2718 ** This routine is used to determine if a term of the HAVING clause can
2719 ** be promoted into the WHERE clause. In order for such a promotion to work,
2720 ** the value of the HAVING clause term must be the same for all members of
2721 ** a "group". The requirement that the GROUP BY term must be BINARY
2722 ** assumes that no other collating sequence will have a finer-grained
2723 ** grouping than binary. In other words (A=B COLLATE binary) implies
2724 ** A=B in every other collating sequence. The requirement that the
2725 ** GROUP BY be BINARY is stricter than necessary. It would also work
2726 ** to promote HAVING clauses that use the same alternative collating
2727 ** sequence as the GROUP BY term, but that is much harder to check,
2728 ** alternative collating sequences are uncommon, and this is only an
2729 ** optimization, so we take the easy way out and simply require the
2730 ** GROUP BY to use the BINARY collating sequence.
2731 */
2733 Walker w;
2741 }
2743 /*
2744 ** Walk an expression tree for the DEFAULT field of a column definition
2745 ** in a CREATE TABLE statement. Return non-zero if the expression is
2746 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2747 ** the expression is constant or a function call with constant arguments.
2748 ** Return and 0 if there are any variables.
2749 **
2750 ** isInit is true when parsing from sqlite_schema. isInit is false when
2751 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2752 ** (such as ? or $abc) in the expression are converted into NULL. When
2753 ** isInit is false, parameters raise an error. Parameters should not be
2754 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2755 ** allowed it, so we need to support it when reading sqlite_schema for
2756 ** backwards compatibility.
2757 **
2758 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2759 **
2760 ** For the purposes of this function, a double-quoted string (ex: "abc")
2761 ** is considered a variable but a single-quoted string (ex: 'abc') is
2762 ** a constant.
2763 */
2767 }
2769 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2770 /*
2771 ** Walk an expression tree. Return 1 if the expression contains a
2772 ** subquery of some kind. Return 0 if there are no subqueries.
2773 */
2775 Walker w;
2779 #ifdef SQLITE_DEBUG
2781 #endif
2784 }
2785 #endif
2787 /*
2788 ** If the expression p codes a constant integer that is small enough
2789 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2790 ** in *pValue. If the expression is not an integer or if it is too big
2791 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2792 */
2797 /* If an expression is an integer literal that fits in a signed 32-bit
2798 ** integer, then the EP_IntValue flag will have already been set */
2805 }
2810 }
2817 }
2819 }
2821 }
2823 }
2825 /*
2826 ** Return FALSE if there is no chance that the expression can be NULL.
2827 **
2828 ** If the expression might be NULL or if the expression is too complex
2829 ** to tell return TRUE.
2830 **
2831 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2832 ** when we know that a value cannot be NULL. Hence, a false positive
2833 ** (returning TRUE when in fact the expression can never be NULL) might
2834 ** be a small performance hit but is otherwise harmless. On the other
2835 ** hand, a false negative (returning FALSE when the result could be NULL)
2836 ** will likely result in an incorrect answer. So when in doubt, return
2837 ** TRUE.
2838 */
2840 u8 op;
2845 }
2858 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
2860 #endif
2867 }
2868 }
2870 /*
2871 ** Return TRUE if the given expression is a constant which would be
2872 ** unchanged by OP_Affinity with the affinity given in the second
2873 ** argument.
2874 **
2875 ** This routine is used to determine if the OP_Affinity operation
2876 ** can be omitted. When in doubt return FALSE. A false negative
2877 ** is harmless. A false positive, however, can result in the wrong
2878 ** answer.
2879 */
2881 u8 op;
2887 }
2893 }
2896 }
2899 }
2902 }
2906 }
2909 }
2910 }
2911 }
2913 /*
2914 ** Return TRUE if the given string is a row-id column name.
2915 */
2921 }
2923 /*
2924 ** Return a pointer to a buffer containing a usable rowid alias for table
2925 ** pTab. An alias is usable if there is not an explicit user-defined column
2926 ** of the same name.
2927 */
2936 }
2939 }
2940 }
2942 }
2944 /*
2945 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2946 ** that can be simplified to a direct table access, then return
2947 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2948 ** or if the SELECT statement needs to be materialized into a transient
2949 ** table, then return NULL.
2950 */
2951 #ifndef SQLITE_OMIT_SUBQUERY
2966 }
2980 /* All SELECT results must be columns. */
2985 }
2987 }
2990 #ifndef SQLITE_OMIT_SUBQUERY
2991 /*
2992 ** Generate code that checks the left-most column of index table iCur to see if
2993 ** it contains any NULL entries. Cause the register at regHasNull to be set
2994 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2995 ** to be set to NULL if iCur contains one or more NULL values.
2996 */
3005 }
3006 #endif
3009 #ifndef SQLITE_OMIT_SUBQUERY
3010 /*
3011 ** The argument is an IN operator with a list (not a subquery) on the
3012 ** right-hand side. Return TRUE if that list is constant.
3013 */
3023 }
3024 #endif
3026 /*
3027 ** This function is used by the implementation of the IN (...) operator.
3028 ** The pX parameter is the expression on the RHS of the IN operator, which
3029 ** might be either a list of expressions or a subquery.
3030 **
3031 ** The job of this routine is to find or create a b-tree object that can
3032 ** be used either to test for membership in the RHS set or to iterate through
3033 ** all members of the RHS set, skipping duplicates.
3034 **
3035 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
3036 ** and the *piTab parameter is set to the index of that cursor.
3037 **
3038 ** The returned value of this function indicates the b-tree type, as follows:
3039 **
3040 ** IN_INDEX_ROWID - The cursor was opened on a database table.
3041 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
3042 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
3043 ** IN_INDEX_EPH - The cursor was opened on a specially created and
3044 ** populated ephemeral table.
3045 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
3046 ** implemented as a sequence of comparisons.
3047 **
3048 ** An existing b-tree might be used if the RHS expression pX is a simple
3049 ** subquery such as:
3050 **
3051 ** SELECT <column1>, <column2>... FROM <table>
3052 **
3053 ** If the RHS of the IN operator is a list or a more complex subquery, then
3054 ** an ephemeral table might need to be generated from the RHS and then
3055 ** pX->iTable made to point to the ephemeral table instead of an
3056 ** existing table. In this case, the creation and initialization of the
3057 ** ephemeral table might be put inside of a subroutine, the EP_Subrtn flag
3058 ** will be set on pX and the pX->y.sub fields will be set to show where
3059 ** the subroutine is coded.
3060 **
3061 ** The inFlags parameter must contain, at a minimum, one of the bits
3062 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
3063 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
3064 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
3065 ** be used to loop over all values of the RHS of the IN operator.
3066 **
3067 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
3068 ** through the set members) then the b-tree must not contain duplicates.
3069 ** An ephemeral table will be created unless the selected columns are guaranteed
3070 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
3071 ** a UNIQUE constraint or index.
3072 **
3073 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
3074 ** for fast set membership tests) then an ephemeral table must
3075 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
3076 ** index can be found with the specified <columns> as its left-most.
3077 **
3078 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
3079 ** if the RHS of the IN operator is a list (not a subquery) then this
3080 ** routine might decide that creating an ephemeral b-tree for membership
3081 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
3082 ** calling routine should implement the IN operator using a sequence
3083 ** of Eq or Ne comparison operations.
3084 **
3085 ** When the b-tree is being used for membership tests, the calling function
3086 ** might need to know whether or not the RHS side of the IN operator
3087 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
3088 ** if there is any chance that the (...) might contain a NULL value at
3089 ** runtime, then a register is allocated and the register number written
3090 ** to *prRhsHasNull. If there is no chance that the (...) contains a
3091 ** NULL value, then *prRhsHasNull is left unchanged.
3092 **
3093 ** If a register is allocated and its location stored in *prRhsHasNull, then
3094 ** the value in that register will be NULL if the b-tree contains one or more
3095 ** NULL values, and it will be some non-NULL value if the b-tree contains no
3096 ** NULL values.
3097 **
3098 ** If the aiMap parameter is not NULL, it must point to an array containing
3099 ** one element for each column returned by the SELECT statement on the RHS
3100 ** of the IN(...) operator. The i'th entry of the array is populated with the
3101 ** offset of the index column that matches the i'th column returned by the
3102 ** SELECT. For example, if the expression and selected index are:
3103 **
3104 ** (?,?,?) IN (SELECT a, b, c FROM t1)
3105 ** CREATE INDEX i1 ON t1(b, c, a);
3106 **
3107 ** then aiMap[] is populated with {2, 0, 1}.
3108 */
3109 #ifndef SQLITE_OMIT_SUBQUERY
3117 ){
3128 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
3129 ** whether or not the SELECT result contains NULL values, check whether
3130 ** or not NULL is actually possible (it may not be, for example, due
3131 ** to NOT NULL constraints in the schema). If no NULL values are possible,
3132 ** set prRhsHasNull to 0 before continuing. */
3138 }
3141 }
3142 }
3144 /* Check to see if an existing table or index can be used to
3145 ** satisfy the query. This is preferable to generating a new
3146 ** ephemeral table. */
3159 /* Code an OP_Transaction and OP_TableLock for <table>. */
3167 /* The "x IN (SELECT rowid FROM table)" case */
3181 /* Check that the affinity that will be used to perform each
3182 ** comparison is the same as the affinity of each column in table
3183 ** on the RHS of the IN operator. If it not, it is not possible to
3184 ** use any index of the RHS table. */
3196 /* sqlite3CompareAffinity() only returns TEXT if one side or the
3197 ** other has no affinity and the other side is TEXT. Hence,
3198 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
3199 ** and for the term on the LHS of the IN to have no affinity. */
3204 }
3205 }
3208 /* Search for an existing index that will work for this IN operator */
3214 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
3215 ** BITMASK(nExpr) without overflowing */
3222 ){
3224 }
3225 }
3239 }
3241 }
3247 }
3251 /* If we reach this point, that means the index pIdx is usable */
3262 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
3266 #endif
3270 }
3271 }
3273 }
3279 /* If no preexisting index is available for the IN clause
3280 ** and IN_INDEX_NOOP is an allowed reply
3281 ** and the RHS of the IN operator is a list, not a subquery
3282 ** and the RHS is not constant or has two or fewer terms,
3283 ** then it is not worth creating an ephemeral table to evaluate
3284 ** the IN operator so return IN_INDEX_NOOP.
3285 */
3290 ){
3294 }
3297 /* Could not find an existing table or index to use as the RHS b-tree.
3298 ** We will have to generate an ephemeral table to do the job.
3299 */
3307 }
3312 }
3314 }
3320 }
3323 }
3324 #endif
3326 #ifndef SQLITE_OMIT_SUBQUERY
3327 /*
3328 ** Argument pExpr is an (?, ?...) IN(...) expression. This
3329 ** function allocates and returns a nul-terminated string containing
3330 ** the affinities to be used for each column of the comparison.
3331 **
3332 ** It is the responsibility of the caller to ensure that the returned
3333 ** string is eventually freed using sqlite3DbFree().
3334 */
3352 }
3353 }
3355 }
3357 }
3358 #endif
3360 #ifndef SQLITE_OMIT_SUBQUERY
3361 /*
3362 ** Load the Parse object passed as the first argument with an error
3363 ** message of the form:
3364 **
3365 ** "sub-select returns N columns - expected M"
3366 */
3371 }
3372 }
3373 #endif
3375 /*
3376 ** Expression pExpr is a vector that has been used in a context where
3377 ** it is not permitted. If pExpr is a sub-select vector, this routine
3378 ** loads the Parse object with a message of the form:
3379 **
3380 ** "sub-select returns N columns - expected 1"
3381 **
3382 ** Or, if it is a regular scalar vector:
3383 **
3384 ** "row value misused"
3385 */
3387 #ifndef SQLITE_OMIT_SUBQUERY
3391 #endif
3392 {
3394 }
3395 }
3397 #ifndef SQLITE_OMIT_SUBQUERY
3398 /*
3399 ** Generate code that will construct an ephemeral table containing all terms
3400 ** in the RHS of an IN operator. The IN operator can be in either of two
3401 ** forms:
3402 **
3403 ** x IN (4,5,11) -- IN operator with list on right-hand side
3404 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
3405 **
3406 ** The pExpr parameter is the IN operator. The cursor number for the
3407 ** constructed ephemeral table is returned. The first time the ephemeral
3408 ** table is computed, the cursor number is also stored in pExpr->iTable,
3409 ** however the cursor number returned might not be the same, as it might
3410 ** have been duplicated using OP_OpenDup.
3411 **
3412 ** If the LHS expression ("x" in the examples) is a column value, or
3413 ** the SELECT statement returns a column value, then the affinity of that
3414 ** column is used to build the index keys. If both 'x' and the
3415 ** SELECT... statement are columns, then numeric affinity is used
3416 ** if either column has NUMERIC or INTEGER affinity. If neither
3417 ** 'x' nor the SELECT... statement are columns, then numeric affinity
3418 ** is used.
3419 */
3424 ){
3435 /* The evaluation of the IN must be repeated every time it
3436 ** is encountered if any of the following is true:
3437 **
3438 ** * The right-hand side is a correlated subquery
3439 ** * The right-hand side is an expression list containing variables
3440 ** * We are inside a trigger
3441 **
3442 ** If all of the above are false, then we can compute the RHS just once
3443 ** and reuse it many names.
3444 */
3446 /* Reuse of the RHS is allowed */
3447 /* If this routine has already been coded, but the previous code
3448 ** might not have been invoked yet, so invoke it now as a subroutine.
3449 */
3455 }
3463 }
3465 /* Begin coding the subroutine */
3474 }
3476 /* Check to see if this is a vector IN operator */
3480 /* Construct the ephemeral table that will contain the content of
3481 ** RHS of the IN operator.
3482 */
3485 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3490 }
3491 #endif
3495 /* Case 1: expr IN (SELECT ...)
3496 **
3497 ** Generate code to write the results of the select into the temporary
3498 ** table allocated and opened above.
3499 */
3505 ));
3506 /* If the LHS and RHS of the IN operator do not match, that
3507 ** error will have been caught long before we reach this point. */
3510 SelectDest dest;
3525 }
3534 );
3535 }
3536 }
3538 /* Case 2: expr IN (exprlist)
3539 **
3540 ** For each expression, build an index key from the evaluation and
3541 ** store it in the temporary table. If <expr> is a column, then use
3542 ** that columns affinity when building index keys. If <expr> is not
3543 ** a column, use numeric affinity.
3544 */
3555 }
3559 }
3561 /* Loop through each expression in <exprlist>. */
3567 /* If the expression is not constant then we will need to
3568 ** disable the test that was generated above that makes sure
3569 ** this code only executes once. Because for a non-constant
3570 ** expression we need to rerun this code each time.
3571 */
3577 }
3579 /* Evaluate the expression and insert it into the temp table */
3583 }
3586 }
3589 }
3593 /* Subroutine return */
3601 }
3602 }
3605 /*
3606 ** Generate code for scalar subqueries used as a subquery expression
3607 ** or EXISTS operator:
3608 **
3609 ** (SELECT a FROM b) -- subquery
3610 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3611 **
3612 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3613 **
3614 ** Return the register that holds the result. For a multi-column SELECT,
3615 ** the result is stored in a contiguous array of registers and the
3616 ** return value is the register of the left-most result column.
3617 ** Return 0 if an error occurs.
3618 */
3619 #ifndef SQLITE_OMIT_SUBQUERY
3627 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3629 #endif
3640 /* If this routine has already been coded, then invoke it as a
3641 ** subroutine. */
3648 }
3650 /* Begin coding the subroutine */
3658 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3659 ** is encountered if any of the following is true:
3660 **
3661 ** * The right-hand side is a correlated subquery
3662 ** * The right-hand side is an expression list containing variables
3663 ** * We are inside a trigger
3664 **
3665 ** If all of the above are false, then we can run this code just once
3666 ** save the results, and reuse the same result on subsequent invocations.
3667 */
3670 }
3672 /* For a SELECT, generate code to put the values for all columns of
3673 ** the first row into an array of registers and return the index of
3674 ** the first register.
3675 **
3676 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3677 ** into a register and return that register number.
3678 **
3679 ** In both cases, the query is augmented with "LIMIT 1". Any
3680 ** preexisting limit is discarded in place of the new LIMIT 1.
3681 */
3698 }
3700 /* The subquery already has a limit. If the pre-existing limit is X
3701 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3708 }
3712 /* If there is no pre-existing limit add a limit of 1 */
3715 }
3721 }
3726 }
3729 /* Subroutine return */
3738 }
3741 #ifndef SQLITE_OMIT_SUBQUERY
3742 /*
3743 ** Expr pIn is an IN(...) expression. This function checks that the
3744 ** sub-select on the RHS of the IN() operator has the same number of
3745 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3746 ** a sub-query, that the LHS is a vector of size 1.
3747 */
3754 }
3758 }
3760 }
3761 #endif
3763 #ifndef SQLITE_OMIT_SUBQUERY
3764 /*
3765 ** Generate code for an IN expression.
3766 **
3767 ** x IN (SELECT ...)
3768 ** x IN (value, value, ...)
3769 **
3770 ** The left-hand side (LHS) is a scalar or vector expression. The
3771 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3772 ** subquery. If the RHS is a subquery, the number of result columns must
3773 ** match the number of columns in the vector on the LHS. If the RHS is
3774 ** a list of values, the LHS must be a scalar.
3775 **
3776 ** The IN operator is true if the LHS value is contained within the RHS.
3777 ** The result is false if the LHS is definitely not in the RHS. The
3778 ** result is NULL if the presence of the LHS in the RHS cannot be
3779 ** determined due to NULLs.
3780 **
3781 ** This routine generates code that jumps to destIfFalse if the LHS is not
3782 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3783 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3784 ** within the RHS then fall through.
3785 **
3786 ** See the separate in-operator.md documentation file in the canonical
3787 ** SQLite source tree for additional information.
3788 */
3794 ){
3821 );
3824 /* Attempt to compute the RHS. After this step, if anything other than
3825 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3826 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3827 ** the RHS has not yet been coded. */
3838 );
3839 #ifdef SQLITE_DEBUG
3840 /* Confirm that aiMap[] contains nVector integer values between 0 and
3841 ** nVector-1. */
3846 }
3847 #endif
3849 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3850 ** vector, then it is stored in an array of nVector registers starting
3851 ** at r1.
3852 **
3853 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3854 ** so that the fields are in the same order as an existing index. The
3855 ** aiMap[] array contains a mapping from the original LHS field order to
3856 ** the field order that matches the RHS index.
3857 **
3858 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3859 ** even if it is constant, as OP_Affinity may be used on the register
3860 ** by code generated below. */
3867 /* LHS fields are not reordered */
3870 /* Need to reorder the LHS fields according to aiMap */
3874 }
3875 }
3877 /* If sqlite3FindInIndex() did not find or create an index that is
3878 ** suitable for evaluating the IN operator, then evaluate using a
3879 ** sequence of comparisons.
3880 **
3881 ** This is step (1) in the in-operator.md optimized algorithm.
3882 */
3896 }
3901 }
3920 }
3921 }
3925 }
3929 }
3931 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3932 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3933 ** We will then skip the binary search of the RHS.
3934 */
3939 }
3946 }
3947 }
3949 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3950 ** of the RHS using the LHS as a probe. If found, the result is
3951 ** true.
3952 */
3954 /* In this case, the RHS is the ROWID of table b-tree and so we also
3955 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3956 ** into a single opcode. */
3963 /* Combine Step 3 and Step 5 into a single opcode */
3967 }
3968 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3971 }
3973 /* Step 4. If the RHS is known to be non-NULL and we did not find
3974 ** an match on the search above, then the result must be FALSE.
3975 */
3979 }
3981 /* Step 5. If we do not care about the difference between NULL and
3982 ** FALSE, then just return false.
3983 */
3986 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3987 ** If any comparison is NULL, then the result is NULL. If all
3988 ** comparisons are FALSE then the final result is FALSE.
3989 **
3990 ** For a scalar LHS, it is sufficient to check just the first row
3991 ** of the RHS.
3992 */
3999 /* For nVector==1, combine steps 6 and 7 by immediately returning
4000 ** FALSE if the first comparison is not NULL */
4002 }
4014 }
4021 /* Step 7: If we reach this point, we know that the result must
4022 ** be false. */
4024 }
4026 /* Jumps here in order to return true. */
4029 sqlite3ExprCodeIN_finished:
4032 sqlite3ExprCodeIN_oom_error:
4035 }
4038 #ifndef SQLITE_OMIT_FLOATING_POINT
4039 /*
4040 ** Generate an instruction that will put the floating point
4041 ** value described by z[0..n-1] into register iMem.
4042 **
4043 ** The z[] string will probably not be zero-terminated. But the
4044 ** z[n] character is guaranteed to be something that does not look
4045 ** like the continuation of the number.
4046 */
4054 }
4055 }
4056 #endif
4059 /*
4060 ** Generate an instruction that will put the integer describe by
4061 ** text z[0..n-1] into register iMem.
4062 **
4063 ** Expr.u.zToken is always UTF8 and zero-terminated.
4064 */
4074 i64 value;
4079 #ifdef SQLITE_OMIT_FLOATING_POINT
4081 #else
4082 #ifndef SQLITE_OMIT_HEX_INTEGER
4087 #endif
4088 {
4090 }
4091 #endif
4095 }
4096 }
4097 }
4100 /* Generate code that will load into register regOut a value that is
4101 ** appropriate for the iIdxCol-th column of index pIdx.
4102 */
4109 ){
4120 }
4121 }
4123 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4124 /*
4125 ** Generate code that will compute the value of generated column pCol
4126 ** and store the result in register regOut
4127 */
4133 ){
4143 }
4147 }
4150 }
4153 /*
4154 ** Generate code to extract the value of the iCol-th column of a table.
4155 */
4162 ){
4176 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4189 }
4191 #endif
4200 }
4203 }
4204 }
4206 /*
4207 ** Generate code that will extract the iColumn-th column from
4208 ** table pTab and store the column value in register iReg.
4209 **
4210 ** There must be an open cursor to pTab in iTable when this routine
4211 ** is called. If iColumn<0 then code is generated that extracts the rowid.
4212 */
4219 u8 p5 /* P5 value for OP_Column + FLAGS */
4220 ){
4229 }
4231 }
4233 /*
4234 ** Generate code to move content from registers iFrom...iFrom+nReg-1
4235 ** over to iTo..iTo+nReg-1.
4236 */
4239 }
4241 /*
4242 ** Convert a scalar expression node to a TK_REGISTER referencing
4243 ** register iReg. The caller must ensure that iReg already contains
4244 ** the correct value for the expression.
4245 */
4253 }
4255 /*
4256 ** Evaluate an expression (either a vector or a scalar expression) and store
4257 ** the result in contiguous temporary registers. Return the index of
4258 ** the first register used to store the result.
4259 **
4260 ** If the returned result register is a temporary scalar, then also write
4261 ** that register number into *piFreeable. If the returned result register
4262 ** is not a temporary or if the expression is a vector set *piFreeable
4263 ** to 0.
4264 */
4273 #if SQLITE_OMIT_SUBQUERY
4275 #else
4277 #endif
4285 }
4286 }
4287 }
4289 }
4291 /*
4292 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
4293 ** so that a subsequent copy will not be merged into this one.
4294 */
4298 }
4299 }
4301 /*
4302 ** Generate code to implement special SQL functions that are implemented
4303 ** in-line rather than by using the usual callbacks.
4304 */
4310 ){
4319 /* Attempt a direct implementation of the built-in COALESCE() and
4320 ** IFNULL() functions. This avoids unnecessary evaluation of
4321 ** arguments past the first non-NULL argument.
4322 */
4331 }
4335 }
4337 Expr caseExpr;
4342 }
4343 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4350 }
4352 }
4353 #endif
4355 /* The UNLIKELY() function is a no-op. The result is the value
4356 ** of the first argument.
4357 */
4361 }
4363 /***********************************************************************
4364 ** Test-only SQL functions that are only usable if enabled
4365 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
4366 */
4367 #if !defined(SQLITE_UNTESTABLE)
4369 /* Compare two expressions using sqlite3ExprCompare() */
4373 target);
4375 }
4378 /* Compare two expressions using sqlite3ExprImpliesExpr() */
4382 target);
4384 }
4387 /* Result of sqlite3ExprImpliesNonNullRow() */
4394 target);
4397 }
4399 }
4402 /* The AFFINITY() function evaluates to a string that describes
4403 ** the type affinity of the argument. This is used for testing of
4404 ** the SQLite type logic.
4405 */
4416 }
4418 }
4420 }
4422 /*
4423 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
4424 ** If it is, then resolve the expression by reading from the index and
4425 ** return the register into which the value has been read. If pExpr is
4426 ** not an indexed expression, then return negative.
4427 */
4432 ){
4436 u8 exprAff;
4442 }
4449 ){
4450 /* Affinity mismatch on a generated column */
4452 }
4457 /* If the index is on a NULL row due to an outer join, then we
4458 ** cannot extract the value from the index. The value must be
4459 ** computed using the original expression. */
4474 }
4476 }
4478 }
4481 /*
4482 ** Expresion pExpr is guaranteed to be a TK_COLUMN or equivalent. This
4483 ** function checks the Parse.pIdxPartExpr list to see if this column
4484 ** can be replaced with a constant value. If so, it generates code to
4485 ** put the constant value in a register (ideally, but not necessarily,
4486 ** register iTarget) and returns the register number.
4487 **
4488 ** Or, if the TK_COLUMN cannot be replaced by a constant, zero is
4489 ** returned.
4490 */
4501 }
4508 }
4510 }
4511 }
4513 }
4516 /*
4517 ** Generate code into the current Vdbe to evaluate the given
4518 ** expression. Attempt to store the results in register "target".
4519 ** Return the register where results are stored.
4520 **
4521 ** With this routine, there is no guarantee that results will
4522 ** be stored in target. The result might be stored in some other
4523 ** register if it is convenient to do so. The calling function
4524 ** must check the return code and move the results to the desired
4525 ** register.
4526 */
4540 expr_code_doover:
4546 ){
4551 }
4560 /* Happens when the left table of a RIGHT JOIN is null and
4561 ** is using an expression index */
4563 #ifdef SQLITE_VDBE_COVERAGE
4564 /* Verify that the OP_Null above is exercised by tests
4565 ** tag-20230325-2 */
4568 #endif
4570 }
4579 /* No comment added */
4587 }
4588 }
4591 /* This case happens when the argument to an aggregate function
4592 ** is rewritten by aggregateConvertIndexedExprRefToColumn() */
4595 }
4596 /* Otherwise, fall thru into the TK_COLUMN case */
4597 /* no break */ deliberate_fall_through
4598 }
4603 /* This COLUMN expression is really a constant due to WHERE clause
4604 ** constraints, and that constant is coded by the pExpr->pLeft
4605 ** expression. However, make sure the constant has the correct
4606 ** datatype by applying the Affinity of the table column to the
4607 ** constant.
4608 */
4620 }
4622 }
4625 /* Other columns in the same row for CHECK constraints or
4626 ** generated columns or for inserting into partial index.
4627 ** The row is unpacked into registers beginning at
4628 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4629 ** immediately prior to the first column.
4630 */
4642 }
4646 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4652 }
4656 }
4667 }
4669 /* Coding an expression that is part of an index where column names
4670 ** in the index refer to the table to which the index belongs */
4672 }
4673 }
4676 ){
4678 }
4685 }
4689 }
4693 }
4694 #ifndef SQLITE_OMIT_FLOATING_POINT
4699 }
4700 #endif
4705 }
4707 /* Make NULL the default case so that if a bug causes an illegal
4708 ** Expr node to be passed into this function, it will be handled
4709 ** sanely and not crash. But keep the assert() to bring the problem
4710 ** to the attention of the developers. */
4714 }
4715 #ifndef SQLITE_OMIT_BLOB_LITERAL
4729 }
4730 #endif
4737 }
4740 }
4741 #ifndef SQLITE_OMIT_CAST
4743 /* Expressions of the form: CAST(pLeft AS token) */
4750 }
4756 /* fall-through */
4783 }
4786 }
4788 }
4818 }
4825 #ifndef SQLITE_OMIT_FLOATING_POINT
4830 #endif
4840 }
4842 }
4851 }
4863 }
4878 }
4884 ){
4889 }
4891 }
4903 #ifndef SQLITE_OMIT_WINDOWFUNC
4906 }
4907 #endif
4911 ){
4912 /* SQL functions can be expensive. So try to avoid running them
4913 ** multiple times if we know they always give the same result */
4915 }
4923 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4926 }
4927 #endif
4931 }
4939 }
4945 }
4948 }
4949 }
4956 }
4958 /* For length() and typeof() and octet_length() functions,
4959 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4960 ** or OPFLAG_TYPEOFARG or OPFLAG_BYTELENARG respectively, to avoid
4961 ** unnecessary data loading.
4962 */
4964 u8 exprOp;
4977 }
4978 }
4983 }
4984 #ifndef SQLITE_OMIT_VIRTUALTABLE
4985 /* Possibly overload the function if the first argument is
4986 ** a virtual table column.
4987 **
4988 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4989 ** second argument, not the first, as the argument to test to
4990 ** see if it is a column in a virtual table. This is done because
4991 ** the left operand of infix functions (the operand we want to
4992 ** control overloading) ends up as the second argument to the
4993 ** function. The expression "A glob B" is equivalent to
4994 ** "glob(B,A). We want to use the A in "A glob B" to test
4995 ** for function overloading. But we use the B term in "glob(B,A)".
4996 */
5001 }
5002 #endif
5006 }
5014 }
5015 }
5017 }
5018 #ifndef SQLITE_OMIT_SUBQUERY
5029 ){
5033 }
5035 }
5042 }
5048 }
5050 }
5061 }
5065 /*
5066 ** x BETWEEN y AND z
5067 **
5068 ** This is equivalent to
5069 **
5070 ** x>=y AND x<=z
5071 **
5072 ** X is stored in pExpr->pLeft.
5073 ** Y is stored in pExpr->pList->a[0].pExpr.
5074 ** Z is stored in pExpr->pList->a[1].pExpr.
5075 */
5079 }
5082 /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
5083 ** "SOFT-COLLATE" that is added to constraints that are pushed down
5084 ** from outer queries into sub-queries by the WHERE-clause push-down
5085 ** optimization. Clear subtypes as subtypes may not cross a subquery
5086 ** boundary.
5087 */
5095 }
5096 }
5101 }
5104 /* If the opcode is TK_TRIGGER, then the expression is a reference
5105 ** to a column in the new.* or old.* pseudo-tables available to
5106 ** trigger programs. In this case Expr.iTable is set to 1 for the
5107 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
5108 ** is set to the column of the pseudo-table to read, or to -1 to
5109 ** read the rowid field.
5110 **
5111 ** The expression is implemented using an OP_Param opcode. The p1
5112 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
5113 ** to reference another column of the old.* pseudo-table, where
5114 ** i is the index of the column. For a new.rowid reference, p1 is
5115 ** set to (n+1), where n is the number of columns in each pseudo-table.
5116 ** For a reference to any other column in the new.* pseudo-table, p1
5117 ** is set to (n+2+i), where n and i are as defined previously. For
5118 ** example, if the table on which triggers are being fired is
5119 ** declared as:
5120 **
5121 ** CREATE TABLE t1(a, b);
5122 **
5123 ** Then p1 is interpreted as follows:
5124 **
5125 ** p1==0 -> old.rowid p1==3 -> new.rowid
5126 ** p1==1 -> old.a p1==4 -> new.a
5127 ** p1==2 -> old.b p1==5 -> new.b
5128 */
5148 ));
5150 #ifndef SQLITE_OMIT_FLOATING_POINT
5151 /* If the column has REAL affinity, it may currently be stored as an
5152 ** integer. Use OP_RealAffinity to make sure it is really real.
5153 **
5154 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
5155 ** floating point when extracting it from the record. */
5158 }
5159 #endif
5161 }
5166 }
5168 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
5169 ** that derive from the right-hand table of a LEFT JOIN. The
5170 ** Expr.iTable value is the table number for the right-hand table.
5171 ** The expression is only evaluated if that table is not currently
5172 ** on a LEFT JOIN NULL row.
5173 */
5183 }
5187 target);
5190 }
5191 }
5193 /* The OP_IfNullRow opcode above can overwrite the result register with
5194 ** NULL. So we have to ensure that the result register is not a value
5195 ** that is suppose to be a constant. Two defenses are needed:
5196 ** (1) Temporarily disable factoring of constant expressions
5197 ** (2) Make sure the computed value really is stored in register
5198 ** "target" and not someplace else.
5199 */
5206 }
5208 /*
5209 ** Form A:
5210 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
5211 **
5212 ** Form B:
5213 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
5214 **
5215 ** Form A is can be transformed into the equivalent form B as follows:
5216 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
5217 ** WHEN x=eN THEN rN ELSE y END
5218 **
5219 ** X (if it exists) is in pExpr->pLeft.
5220 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
5221 ** odd. The Y is also optional. If the number of elements in x.pList
5222 ** is even, then Y is omitted and the "otherwise" result is NULL.
5223 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
5224 **
5225 ** The result of the expression is the Ri for the first matching Ei,
5226 ** or if there is no matching Ei, the ELSE term Y, or if there is
5227 ** no ELSE term, NULL.
5228 */
5253 }
5261 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
5262 ** The value in regFree1 might get SCopy-ed into the file result.
5263 ** So make sure that the regFree1 register is not reused for other
5264 ** purposes and possibly overwritten. */
5266 }
5273 }
5281 }
5286 }
5291 }
5292 #ifndef SQLITE_OMIT_TRIGGER
5298 );
5303 }
5306 }
5316 }
5319 }
5320 #endif
5321 }
5325 }
5327 /*
5328 ** Generate code that will evaluate expression pExpr just one time
5329 ** per prepared statement execution.
5330 **
5331 ** If the expression uses functions (that might throw an exception) then
5332 ** guard them with an OP_Once opcode to ensure that the code is only executed
5333 ** once. If no functions are involved, then factor the code out and put it at
5334 ** the end of the prepared statement in the initialization section.
5335 **
5336 ** If regDest>0 then the result is always stored in that register and the
5337 ** result is not reusable. If regDest<0 then this routine is free to
5338 ** store the value wherever it wants. The register where the expression
5339 ** is stored is returned. When regDest<0, two identical expressions might
5340 ** code to the same register, if they do not contain function calls and hence
5341 ** are factored out into the initialization section at the end of the
5342 ** prepared statement.
5343 */
5348 ){
5359 ){
5361 }
5362 }
5363 }
5374 }
5385 }
5387 }
5389 }
5391 /*
5392 ** Generate code to evaluate an expression and store the results
5393 ** into a register. Return the register number where the results
5394 ** are stored.
5395 **
5396 ** If the register is a temporary register that can be deallocated,
5397 ** then write its number into *pReg. If the result register is not
5398 ** a temporary, then set *pReg to zero.
5399 **
5400 ** If pExpr is a constant, then this routine might generate this
5401 ** code to fill the register in the initialization section of the
5402 ** VDBE program, in order to factor it out of the evaluation loop.
5403 */
5411 ){
5422 }
5423 }
5425 }
5427 /*
5428 ** Generate code that will evaluate expression pExpr and store the
5429 ** results in register target. The results are guaranteed to appear
5430 ** in register target.
5431 */
5441 u8 op;
5446 ){
5450 }
5452 }
5453 }
5455 /*
5456 ** Make a transient copy of expression pExpr and then code it using
5457 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
5458 ** except that the input expression is guaranteed to be unchanged.
5459 */
5465 }
5467 /*
5468 ** Generate code that will evaluate expression pExpr and store the
5469 ** results in register target. The results are guaranteed to appear
5470 ** in register target. If the expression is constant, then this routine
5471 ** might choose to code the expression at initialization time.
5472 */
5478 }
5479 }
5481 /*
5482 ** Generate code that pushes the value of every element of the given
5483 ** expression list into a sequence of registers beginning at target.
5484 **
5485 ** Return the number of elements evaluated. The number returned will
5486 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
5487 ** is defined.
5488 **
5489 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
5490 ** filled using OP_SCopy. OP_Copy must be used instead.
5491 **
5492 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
5493 ** factored out into initialization code.
5494 **
5495 ** The SQLITE_ECEL_REF flag means that expressions in the list with
5496 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
5497 ** in registers at srcReg, and so the value can be copied from there.
5498 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
5499 ** are simply omitted rather than being copied from srcReg.
5500 */
5506 u8 flags /* SQLITE_ECEL_* flags */
5507 ){
5519 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
5521 i--;
5522 n--;
5524 #endif
5527 i--;
5528 n--;
5531 }
5534 ){
5545 ){
5549 }
5550 }
5551 }
5552 }
5554 }
5556 /*
5557 ** Generate code for a BETWEEN operator.
5558 **
5559 ** x BETWEEN y AND z
5560 **
5561 ** The above is equivalent to
5562 **
5563 ** x>=y AND x<=z
5564 **
5565 ** Code it as such, taking care to do the common subexpression
5566 ** elimination of x.
5567 **
5568 ** The xJumpIf parameter determines details:
5569 **
5570 ** NULL: Store the boolean result in reg[dest]
5571 ** sqlite3ExprIfTrue: Jump to dest if true
5572 ** sqlite3ExprIfFalse: Jump to dest if false
5573 **
5574 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
5575 */
5582 ){
5610 /* Mark the expression is being from the ON or USING clause of a join
5611 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5612 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5613 ** for clarity, but we are out of bits in the Expr.flags field so we
5614 ** have to reuse the EP_OuterON bit. Bummer. */
5617 }
5619 }
5622 /* Ensure adequate test coverage */
5632 }
5634 /*
5635 ** Generate code for a boolean expression such that a jump is made
5636 ** to the label "dest" if the expression is true but execution
5637 ** continues straight thru if the expression is false.
5638 **
5639 ** If the expression evaluates to NULL (neither true nor false), then
5640 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5641 **
5642 ** This code depends on the fact that certain token values (ex: TK_EQ)
5643 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5644 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5645 ** the make process cause these values to align. Assert()s in the code
5646 ** below verify that the numbers are aligned correctly.
5647 */
5677 }
5679 }
5684 }
5699 }
5701 }
5708 /* no break */ deliberate_fall_through
5734 }
5746 }
5751 }
5752 #ifndef SQLITE_OMIT_SUBQUERY
5760 }
5761 #endif
5763 default_expr:
5767 /* No-op */
5774 }
5776 }
5777 }
5780 }
5782 /*
5783 ** Generate code for a boolean expression such that a jump is made
5784 ** to the label "dest" if the expression is false but execution
5785 ** continues straight thru if the expression is true.
5786 **
5787 ** If the expression evaluates to NULL (neither true nor false) then
5788 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5789 ** is 0.
5790 */
5803 /* The value of pExpr->op and op are related as follows:
5804 **
5805 ** pExpr->op op
5806 ** --------- ----------
5807 ** TK_ISNULL OP_NotNull
5808 ** TK_NOTNULL OP_IsNull
5809 ** TK_NE OP_Eq
5810 ** TK_EQ OP_Ne
5811 ** TK_GT OP_Le
5812 ** TK_LE OP_Gt
5813 ** TK_GE OP_Lt
5814 ** TK_LT OP_Ge
5815 **
5816 ** For other values of pExpr->op, op is undefined and unused.
5817 ** The value of TK_ and OP_ constants are arranged such that we
5818 ** can compute the mapping above using the following expression.
5819 ** Assert()s verify that the computation is correct.
5820 */
5823 /* Verify correct alignment of TK_ and OP_ constants
5824 */
5851 }
5853 }
5858 }
5868 /* IS TRUE and IS NOT FALSE */
5873 /* IS FALSE and IS NOT TRUE */
5876 }
5878 }
5885 /* no break */ deliberate_fall_through
5911 }
5921 }
5926 }
5927 #ifndef SQLITE_OMIT_SUBQUERY
5935 }
5937 }
5938 #endif
5940 default_expr:
5944 /* no-op */
5951 }
5953 }
5954 }
5957 }
5959 /*
5960 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5961 ** code generation, and that copy is deleted after code generation. This
5962 ** ensures that the original pExpr is unchanged.
5963 */
5969 }
5971 }
5973 /*
5974 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5975 ** type of expression.
5976 **
5977 ** If pExpr is a simple SQL value - an integer, real, string, blob
5978 ** or NULL value - then the VDBE currently being prepared is configured
5979 ** to re-prepare each time a new value is bound to variable pVar.
5980 **
5981 ** Additionally, if pExpr is a simple SQL value and the value is the
5982 ** same as that currently bound to variable pVar, non-zero is returned.
5983 ** Otherwise, if the values are not the same or if pExpr is not a simple
5984 ** SQL value, zero is returned.
5985 */
5990 ){
6003 }
6005 }
6008 }
6011 }
6013 /*
6014 ** Do a deep comparison of two expression trees. Return 0 if the two
6015 ** expressions are completely identical. Return 1 if they differ only
6016 ** by a COLLATE operator at the top level. Return 2 if there are differences
6017 ** other than the top-level COLLATE operator.
6018 **
6019 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
6020 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
6021 **
6022 ** The pA side might be using TK_REGISTER. If that is the case and pB is
6023 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
6024 **
6025 ** Sometimes this routine will return 2 even if the two expressions
6026 ** really are equivalent. If we cannot prove that the expressions are
6027 ** identical, we return 2 just to be safe. So if this routine
6028 ** returns 2, then you do not really know for certain if the two
6029 ** expressions are the same. But if you get a 0 or 1 return, then you
6030 ** can be sure the expressions are the same. In the places where
6031 ** this routine is used, it does not hurt to get an extra 2 - that
6032 ** just might result in some slightly slower code. But returning
6033 ** an incorrect 0 or 1 could lead to a malfunction.
6034 **
6035 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
6036 ** pParse->pReprepare can be matched against literals in pB. The
6037 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
6038 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
6039 ** Argument pParse should normally be NULL. If it is not NULL and pA or
6040 ** pB causes a return value of 2.
6041 */
6046 int iTab
6047 ){
6048 u32 combinedFlags;
6051 }
6054 }
6059 }
6061 }
6065 }
6068 }
6071 ){
6072 /* fall through */
6075 }
6076 }
6082 #ifndef SQLITE_OMIT_WINDOWFUNC
6086 }
6090 }
6091 }
6092 #endif
6102 ){
6104 }
6105 }
6117 ){
6122 }
6123 }
6124 }
6126 }
6128 /*
6129 ** Compare two ExprList objects. Return 0 if they are identical, 1
6130 ** if they are certainly different, or 2 if it is not possible to
6131 ** determine if they are identical or not.
6132 **
6133 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
6134 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
6135 **
6136 ** This routine might return non-zero for equivalent ExprLists. The
6137 ** only consequence will be disabled optimizations. But this routine
6138 ** must never return 0 if the two ExprList objects are different, or
6139 ** a malfunction will result.
6140 **
6141 ** Two NULL pointers are considered to be the same. But a NULL pointer
6142 ** always differs from a non-NULL pointer.
6143 */
6155 }
6157 }
6159 /*
6160 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
6161 ** are ignored.
6162 */
6167 iTab);
6168 }
6170 /*
6171 ** Return non-zero if Expr p can only be true if pNN is not NULL.
6172 **
6173 ** Or if seenNot is true, return non-zero if Expr p can only be
6174 ** non-NULL if pNN is not NULL
6175 */
6182 ){
6187 }
6193 }
6203 ){
6205 }
6207 }
6221 /* no break */ deliberate_fall_through
6227 /* no break */ deliberate_fall_through
6228 }
6234 }
6239 }
6243 }
6244 }
6246 }
6248 /*
6249 ** Return true if we can prove the pE2 will always be true if pE1 is
6250 ** true. Return false if we cannot complete the proof or if pE2 might
6251 ** be false. Examples:
6252 **
6253 ** pE1: x==5 pE2: x==5 Result: true
6254 ** pE1: x>0 pE2: x==5 Result: false
6255 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
6256 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
6257 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
6258 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
6259 ** pE1: x IS ?2 pE2: x IS NOT NULL Result: false
6260 **
6261 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
6262 ** Expr.iTable<0 then assume a table number given by iTab.
6263 **
6264 ** If pParse is not NULL, then the values of bound variables in pE1 are
6265 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
6266 ** modified to record which bound variables are referenced. If pParse
6267 ** is NULL, then false will be returned if pE1 contains any bound variables.
6268 **
6269 ** When in doubt, return false. Returning true might give a performance
6270 ** improvement. Returning false might cause a performance reduction, but
6271 ** it will always give the correct answer and is hence always safe.
6272 */
6277 int iTab
6278 ){
6281 }
6285 ){
6287 }
6290 ){
6292 }
6294 }
6296 /* This is a helper function to impliesNotNullRow(). In this routine,
6297 ** set pWalker->eCode to one only if *both* of the input expressions
6298 ** separately have the implies-not-null-row property.
6299 */
6306 }
6307 }
6308 }
6310 /*
6311 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
6312 ** If the expression node requires that the table at pWalker->iCur
6313 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
6314 **
6315 ** pWalker->mWFlags is non-zero if this inquiry is being undertaking on
6316 ** behalf of a RIGHT JOIN (or FULL JOIN). That makes a difference when
6317 ** evaluating terms in the ON clause of an inner join.
6318 **
6319 ** This routine controls an optimization. False positives (setting
6320 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
6321 ** (never setting pWalker->eCode) is a harmless missed optimization.
6322 */
6328 /* If iCur is used in an inner-join ON clause to the left of a
6329 ** RIGHT JOIN, that does *not* mean that the table must be non-null.
6330 ** But it is difficult to check for that condition precisely.
6331 ** To keep things simple, any use of iCur from any inner-join is
6332 ** ignored while attempting to simplify a RIGHT JOIN. */
6334 }
6358 }
6363 /* Both sides of an AND or OR must separately imply non-null-row.
6364 ** Consider these cases:
6365 ** 1. NOT (x AND y)
6366 ** 2. x OR y
6367 ** If only one of x or y is non-null-row, then the overall expression
6368 ** can be true if the other arm is false (case 1) or true (case 2).
6369 */
6376 /* Beware of "x NOT IN ()" and "x NOT IN (SELECT 1 WHERE false)",
6377 ** both of which can be true. But apart from these cases, if
6378 ** the left-hand side of the IN is NULL then the IN itself will be
6379 ** NULL. */
6382 }
6386 /* In "x NOT BETWEEN y AND z" either x must be non-null-row or else
6387 ** both y and z must be non-null row */
6395 /* Virtual tables are allowed to use constraints like x=NULL. So
6396 ** a term of the form x=y does not prove that y is not null if x
6397 ** is the column of a virtual table */
6412 /* The y.pTab=0 assignment in wherecode.c always happens after the
6413 ** impliesNotNullRow() test */
6422 ){
6424 }
6425 /* no break */ deliberate_fall_through
6426 }
6429 }
6430 }
6432 /*
6433 ** Return true (non-zero) if expression p can only be true if at least
6434 ** one column of table iTab is non-null. In other words, return true
6435 ** if expression p will always be NULL or false if every column of iTab
6436 ** is NULL.
6437 **
6438 ** False negatives are acceptable. In other words, it is ok to return
6439 ** zero even if expression p will never be true of every column of iTab
6440 ** is NULL. A false negative is merely a missed optimization opportunity.
6441 **
6442 ** False positives are not allowed, however. A false positive may result
6443 ** in an incorrect answer.
6444 **
6445 ** Terms of p that are marked with EP_OuterON (and hence that come from
6446 ** the ON or USING clauses of OUTER JOINS) are excluded from the analysis.
6447 **
6448 ** This routine is used to check if a LEFT JOIN can be converted into
6449 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
6450 ** clause requires that some column of the right table of the LEFT JOIN
6451 ** be non-NULL, then the LEFT JOIN can be safely converted into an
6452 ** ordinary join.
6453 */
6455 Walker w;
6464 }
6465 }
6474 }
6476 /*
6477 ** An instance of the following structure is used by the tree walker
6478 ** to determine if an expression can be evaluated by reference to the
6479 ** index only, without having to do a search for the corresponding
6480 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
6481 ** is the cursor for the table.
6482 */
6486 };
6488 /*
6489 ** Check to see if there are references to columns in table
6490 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
6491 ** pWalker->u.pIdxCover->pIdx.
6492 */
6497 ){
6500 }
6502 }
6504 /*
6505 ** Determine if an index pIdx on table with cursor iCur contains will
6506 ** the expression pExpr. Return true if the index does cover the
6507 ** expression and false if the pExpr expression references table columns
6508 ** that are not found in the index pIdx.
6509 **
6510 ** An index covering an expression means that the expression can be
6511 ** evaluated using only the index and without having to lookup the
6512 ** corresponding table entry.
6513 */
6518 ){
6519 Walker w;
6528 }
6531 /* Structure used to pass information throughout the Walker in order to
6532 ** implement sqlite3ReferencesSrcList().
6533 */
6539 };
6541 /*
6542 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
6543 **
6544 ** When entering a new subquery on the pExpr argument, add all FROM clause
6545 ** entries for that subquery to the exclude list.
6546 **
6547 ** When leaving the subquery, remove those entries from the exclude list.
6548 */
6563 }
6566 }
6568 }
6575 }
6576 }
6578 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
6579 **
6580 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
6581 ** of the tables shown in RefSrcList.pRef.
6582 **
6583 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
6584 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
6585 */
6589 ){
6598 }
6599 }
6603 }
6604 }
6606 }
6608 /*
6609 ** Check to see if pExpr references any tables in pSrcList.
6610 ** Possible return values:
6611 **
6612 ** 1 pExpr does references a table in pSrcList.
6613 **
6614 ** 0 pExpr references some table that is not defined in either
6615 ** pSrcList or in subqueries of pExpr itself.
6616 **
6617 ** -1 pExpr only references no tables at all, or it only
6618 ** references tables defined in subqueries of pExpr itself.
6619 **
6620 ** As currently used, pExpr is always an aggregate function call. That
6621 ** fact is exploited for efficiency.
6622 */
6624 Walker w;
6643 }
6644 #ifndef SQLITE_OMIT_WINDOWFUNC
6647 }
6648 #endif
6656 }
6657 }
6659 /*
6660 ** This is a Walker expression node callback.
6661 **
6662 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6663 ** object that is referenced does not refer directly to the Expr. If
6664 ** it does, make a copy. This is done because the pExpr argument is
6665 ** subject to change.
6666 **
6667 ** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete()
6668 ** which builds on the sqlite3ParserAddCleanup() mechanism.
6669 */
6673 ){
6682 ){
6686 }
6687 }
6692 ){
6696 }
6697 }
6698 }
6699 }
6701 }
6703 /*
6704 ** Initialize a Walker object so that will persist AggInfo entries referenced
6705 ** by the tree that is walked.
6706 */
6712 }
6714 /*
6715 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6716 ** the new element. Return a negative number if malloc fails.
6717 */
6721 db,
6725 &i
6726 );
6728 }
6730 /*
6731 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6732 ** the new element. Return a negative number if malloc fails.
6733 */
6737 db,
6741 &i
6742 );
6744 }
6746 /*
6747 ** Search the AggInfo object for an aCol[] entry that has iTable and iColumn.
6748 ** Return the index in aCol[] of the entry that describes that column.
6749 **
6750 ** If no prior entry is found, create a new one and return -1. The
6751 ** new column will have an index of pAggInfo->nColumn-1.
6752 */
6757 ){
6768 ){
6770 }
6771 }
6774 /* OOM on resize */
6777 }
6795 ){
6798 }
6799 }
6800 }
6803 }
6804 fix_up_expr:
6810 }
6812 }
6814 /*
6815 ** This is the xExprCallback for a tree walker. It is used to
6816 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
6817 ** for additional information.
6818 */
6831 Expr tmp;
6839 }
6844 }
6849 /* If we reach this point, it means that expression pExpr can be
6850 ** translated into a reference to an index column as described by
6851 ** pIEpr.
6852 */
6865 }
6872 /* Check to see if the column is in one of the tables in the FROM
6873 ** clause of the aggregate query */
6883 }
6885 }
6890 ){
6891 /* Check to see if pExpr is a duplicate of another aggregate
6892 ** function that is already in the pAggInfo structure
6893 */
6899 }
6900 }
6902 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
6903 */
6918 ){
6919 /* The NEEDCOLL test above causes any ORDER BY clause on
6920 ** aggregate min() or max() to be ignored. */
6933 ){
6938 }
6943 }
6948 }
6949 }
6950 }
6951 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
6952 */
6960 }
6961 }
6962 }
6964 }
6966 /*
6967 ** Analyze the pExpr expression looking for aggregate functions and
6968 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
6969 ** points to. Additional entries are made on the AggInfo object as
6970 ** necessary.
6971 **
6972 ** This routine should only be called after the expression has been
6973 ** analyzed by sqlite3ResolveExprNames().
6974 */
6976 Walker w;
6985 }
6987 /*
6988 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
6989 ** expression list. Return the number of errors.
6990 **
6991 ** If an error is found, the analysis is cut short.
6992 */
6999 }
7000 }
7001 }
7003 /*
7004 ** Allocate a single new register for use to hold some intermediate result.
7005 */
7009 }
7011 }
7013 /*
7014 ** Deallocate a register, making available for reuse for some other
7015 ** purpose.
7016 */
7022 }
7023 }
7024 }
7026 /*
7027 ** Allocate or deallocate a block of nReg consecutive registers.
7028 */
7040 }
7042 }
7047 }
7052 }
7053 }
7055 /*
7056 ** Mark all temporary registers as being unavailable for reuse.
7057 **
7058 ** Always invoke this procedure after coding a subroutine or co-routine
7059 ** that might be invoked from other parts of the code, to ensure that
7060 ** the sub/co-routine does not use registers in common with the code that
7061 ** invokes the sub/co-routine.
7062 */
7066 }
7068 /*
7069 ** Make sure sufficient registers have been allocated so that
7070 ** iReg is a valid register number.
7071 */
7074 }
7076 #if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG)
7077 /*
7078 ** Return the latest reusable register in the set of all registers.
7079 ** The value returned is no less than iMin. If any register iMin or
7080 ** greater is in permanent use, then return one more than that last
7081 ** permanent register.
7082 */
7090 }
7091 }
7092 }
7096 }
7099 /*
7100 ** Validate that no temporary register falls within the range of
7101 ** iFirst..iLast, inclusive. This routine is only call from within assert()
7102 ** statements.
7103 */
7104 #ifdef SQLITE_DEBUG
7110 ){
7112 }
7116 }
7117 }
7124 }
7125 }
7127 }