| blob | e4bfa995d7bb490f69b7f624dffe3a3e1217ea03 |
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 */
224 }
225 }
227 }
229 /*
230 ** Return the collation sequence for the expression pExpr. If
231 ** there is no defined collating sequence, return NULL.
232 **
233 ** See also: sqlite3ExprNNCollSeq()
234 **
235 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
236 ** default collation if pExpr has no defined collation.
237 **
238 ** The collating sequence might be determined by a COLLATE operator
239 ** or by the presence of a column with a defined collating sequence.
240 ** COLLATE operators take first precedence. Left operands take
241 ** precedence over right operands.
242 */
252 ){
259 }
261 }
265 }
270 }
275 }
281 /* The Expr.x union is never used at the same time as Expr.pRight */
289 }
290 }
291 }
293 }
296 }
297 }
300 }
302 }
304 /*
305 ** Return the collation sequence for the expression pExpr. If
306 ** there is no defined collating sequence, return a pointer to the
307 ** default collation sequence.
308 **
309 ** See also: sqlite3ExprCollSeq()
310 **
311 ** The sqlite3ExprCollSeq() routine works the same except that it
312 ** returns NULL if there is no defined collation.
313 */
319 }
321 /*
322 ** Return TRUE if the two expressions have equivalent collating sequences.
323 */
328 }
330 /*
331 ** pExpr is an operand of a comparison operator. aff2 is the
332 ** type affinity of the other operand. This routine returns the
333 ** type affinity that should be used for the comparison operator.
334 */
338 /* Both sides of the comparison are columns. If one has numeric
339 ** affinity, use that. Otherwise use no affinity.
340 */
345 }
347 /* One side is a column, the other is not. Use the columns affinity. */
350 }
351 }
353 /*
354 ** pExpr is a comparison operator. Return the type affinity that should
355 ** be applied to both operands prior to doing the comparison.
356 */
370 }
372 }
374 /*
375 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
376 ** idx_affinity is the affinity of an indexed column. Return true
377 ** if the index with affinity idx_affinity may be used to implement
378 ** the comparison in pExpr.
379 */
384 }
387 }
389 }
391 /*
392 ** Return the P5 value that should be used for a binary comparison
393 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
394 */
399 ){
403 }
405 /*
406 ** Return a pointer to the collation sequence that should be used by
407 ** a binary comparison operator comparing pLeft and pRight.
408 **
409 ** If the left hand expression has a collating sequence type, then it is
410 ** used. Otherwise the collation sequence for the right hand expression
411 ** is used, or the default (BINARY) if neither expression has a collating
412 ** type.
413 **
414 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
415 ** it is not considered.
416 */
421 ){
432 }
433 }
435 }
437 /* Expression p is a comparison operator. Return a collation sequence
438 ** appropriate for the comparison operator.
439 **
440 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
441 ** However, if the OP_Commuted flag is set, then the order of the operands
442 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
443 ** correct collating sequence is found.
444 */
450 }
451 }
453 /*
454 ** Generate code for a comparison operator.
455 */
465 ){
475 }
481 }
483 /*
484 ** Return true if expression pExpr is a vector, or false otherwise.
485 **
486 ** A vector is defined as any expression that results in two or more
487 ** columns of result. Every TK_VECTOR node is an vector because the
488 ** parser will not generate a TK_VECTOR with fewer than two entries.
489 ** But a TK_SELECT might be either a vector or a scalar. It is only
490 ** considered a vector if it has two or more result columns.
491 */
494 }
496 /*
497 ** If the expression passed as the only argument is of type TK_VECTOR
498 ** return the number of expressions in the vector. Or, if the expression
499 ** is a sub-select, return the number of columns in the sub-select. For
500 ** any other type of expression, return 1.
501 */
513 }
514 }
516 /*
517 ** Return a pointer to a subexpression of pVector that is the i-th
518 ** column of the vector (numbered starting with 0). The caller must
519 ** ensure that i is within range.
520 **
521 ** If pVector is really a scalar (and "scalar" here includes subqueries
522 ** that return a single column!) then return pVector unmodified.
523 **
524 ** pVector retains ownership of the returned subexpression.
525 **
526 ** If the vector is a (SELECT ...) then the expression returned is
527 ** just the expression for the i-th term of the result set, and may
528 ** not be ready for evaluation because the table cursor has not yet
529 ** been positioned.
530 */
541 }
542 }
544 }
546 /*
547 ** Compute and return a new Expr object which when passed to
548 ** sqlite3ExprCode() will generate all necessary code to compute
549 ** the iField-th column of the vector expression pVector.
550 **
551 ** It is ok for pVector to be a scalar (as long as iField==0).
552 ** In that case, this routine works like sqlite3ExprDup().
553 **
554 ** The caller owns the returned Expr object and is responsible for
555 ** ensuring that the returned value eventually gets freed.
556 **
557 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
558 ** then the returned object will reference pVector and so pVector must remain
559 ** valid for the life of the returned object. If pVector is a TK_VECTOR
560 ** or a scalar expression, then it can be deleted as soon as this routine
561 ** returns.
562 **
563 ** A trick to cause a TK_SELECT pVector to be deleted together with
564 ** the returned Expr object is to attach the pVector to the pRight field
565 ** of the returned TK_SELECT_COLUMN Expr object.
566 */
572 ){
576 /* The TK_SELECT_COLUMN Expr node:
577 **
578 ** pLeft: pVector containing TK_SELECT. Not deleted.
579 ** pRight: not used. But recursively deleted.
580 ** iColumn: Index of a column in pVector
581 ** iTable: 0 or the number of columns on the LHS of an assignment
582 ** pLeft->iTable: First in an array of register holding result, or 0
583 ** if the result is not yet computed.
584 **
585 ** sqlite3ExprDelete() specifically skips the recursive delete of
586 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
587 ** can be attached to pRight to cause this node to take ownership of
588 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
589 ** with the same pLeft pointer to the pVector, but only one of them
590 ** will own the pVector.
591 */
598 }
606 /* This must be a vector UPDATE inside a trigger */
609 }
610 }
612 }
614 }
616 /*
617 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
618 ** it. Return the register in which the result is stored (or, if the
619 ** sub-select returns more than one column, the first in an array
620 ** of registers in which the result is stored).
621 **
622 ** If pExpr is not a TK_SELECT expression, return 0.
623 */
626 #ifndef SQLITE_OMIT_SUBQUERY
629 }
630 #endif
632 }
634 /*
635 ** Argument pVector points to a vector expression - either a TK_VECTOR
636 ** or TK_SELECT that returns more than one column. This function returns
637 ** the register number of a register that contains the value of
638 ** element iField of the vector.
639 **
640 ** If pVector is a TK_SELECT expression, then code for it must have
641 ** already been generated using the exprCodeSubselect() routine. In this
642 ** case parameter regSelect should be the first in an array of registers
643 ** containing the results of the sub-select.
644 **
645 ** If pVector is of type TK_VECTOR, then code for the requested field
646 ** is generated. In this case (*pRegFree) may be set to the number of
647 ** a temporary register to be freed by the caller before returning.
648 **
649 ** Before returning, output parameter (*ppExpr) is set to point to the
650 ** Expr object corresponding to element iElem of the vector.
651 */
659 ){
665 }
670 }
675 }
677 }
679 /*
680 ** Expression pExpr is a comparison between two vector values. Compute
681 ** the result of the comparison (1, 0, or NULL) and write that
682 ** result into register dest.
683 **
684 ** The caller must satisfy the following preconditions:
685 **
686 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
687 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
688 ** otherwise: op==pExpr->op and p5==0
689 */
695 u8 p5 /* SQLITE_NULLEQ or zero */
696 ){
714 }
719 );
755 }
760 }
763 }
770 }
771 }
776 }
777 }
779 #if SQLITE_MAX_EXPR_DEPTH>0
780 /*
781 ** Check that argument nHeight is less than or equal to the maximum
782 ** expression depth allowed. If it is not, leave an error message in
783 ** pParse.
784 */
791 );
793 }
795 }
797 /* The following three functions, heightOfExpr(), heightOfExprList()
798 ** and heightOfSelect(), are used to determine the maximum height
799 ** of any expression tree referenced by the structure passed as the
800 ** first argument.
801 **
802 ** If this maximum height is greater than the current value pointed
803 ** to by pnHeight, the second parameter, then set *pnHeight to that
804 ** value.
805 */
810 }
811 }
812 }
818 }
819 }
820 }
830 }
831 }
833 /*
834 ** Set the Expr.nHeight variable in the structure passed as an
835 ** argument. An expression with no children, Expr.pList or
836 ** Expr.pSelect member has a height of 1. Any other expression
837 ** has a height equal to the maximum height of any other
838 ** referenced Expr plus one.
839 **
840 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
841 ** if appropriate.
842 */
847 }
853 }
855 }
857 /*
858 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
859 ** the height is greater than the maximum allowed expression depth,
860 ** leave an error in pParse.
861 **
862 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
863 ** Expr.flags.
864 */
869 }
871 /*
872 ** Return the maximum height of any expression tree referenced
873 ** by the select statement passed as an argument.
874 */
879 }
881 /*
882 ** Propagate all EP_Propagate flags from the Expr.x.pList into
883 ** Expr.flags.
884 */
889 }
890 }
891 #define exprSetHeight(y)
894 /*
895 ** Set the error offset for an Expr node, if possible.
896 */
901 }
903 /*
904 ** This routine is the core allocator for Expr nodes.
905 **
906 ** Construct a new expression node and return a pointer to it. Memory
907 ** for this node and for the pToken argument is a single allocation
908 ** obtained from sqlite3DbMalloc(). The calling function
909 ** is responsible for making sure the node eventually gets freed.
910 **
911 ** If dequote is true, then the token (if it exists) is dequoted.
912 ** If dequote is false, no dequoting is performed. The deQuote
913 ** parameter is ignored if pToken is NULL or if the token does not
914 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
915 ** then the EP_DblQuoted flag is set on the expression node.
916 **
917 ** Special case (tag-20240227-a): If op==TK_INTEGER and pToken points to
918 ** a string that can be translated into a 32-bit integer, then the token is
919 ** not stored in u.zToken. Instead, the integer values is written
920 ** into u.iValue and the EP_IntValue flag is set. No extra storage
921 ** is allocated to hold the integer text and the dequote flag is ignored.
922 ** See also tag-20240227-b.
923 */
929 ){
940 }
941 }
958 }
959 }
960 }
961 #if SQLITE_MAX_EXPR_DEPTH>0
963 #endif
964 }
966 }
968 /*
969 ** Allocate a new expression node from a zero-terminated token that has
970 ** already been dequoted.
971 */
976 ){
977 Token x;
981 }
983 /*
984 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
985 **
986 ** If pRoot==NULL that means that a memory allocation error has occurred.
987 ** In that case, delete the subtrees pLeft and pRight.
988 */
993 Expr *pRight
994 ){
1005 #if SQLITE_MAX_EXPR_DEPTH>0
1009 #endif
1010 }
1014 #if SQLITE_MAX_EXPR_DEPTH>0
1017 }
1018 #endif
1019 }
1020 }
1021 }
1023 /*
1024 ** Allocate an Expr node which joins as many as two subtrees.
1025 **
1026 ** One or both of the subtrees can be NULL. Return a pointer to the new
1027 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
1028 ** free the subtrees and return NULL.
1029 */
1035 ){
1047 }
1049 }
1051 /*
1052 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
1053 ** do a memory allocation failure) then delete the pSelect object.
1054 */
1063 }
1064 }
1066 /*
1067 ** Expression list pEList is a list of vector values. This function
1068 ** converts the contents of pEList to a VALUES(...) Select statement
1069 ** returning 1 row for each element of the list. For example, the
1070 ** expression list:
1071 **
1072 ** ( (1,2), (3,4) (5,6) )
1073 **
1074 ** is translated to the equivalent of:
1075 **
1076 ** VALUES(1,2), (3,4), (5,6)
1077 **
1078 ** Each of the vector values in pEList must contain exactly nElem terms.
1079 ** If a list element that is not a vector or does not contain nElem terms,
1080 ** an error message is left in pParse.
1081 **
1082 ** This is used as part of processing IN(...) expressions with a list
1083 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
1084 */
1098 }
1102 );
1104 }
1112 }
1114 }
1115 }
1119 }
1122 }
1124 /*
1125 ** Join two expressions using an AND operator. If either expression is
1126 ** NULL, then just return the other expression.
1127 **
1128 ** If one side or the other of the AND is known to be false, and neither side
1129 ** is part of an ON clause, then instead of returning an AND expression,
1130 ** just return a constant expression with a value of false.
1131 */
1141 && !IN_RENAME_OBJECT
1142 ){
1148 }
1149 }
1150 }
1152 /*
1153 ** Construct a new expression node for a function with multiple
1154 ** arguments.
1155 */
1161 ){
1169 }
1175 ){
1177 }
1184 }
1186 /*
1187 ** Report an error when attempting to use an ORDER BY clause within
1188 ** the arguments of a non-aggregate function.
1189 */
1193 );
1194 }
1196 /*
1197 ** Attach an ORDER BY clause to a function call.
1198 **
1199 ** functionname( arguments ORDER BY sortlist )
1200 ** \_____________________/ \______/
1201 ** pExpr pOrderBy
1202 **
1203 ** The ORDER BY clause is inserted into a new Expr node of type TK_ORDER
1204 ** and added to the Expr.pLeft field of the parent TK_FUNCTION node.
1205 */
1210 ){
1216 }
1221 }
1226 /* Ignore ORDER BY on zero-argument aggregates */
1229 }
1234 }
1240 }
1245 }
1247 /*
1248 ** Check to see if a function is usable according to current access
1249 ** rules:
1250 **
1251 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1252 **
1253 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1254 ** top-level SQL
1255 **
1256 ** If the function is not usable, create an error.
1257 */
1262 ){
1268 ){
1269 /* Functions prohibited in triggers and views if:
1270 ** (1) tagged with SQLITE_DIRECTONLY
1271 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1272 ** is tagged with SQLITE_FUNC_UNSAFE) and
1273 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1274 ** that the schema is possibly tainted).
1275 */
1277 }
1278 }
1279 }
1281 /*
1282 ** Assign a variable number to an expression that encodes a wildcard
1283 ** in the original SQL statement.
1284 **
1285 ** Wildcards consisting of a single "?" are assigned the next sequential
1286 ** variable number.
1287 **
1288 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1289 ** sure "nnn" is not too big to avoid a denial of service attack when
1290 ** the SQL statement comes from an external source.
1291 **
1292 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1293 ** as the previous instance of the same wildcard. Or if this is the first
1294 ** instance of the wildcard, the next sequential variable number is
1295 ** assigned.
1296 */
1300 ynVar x;
1309 /* Wildcard of the form "?". Assign the next variable number */
1315 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1316 ** use it as the variable number */
1317 i64 i;
1324 }
1334 }
1341 }
1343 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1344 ** number as the prior appearance of the same name, or if the name
1345 ** has never appeared before, reuse the same variable number
1346 */
1351 }
1352 }
1355 }
1356 }
1361 }
1362 }
1364 /*
1365 ** Recursively delete an expression tree.
1366 */
1374 #ifdef SQLITE_DEBUG
1380 }
1381 #endif
1383 /* The Expr.x union is never used at the same time as Expr.pRight */
1394 #ifndef SQLITE_OMIT_WINDOWFUNC
1397 }
1398 #endif
1399 }
1400 }
1403 }
1404 }
1407 }
1410 }
1412 /*
1413 ** Clear both elements of an OnOrUsing object
1414 */
1417 /* Nothing to clear */
1422 }
1423 }
1425 /*
1426 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1427 ** This is similar to sqlite3ExprDelete() except that the delete is
1428 ** deferred until the pParse is deleted.
1429 **
1430 ** The pExpr might be deleted immediately on an OOM error.
1431 **
1432 ** The deferred delete is (currently) implemented by adding the
1433 ** pExpr to the pParse->pConstExpr list with a register number of 0.
1434 */
1437 }
1439 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1440 ** expression.
1441 */
1446 }
1448 }
1449 }
1451 /*
1452 ** Return the number of bytes allocated for the expression structure
1453 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1454 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1455 */
1460 }
1462 /*
1463 ** The dupedExpr*Size() routines each return the number of bytes required
1464 ** to store a copy of an expression or expression tree. They differ in
1465 ** how much of the tree is measured.
1466 **
1467 ** dupedExprStructSize() Size of only the Expr structure
1468 ** dupedExprNodeSize() Size of Expr + space for token
1469 ** dupedExprSize() Expr + token + subtree components
1470 **
1471 ***************************************************************************
1472 **
1473 ** The dupedExprStructSize() function returns two values OR-ed together:
1474 ** (1) the space required for a copy of the Expr structure only and
1475 ** (2) the EP_xxx flags that indicate what the structure size should be.
1476 ** The return values is always one of:
1477 **
1478 ** EXPR_FULLSIZE
1479 ** EXPR_REDUCEDSIZE | EP_Reduced
1480 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1481 **
1482 ** The size of the structure can be found by masking the return value
1483 ** of this routine with 0xfff. The flags can be found by masking the
1484 ** return value with EP_Reduced|EP_TokenOnly.
1485 **
1486 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1487 ** (unreduced) Expr objects as they or originally constructed by the parser.
1488 ** During expression analysis, extra information is computed and moved into
1489 ** later parts of the Expr object and that extra information might get chopped
1490 ** off if the expression is reduced. Note also that it does not work to
1491 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1492 ** to reduce a pristine expression tree from the parser. The implementation
1493 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1494 ** to enforce this constraint.
1495 */
1512 }
1513 }
1515 }
1517 /*
1518 ** This function returns the space in bytes required to store the copy
1519 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1520 ** string is defined.)
1521 */
1526 }
1528 }
1530 /*
1531 ** Return the number of bytes required to create a duplicate of the
1532 ** expression passed as the first argument.
1533 **
1534 ** The value returned includes space to create a copy of the Expr struct
1535 ** itself and the buffer referred to by Expr.u.zToken, if any.
1536 **
1537 ** The return value includes space to duplicate all Expr nodes in the
1538 ** tree formed by Expr.pLeft and Expr.pRight, but not any other
1539 ** substructure such as Expr.x.pList, Expr.x.pSelect, and Expr.y.pWin.
1540 */
1549 }
1551 /*
1552 ** An EdupBuf is a memory allocation used to stored multiple Expr objects
1553 ** together with their Expr.zToken content. This is used to help implement
1554 ** compression while doing sqlite3ExprDup(). The top-level Expr does the
1555 ** allocation for itself and many of its decendents, then passes an instance
1556 ** of the structure down into exprDup() so that they decendents can have
1557 ** access to that memory.
1558 */
1562 #ifdef SQLITE_DEBUG
1564 #endif
1565 };
1567 /*
1568 ** This function is similar to sqlite3ExprDup(), except that if pEdupBuf
1569 ** is not NULL then it points to memory that can be used to store a copy
1570 ** of the input Expr p together with its p->u.zToken (if any). pEdupBuf
1571 ** is updated with the new buffer tail prior to returning.
1572 */
1578 ){
1589 /* Figure out where to write the new Expr structure. */
1592 #ifdef SQLITE_DEBUG
1594 #endif
1608 }
1611 #ifdef SQLITE_DEBUG
1613 #endif
1616 }
1621 /* Set nNewSize to the size allocated for the structure pointed to
1622 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1623 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1624 ** by the copy of the p->u.zToken string (if any).
1625 */
1633 }
1634 }
1646 }
1648 }
1650 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1657 }
1659 /* Copy the p->u.zToken string, if any. */
1665 }
1670 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1676 }
1678 #ifndef SQLITE_OMIT_WINDOWFUNC
1682 }
1685 /* Fill in pNew->pLeft and pNew->pRight. */
1695 }
1706 }
1708 }
1709 }
1710 }
1714 }
1716 /*
1717 ** Create and return a deep copy of the object passed as the second
1718 ** argument. If an OOM condition is encountered, NULL is returned
1719 ** and the db->mallocFailed flag set.
1720 */
1721 #ifndef SQLITE_OMIT_CTE
1735 }
1736 }
1737 }
1739 }
1740 #else
1741 # define sqlite3WithDup(x,y) 0
1742 #endif
1744 #ifndef SQLITE_OMIT_WINDOWFUNC
1745 /*
1746 ** The gatherSelectWindows() procedure and its helper routine
1747 ** gatherSelectWindowsCallback() are used to scan all the expressions
1748 ** an a newly duplicated SELECT statement and gather all of the Window
1749 ** objects found there, assembling them onto the linked list at Select->pWin.
1750 */
1759 }
1761 }
1764 }
1766 Walker w;
1773 }
1774 #endif
1777 /*
1778 ** The following group of routines make deep copies of expressions,
1779 ** expression lists, ID lists, and select statements. The copies can
1780 ** be deleted (by being passed to their respective ...Delete() routines)
1781 ** without effecting the originals.
1782 **
1783 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1784 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1785 ** by subsequent calls to sqlite*ListAppend() routines.
1786 **
1787 ** Any tables that the SrcList might point to are not duplicated.
1788 **
1789 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1790 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1791 ** truncated version of the usual Expr structure that will be stored as
1792 ** part of the in-memory representation of the database schema.
1793 */
1797 }
1820 ){
1830 }
1832 }
1833 }
1838 }
1840 }
1842 /*
1843 ** If cursors, triggers, views and subqueries are all omitted from
1844 ** the build, then none of the following routines, except for
1845 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1846 ** called with a NULL argument.
1847 */
1848 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1849 || !defined(SQLITE_OMIT_SUBQUERY)
1875 }
1879 }
1883 }
1887 }
1894 }
1896 }
1898 }
1914 }
1916 }
1944 #ifndef SQLITE_OMIT_WINDOWFUNC
1948 #endif
1951 /* Any prior OOM might have left the Select object incomplete.
1952 ** Delete the whole thing rather than allow an incomplete Select
1953 ** to be used by the code generator. */
1957 }
1961 }
1964 }
1965 #else
1969 }
1970 #endif
1973 /*
1974 ** Add a new element to the end of an expression list. If pList is
1975 ** initially NULL, then create a new expression list.
1976 **
1977 ** The pList argument must be either NULL or a pointer to an ExprList
1978 ** obtained from a prior call to sqlite3ExprListAppend().
1979 **
1980 ** If a memory allocation error occurs, the entire list is freed and
1981 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1982 ** that the new entry was successfully appended.
1983 */
1988 ){
1996 }
2003 }
2008 ){
2020 }
2025 }
2030 ){
2034 }
2037 }
2042 }
2044 /*
2045 ** pColumns and pExpr form a vector assignment which is part of the SET
2046 ** clause of an UPDATE statement. Like this:
2047 **
2048 ** (a,b,c) = (expr1,expr2,expr3)
2049 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
2050 **
2051 ** For each term of the vector assignment, append new entries to the
2052 ** expression list pList. In the case of a subquery on the RHS, append
2053 ** TK_SELECT_COLUMN expressions.
2054 */
2060 ){
2065 /* pColumns can only be NULL due to an OOM but an OOM will cause an
2066 ** exit prior to this routine being invoked */
2070 /* If the RHS is a vector, then we can immediately check to see that
2071 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
2072 ** wildcards ("*") in the result set of the SELECT must be expanded before
2073 ** we can do the size check, so defer the size check until code generation.
2074 */
2079 }
2090 }
2091 }
2098 /* Store the SELECT statement in pRight so it will be deleted when
2099 ** sqlite3ExprListDelete() is called */
2103 /* Remember the size of the LHS in iTable so that we can check that
2104 ** the RHS and LHS sizes match during code generation. */
2106 }
2108 vector_append_error:
2112 }
2114 /*
2115 ** Set the sort order for the last element on the given ExprList.
2116 */
2126 );
2130 );
2136 }
2143 }
2144 }
2145 }
2147 /*
2148 ** Set the ExprList.a[].zEName element of the most recently added item
2149 ** on the expression list.
2150 **
2151 ** pList might be NULL following an OOM error. But pName should never be
2152 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2153 ** is set.
2154 */
2160 ){
2171 /* If dequote==0, then pName->z does not point to part of a DDL
2172 ** statement handled by the parser. And so no token need be added
2173 ** to the token-map. */
2177 }
2178 }
2179 }
2180 }
2182 /*
2183 ** Set the ExprList.a[].zSpan element of the most recently added item
2184 ** on the expression list.
2185 **
2186 ** pList might be NULL following an OOM error. But pSpan should never be
2187 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2188 ** is set.
2189 */
2195 ){
2204 }
2205 }
2206 }
2208 /*
2209 ** If the expression list pEList contains more than iLimit elements,
2210 ** leave an error message in pParse.
2211 */
2216 ){
2222 }
2223 }
2225 /*
2226 ** Delete an entire expression list.
2227 */
2236 pItem++;
2239 }
2242 }
2245 }
2247 /*
2248 ** Return the bitwise-OR of all Expr.flags fields in the given
2249 ** ExprList.
2250 */
2259 }
2261 }
2263 /*
2264 ** This is a SELECT-node callback for the expression walker that
2265 ** always "fails". By "fail" in this case, we mean set
2266 ** pWalker->eCode to zero and abort.
2267 **
2268 ** This callback is used by multiple expression walkers.
2269 */
2274 }
2276 /*
2277 ** Check the input string to see if it is "true" or "false" (in any case).
2278 **
2279 ** If the string is.... Return
2280 ** "true" EP_IsTrue
2281 ** "false" EP_IsFalse
2282 ** anything else 0
2283 */
2288 }
2291 /*
2292 ** If the input expression is an ID with the name "true" or "false"
2293 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2294 ** the conversion happened, and zero if the expression is unaltered.
2295 */
2297 u32 v;
2301 ){
2305 }
2307 }
2309 /*
2310 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2311 ** and 0 if it is FALSE.
2312 */
2320 }
2322 /*
2323 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2324 ** terms that are always true or false. Return the simplified expression.
2325 ** Or return the original expression if no simplification is possible.
2326 **
2327 ** Examples:
2328 **
2329 ** (x<10) AND true => (x<10)
2330 ** (x<10) AND false => false
2331 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2332 ** (x<10) AND (y=22 OR true) => (x<10)
2333 ** (y=22) OR true => true
2334 */
2344 }
2345 }
2347 }
2350 /*
2351 ** These routines are Walker callbacks used to check expressions to
2352 ** see if they are "constant" for some definition of constant. The
2353 ** Walker.eCode value determines the type of "constant" we are looking
2354 ** for.
2355 **
2356 ** These callback routines are used to implement the following:
2357 **
2358 ** sqlite3ExprIsConstant() pWalker->eCode==1
2359 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2360 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2361 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2362 **
2363 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2364 ** is found to not be a constant.
2365 **
2366 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2367 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2368 ** when parsing an existing schema out of the sqlite_schema table and 4
2369 ** when processing a new CREATE TABLE statement. A bound parameter raises
2370 ** an error for new statements, but is silently converted
2371 ** to NULL for existing schemas. This allows sqlite_schema tables that
2372 ** contain a bound parameter because they were generated by older versions
2373 ** of SQLite to be parsed by newer versions of SQLite without raising a
2374 ** malformed schema error.
2375 */
2378 /* If pWalker->eCode is 2 then any term of the expression that comes from
2379 ** the ON or USING clauses of an outer join disqualifies the expression
2380 ** from being considered constant. */
2384 }
2387 /* Consider functions to be constant if all their arguments are constant
2388 ** and either pWalker->eCode==4 or 5 or the function has the
2389 ** SQLITE_FUNC_CONST flag. */
2393 ){
2399 }
2401 /* Convert "true" or "false" in a DEFAULT clause into the
2402 ** appropriate TK_TRUEFALSE operator */
2405 }
2406 /* no break */ deliberate_fall_through
2416 }
2419 }
2420 /* no break */ deliberate_fall_through
2431 /* Silently convert bound parameters that appear inside of CREATE
2432 ** statements into a NULL when parsing the CREATE statement text out
2433 ** of the sqlite_schema table */
2436 /* A bound parameter in a CREATE statement that originates from
2437 ** sqlite3_prepare() causes an error */
2440 }
2441 /* no break */ deliberate_fall_through
2446 }
2447 }
2449 Walker w;
2453 #ifdef SQLITE_DEBUG
2455 #endif
2459 }
2461 /*
2462 ** Walk an expression tree. Return non-zero if the expression is constant
2463 ** and 0 if it involves variables or function calls.
2464 **
2465 ** For the purposes of this function, a double-quoted string (ex: "abc")
2466 ** is considered a variable but a single-quoted string (ex: 'abc') is
2467 ** a constant.
2468 */
2471 }
2473 /*
2474 ** Walk an expression tree. Return non-zero if
2475 **
2476 ** (1) the expression is constant, and
2477 ** (2) the expression does originate in the ON or USING clause
2478 ** of a LEFT JOIN, and
2479 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2480 ** operands created by the constant propagation optimization.
2481 **
2482 ** When this routine returns true, it indicates that the expression
2483 ** can be added to the pParse->pConstExpr list and evaluated once when
2484 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2485 */
2488 }
2490 /*
2491 ** Walk an expression tree. Return non-zero if the expression is constant
2492 ** for any single row of the table with cursor iCur. In other words, the
2493 ** expression must not refer to any non-deterministic function nor any
2494 ** table other than iCur.
2495 */
2498 }
2500 /*
2501 ** Check pExpr to see if it is an constraint on the single data source
2502 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
2503 ** constrains pSrc but does not depend on any other tables or data
2504 ** sources anywhere else in the query. Return true (non-zero) if pExpr
2505 ** is a constraint on pSrc only.
2506 **
2507 ** This is an optimization. False negatives will perhaps cause slower
2508 ** queries, but false positives will yield incorrect answers. So when in
2509 ** doubt, return 0.
2510 **
2511 ** To be an single-source constraint, the following must be true:
2512 **
2513 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
2514 **
2515 ** (2) pExpr cannot use subqueries or non-deterministic functions.
2516 **
2517 ** (3) pSrc cannot be part of the left operand for a RIGHT JOIN.
2518 ** (Is there some way to relax this constraint?)
2519 **
2520 ** (4) If pSrc is the right operand of a LEFT JOIN, then...
2521 ** (4a) pExpr must come from an ON clause..
2522 ** (4b) and specifically the ON clause associated with the LEFT JOIN.
2523 **
2524 ** (5) If pSrc is not the right operand of a LEFT JOIN or the left
2525 ** operand of a RIGHT JOIN, then pExpr must be from the WHERE
2526 ** clause, not an ON clause.
2527 **
2528 ** (6) Either:
2529 **
2530 ** (6a) pExpr does not originate in an ON or USING clause, or
2531 **
2532 ** (6b) The ON or USING clause from which pExpr is derived is
2533 ** not to the left of a RIGHT JOIN (or FULL JOIN).
2534 **
2535 ** Without this restriction, accepting pExpr as a single-table
2536 ** constraint might move the the ON/USING filter expression
2537 ** from the left side of a RIGHT JOIN over to the right side,
2538 ** which leads to incorrect answers. See also restriction (9)
2539 ** on push-down.
2540 */
2545 ){
2549 }
2555 }
2558 ){
2564 }
2566 }
2567 }
2568 }
2570 }
2573 /*
2574 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2575 */
2580 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2581 ** it constant. */
2588 }
2589 }
2590 }
2592 /* Check if pExpr is a sub-select. If so, consider it variable. */
2596 }
2599 }
2601 /*
2602 ** Walk the expression tree passed as the first argument. Return non-zero
2603 ** if the expression consists entirely of constants or copies of terms
2604 ** in pGroupBy that sort with the BINARY collation sequence.
2605 **
2606 ** This routine is used to determine if a term of the HAVING clause can
2607 ** be promoted into the WHERE clause. In order for such a promotion to work,
2608 ** the value of the HAVING clause term must be the same for all members of
2609 ** a "group". The requirement that the GROUP BY term must be BINARY
2610 ** assumes that no other collating sequence will have a finer-grained
2611 ** grouping than binary. In other words (A=B COLLATE binary) implies
2612 ** A=B in every other collating sequence. The requirement that the
2613 ** GROUP BY be BINARY is stricter than necessary. It would also work
2614 ** to promote HAVING clauses that use the same alternative collating
2615 ** sequence as the GROUP BY term, but that is much harder to check,
2616 ** alternative collating sequences are uncommon, and this is only an
2617 ** optimization, so we take the easy way out and simply require the
2618 ** GROUP BY to use the BINARY collating sequence.
2619 */
2621 Walker w;
2629 }
2631 /*
2632 ** Walk an expression tree for the DEFAULT field of a column definition
2633 ** in a CREATE TABLE statement. Return non-zero if the expression is
2634 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2635 ** the expression is constant or a function call with constant arguments.
2636 ** Return and 0 if there are any variables.
2637 **
2638 ** isInit is true when parsing from sqlite_schema. isInit is false when
2639 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2640 ** (such as ? or $abc) in the expression are converted into NULL. When
2641 ** isInit is false, parameters raise an error. Parameters should not be
2642 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2643 ** allowed it, so we need to support it when reading sqlite_schema for
2644 ** backwards compatibility.
2645 **
2646 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2647 **
2648 ** For the purposes of this function, a double-quoted string (ex: "abc")
2649 ** is considered a variable but a single-quoted string (ex: 'abc') is
2650 ** a constant.
2651 */
2655 }
2657 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2658 /*
2659 ** Walk an expression tree. Return 1 if the expression contains a
2660 ** subquery of some kind. Return 0 if there are no subqueries.
2661 */
2663 Walker w;
2667 #ifdef SQLITE_DEBUG
2669 #endif
2672 }
2673 #endif
2675 /*
2676 ** If the expression p codes a constant integer that is small enough
2677 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2678 ** in *pValue. If the expression is not an integer or if it is too big
2679 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2680 */
2685 /* If an expression is an integer literal that fits in a signed 32-bit
2686 ** integer, then the EP_IntValue flag will have already been set */
2693 }
2698 }
2705 }
2707 }
2709 }
2711 }
2713 /*
2714 ** Return FALSE if there is no chance that the expression can be NULL.
2715 **
2716 ** If the expression might be NULL or if the expression is too complex
2717 ** to tell return TRUE.
2718 **
2719 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2720 ** when we know that a value cannot be NULL. Hence, a false positive
2721 ** (returning TRUE when in fact the expression can never be NULL) might
2722 ** be a small performance hit but is otherwise harmless. On the other
2723 ** hand, a false negative (returning FALSE when the result could be NULL)
2724 ** will likely result in an incorrect answer. So when in doubt, return
2725 ** TRUE.
2726 */
2728 u8 op;
2733 }
2752 }
2753 }
2755 /*
2756 ** Return TRUE if the given expression is a constant which would be
2757 ** unchanged by OP_Affinity with the affinity given in the second
2758 ** argument.
2759 **
2760 ** This routine is used to determine if the OP_Affinity operation
2761 ** can be omitted. When in doubt return FALSE. A false negative
2762 ** is harmless. A false positive, however, can result in the wrong
2763 ** answer.
2764 */
2766 u8 op;
2772 }
2778 }
2781 }
2784 }
2787 }
2791 }
2794 }
2795 }
2796 }
2798 /*
2799 ** Return TRUE if the given string is a row-id column name.
2800 */
2806 }
2808 /*
2809 ** Return a pointer to a buffer containing a usable rowid alias for table
2810 ** pTab. An alias is usable if there is not an explicit user-defined column
2811 ** of the same name.
2812 */
2821 }
2824 }
2825 }
2827 }
2829 /*
2830 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2831 ** that can be simplified to a direct table access, then return
2832 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2833 ** or if the SELECT statement needs to be materialized into a transient
2834 ** table, then return NULL.
2835 */
2836 #ifndef SQLITE_OMIT_SUBQUERY
2851 }
2865 /* All SELECT results must be columns. */
2870 }
2872 }
2875 #ifndef SQLITE_OMIT_SUBQUERY
2876 /*
2877 ** Generate code that checks the left-most column of index table iCur to see if
2878 ** it contains any NULL entries. Cause the register at regHasNull to be set
2879 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2880 ** to be set to NULL if iCur contains one or more NULL values.
2881 */
2890 }
2891 #endif
2894 #ifndef SQLITE_OMIT_SUBQUERY
2895 /*
2896 ** The argument is an IN operator with a list (not a subquery) on the
2897 ** right-hand side. Return TRUE if that list is constant.
2898 */
2908 }
2909 #endif
2911 /*
2912 ** This function is used by the implementation of the IN (...) operator.
2913 ** The pX parameter is the expression on the RHS of the IN operator, which
2914 ** might be either a list of expressions or a subquery.
2915 **
2916 ** The job of this routine is to find or create a b-tree object that can
2917 ** be used either to test for membership in the RHS set or to iterate through
2918 ** all members of the RHS set, skipping duplicates.
2919 **
2920 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2921 ** and the *piTab parameter is set to the index of that cursor.
2922 **
2923 ** The returned value of this function indicates the b-tree type, as follows:
2924 **
2925 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2926 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2927 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2928 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2929 ** populated ephemeral table.
2930 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2931 ** implemented as a sequence of comparisons.
2932 **
2933 ** An existing b-tree might be used if the RHS expression pX is a simple
2934 ** subquery such as:
2935 **
2936 ** SELECT <column1>, <column2>... FROM <table>
2937 **
2938 ** If the RHS of the IN operator is a list or a more complex subquery, then
2939 ** an ephemeral table might need to be generated from the RHS and then
2940 ** pX->iTable made to point to the ephemeral table instead of an
2941 ** existing table. In this case, the creation and initialization of the
2942 ** ephemeral table might be put inside of a subroutine, the EP_Subrtn flag
2943 ** will be set on pX and the pX->y.sub fields will be set to show where
2944 ** the subroutine is coded.
2945 **
2946 ** The inFlags parameter must contain, at a minimum, one of the bits
2947 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2948 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2949 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2950 ** be used to loop over all values of the RHS of the IN operator.
2951 **
2952 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2953 ** through the set members) then the b-tree must not contain duplicates.
2954 ** An ephemeral table will be created unless the selected columns are guaranteed
2955 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2956 ** a UNIQUE constraint or index.
2957 **
2958 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2959 ** for fast set membership tests) then an ephemeral table must
2960 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2961 ** index can be found with the specified <columns> as its left-most.
2962 **
2963 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2964 ** if the RHS of the IN operator is a list (not a subquery) then this
2965 ** routine might decide that creating an ephemeral b-tree for membership
2966 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2967 ** calling routine should implement the IN operator using a sequence
2968 ** of Eq or Ne comparison operations.
2969 **
2970 ** When the b-tree is being used for membership tests, the calling function
2971 ** might need to know whether or not the RHS side of the IN operator
2972 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2973 ** if there is any chance that the (...) might contain a NULL value at
2974 ** runtime, then a register is allocated and the register number written
2975 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2976 ** NULL value, then *prRhsHasNull is left unchanged.
2977 **
2978 ** If a register is allocated and its location stored in *prRhsHasNull, then
2979 ** the value in that register will be NULL if the b-tree contains one or more
2980 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2981 ** NULL values.
2982 **
2983 ** If the aiMap parameter is not NULL, it must point to an array containing
2984 ** one element for each column returned by the SELECT statement on the RHS
2985 ** of the IN(...) operator. The i'th entry of the array is populated with the
2986 ** offset of the index column that matches the i'th column returned by the
2987 ** SELECT. For example, if the expression and selected index are:
2988 **
2989 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2990 ** CREATE INDEX i1 ON t1(b, c, a);
2991 **
2992 ** then aiMap[] is populated with {2, 0, 1}.
2993 */
2994 #ifndef SQLITE_OMIT_SUBQUERY
3002 ){
3013 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
3014 ** whether or not the SELECT result contains NULL values, check whether
3015 ** or not NULL is actually possible (it may not be, for example, due
3016 ** to NOT NULL constraints in the schema). If no NULL values are possible,
3017 ** set prRhsHasNull to 0 before continuing. */
3023 }
3026 }
3027 }
3029 /* Check to see if an existing table or index can be used to
3030 ** satisfy the query. This is preferable to generating a new
3031 ** ephemeral table. */
3044 /* Code an OP_Transaction and OP_TableLock for <table>. */
3052 /* The "x IN (SELECT rowid FROM table)" case */
3066 /* Check that the affinity that will be used to perform each
3067 ** comparison is the same as the affinity of each column in table
3068 ** on the RHS of the IN operator. If it not, it is not possible to
3069 ** use any index of the RHS table. */
3081 /* sqlite3CompareAffinity() only returns TEXT if one side or the
3082 ** other has no affinity and the other side is TEXT. Hence,
3083 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
3084 ** and for the term on the LHS of the IN to have no affinity. */
3089 }
3090 }
3093 /* Search for an existing index that will work for this IN operator */
3099 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
3100 ** BITMASK(nExpr) without overflowing */
3107 ){
3109 }
3110 }
3124 }
3126 }
3132 }
3136 /* If we reach this point, that means the index pIdx is usable */
3147 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
3151 #endif
3155 }
3156 }
3158 }
3164 /* If no preexisting index is available for the IN clause
3165 ** and IN_INDEX_NOOP is an allowed reply
3166 ** and the RHS of the IN operator is a list, not a subquery
3167 ** and the RHS is not constant or has two or fewer terms,
3168 ** then it is not worth creating an ephemeral table to evaluate
3169 ** the IN operator so return IN_INDEX_NOOP.
3170 */
3175 ){
3179 }
3182 /* Could not find an existing table or index to use as the RHS b-tree.
3183 ** We will have to generate an ephemeral table to do the job.
3184 */
3192 }
3197 }
3199 }
3205 }
3208 }
3209 #endif
3211 #ifndef SQLITE_OMIT_SUBQUERY
3212 /*
3213 ** Argument pExpr is an (?, ?...) IN(...) expression. This
3214 ** function allocates and returns a nul-terminated string containing
3215 ** the affinities to be used for each column of the comparison.
3216 **
3217 ** It is the responsibility of the caller to ensure that the returned
3218 ** string is eventually freed using sqlite3DbFree().
3219 */
3237 }
3238 }
3240 }
3242 }
3243 #endif
3245 #ifndef SQLITE_OMIT_SUBQUERY
3246 /*
3247 ** Load the Parse object passed as the first argument with an error
3248 ** message of the form:
3249 **
3250 ** "sub-select returns N columns - expected M"
3251 */
3256 }
3257 }
3258 #endif
3260 /*
3261 ** Expression pExpr is a vector that has been used in a context where
3262 ** it is not permitted. If pExpr is a sub-select vector, this routine
3263 ** loads the Parse object with a message of the form:
3264 **
3265 ** "sub-select returns N columns - expected 1"
3266 **
3267 ** Or, if it is a regular scalar vector:
3268 **
3269 ** "row value misused"
3270 */
3272 #ifndef SQLITE_OMIT_SUBQUERY
3276 #endif
3277 {
3279 }
3280 }
3282 #ifndef SQLITE_OMIT_SUBQUERY
3283 /*
3284 ** Generate code that will construct an ephemeral table containing all terms
3285 ** in the RHS of an IN operator. The IN operator can be in either of two
3286 ** forms:
3287 **
3288 ** x IN (4,5,11) -- IN operator with list on right-hand side
3289 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
3290 **
3291 ** The pExpr parameter is the IN operator. The cursor number for the
3292 ** constructed ephemeral table is returned. The first time the ephemeral
3293 ** table is computed, the cursor number is also stored in pExpr->iTable,
3294 ** however the cursor number returned might not be the same, as it might
3295 ** have been duplicated using OP_OpenDup.
3296 **
3297 ** If the LHS expression ("x" in the examples) is a column value, or
3298 ** the SELECT statement returns a column value, then the affinity of that
3299 ** column is used to build the index keys. If both 'x' and the
3300 ** SELECT... statement are columns, then numeric affinity is used
3301 ** if either column has NUMERIC or INTEGER affinity. If neither
3302 ** 'x' nor the SELECT... statement are columns, then numeric affinity
3303 ** is used.
3304 */
3309 ){
3320 /* The evaluation of the IN must be repeated every time it
3321 ** is encountered if any of the following is true:
3322 **
3323 ** * The right-hand side is a correlated subquery
3324 ** * The right-hand side is an expression list containing variables
3325 ** * We are inside a trigger
3326 **
3327 ** If all of the above are false, then we can compute the RHS just once
3328 ** and reuse it many names.
3329 */
3331 /* Reuse of the RHS is allowed */
3332 /* If this routine has already been coded, but the previous code
3333 ** might not have been invoked yet, so invoke it now as a subroutine.
3334 */
3340 }
3348 }
3350 /* Begin coding the subroutine */
3359 }
3361 /* Check to see if this is a vector IN operator */
3365 /* Construct the ephemeral table that will contain the content of
3366 ** RHS of the IN operator.
3367 */
3370 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3375 }
3376 #endif
3380 /* Case 1: expr IN (SELECT ...)
3381 **
3382 ** Generate code to write the results of the select into the temporary
3383 ** table allocated and opened above.
3384 */
3390 ));
3391 /* If the LHS and RHS of the IN operator do not match, that
3392 ** error will have been caught long before we reach this point. */
3395 SelectDest dest;
3410 }
3419 );
3420 }
3421 }
3423 /* Case 2: expr IN (exprlist)
3424 **
3425 ** For each expression, build an index key from the evaluation and
3426 ** store it in the temporary table. If <expr> is a column, then use
3427 ** that columns affinity when building index keys. If <expr> is not
3428 ** a column, use numeric affinity.
3429 */
3440 }
3444 }
3446 /* Loop through each expression in <exprlist>. */
3452 /* If the expression is not constant then we will need to
3453 ** disable the test that was generated above that makes sure
3454 ** this code only executes once. Because for a non-constant
3455 ** expression we need to rerun this code each time.
3456 */
3462 }
3464 /* Evaluate the expression and insert it into the temp table */
3468 }
3471 }
3474 }
3478 /* Subroutine return */
3486 }
3487 }
3490 /*
3491 ** Generate code for scalar subqueries used as a subquery expression
3492 ** or EXISTS operator:
3493 **
3494 ** (SELECT a FROM b) -- subquery
3495 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3496 **
3497 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3498 **
3499 ** Return the register that holds the result. For a multi-column SELECT,
3500 ** the result is stored in a contiguous array of registers and the
3501 ** return value is the register of the left-most result column.
3502 ** Return 0 if an error occurs.
3503 */
3504 #ifndef SQLITE_OMIT_SUBQUERY
3512 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3514 #endif
3525 /* If this routine has already been coded, then invoke it as a
3526 ** subroutine. */
3533 }
3535 /* Begin coding the subroutine */
3543 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3544 ** is encountered if any of the following is true:
3545 **
3546 ** * The right-hand side is a correlated subquery
3547 ** * The right-hand side is an expression list containing variables
3548 ** * We are inside a trigger
3549 **
3550 ** If all of the above are false, then we can run this code just once
3551 ** save the results, and reuse the same result on subsequent invocations.
3552 */
3555 }
3557 /* For a SELECT, generate code to put the values for all columns of
3558 ** the first row into an array of registers and return the index of
3559 ** the first register.
3560 **
3561 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3562 ** into a register and return that register number.
3563 **
3564 ** In both cases, the query is augmented with "LIMIT 1". Any
3565 ** preexisting limit is discarded in place of the new LIMIT 1.
3566 */
3583 }
3585 /* The subquery already has a limit. If the pre-existing limit is X
3586 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3593 }
3597 /* If there is no pre-existing limit add a limit of 1 */
3600 }
3606 }
3611 }
3614 /* Subroutine return */
3623 }
3626 #ifndef SQLITE_OMIT_SUBQUERY
3627 /*
3628 ** Expr pIn is an IN(...) expression. This function checks that the
3629 ** sub-select on the RHS of the IN() operator has the same number of
3630 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3631 ** a sub-query, that the LHS is a vector of size 1.
3632 */
3639 }
3643 }
3645 }
3646 #endif
3648 #ifndef SQLITE_OMIT_SUBQUERY
3649 /*
3650 ** Generate code for an IN expression.
3651 **
3652 ** x IN (SELECT ...)
3653 ** x IN (value, value, ...)
3654 **
3655 ** The left-hand side (LHS) is a scalar or vector expression. The
3656 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3657 ** subquery. If the RHS is a subquery, the number of result columns must
3658 ** match the number of columns in the vector on the LHS. If the RHS is
3659 ** a list of values, the LHS must be a scalar.
3660 **
3661 ** The IN operator is true if the LHS value is contained within the RHS.
3662 ** The result is false if the LHS is definitely not in the RHS. The
3663 ** result is NULL if the presence of the LHS in the RHS cannot be
3664 ** determined due to NULLs.
3665 **
3666 ** This routine generates code that jumps to destIfFalse if the LHS is not
3667 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3668 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3669 ** within the RHS then fall through.
3670 **
3671 ** See the separate in-operator.md documentation file in the canonical
3672 ** SQLite source tree for additional information.
3673 */
3679 ){
3706 );
3709 /* Attempt to compute the RHS. After this step, if anything other than
3710 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3711 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3712 ** the RHS has not yet been coded. */
3723 );
3724 #ifdef SQLITE_DEBUG
3725 /* Confirm that aiMap[] contains nVector integer values between 0 and
3726 ** nVector-1. */
3731 }
3732 #endif
3734 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3735 ** vector, then it is stored in an array of nVector registers starting
3736 ** at r1.
3737 **
3738 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3739 ** so that the fields are in the same order as an existing index. The
3740 ** aiMap[] array contains a mapping from the original LHS field order to
3741 ** the field order that matches the RHS index.
3742 **
3743 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3744 ** even if it is constant, as OP_Affinity may be used on the register
3745 ** by code generated below. */
3752 /* LHS fields are not reordered */
3755 /* Need to reorder the LHS fields according to aiMap */
3759 }
3760 }
3762 /* If sqlite3FindInIndex() did not find or create an index that is
3763 ** suitable for evaluating the IN operator, then evaluate using a
3764 ** sequence of comparisons.
3765 **
3766 ** This is step (1) in the in-operator.md optimized algorithm.
3767 */
3781 }
3786 }
3805 }
3806 }
3810 }
3814 }
3816 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3817 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3818 ** We will then skip the binary search of the RHS.
3819 */
3824 }
3831 }
3832 }
3834 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3835 ** of the RHS using the LHS as a probe. If found, the result is
3836 ** true.
3837 */
3839 /* In this case, the RHS is the ROWID of table b-tree and so we also
3840 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3841 ** into a single opcode. */
3848 /* Combine Step 3 and Step 5 into a single opcode */
3852 }
3853 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3856 }
3858 /* Step 4. If the RHS is known to be non-NULL and we did not find
3859 ** an match on the search above, then the result must be FALSE.
3860 */
3864 }
3866 /* Step 5. If we do not care about the difference between NULL and
3867 ** FALSE, then just return false.
3868 */
3871 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3872 ** If any comparison is NULL, then the result is NULL. If all
3873 ** comparisons are FALSE then the final result is FALSE.
3874 **
3875 ** For a scalar LHS, it is sufficient to check just the first row
3876 ** of the RHS.
3877 */
3884 /* For nVector==1, combine steps 6 and 7 by immediately returning
3885 ** FALSE if the first comparison is not NULL */
3887 }
3899 }
3906 /* Step 7: If we reach this point, we know that the result must
3907 ** be false. */
3909 }
3911 /* Jumps here in order to return true. */
3914 sqlite3ExprCodeIN_finished:
3917 sqlite3ExprCodeIN_oom_error:
3920 }
3923 #ifndef SQLITE_OMIT_FLOATING_POINT
3924 /*
3925 ** Generate an instruction that will put the floating point
3926 ** value described by z[0..n-1] into register iMem.
3927 **
3928 ** The z[] string will probably not be zero-terminated. But the
3929 ** z[n] character is guaranteed to be something that does not look
3930 ** like the continuation of the number.
3931 */
3939 }
3940 }
3941 #endif
3944 /*
3945 ** Generate an instruction that will put the integer describe by
3946 ** text z[0..n-1] into register iMem.
3947 **
3948 ** Expr.u.zToken is always UTF8 and zero-terminated.
3949 */
3959 i64 value;
3964 #ifdef SQLITE_OMIT_FLOATING_POINT
3966 #else
3967 #ifndef SQLITE_OMIT_HEX_INTEGER
3972 #endif
3973 {
3975 }
3976 #endif
3980 }
3981 }
3982 }
3985 /* Generate code that will load into register regOut a value that is
3986 ** appropriate for the iIdxCol-th column of index pIdx.
3987 */
3994 ){
4005 }
4006 }
4008 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4009 /*
4010 ** Generate code that will compute the value of generated column pCol
4011 ** and store the result in register regOut
4012 */
4018 ){
4028 }
4032 }
4035 }
4038 /*
4039 ** Generate code to extract the value of the iCol-th column of a table.
4040 */
4047 ){
4061 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4074 }
4076 #endif
4085 }
4088 }
4089 }
4091 /*
4092 ** Generate code that will extract the iColumn-th column from
4093 ** table pTab and store the column value in register iReg.
4094 **
4095 ** There must be an open cursor to pTab in iTable when this routine
4096 ** is called. If iColumn<0 then code is generated that extracts the rowid.
4097 */
4104 u8 p5 /* P5 value for OP_Column + FLAGS */
4105 ){
4114 }
4116 }
4118 /*
4119 ** Generate code to move content from registers iFrom...iFrom+nReg-1
4120 ** over to iTo..iTo+nReg-1.
4121 */
4124 }
4126 /*
4127 ** Convert a scalar expression node to a TK_REGISTER referencing
4128 ** register iReg. The caller must ensure that iReg already contains
4129 ** the correct value for the expression.
4130 */
4138 }
4140 /*
4141 ** Evaluate an expression (either a vector or a scalar expression) and store
4142 ** the result in contiguous temporary registers. Return the index of
4143 ** the first register used to store the result.
4144 **
4145 ** If the returned result register is a temporary scalar, then also write
4146 ** that register number into *piFreeable. If the returned result register
4147 ** is not a temporary or if the expression is a vector set *piFreeable
4148 ** to 0.
4149 */
4158 #if SQLITE_OMIT_SUBQUERY
4160 #else
4162 #endif
4170 }
4171 }
4172 }
4174 }
4176 /*
4177 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
4178 ** so that a subsequent copy will not be merged into this one.
4179 */
4183 }
4184 }
4186 /*
4187 ** Generate code to implement special SQL functions that are implemented
4188 ** in-line rather than by using the usual callbacks.
4189 */
4195 ){
4204 /* Attempt a direct implementation of the built-in COALESCE() and
4205 ** IFNULL() functions. This avoids unnecessary evaluation of
4206 ** arguments past the first non-NULL argument.
4207 */
4216 }
4220 }
4222 Expr caseExpr;
4227 }
4228 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4235 }
4237 }
4238 #endif
4240 /* The UNLIKELY() function is a no-op. The result is the value
4241 ** of the first argument.
4242 */
4246 }
4248 /***********************************************************************
4249 ** Test-only SQL functions that are only usable if enabled
4250 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
4251 */
4252 #if !defined(SQLITE_UNTESTABLE)
4254 /* Compare two expressions using sqlite3ExprCompare() */
4258 target);
4260 }
4263 /* Compare two expressions using sqlite3ExprImpliesExpr() */
4267 target);
4269 }
4272 /* Result of sqlite3ExprImpliesNonNullRow() */
4279 target);
4282 }
4284 }
4287 /* The AFFINITY() function evaluates to a string that describes
4288 ** the type affinity of the argument. This is used for testing of
4289 ** the SQLite type logic.
4290 */
4301 }
4303 }
4305 }
4307 /*
4308 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
4309 ** If it is, then resolve the expression by reading from the index and
4310 ** return the register into which the value has been read. If pExpr is
4311 ** not an indexed expression, then return negative.
4312 */
4317 ){
4321 u8 exprAff;
4327 }
4334 ){
4335 /* Affinity mismatch on a generated column */
4337 }
4342 /* If the index is on a NULL row due to an outer join, then we
4343 ** cannot extract the value from the index. The value must be
4344 ** computed using the original expression. */
4359 }
4361 }
4363 }
4366 /*
4367 ** Expresion pExpr is guaranteed to be a TK_COLUMN or equivalent. This
4368 ** function checks the Parse.pIdxPartExpr list to see if this column
4369 ** can be replaced with a constant value. If so, it generates code to
4370 ** put the constant value in a register (ideally, but not necessarily,
4371 ** register iTarget) and returns the register number.
4372 **
4373 ** Or, if the TK_COLUMN cannot be replaced by a constant, zero is
4374 ** returned.
4375 */
4386 }
4393 }
4395 }
4396 }
4398 }
4401 /*
4402 ** Generate code into the current Vdbe to evaluate the given
4403 ** expression. Attempt to store the results in register "target".
4404 ** Return the register where results are stored.
4405 **
4406 ** With this routine, there is no guarantee that results will
4407 ** be stored in target. The result might be stored in some other
4408 ** register if it is convenient to do so. The calling function
4409 ** must check the return code and move the results to the desired
4410 ** register.
4411 */
4425 expr_code_doover:
4431 ){
4436 }
4445 /* Happens when the left table of a RIGHT JOIN is null and
4446 ** is using an expression index */
4448 #ifdef SQLITE_VDBE_COVERAGE
4449 /* Verify that the OP_Null above is exercised by tests
4450 ** tag-20230325-2 */
4453 #endif
4455 }
4464 /* No comment added */
4472 }
4473 }
4476 /* This case happens when the argument to an aggregate function
4477 ** is rewritten by aggregateConvertIndexedExprRefToColumn() */
4480 }
4481 /* Otherwise, fall thru into the TK_COLUMN case */
4482 /* no break */ deliberate_fall_through
4483 }
4488 /* This COLUMN expression is really a constant due to WHERE clause
4489 ** constraints, and that constant is coded by the pExpr->pLeft
4490 ** expression. However, make sure the constant has the correct
4491 ** datatype by applying the Affinity of the table column to the
4492 ** constant.
4493 */
4505 }
4507 }
4510 /* Other columns in the same row for CHECK constraints or
4511 ** generated columns or for inserting into partial index.
4512 ** The row is unpacked into registers beginning at
4513 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4514 ** immediately prior to the first column.
4515 */
4527 }
4531 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4537 }
4541 }
4552 }
4554 /* Coding an expression that is part of an index where column names
4555 ** in the index refer to the table to which the index belongs */
4557 }
4558 }
4561 ){
4563 }
4570 }
4574 }
4578 }
4579 #ifndef SQLITE_OMIT_FLOATING_POINT
4584 }
4585 #endif
4590 }
4592 /* Make NULL the default case so that if a bug causes an illegal
4593 ** Expr node to be passed into this function, it will be handled
4594 ** sanely and not crash. But keep the assert() to bring the problem
4595 ** to the attention of the developers. */
4599 }
4600 #ifndef SQLITE_OMIT_BLOB_LITERAL
4614 }
4615 #endif
4622 }
4625 }
4626 #ifndef SQLITE_OMIT_CAST
4628 /* Expressions of the form: CAST(pLeft AS token) */
4635 }
4641 /* fall-through */
4668 }
4671 }
4673 }
4703 }
4710 #ifndef SQLITE_OMIT_FLOATING_POINT
4715 #endif
4725 }
4727 }
4736 }
4748 }
4763 }
4769 ){
4774 }
4776 }
4788 #ifndef SQLITE_OMIT_WINDOWFUNC
4791 }
4792 #endif
4795 /* SQL functions can be expensive. So try to avoid running them
4796 ** multiple times if we know they always give the same result */
4798 }
4806 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4809 }
4810 #endif
4814 }
4822 }
4828 }
4831 }
4832 }
4839 }
4841 /* For length() and typeof() and octet_length() functions,
4842 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4843 ** or OPFLAG_TYPEOFARG or OPFLAG_BYTELENARG respectively, to avoid
4844 ** unnecessary data loading.
4845 */
4847 u8 exprOp;
4860 }
4861 }
4866 }
4867 #ifndef SQLITE_OMIT_VIRTUALTABLE
4868 /* Possibly overload the function if the first argument is
4869 ** a virtual table column.
4870 **
4871 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4872 ** second argument, not the first, as the argument to test to
4873 ** see if it is a column in a virtual table. This is done because
4874 ** the left operand of infix functions (the operand we want to
4875 ** control overloading) ends up as the second argument to the
4876 ** function. The expression "A glob B" is equivalent to
4877 ** "glob(B,A). We want to use the A in "A glob B" to test
4878 ** for function overloading. But we use the B term in "glob(B,A)".
4879 */
4884 }
4885 #endif
4889 }
4897 }
4898 }
4900 }
4901 #ifndef SQLITE_OMIT_SUBQUERY
4912 ){
4916 }
4918 }
4925 }
4931 }
4933 }
4944 }
4948 /*
4949 ** x BETWEEN y AND z
4950 **
4951 ** This is equivalent to
4952 **
4953 ** x>=y AND x<=z
4954 **
4955 ** X is stored in pExpr->pLeft.
4956 ** Y is stored in pExpr->pList->a[0].pExpr.
4957 ** Z is stored in pExpr->pList->a[1].pExpr.
4958 */
4962 }
4965 /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
4966 ** "SOFT-COLLATE" that is added to constraints that are pushed down
4967 ** from outer queries into sub-queries by the push-down optimization.
4968 ** Clear subtypes as subtypes may not cross a subquery boundary.
4969 */
4977 }
4978 }
4983 }
4986 /* If the opcode is TK_TRIGGER, then the expression is a reference
4987 ** to a column in the new.* or old.* pseudo-tables available to
4988 ** trigger programs. In this case Expr.iTable is set to 1 for the
4989 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4990 ** is set to the column of the pseudo-table to read, or to -1 to
4991 ** read the rowid field.
4992 **
4993 ** The expression is implemented using an OP_Param opcode. The p1
4994 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4995 ** to reference another column of the old.* pseudo-table, where
4996 ** i is the index of the column. For a new.rowid reference, p1 is
4997 ** set to (n+1), where n is the number of columns in each pseudo-table.
4998 ** For a reference to any other column in the new.* pseudo-table, p1
4999 ** is set to (n+2+i), where n and i are as defined previously. For
5000 ** example, if the table on which triggers are being fired is
5001 ** declared as:
5002 **
5003 ** CREATE TABLE t1(a, b);
5004 **
5005 ** Then p1 is interpreted as follows:
5006 **
5007 ** p1==0 -> old.rowid p1==3 -> new.rowid
5008 ** p1==1 -> old.a p1==4 -> new.a
5009 ** p1==2 -> old.b p1==5 -> new.b
5010 */
5030 ));
5032 #ifndef SQLITE_OMIT_FLOATING_POINT
5033 /* If the column has REAL affinity, it may currently be stored as an
5034 ** integer. Use OP_RealAffinity to make sure it is really real.
5035 **
5036 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
5037 ** floating point when extracting it from the record. */
5040 }
5041 #endif
5043 }
5048 }
5050 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
5051 ** that derive from the right-hand table of a LEFT JOIN. The
5052 ** Expr.iTable value is the table number for the right-hand table.
5053 ** The expression is only evaluated if that table is not currently
5054 ** on a LEFT JOIN NULL row.
5055 */
5065 }
5069 target);
5072 }
5073 }
5075 /* The OP_IfNullRow opcode above can overwrite the result register with
5076 ** NULL. So we have to ensure that the result register is not a value
5077 ** that is suppose to be a constant. Two defenses are needed:
5078 ** (1) Temporarily disable factoring of constant expressions
5079 ** (2) Make sure the computed value really is stored in register
5080 ** "target" and not someplace else.
5081 */
5088 }
5090 /*
5091 ** Form A:
5092 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
5093 **
5094 ** Form B:
5095 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
5096 **
5097 ** Form A is can be transformed into the equivalent form B as follows:
5098 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
5099 ** WHEN x=eN THEN rN ELSE y END
5100 **
5101 ** X (if it exists) is in pExpr->pLeft.
5102 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
5103 ** odd. The Y is also optional. If the number of elements in x.pList
5104 ** is even, then Y is omitted and the "otherwise" result is NULL.
5105 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
5106 **
5107 ** The result of the expression is the Ri for the first matching Ei,
5108 ** or if there is no matching Ei, the ELSE term Y, or if there is
5109 ** no ELSE term, NULL.
5110 */
5135 }
5143 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
5144 ** The value in regFree1 might get SCopy-ed into the file result.
5145 ** So make sure that the regFree1 register is not reused for other
5146 ** purposes and possibly overwritten. */
5148 }
5155 }
5163 }
5168 }
5173 }
5174 #ifndef SQLITE_OMIT_TRIGGER
5180 );
5185 }
5188 }
5198 }
5201 }
5202 #endif
5203 }
5207 }
5209 /*
5210 ** Generate code that will evaluate expression pExpr just one time
5211 ** per prepared statement execution.
5212 **
5213 ** If the expression uses functions (that might throw an exception) then
5214 ** guard them with an OP_Once opcode to ensure that the code is only executed
5215 ** once. If no functions are involved, then factor the code out and put it at
5216 ** the end of the prepared statement in the initialization section.
5217 **
5218 ** If regDest>0 then the result is always stored in that register and the
5219 ** result is not reusable. If regDest<0 then this routine is free to
5220 ** store the value wherever it wants. The register where the expression
5221 ** is stored is returned. When regDest<0, two identical expressions might
5222 ** code to the same register, if they do not contain function calls and hence
5223 ** are factored out into the initialization section at the end of the
5224 ** prepared statement.
5225 */
5230 ){
5241 ){
5243 }
5244 }
5245 }
5256 }
5267 }
5269 }
5271 }
5273 /*
5274 ** Generate code to evaluate an expression and store the results
5275 ** into a register. Return the register number where the results
5276 ** are stored.
5277 **
5278 ** If the register is a temporary register that can be deallocated,
5279 ** then write its number into *pReg. If the result register is not
5280 ** a temporary, then set *pReg to zero.
5281 **
5282 ** If pExpr is a constant, then this routine might generate this
5283 ** code to fill the register in the initialization section of the
5284 ** VDBE program, in order to factor it out of the evaluation loop.
5285 */
5293 ){
5304 }
5305 }
5307 }
5309 /*
5310 ** Generate code that will evaluate expression pExpr and store the
5311 ** results in register target. The results are guaranteed to appear
5312 ** in register target.
5313 */
5323 u8 op;
5328 ){
5332 }
5334 }
5335 }
5337 /*
5338 ** Make a transient copy of expression pExpr and then code it using
5339 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
5340 ** except that the input expression is guaranteed to be unchanged.
5341 */
5347 }
5349 /*
5350 ** Generate code that will evaluate expression pExpr and store the
5351 ** results in register target. The results are guaranteed to appear
5352 ** in register target. If the expression is constant, then this routine
5353 ** might choose to code the expression at initialization time.
5354 */
5360 }
5361 }
5363 /*
5364 ** Generate code that pushes the value of every element of the given
5365 ** expression list into a sequence of registers beginning at target.
5366 **
5367 ** Return the number of elements evaluated. The number returned will
5368 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
5369 ** is defined.
5370 **
5371 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
5372 ** filled using OP_SCopy. OP_Copy must be used instead.
5373 **
5374 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
5375 ** factored out into initialization code.
5376 **
5377 ** The SQLITE_ECEL_REF flag means that expressions in the list with
5378 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
5379 ** in registers at srcReg, and so the value can be copied from there.
5380 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
5381 ** are simply omitted rather than being copied from srcReg.
5382 */
5388 u8 flags /* SQLITE_ECEL_* flags */
5389 ){
5401 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
5403 i--;
5404 n--;
5406 #endif
5409 i--;
5410 n--;
5413 }
5416 ){
5427 ){
5431 }
5432 }
5433 }
5434 }
5436 }
5438 /*
5439 ** Generate code for a BETWEEN operator.
5440 **
5441 ** x BETWEEN y AND z
5442 **
5443 ** The above is equivalent to
5444 **
5445 ** x>=y AND x<=z
5446 **
5447 ** Code it as such, taking care to do the common subexpression
5448 ** elimination of x.
5449 **
5450 ** The xJumpIf parameter determines details:
5451 **
5452 ** NULL: Store the boolean result in reg[dest]
5453 ** sqlite3ExprIfTrue: Jump to dest if true
5454 ** sqlite3ExprIfFalse: Jump to dest if false
5455 **
5456 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
5457 */
5464 ){
5492 /* Mark the expression is being from the ON or USING clause of a join
5493 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5494 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5495 ** for clarity, but we are out of bits in the Expr.flags field so we
5496 ** have to reuse the EP_OuterON bit. Bummer. */
5499 }
5501 }
5504 /* Ensure adequate test coverage */
5514 }
5516 /*
5517 ** Generate code for a boolean expression such that a jump is made
5518 ** to the label "dest" if the expression is true but execution
5519 ** continues straight thru if the expression is false.
5520 **
5521 ** If the expression evaluates to NULL (neither true nor false), then
5522 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5523 **
5524 ** This code depends on the fact that certain token values (ex: TK_EQ)
5525 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5526 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5527 ** the make process cause these values to align. Assert()s in the code
5528 ** below verify that the numbers are aligned correctly.
5529 */
5559 }
5561 }
5566 }
5581 }
5583 }
5590 /* no break */ deliberate_fall_through
5616 }
5628 }
5633 }
5634 #ifndef SQLITE_OMIT_SUBQUERY
5642 }
5643 #endif
5645 default_expr:
5649 /* No-op */
5656 }
5658 }
5659 }
5662 }
5664 /*
5665 ** Generate code for a boolean expression such that a jump is made
5666 ** to the label "dest" if the expression is false but execution
5667 ** continues straight thru if the expression is true.
5668 **
5669 ** If the expression evaluates to NULL (neither true nor false) then
5670 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5671 ** is 0.
5672 */
5685 /* The value of pExpr->op and op are related as follows:
5686 **
5687 ** pExpr->op op
5688 ** --------- ----------
5689 ** TK_ISNULL OP_NotNull
5690 ** TK_NOTNULL OP_IsNull
5691 ** TK_NE OP_Eq
5692 ** TK_EQ OP_Ne
5693 ** TK_GT OP_Le
5694 ** TK_LE OP_Gt
5695 ** TK_GE OP_Lt
5696 ** TK_LT OP_Ge
5697 **
5698 ** For other values of pExpr->op, op is undefined and unused.
5699 ** The value of TK_ and OP_ constants are arranged such that we
5700 ** can compute the mapping above using the following expression.
5701 ** Assert()s verify that the computation is correct.
5702 */
5705 /* Verify correct alignment of TK_ and OP_ constants
5706 */
5733 }
5735 }
5740 }
5750 /* IS TRUE and IS NOT FALSE */
5755 /* IS FALSE and IS NOT TRUE */
5758 }
5760 }
5767 /* no break */ deliberate_fall_through
5793 }
5803 }
5808 }
5809 #ifndef SQLITE_OMIT_SUBQUERY
5817 }
5819 }
5820 #endif
5822 default_expr:
5826 /* no-op */
5833 }
5835 }
5836 }
5839 }
5841 /*
5842 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5843 ** code generation, and that copy is deleted after code generation. This
5844 ** ensures that the original pExpr is unchanged.
5845 */
5851 }
5853 }
5855 /*
5856 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5857 ** type of expression.
5858 **
5859 ** If pExpr is a simple SQL value - an integer, real, string, blob
5860 ** or NULL value - then the VDBE currently being prepared is configured
5861 ** to re-prepare each time a new value is bound to variable pVar.
5862 **
5863 ** Additionally, if pExpr is a simple SQL value and the value is the
5864 ** same as that currently bound to variable pVar, non-zero is returned.
5865 ** Otherwise, if the values are not the same or if pExpr is not a simple
5866 ** SQL value, zero is returned.
5867 */
5872 ){
5885 }
5887 }
5890 }
5893 }
5895 /*
5896 ** Do a deep comparison of two expression trees. Return 0 if the two
5897 ** expressions are completely identical. Return 1 if they differ only
5898 ** by a COLLATE operator at the top level. Return 2 if there are differences
5899 ** other than the top-level COLLATE operator.
5900 **
5901 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5902 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5903 **
5904 ** The pA side might be using TK_REGISTER. If that is the case and pB is
5905 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
5906 **
5907 ** Sometimes this routine will return 2 even if the two expressions
5908 ** really are equivalent. If we cannot prove that the expressions are
5909 ** identical, we return 2 just to be safe. So if this routine
5910 ** returns 2, then you do not really know for certain if the two
5911 ** expressions are the same. But if you get a 0 or 1 return, then you
5912 ** can be sure the expressions are the same. In the places where
5913 ** this routine is used, it does not hurt to get an extra 2 - that
5914 ** just might result in some slightly slower code. But returning
5915 ** an incorrect 0 or 1 could lead to a malfunction.
5916 **
5917 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
5918 ** pParse->pReprepare can be matched against literals in pB. The
5919 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
5920 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
5921 ** Argument pParse should normally be NULL. If it is not NULL and pA or
5922 ** pB causes a return value of 2.
5923 */
5928 int iTab
5929 ){
5930 u32 combinedFlags;
5933 }
5936 }
5941 }
5943 }
5947 }
5950 }
5953 ){
5954 /* fall through */
5957 }
5958 }
5964 #ifndef SQLITE_OMIT_WINDOWFUNC
5968 }
5972 }
5973 }
5974 #endif
5984 ){
5986 }
5987 }
5999 ){
6004 }
6005 }
6006 }
6008 }
6010 /*
6011 ** Compare two ExprList objects. Return 0 if they are identical, 1
6012 ** if they are certainly different, or 2 if it is not possible to
6013 ** determine if they are identical or not.
6014 **
6015 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
6016 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
6017 **
6018 ** This routine might return non-zero for equivalent ExprLists. The
6019 ** only consequence will be disabled optimizations. But this routine
6020 ** must never return 0 if the two ExprList objects are different, or
6021 ** a malfunction will result.
6022 **
6023 ** Two NULL pointers are considered to be the same. But a NULL pointer
6024 ** always differs from a non-NULL pointer.
6025 */
6037 }
6039 }
6041 /*
6042 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
6043 ** are ignored.
6044 */
6049 iTab);
6050 }
6052 /*
6053 ** Return non-zero if Expr p can only be true if pNN is not NULL.
6054 **
6055 ** Or if seenNot is true, return non-zero if Expr p can only be
6056 ** non-NULL if pNN is not NULL
6057 */
6064 ){
6069 }
6075 }
6085 ){
6087 }
6089 }
6103 /* no break */ deliberate_fall_through
6109 /* no break */ deliberate_fall_through
6110 }
6116 }
6121 }
6125 }
6126 }
6128 }
6130 /*
6131 ** Return true if we can prove the pE2 will always be true if pE1 is
6132 ** true. Return false if we cannot complete the proof or if pE2 might
6133 ** be false. Examples:
6134 **
6135 ** pE1: x==5 pE2: x==5 Result: true
6136 ** pE1: x>0 pE2: x==5 Result: false
6137 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
6138 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
6139 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
6140 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
6141 ** pE1: x IS ?2 pE2: x IS NOT NULL Result: false
6142 **
6143 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
6144 ** Expr.iTable<0 then assume a table number given by iTab.
6145 **
6146 ** If pParse is not NULL, then the values of bound variables in pE1 are
6147 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
6148 ** modified to record which bound variables are referenced. If pParse
6149 ** is NULL, then false will be returned if pE1 contains any bound variables.
6150 **
6151 ** When in doubt, return false. Returning true might give a performance
6152 ** improvement. Returning false might cause a performance reduction, but
6153 ** it will always give the correct answer and is hence always safe.
6154 */
6159 int iTab
6160 ){
6163 }
6167 ){
6169 }
6172 ){
6174 }
6176 }
6178 /* This is a helper function to impliesNotNullRow(). In this routine,
6179 ** set pWalker->eCode to one only if *both* of the input expressions
6180 ** separately have the implies-not-null-row property.
6181 */
6188 }
6189 }
6190 }
6192 /*
6193 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
6194 ** If the expression node requires that the table at pWalker->iCur
6195 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
6196 **
6197 ** pWalker->mWFlags is non-zero if this inquiry is being undertaking on
6198 ** behalf of a RIGHT JOIN (or FULL JOIN). That makes a difference when
6199 ** evaluating terms in the ON clause of an inner join.
6200 **
6201 ** This routine controls an optimization. False positives (setting
6202 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
6203 ** (never setting pWalker->eCode) is a harmless missed optimization.
6204 */
6210 /* If iCur is used in an inner-join ON clause to the left of a
6211 ** RIGHT JOIN, that does *not* mean that the table must be non-null.
6212 ** But it is difficult to check for that condition precisely.
6213 ** To keep things simple, any use of iCur from any inner-join is
6214 ** ignored while attempting to simplify a RIGHT JOIN. */
6216 }
6240 }
6245 /* Both sides of an AND or OR must separately imply non-null-row.
6246 ** Consider these cases:
6247 ** 1. NOT (x AND y)
6248 ** 2. x OR y
6249 ** If only one of x or y is non-null-row, then the overall expression
6250 ** can be true if the other arm is false (case 1) or true (case 2).
6251 */
6258 /* Beware of "x NOT IN ()" and "x NOT IN (SELECT 1 WHERE false)",
6259 ** both of which can be true. But apart from these cases, if
6260 ** the left-hand side of the IN is NULL then the IN itself will be
6261 ** NULL. */
6264 }
6268 /* In "x NOT BETWEEN y AND z" either x must be non-null-row or else
6269 ** both y and z must be non-null row */
6277 /* Virtual tables are allowed to use constraints like x=NULL. So
6278 ** a term of the form x=y does not prove that y is not null if x
6279 ** is the column of a virtual table */
6294 /* The y.pTab=0 assignment in wherecode.c always happens after the
6295 ** impliesNotNullRow() test */
6304 ){
6306 }
6307 /* no break */ deliberate_fall_through
6308 }
6311 }
6312 }
6314 /*
6315 ** Return true (non-zero) if expression p can only be true if at least
6316 ** one column of table iTab is non-null. In other words, return true
6317 ** if expression p will always be NULL or false if every column of iTab
6318 ** is NULL.
6319 **
6320 ** False negatives are acceptable. In other words, it is ok to return
6321 ** zero even if expression p will never be true of every column of iTab
6322 ** is NULL. A false negative is merely a missed optimization opportunity.
6323 **
6324 ** False positives are not allowed, however. A false positive may result
6325 ** in an incorrect answer.
6326 **
6327 ** Terms of p that are marked with EP_OuterON (and hence that come from
6328 ** the ON or USING clauses of OUTER JOINS) are excluded from the analysis.
6329 **
6330 ** This routine is used to check if a LEFT JOIN can be converted into
6331 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
6332 ** clause requires that some column of the right table of the LEFT JOIN
6333 ** be non-NULL, then the LEFT JOIN can be safely converted into an
6334 ** ordinary join.
6335 */
6337 Walker w;
6346 }
6347 }
6356 }
6358 /*
6359 ** An instance of the following structure is used by the tree walker
6360 ** to determine if an expression can be evaluated by reference to the
6361 ** index only, without having to do a search for the corresponding
6362 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
6363 ** is the cursor for the table.
6364 */
6368 };
6370 /*
6371 ** Check to see if there are references to columns in table
6372 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
6373 ** pWalker->u.pIdxCover->pIdx.
6374 */
6379 ){
6382 }
6384 }
6386 /*
6387 ** Determine if an index pIdx on table with cursor iCur contains will
6388 ** the expression pExpr. Return true if the index does cover the
6389 ** expression and false if the pExpr expression references table columns
6390 ** that are not found in the index pIdx.
6391 **
6392 ** An index covering an expression means that the expression can be
6393 ** evaluated using only the index and without having to lookup the
6394 ** corresponding table entry.
6395 */
6400 ){
6401 Walker w;
6410 }
6413 /* Structure used to pass information throughout the Walker in order to
6414 ** implement sqlite3ReferencesSrcList().
6415 */
6421 };
6423 /*
6424 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
6425 **
6426 ** When entering a new subquery on the pExpr argument, add all FROM clause
6427 ** entries for that subquery to the exclude list.
6428 **
6429 ** When leaving the subquery, remove those entries from the exclude list.
6430 */
6445 }
6448 }
6450 }
6457 }
6458 }
6460 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
6461 **
6462 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
6463 ** of the tables shown in RefSrcList.pRef.
6464 **
6465 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
6466 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
6467 */
6471 ){
6480 }
6481 }
6485 }
6486 }
6488 }
6490 /*
6491 ** Check to see if pExpr references any tables in pSrcList.
6492 ** Possible return values:
6493 **
6494 ** 1 pExpr does references a table in pSrcList.
6495 **
6496 ** 0 pExpr references some table that is not defined in either
6497 ** pSrcList or in subqueries of pExpr itself.
6498 **
6499 ** -1 pExpr only references no tables at all, or it only
6500 ** references tables defined in subqueries of pExpr itself.
6501 **
6502 ** As currently used, pExpr is always an aggregate function call. That
6503 ** fact is exploited for efficiency.
6504 */
6506 Walker w;
6525 }
6526 #ifndef SQLITE_OMIT_WINDOWFUNC
6529 }
6530 #endif
6538 }
6539 }
6541 /*
6542 ** This is a Walker expression node callback.
6543 **
6544 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6545 ** object that is referenced does not refer directly to the Expr. If
6546 ** it does, make a copy. This is done because the pExpr argument is
6547 ** subject to change.
6548 **
6549 ** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete()
6550 ** which builds on the sqlite3ParserAddCleanup() mechanism.
6551 */
6555 ){
6564 ){
6569 }
6570 }
6575 ){
6580 }
6581 }
6582 }
6583 }
6585 }
6587 /*
6588 ** Initialize a Walker object so that will persist AggInfo entries referenced
6589 ** by the tree that is walked.
6590 */
6596 }
6598 /*
6599 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6600 ** the new element. Return a negative number if malloc fails.
6601 */
6605 db,
6609 &i
6610 );
6612 }
6614 /*
6615 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6616 ** the new element. Return a negative number if malloc fails.
6617 */
6621 db,
6625 &i
6626 );
6628 }
6630 /*
6631 ** Search the AggInfo object for an aCol[] entry that has iTable and iColumn.
6632 ** Return the index in aCol[] of the entry that describes that column.
6633 **
6634 ** If no prior entry is found, create a new one and return -1. The
6635 ** new column will have an index of pAggInfo->nColumn-1.
6636 */
6641 ){
6652 ){
6654 }
6655 }
6658 /* OOM on resize */
6661 }
6679 ){
6682 }
6683 }
6684 }
6687 }
6688 fix_up_expr:
6694 }
6696 }
6698 /*
6699 ** This is the xExprCallback for a tree walker. It is used to
6700 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
6701 ** for additional information.
6702 */
6715 Expr tmp;
6723 }
6728 }
6733 /* If we reach this point, it means that expression pExpr can be
6734 ** translated into a reference to an index column as described by
6735 ** pIEpr.
6736 */
6749 }
6756 /* Check to see if the column is in one of the tables in the FROM
6757 ** clause of the aggregate query */
6767 }
6769 }
6774 ){
6775 /* Check to see if pExpr is a duplicate of another aggregate
6776 ** function that is already in the pAggInfo structure
6777 */
6783 }
6784 }
6786 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
6787 */
6802 ){
6803 /* The NEEDCOLL test above causes any ORDER BY clause on
6804 ** aggregate min() or max() to be ignored. */
6817 ){
6822 }
6827 }
6832 }
6833 }
6834 }
6835 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
6836 */
6844 }
6845 }
6846 }
6848 }
6850 /*
6851 ** Analyze the pExpr expression looking for aggregate functions and
6852 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
6853 ** points to. Additional entries are made on the AggInfo object as
6854 ** necessary.
6855 **
6856 ** This routine should only be called after the expression has been
6857 ** analyzed by sqlite3ResolveExprNames().
6858 */
6860 Walker w;
6869 }
6871 /*
6872 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
6873 ** expression list. Return the number of errors.
6874 **
6875 ** If an error is found, the analysis is cut short.
6876 */
6883 }
6884 }
6885 }
6887 /*
6888 ** Allocate a single new register for use to hold some intermediate result.
6889 */
6893 }
6895 }
6897 /*
6898 ** Deallocate a register, making available for reuse for some other
6899 ** purpose.
6900 */
6906 }
6907 }
6908 }
6910 /*
6911 ** Allocate or deallocate a block of nReg consecutive registers.
6912 */
6924 }
6926 }
6931 }
6936 }
6937 }
6939 /*
6940 ** Mark all temporary registers as being unavailable for reuse.
6941 **
6942 ** Always invoke this procedure after coding a subroutine or co-routine
6943 ** that might be invoked from other parts of the code, to ensure that
6944 ** the sub/co-routine does not use registers in common with the code that
6945 ** invokes the sub/co-routine.
6946 */
6950 }
6952 /*
6953 ** Make sure sufficient registers have been allocated so that
6954 ** iReg is a valid register number.
6955 */
6958 }
6960 #if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG)
6961 /*
6962 ** Return the latest reusable register in the set of all registers.
6963 ** The value returned is no less than iMin. If any register iMin or
6964 ** greater is in permanent use, then return one more than that last
6965 ** permanent register.
6966 */
6974 }
6975 }
6976 }
6980 }
6983 /*
6984 ** Validate that no temporary register falls within the range of
6985 ** iFirst..iLast, inclusive. This routine is only call from within assert()
6986 ** statements.
6987 */
6988 #ifdef SQLITE_DEBUG
6994 ){
6996 }
7000 }
7001 }
7008 }
7009 }
7011 }