| blob | d96f362856b19d4380f3b87a5dc96ae333147531 |
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 */
597 }
605 /* This must be a vector UPDATE inside a trigger */
608 }
609 }
611 }
613 }
615 /*
616 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
617 ** it. Return the register in which the result is stored (or, if the
618 ** sub-select returns more than one column, the first in an array
619 ** of registers in which the result is stored).
620 **
621 ** If pExpr is not a TK_SELECT expression, return 0.
622 */
625 #ifndef SQLITE_OMIT_SUBQUERY
628 }
629 #endif
631 }
633 /*
634 ** Argument pVector points to a vector expression - either a TK_VECTOR
635 ** or TK_SELECT that returns more than one column. This function returns
636 ** the register number of a register that contains the value of
637 ** element iField of the vector.
638 **
639 ** If pVector is a TK_SELECT expression, then code for it must have
640 ** already been generated using the exprCodeSubselect() routine. In this
641 ** case parameter regSelect should be the first in an array of registers
642 ** containing the results of the sub-select.
643 **
644 ** If pVector is of type TK_VECTOR, then code for the requested field
645 ** is generated. In this case (*pRegFree) may be set to the number of
646 ** a temporary register to be freed by the caller before returning.
647 **
648 ** Before returning, output parameter (*ppExpr) is set to point to the
649 ** Expr object corresponding to element iElem of the vector.
650 */
658 ){
664 }
669 }
674 }
676 }
678 /*
679 ** Expression pExpr is a comparison between two vector values. Compute
680 ** the result of the comparison (1, 0, or NULL) and write that
681 ** result into register dest.
682 **
683 ** The caller must satisfy the following preconditions:
684 **
685 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
686 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
687 ** otherwise: op==pExpr->op and p5==0
688 */
694 u8 p5 /* SQLITE_NULLEQ or zero */
695 ){
713 }
718 );
754 }
759 }
762 }
769 }
770 }
775 }
776 }
778 #if SQLITE_MAX_EXPR_DEPTH>0
779 /*
780 ** Check that argument nHeight is less than or equal to the maximum
781 ** expression depth allowed. If it is not, leave an error message in
782 ** pParse.
783 */
790 );
792 }
794 }
796 /* The following three functions, heightOfExpr(), heightOfExprList()
797 ** and heightOfSelect(), are used to determine the maximum height
798 ** of any expression tree referenced by the structure passed as the
799 ** first argument.
800 **
801 ** If this maximum height is greater than the current value pointed
802 ** to by pnHeight, the second parameter, then set *pnHeight to that
803 ** value.
804 */
809 }
810 }
811 }
817 }
818 }
819 }
829 }
830 }
832 /*
833 ** Set the Expr.nHeight variable in the structure passed as an
834 ** argument. An expression with no children, Expr.pList or
835 ** Expr.pSelect member has a height of 1. Any other expression
836 ** has a height equal to the maximum height of any other
837 ** referenced Expr plus one.
838 **
839 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
840 ** if appropriate.
841 */
846 }
852 }
854 }
856 /*
857 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
858 ** the height is greater than the maximum allowed expression depth,
859 ** leave an error in pParse.
860 **
861 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
862 ** Expr.flags.
863 */
868 }
870 /*
871 ** Return the maximum height of any expression tree referenced
872 ** by the select statement passed as an argument.
873 */
878 }
880 /*
881 ** Propagate all EP_Propagate flags from the Expr.x.pList into
882 ** Expr.flags.
883 */
888 }
889 }
890 #define exprSetHeight(y)
893 /*
894 ** Set the error offset for an Expr node, if possible.
895 */
900 }
902 /*
903 ** This routine is the core allocator for Expr nodes.
904 **
905 ** Construct a new expression node and return a pointer to it. Memory
906 ** for this node and for the pToken argument is a single allocation
907 ** obtained from sqlite3DbMalloc(). The calling function
908 ** is responsible for making sure the node eventually gets freed.
909 **
910 ** If dequote is true, then the token (if it exists) is dequoted.
911 ** If dequote is false, no dequoting is performed. The deQuote
912 ** parameter is ignored if pToken is NULL or if the token does not
913 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
914 ** then the EP_DblQuoted flag is set on the expression node.
915 **
916 ** Special case: If op==TK_INTEGER and pToken points to a string that
917 ** can be translated into a 32-bit integer, then the token is not
918 ** stored in u.zToken. Instead, the integer values is written
919 ** into u.iValue and the EP_IntValue flag is set. No extra storage
920 ** is allocated to hold the integer text and the dequote flag is ignored.
921 */
927 ){
938 }
939 }
956 }
957 }
958 }
959 #if SQLITE_MAX_EXPR_DEPTH>0
961 #endif
962 }
964 }
966 /*
967 ** Allocate a new expression node from a zero-terminated token that has
968 ** already been dequoted.
969 */
974 ){
975 Token x;
979 }
981 /*
982 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
983 **
984 ** If pRoot==NULL that means that a memory allocation error has occurred.
985 ** In that case, delete the subtrees pLeft and pRight.
986 */
991 Expr *pRight
992 ){
1003 #if SQLITE_MAX_EXPR_DEPTH>0
1007 #endif
1008 }
1012 #if SQLITE_MAX_EXPR_DEPTH>0
1015 }
1016 #endif
1017 }
1018 }
1019 }
1021 /*
1022 ** Allocate an Expr node which joins as many as two subtrees.
1023 **
1024 ** One or both of the subtrees can be NULL. Return a pointer to the new
1025 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
1026 ** free the subtrees and return NULL.
1027 */
1033 ){
1045 }
1047 }
1049 /*
1050 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
1051 ** do a memory allocation failure) then delete the pSelect object.
1052 */
1061 }
1062 }
1064 /*
1065 ** Expression list pEList is a list of vector values. This function
1066 ** converts the contents of pEList to a VALUES(...) Select statement
1067 ** returning 1 row for each element of the list. For example, the
1068 ** expression list:
1069 **
1070 ** ( (1,2), (3,4) (5,6) )
1071 **
1072 ** is translated to the equivalent of:
1073 **
1074 ** VALUES(1,2), (3,4), (5,6)
1075 **
1076 ** Each of the vector values in pEList must contain exactly nElem terms.
1077 ** If a list element that is not a vector or does not contain nElem terms,
1078 ** an error message is left in pParse.
1079 **
1080 ** This is used as part of processing IN(...) expressions with a list
1081 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
1082 */
1096 }
1100 );
1102 }
1110 }
1112 }
1113 }
1117 }
1120 }
1122 /*
1123 ** Join two expressions using an AND operator. If either expression is
1124 ** NULL, then just return the other expression.
1125 **
1126 ** If one side or the other of the AND is known to be false, and neither side
1127 ** is part of an ON clause, then instead of returning an AND expression,
1128 ** just return a constant expression with a value of false.
1129 */
1139 && !IN_RENAME_OBJECT
1140 ){
1146 }
1147 }
1148 }
1150 /*
1151 ** Construct a new expression node for a function with multiple
1152 ** arguments.
1153 */
1159 ){
1167 }
1173 ){
1175 }
1182 }
1184 /*
1185 ** Check to see if a function is usable according to current access
1186 ** rules:
1187 **
1188 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1189 **
1190 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1191 ** top-level SQL
1192 **
1193 ** If the function is not usable, create an error.
1194 */
1199 ){
1205 ){
1206 /* Functions prohibited in triggers and views if:
1207 ** (1) tagged with SQLITE_DIRECTONLY
1208 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1209 ** is tagged with SQLITE_FUNC_UNSAFE) and
1210 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1211 ** that the schema is possibly tainted).
1212 */
1214 }
1215 }
1216 }
1218 /*
1219 ** Assign a variable number to an expression that encodes a wildcard
1220 ** in the original SQL statement.
1221 **
1222 ** Wildcards consisting of a single "?" are assigned the next sequential
1223 ** variable number.
1224 **
1225 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1226 ** sure "nnn" is not too big to avoid a denial of service attack when
1227 ** the SQL statement comes from an external source.
1228 **
1229 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1230 ** as the previous instance of the same wildcard. Or if this is the first
1231 ** instance of the wildcard, the next sequential variable number is
1232 ** assigned.
1233 */
1237 ynVar x;
1246 /* Wildcard of the form "?". Assign the next variable number */
1252 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1253 ** use it as the variable number */
1254 i64 i;
1261 }
1271 }
1278 }
1280 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1281 ** number as the prior appearance of the same name, or if the name
1282 ** has never appeared before, reuse the same variable number
1283 */
1288 }
1289 }
1292 }
1293 }
1298 }
1299 }
1301 /*
1302 ** Recursively delete an expression tree.
1303 */
1311 #ifdef SQLITE_DEBUG
1317 }
1318 #endif
1320 /* The Expr.x union is never used at the same time as Expr.pRight */
1331 #ifndef SQLITE_OMIT_WINDOWFUNC
1334 }
1335 #endif
1336 }
1337 }
1340 }
1341 }
1344 }
1346 /*
1347 ** Clear both elements of an OnOrUsing object
1348 */
1351 /* Nothing to clear */
1356 }
1357 }
1359 /*
1360 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1361 ** This is similar to sqlite3ExprDelete() except that the delete is
1362 ** deferred until the pParse is deleted.
1363 **
1364 ** The pExpr might be deleted immediately on an OOM error.
1365 **
1366 ** The deferred delete is (currently) implemented by adding the
1367 ** pExpr to the pParse->pConstExpr list with a register number of 0.
1368 */
1372 pExpr);
1373 }
1375 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1376 ** expression.
1377 */
1382 }
1384 }
1385 }
1387 /*
1388 ** Return the number of bytes allocated for the expression structure
1389 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1390 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1391 */
1396 }
1398 /*
1399 ** The dupedExpr*Size() routines each return the number of bytes required
1400 ** to store a copy of an expression or expression tree. They differ in
1401 ** how much of the tree is measured.
1402 **
1403 ** dupedExprStructSize() Size of only the Expr structure
1404 ** dupedExprNodeSize() Size of Expr + space for token
1405 ** dupedExprSize() Expr + token + subtree components
1406 **
1407 ***************************************************************************
1408 **
1409 ** The dupedExprStructSize() function returns two values OR-ed together:
1410 ** (1) the space required for a copy of the Expr structure only and
1411 ** (2) the EP_xxx flags that indicate what the structure size should be.
1412 ** The return values is always one of:
1413 **
1414 ** EXPR_FULLSIZE
1415 ** EXPR_REDUCEDSIZE | EP_Reduced
1416 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1417 **
1418 ** The size of the structure can be found by masking the return value
1419 ** of this routine with 0xfff. The flags can be found by masking the
1420 ** return value with EP_Reduced|EP_TokenOnly.
1421 **
1422 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1423 ** (unreduced) Expr objects as they or originally constructed by the parser.
1424 ** During expression analysis, extra information is computed and moved into
1425 ** later parts of the Expr object and that extra information might get chopped
1426 ** off if the expression is reduced. Note also that it does not work to
1427 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1428 ** to reduce a pristine expression tree from the parser. The implementation
1429 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1430 ** to enforce this constraint.
1431 */
1438 #ifndef SQLITE_OMIT_WINDOWFUNC
1440 #endif
1441 ){
1452 }
1453 }
1455 }
1457 /*
1458 ** This function returns the space in bytes required to store the copy
1459 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1460 ** string is defined.)
1461 */
1466 }
1468 }
1470 /*
1471 ** Return the number of bytes required to create a duplicate of the
1472 ** expression passed as the first argument. The second argument is a
1473 ** mask containing EXPRDUP_XXX flags.
1474 **
1475 ** The value returned includes space to create a copy of the Expr struct
1476 ** itself and the buffer referred to by Expr.u.zToken, if any.
1477 **
1478 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1479 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1480 ** and Expr.pRight variables (but not for any structures pointed to or
1481 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1482 */
1489 }
1490 }
1492 }
1494 /*
1495 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1496 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1497 ** to store the copy of expression p, the copies of p->u.zToken
1498 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1499 ** if any. Before returning, *pzBuffer is set to the first byte past the
1500 ** portion of the buffer copied into by this function.
1501 */
1512 /* Figure out where to write the new Expr structure. */
1520 }
1524 /* Set nNewSize to the size allocated for the structure pointed to
1525 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1526 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1527 ** by the copy of the p->u.zToken string (if any).
1528 */
1536 }
1545 }
1546 }
1548 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1555 }
1557 /* Copy the p->u.zToken string, if any. */
1561 }
1564 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1569 }
1570 }
1572 /* Fill in pNew->pLeft and pNew->pRight. */
1580 }
1581 #ifndef SQLITE_OMIT_WINDOWFUNC
1585 }
1589 }
1598 }
1600 }
1601 }
1602 }
1604 }
1606 /*
1607 ** Create and return a deep copy of the object passed as the second
1608 ** argument. If an OOM condition is encountered, NULL is returned
1609 ** and the db->mallocFailed flag set.
1610 */
1611 #ifndef SQLITE_OMIT_CTE
1625 }
1626 }
1627 }
1629 }
1630 #else
1631 # define sqlite3WithDup(x,y) 0
1632 #endif
1634 #ifndef SQLITE_OMIT_WINDOWFUNC
1635 /*
1636 ** The gatherSelectWindows() procedure and its helper routine
1637 ** gatherSelectWindowsCallback() are used to scan all the expressions
1638 ** an a newly duplicated SELECT statement and gather all of the Window
1639 ** objects found there, assembling them onto the linked list at Select->pWin.
1640 */
1649 }
1651 }
1654 }
1656 Walker w;
1663 }
1664 #endif
1667 /*
1668 ** The following group of routines make deep copies of expressions,
1669 ** expression lists, ID lists, and select statements. The copies can
1670 ** be deleted (by being passed to their respective ...Delete() routines)
1671 ** without effecting the originals.
1672 **
1673 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1674 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1675 ** by subsequent calls to sqlite*ListAppend() routines.
1676 **
1677 ** Any tables that the SrcList might point to are not duplicated.
1678 **
1679 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1680 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1681 ** truncated version of the usual Expr structure that will be stored as
1682 ** part of the in-memory representation of the database schema.
1683 */
1687 }
1710 ){
1720 }
1722 }
1723 }
1728 }
1730 }
1732 /*
1733 ** If cursors, triggers, views and subqueries are all omitted from
1734 ** the build, then none of the following routines, except for
1735 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1736 ** called with a NULL argument.
1737 */
1738 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1739 || !defined(SQLITE_OMIT_SUBQUERY)
1764 }
1768 }
1772 }
1776 }
1783 }
1785 }
1787 }
1803 }
1805 }
1833 #ifndef SQLITE_OMIT_WINDOWFUNC
1837 #endif
1840 /* Any prior OOM might have left the Select object incomplete.
1841 ** Delete the whole thing rather than allow an incomplete Select
1842 ** to be used by the code generator. */
1846 }
1850 }
1853 }
1854 #else
1858 }
1859 #endif
1862 /*
1863 ** Add a new element to the end of an expression list. If pList is
1864 ** initially NULL, then create a new expression list.
1865 **
1866 ** The pList argument must be either NULL or a pointer to an ExprList
1867 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1868 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1869 ** Reason: This routine assumes that the number of slots in pList->a[]
1870 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1871 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1872 **
1873 ** If a memory allocation error occurs, the entire list is freed and
1874 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1875 ** that the new entry was successfully appended.
1876 */
1881 ){
1889 }
1896 }
1901 ){
1913 }
1918 }
1923 ){
1927 }
1930 }
1935 }
1937 /*
1938 ** pColumns and pExpr form a vector assignment which is part of the SET
1939 ** clause of an UPDATE statement. Like this:
1940 **
1941 ** (a,b,c) = (expr1,expr2,expr3)
1942 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1943 **
1944 ** For each term of the vector assignment, append new entries to the
1945 ** expression list pList. In the case of a subquery on the RHS, append
1946 ** TK_SELECT_COLUMN expressions.
1947 */
1953 ){
1958 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1959 ** exit prior to this routine being invoked */
1963 /* If the RHS is a vector, then we can immediately check to see that
1964 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1965 ** wildcards ("*") in the result set of the SELECT must be expanded before
1966 ** we can do the size check, so defer the size check until code generation.
1967 */
1972 }
1983 }
1984 }
1991 /* Store the SELECT statement in pRight so it will be deleted when
1992 ** sqlite3ExprListDelete() is called */
1996 /* Remember the size of the LHS in iTable so that we can check that
1997 ** the RHS and LHS sizes match during code generation. */
1999 }
2001 vector_append_error:
2005 }
2007 /*
2008 ** Set the sort order for the last element on the given ExprList.
2009 */
2019 );
2023 );
2029 }
2036 }
2037 }
2038 }
2040 /*
2041 ** Set the ExprList.a[].zEName element of the most recently added item
2042 ** on the expression list.
2043 **
2044 ** pList might be NULL following an OOM error. But pName should never be
2045 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2046 ** is set.
2047 */
2053 ){
2064 /* If dequote==0, then pName->z does not point to part of a DDL
2065 ** statement handled by the parser. And so no token need be added
2066 ** to the token-map. */
2070 }
2071 }
2072 }
2073 }
2075 /*
2076 ** Set the ExprList.a[].zSpan element of the most recently added item
2077 ** on the expression list.
2078 **
2079 ** pList might be NULL following an OOM error. But pSpan should never be
2080 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2081 ** is set.
2082 */
2088 ){
2097 }
2098 }
2099 }
2101 /*
2102 ** If the expression list pEList contains more than iLimit elements,
2103 ** leave an error message in pParse.
2104 */
2109 ){
2115 }
2116 }
2118 /*
2119 ** Delete an entire expression list.
2120 */
2129 pItem++;
2132 }
2135 }
2137 /*
2138 ** Return the bitwise-OR of all Expr.flags fields in the given
2139 ** ExprList.
2140 */
2149 }
2151 }
2153 /*
2154 ** This is a SELECT-node callback for the expression walker that
2155 ** always "fails". By "fail" in this case, we mean set
2156 ** pWalker->eCode to zero and abort.
2157 **
2158 ** This callback is used by multiple expression walkers.
2159 */
2164 }
2166 /*
2167 ** Check the input string to see if it is "true" or "false" (in any case).
2168 **
2169 ** If the string is.... Return
2170 ** "true" EP_IsTrue
2171 ** "false" EP_IsFalse
2172 ** anything else 0
2173 */
2178 }
2181 /*
2182 ** If the input expression is an ID with the name "true" or "false"
2183 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2184 ** the conversion happened, and zero if the expression is unaltered.
2185 */
2187 u32 v;
2191 ){
2195 }
2197 }
2199 /*
2200 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2201 ** and 0 if it is FALSE.
2202 */
2210 }
2212 /*
2213 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2214 ** terms that are always true or false. Return the simplified expression.
2215 ** Or return the original expression if no simplification is possible.
2216 **
2217 ** Examples:
2218 **
2219 ** (x<10) AND true => (x<10)
2220 ** (x<10) AND false => false
2221 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2222 ** (x<10) AND (y=22 OR true) => (x<10)
2223 ** (y=22) OR true => true
2224 */
2234 }
2235 }
2237 }
2240 /*
2241 ** These routines are Walker callbacks used to check expressions to
2242 ** see if they are "constant" for some definition of constant. The
2243 ** Walker.eCode value determines the type of "constant" we are looking
2244 ** for.
2245 **
2246 ** These callback routines are used to implement the following:
2247 **
2248 ** sqlite3ExprIsConstant() pWalker->eCode==1
2249 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2250 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2251 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2252 **
2253 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2254 ** is found to not be a constant.
2255 **
2256 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2257 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2258 ** when parsing an existing schema out of the sqlite_schema table and 4
2259 ** when processing a new CREATE TABLE statement. A bound parameter raises
2260 ** an error for new statements, but is silently converted
2261 ** to NULL for existing schemas. This allows sqlite_schema tables that
2262 ** contain a bound parameter because they were generated by older versions
2263 ** of SQLite to be parsed by newer versions of SQLite without raising a
2264 ** malformed schema error.
2265 */
2268 /* If pWalker->eCode is 2 then any term of the expression that comes from
2269 ** the ON or USING clauses of an outer join disqualifies the expression
2270 ** from being considered constant. */
2274 }
2277 /* Consider functions to be constant if all their arguments are constant
2278 ** and either pWalker->eCode==4 or 5 or the function has the
2279 ** SQLITE_FUNC_CONST flag. */
2283 ){
2289 }
2291 /* Convert "true" or "false" in a DEFAULT clause into the
2292 ** appropriate TK_TRUEFALSE operator */
2295 }
2296 /* no break */ deliberate_fall_through
2306 }
2309 }
2310 /* no break */ deliberate_fall_through
2321 /* Silently convert bound parameters that appear inside of CREATE
2322 ** statements into a NULL when parsing the CREATE statement text out
2323 ** of the sqlite_schema table */
2326 /* A bound parameter in a CREATE statement that originates from
2327 ** sqlite3_prepare() causes an error */
2330 }
2331 /* no break */ deliberate_fall_through
2336 }
2337 }
2339 Walker w;
2343 #ifdef SQLITE_DEBUG
2345 #endif
2349 }
2351 /*
2352 ** Walk an expression tree. Return non-zero if the expression is constant
2353 ** and 0 if it involves variables or function calls.
2354 **
2355 ** For the purposes of this function, a double-quoted string (ex: "abc")
2356 ** is considered a variable but a single-quoted string (ex: 'abc') is
2357 ** a constant.
2358 */
2361 }
2363 /*
2364 ** Walk an expression tree. Return non-zero if
2365 **
2366 ** (1) the expression is constant, and
2367 ** (2) the expression does originate in the ON or USING clause
2368 ** of a LEFT JOIN, and
2369 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2370 ** operands created by the constant propagation optimization.
2371 **
2372 ** When this routine returns true, it indicates that the expression
2373 ** can be added to the pParse->pConstExpr list and evaluated once when
2374 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2375 */
2378 }
2380 /*
2381 ** Walk an expression tree. Return non-zero if the expression is constant
2382 ** for any single row of the table with cursor iCur. In other words, the
2383 ** expression must not refer to any non-deterministic function nor any
2384 ** table other than iCur.
2385 */
2388 }
2390 /*
2391 ** Check pExpr to see if it is an constraint on the single data source
2392 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
2393 ** constrains pSrc but does not depend on any other tables or data
2394 ** sources anywhere else in the query. Return true (non-zero) if pExpr
2395 ** is a constraint on pSrc only.
2396 **
2397 ** This is an optimization. False negatives will perhaps cause slower
2398 ** queries, but false positives will yield incorrect answers. So when in
2399 ** doubt, return 0.
2400 **
2401 ** To be an single-source constraint, the following must be true:
2402 **
2403 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
2404 **
2405 ** (2) pExpr cannot use subqueries or non-deterministic functions.
2406 **
2407 ** (3) pSrc cannot be part of the left operand for a RIGHT JOIN.
2408 ** (Is there some way to relax this constraint?)
2409 **
2410 ** (4) If pSrc is the right operand of a LEFT JOIN, then...
2411 ** (4a) pExpr must come from an ON clause..
2412 ** (4b) and specifically the ON clause associated with the LEFT JOIN.
2413 **
2414 ** (5) If pSrc is not the right operand of a LEFT JOIN or the left
2415 ** operand of a RIGHT JOIN, then pExpr must be from the WHERE
2416 ** clause, not an ON clause.
2417 **
2418 ** (6) Either:
2419 **
2420 ** (6a) pExpr does not originate in an ON or USING clause, or
2421 **
2422 ** (6b) The ON or USING clause from which pExpr is derived is
2423 ** not to the left of a RIGHT JOIN (or FULL JOIN).
2424 **
2425 ** Without this restriction, accepting pExpr as a single-table
2426 ** constraint might move the the ON/USING filter expression
2427 ** from the left side of a RIGHT JOIN over to the right side,
2428 ** which leads to incorrect answers. See also restriction (9)
2429 ** on push-down.
2430 */
2435 ){
2439 }
2445 }
2448 ){
2454 }
2456 }
2457 }
2458 }
2460 }
2463 /*
2464 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2465 */
2470 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2471 ** it constant. */
2478 }
2479 }
2480 }
2482 /* Check if pExpr is a sub-select. If so, consider it variable. */
2486 }
2489 }
2491 /*
2492 ** Walk the expression tree passed as the first argument. Return non-zero
2493 ** if the expression consists entirely of constants or copies of terms
2494 ** in pGroupBy that sort with the BINARY collation sequence.
2495 **
2496 ** This routine is used to determine if a term of the HAVING clause can
2497 ** be promoted into the WHERE clause. In order for such a promotion to work,
2498 ** the value of the HAVING clause term must be the same for all members of
2499 ** a "group". The requirement that the GROUP BY term must be BINARY
2500 ** assumes that no other collating sequence will have a finer-grained
2501 ** grouping than binary. In other words (A=B COLLATE binary) implies
2502 ** A=B in every other collating sequence. The requirement that the
2503 ** GROUP BY be BINARY is stricter than necessary. It would also work
2504 ** to promote HAVING clauses that use the same alternative collating
2505 ** sequence as the GROUP BY term, but that is much harder to check,
2506 ** alternative collating sequences are uncommon, and this is only an
2507 ** optimization, so we take the easy way out and simply require the
2508 ** GROUP BY to use the BINARY collating sequence.
2509 */
2511 Walker w;
2519 }
2521 /*
2522 ** Walk an expression tree for the DEFAULT field of a column definition
2523 ** in a CREATE TABLE statement. Return non-zero if the expression is
2524 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2525 ** the expression is constant or a function call with constant arguments.
2526 ** Return and 0 if there are any variables.
2527 **
2528 ** isInit is true when parsing from sqlite_schema. isInit is false when
2529 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2530 ** (such as ? or $abc) in the expression are converted into NULL. When
2531 ** isInit is false, parameters raise an error. Parameters should not be
2532 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2533 ** allowed it, so we need to support it when reading sqlite_schema for
2534 ** backwards compatibility.
2535 **
2536 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2537 **
2538 ** For the purposes of this function, a double-quoted string (ex: "abc")
2539 ** is considered a variable but a single-quoted string (ex: 'abc') is
2540 ** a constant.
2541 */
2545 }
2547 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2548 /*
2549 ** Walk an expression tree. Return 1 if the expression contains a
2550 ** subquery of some kind. Return 0 if there are no subqueries.
2551 */
2553 Walker w;
2557 #ifdef SQLITE_DEBUG
2559 #endif
2562 }
2563 #endif
2565 /*
2566 ** If the expression p codes a constant integer that is small enough
2567 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2568 ** in *pValue. If the expression is not an integer or if it is too big
2569 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2570 */
2575 /* If an expression is an integer literal that fits in a signed 32-bit
2576 ** integer, then the EP_IntValue flag will have already been set */
2583 }
2588 }
2595 }
2597 }
2599 }
2601 }
2603 /*
2604 ** Return FALSE if there is no chance that the expression can be NULL.
2605 **
2606 ** If the expression might be NULL or if the expression is too complex
2607 ** to tell return TRUE.
2608 **
2609 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2610 ** when we know that a value cannot be NULL. Hence, a false positive
2611 ** (returning TRUE when in fact the expression can never be NULL) might
2612 ** be a small performance hit but is otherwise harmless. On the other
2613 ** hand, a false negative (returning FALSE when the result could be NULL)
2614 ** will likely result in an incorrect answer. So when in doubt, return
2615 ** TRUE.
2616 */
2618 u8 op;
2623 }
2641 }
2642 }
2644 /*
2645 ** Return TRUE if the given expression is a constant which would be
2646 ** unchanged by OP_Affinity with the affinity given in the second
2647 ** argument.
2648 **
2649 ** This routine is used to determine if the OP_Affinity operation
2650 ** can be omitted. When in doubt return FALSE. A false negative
2651 ** is harmless. A false positive, however, can result in the wrong
2652 ** answer.
2653 */
2655 u8 op;
2661 }
2667 }
2670 }
2673 }
2676 }
2680 }
2683 }
2684 }
2685 }
2687 /*
2688 ** Return TRUE if the given string is a row-id column name.
2689 */
2695 }
2697 /*
2698 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2699 ** that can be simplified to a direct table access, then return
2700 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2701 ** or if the SELECT statement needs to be materialized into a transient
2702 ** table, then return NULL.
2703 */
2704 #ifndef SQLITE_OMIT_SUBQUERY
2719 }
2733 /* All SELECT results must be columns. */
2738 }
2740 }
2743 #ifndef SQLITE_OMIT_SUBQUERY
2744 /*
2745 ** Generate code that checks the left-most column of index table iCur to see if
2746 ** it contains any NULL entries. Cause the register at regHasNull to be set
2747 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2748 ** to be set to NULL if iCur contains one or more NULL values.
2749 */
2758 }
2759 #endif
2762 #ifndef SQLITE_OMIT_SUBQUERY
2763 /*
2764 ** The argument is an IN operator with a list (not a subquery) on the
2765 ** right-hand side. Return TRUE if that list is constant.
2766 */
2776 }
2777 #endif
2779 /*
2780 ** This function is used by the implementation of the IN (...) operator.
2781 ** The pX parameter is the expression on the RHS of the IN operator, which
2782 ** might be either a list of expressions or a subquery.
2783 **
2784 ** The job of this routine is to find or create a b-tree object that can
2785 ** be used either to test for membership in the RHS set or to iterate through
2786 ** all members of the RHS set, skipping duplicates.
2787 **
2788 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2789 ** and the *piTab parameter is set to the index of that cursor.
2790 **
2791 ** The returned value of this function indicates the b-tree type, as follows:
2792 **
2793 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2794 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2795 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2796 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2797 ** populated ephemeral table.
2798 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2799 ** implemented as a sequence of comparisons.
2800 **
2801 ** An existing b-tree might be used if the RHS expression pX is a simple
2802 ** subquery such as:
2803 **
2804 ** SELECT <column1>, <column2>... FROM <table>
2805 **
2806 ** If the RHS of the IN operator is a list or a more complex subquery, then
2807 ** an ephemeral table might need to be generated from the RHS and then
2808 ** pX->iTable made to point to the ephemeral table instead of an
2809 ** existing table. In this case, the creation and initialization of the
2810 ** ephemeral table might be put inside of a subroutine, the EP_Subrtn flag
2811 ** will be set on pX and the pX->y.sub fields will be set to show where
2812 ** the subroutine is coded.
2813 **
2814 ** The inFlags parameter must contain, at a minimum, one of the bits
2815 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2816 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2817 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2818 ** be used to loop over all values of the RHS of the IN operator.
2819 **
2820 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2821 ** through the set members) then the b-tree must not contain duplicates.
2822 ** An ephemeral table will be created unless the selected columns are guaranteed
2823 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2824 ** a UNIQUE constraint or index.
2825 **
2826 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2827 ** for fast set membership tests) then an ephemeral table must
2828 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2829 ** index can be found with the specified <columns> as its left-most.
2830 **
2831 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2832 ** if the RHS of the IN operator is a list (not a subquery) then this
2833 ** routine might decide that creating an ephemeral b-tree for membership
2834 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2835 ** calling routine should implement the IN operator using a sequence
2836 ** of Eq or Ne comparison operations.
2837 **
2838 ** When the b-tree is being used for membership tests, the calling function
2839 ** might need to know whether or not the RHS side of the IN operator
2840 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2841 ** if there is any chance that the (...) might contain a NULL value at
2842 ** runtime, then a register is allocated and the register number written
2843 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2844 ** NULL value, then *prRhsHasNull is left unchanged.
2845 **
2846 ** If a register is allocated and its location stored in *prRhsHasNull, then
2847 ** the value in that register will be NULL if the b-tree contains one or more
2848 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2849 ** NULL values.
2850 **
2851 ** If the aiMap parameter is not NULL, it must point to an array containing
2852 ** one element for each column returned by the SELECT statement on the RHS
2853 ** of the IN(...) operator. The i'th entry of the array is populated with the
2854 ** offset of the index column that matches the i'th column returned by the
2855 ** SELECT. For example, if the expression and selected index are:
2856 **
2857 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2858 ** CREATE INDEX i1 ON t1(b, c, a);
2859 **
2860 ** then aiMap[] is populated with {2, 0, 1}.
2861 */
2862 #ifndef SQLITE_OMIT_SUBQUERY
2870 ){
2881 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2882 ** whether or not the SELECT result contains NULL values, check whether
2883 ** or not NULL is actually possible (it may not be, for example, due
2884 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2885 ** set prRhsHasNull to 0 before continuing. */
2891 }
2894 }
2895 }
2897 /* Check to see if an existing table or index can be used to
2898 ** satisfy the query. This is preferable to generating a new
2899 ** ephemeral table. */
2912 /* Code an OP_Transaction and OP_TableLock for <table>. */
2920 /* The "x IN (SELECT rowid FROM table)" case */
2934 /* Check that the affinity that will be used to perform each
2935 ** comparison is the same as the affinity of each column in table
2936 ** on the RHS of the IN operator. If it not, it is not possible to
2937 ** use any index of the RHS table. */
2949 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2950 ** other has no affinity and the other side is TEXT. Hence,
2951 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2952 ** and for the term on the LHS of the IN to have no affinity. */
2957 }
2958 }
2961 /* Search for an existing index that will work for this IN operator */
2967 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2968 ** BITMASK(nExpr) without overflowing */
2975 ){
2977 }
2978 }
2992 }
2994 }
3000 }
3004 /* If we reach this point, that means the index pIdx is usable */
3015 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
3019 #endif
3023 }
3024 }
3026 }
3032 /* If no preexisting index is available for the IN clause
3033 ** and IN_INDEX_NOOP is an allowed reply
3034 ** and the RHS of the IN operator is a list, not a subquery
3035 ** and the RHS is not constant or has two or fewer terms,
3036 ** then it is not worth creating an ephemeral table to evaluate
3037 ** the IN operator so return IN_INDEX_NOOP.
3038 */
3043 ){
3047 }
3050 /* Could not find an existing table or index to use as the RHS b-tree.
3051 ** We will have to generate an ephemeral table to do the job.
3052 */
3060 }
3065 }
3067 }
3073 }
3076 }
3077 #endif
3079 #ifndef SQLITE_OMIT_SUBQUERY
3080 /*
3081 ** Argument pExpr is an (?, ?...) IN(...) expression. This
3082 ** function allocates and returns a nul-terminated string containing
3083 ** the affinities to be used for each column of the comparison.
3084 **
3085 ** It is the responsibility of the caller to ensure that the returned
3086 ** string is eventually freed using sqlite3DbFree().
3087 */
3105 }
3106 }
3108 }
3110 }
3111 #endif
3113 #ifndef SQLITE_OMIT_SUBQUERY
3114 /*
3115 ** Load the Parse object passed as the first argument with an error
3116 ** message of the form:
3117 **
3118 ** "sub-select returns N columns - expected M"
3119 */
3124 }
3125 }
3126 #endif
3128 /*
3129 ** Expression pExpr is a vector that has been used in a context where
3130 ** it is not permitted. If pExpr is a sub-select vector, this routine
3131 ** loads the Parse object with a message of the form:
3132 **
3133 ** "sub-select returns N columns - expected 1"
3134 **
3135 ** Or, if it is a regular scalar vector:
3136 **
3137 ** "row value misused"
3138 */
3140 #ifndef SQLITE_OMIT_SUBQUERY
3144 #endif
3145 {
3147 }
3148 }
3150 #ifndef SQLITE_OMIT_SUBQUERY
3151 /*
3152 ** Generate code that will construct an ephemeral table containing all terms
3153 ** in the RHS of an IN operator. The IN operator can be in either of two
3154 ** forms:
3155 **
3156 ** x IN (4,5,11) -- IN operator with list on right-hand side
3157 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
3158 **
3159 ** The pExpr parameter is the IN operator. The cursor number for the
3160 ** constructed ephemeral table is returned. The first time the ephemeral
3161 ** table is computed, the cursor number is also stored in pExpr->iTable,
3162 ** however the cursor number returned might not be the same, as it might
3163 ** have been duplicated using OP_OpenDup.
3164 **
3165 ** If the LHS expression ("x" in the examples) is a column value, or
3166 ** the SELECT statement returns a column value, then the affinity of that
3167 ** column is used to build the index keys. If both 'x' and the
3168 ** SELECT... statement are columns, then numeric affinity is used
3169 ** if either column has NUMERIC or INTEGER affinity. If neither
3170 ** 'x' nor the SELECT... statement are columns, then numeric affinity
3171 ** is used.
3172 */
3177 ){
3188 /* The evaluation of the IN must be repeated every time it
3189 ** is encountered if any of the following is true:
3190 **
3191 ** * The right-hand side is a correlated subquery
3192 ** * The right-hand side is an expression list containing variables
3193 ** * We are inside a trigger
3194 **
3195 ** If all of the above are false, then we can compute the RHS just once
3196 ** and reuse it many names.
3197 */
3199 /* Reuse of the RHS is allowed */
3200 /* If this routine has already been coded, but the previous code
3201 ** might not have been invoked yet, so invoke it now as a subroutine.
3202 */
3208 }
3216 }
3218 /* Begin coding the subroutine */
3227 }
3229 /* Check to see if this is a vector IN operator */
3233 /* Construct the ephemeral table that will contain the content of
3234 ** RHS of the IN operator.
3235 */
3238 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3243 }
3244 #endif
3248 /* Case 1: expr IN (SELECT ...)
3249 **
3250 ** Generate code to write the results of the select into the temporary
3251 ** table allocated and opened above.
3252 */
3258 ));
3259 /* If the LHS and RHS of the IN operator do not match, that
3260 ** error will have been caught long before we reach this point. */
3263 SelectDest dest;
3278 }
3287 );
3288 }
3289 }
3291 /* Case 2: expr IN (exprlist)
3292 **
3293 ** For each expression, build an index key from the evaluation and
3294 ** store it in the temporary table. If <expr> is a column, then use
3295 ** that columns affinity when building index keys. If <expr> is not
3296 ** a column, use numeric affinity.
3297 */
3308 }
3312 }
3314 /* Loop through each expression in <exprlist>. */
3320 /* If the expression is not constant then we will need to
3321 ** disable the test that was generated above that makes sure
3322 ** this code only executes once. Because for a non-constant
3323 ** expression we need to rerun this code each time.
3324 */
3330 }
3332 /* Evaluate the expression and insert it into the temp table */
3336 }
3339 }
3342 }
3346 /* Subroutine return */
3354 }
3355 }
3358 /*
3359 ** Generate code for scalar subqueries used as a subquery expression
3360 ** or EXISTS operator:
3361 **
3362 ** (SELECT a FROM b) -- subquery
3363 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3364 **
3365 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3366 **
3367 ** Return the register that holds the result. For a multi-column SELECT,
3368 ** the result is stored in a contiguous array of registers and the
3369 ** return value is the register of the left-most result column.
3370 ** Return 0 if an error occurs.
3371 */
3372 #ifndef SQLITE_OMIT_SUBQUERY
3380 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3382 #endif
3393 /* If this routine has already been coded, then invoke it as a
3394 ** subroutine. */
3401 }
3403 /* Begin coding the subroutine */
3411 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3412 ** is encountered if any of the following is true:
3413 **
3414 ** * The right-hand side is a correlated subquery
3415 ** * The right-hand side is an expression list containing variables
3416 ** * We are inside a trigger
3417 **
3418 ** If all of the above are false, then we can run this code just once
3419 ** save the results, and reuse the same result on subsequent invocations.
3420 */
3423 }
3425 /* For a SELECT, generate code to put the values for all columns of
3426 ** the first row into an array of registers and return the index of
3427 ** the first register.
3428 **
3429 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3430 ** into a register and return that register number.
3431 **
3432 ** In both cases, the query is augmented with "LIMIT 1". Any
3433 ** preexisting limit is discarded in place of the new LIMIT 1.
3434 */
3451 }
3453 /* The subquery already has a limit. If the pre-existing limit is X
3454 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3461 }
3465 /* If there is no pre-existing limit add a limit of 1 */
3468 }
3474 }
3479 }
3482 /* Subroutine return */
3491 }
3494 #ifndef SQLITE_OMIT_SUBQUERY
3495 /*
3496 ** Expr pIn is an IN(...) expression. This function checks that the
3497 ** sub-select on the RHS of the IN() operator has the same number of
3498 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3499 ** a sub-query, that the LHS is a vector of size 1.
3500 */
3507 }
3511 }
3513 }
3514 #endif
3516 #ifndef SQLITE_OMIT_SUBQUERY
3517 /*
3518 ** Generate code for an IN expression.
3519 **
3520 ** x IN (SELECT ...)
3521 ** x IN (value, value, ...)
3522 **
3523 ** The left-hand side (LHS) is a scalar or vector expression. The
3524 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3525 ** subquery. If the RHS is a subquery, the number of result columns must
3526 ** match the number of columns in the vector on the LHS. If the RHS is
3527 ** a list of values, the LHS must be a scalar.
3528 **
3529 ** The IN operator is true if the LHS value is contained within the RHS.
3530 ** The result is false if the LHS is definitely not in the RHS. The
3531 ** result is NULL if the presence of the LHS in the RHS cannot be
3532 ** determined due to NULLs.
3533 **
3534 ** This routine generates code that jumps to destIfFalse if the LHS is not
3535 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3536 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3537 ** within the RHS then fall through.
3538 **
3539 ** See the separate in-operator.md documentation file in the canonical
3540 ** SQLite source tree for additional information.
3541 */
3547 ){
3574 );
3577 /* Attempt to compute the RHS. After this step, if anything other than
3578 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3579 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3580 ** the RHS has not yet been coded. */
3591 );
3592 #ifdef SQLITE_DEBUG
3593 /* Confirm that aiMap[] contains nVector integer values between 0 and
3594 ** nVector-1. */
3599 }
3600 #endif
3602 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3603 ** vector, then it is stored in an array of nVector registers starting
3604 ** at r1.
3605 **
3606 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3607 ** so that the fields are in the same order as an existing index. The
3608 ** aiMap[] array contains a mapping from the original LHS field order to
3609 ** the field order that matches the RHS index.
3610 **
3611 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3612 ** even if it is constant, as OP_Affinity may be used on the register
3613 ** by code generated below. */
3620 /* LHS fields are not reordered */
3623 /* Need to reorder the LHS fields according to aiMap */
3627 }
3628 }
3630 /* If sqlite3FindInIndex() did not find or create an index that is
3631 ** suitable for evaluating the IN operator, then evaluate using a
3632 ** sequence of comparisons.
3633 **
3634 ** This is step (1) in the in-operator.md optimized algorithm.
3635 */
3649 }
3654 }
3673 }
3674 }
3678 }
3682 }
3684 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3685 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3686 ** We will then skip the binary search of the RHS.
3687 */
3692 }
3699 }
3700 }
3702 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3703 ** of the RHS using the LHS as a probe. If found, the result is
3704 ** true.
3705 */
3707 /* In this case, the RHS is the ROWID of table b-tree and so we also
3708 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3709 ** into a single opcode. */
3716 /* Combine Step 3 and Step 5 into a single opcode */
3720 }
3721 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3724 }
3726 /* Step 4. If the RHS is known to be non-NULL and we did not find
3727 ** an match on the search above, then the result must be FALSE.
3728 */
3732 }
3734 /* Step 5. If we do not care about the difference between NULL and
3735 ** FALSE, then just return false.
3736 */
3739 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3740 ** If any comparison is NULL, then the result is NULL. If all
3741 ** comparisons are FALSE then the final result is FALSE.
3742 **
3743 ** For a scalar LHS, it is sufficient to check just the first row
3744 ** of the RHS.
3745 */
3752 /* For nVector==1, combine steps 6 and 7 by immediately returning
3753 ** FALSE if the first comparison is not NULL */
3755 }
3767 }
3774 /* Step 7: If we reach this point, we know that the result must
3775 ** be false. */
3777 }
3779 /* Jumps here in order to return true. */
3782 sqlite3ExprCodeIN_finished:
3785 sqlite3ExprCodeIN_oom_error:
3788 }
3791 #ifndef SQLITE_OMIT_FLOATING_POINT
3792 /*
3793 ** Generate an instruction that will put the floating point
3794 ** value described by z[0..n-1] into register iMem.
3795 **
3796 ** The z[] string will probably not be zero-terminated. But the
3797 ** z[n] character is guaranteed to be something that does not look
3798 ** like the continuation of the number.
3799 */
3807 }
3808 }
3809 #endif
3812 /*
3813 ** Generate an instruction that will put the integer describe by
3814 ** text z[0..n-1] into register iMem.
3815 **
3816 ** Expr.u.zToken is always UTF8 and zero-terminated.
3817 */
3827 i64 value;
3832 #ifdef SQLITE_OMIT_FLOATING_POINT
3834 #else
3835 #ifndef SQLITE_OMIT_HEX_INTEGER
3840 #endif
3841 {
3843 }
3844 #endif
3848 }
3849 }
3850 }
3853 /* Generate code that will load into register regOut a value that is
3854 ** appropriate for the iIdxCol-th column of index pIdx.
3855 */
3862 ){
3873 }
3874 }
3876 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3877 /*
3878 ** Generate code that will compute the value of generated column pCol
3879 ** and store the result in register regOut
3880 */
3886 ){
3896 }
3900 }
3903 }
3906 /*
3907 ** Generate code to extract the value of the iCol-th column of a table.
3908 */
3915 ){
3929 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3942 }
3944 #endif
3953 }
3956 }
3957 }
3959 /*
3960 ** Generate code that will extract the iColumn-th column from
3961 ** table pTab and store the column value in register iReg.
3962 **
3963 ** There must be an open cursor to pTab in iTable when this routine
3964 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3965 */
3972 u8 p5 /* P5 value for OP_Column + FLAGS */
3973 ){
3982 }
3984 }
3986 /*
3987 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3988 ** over to iTo..iTo+nReg-1.
3989 */
3992 }
3994 /*
3995 ** Convert a scalar expression node to a TK_REGISTER referencing
3996 ** register iReg. The caller must ensure that iReg already contains
3997 ** the correct value for the expression.
3998 */
4006 }
4008 /*
4009 ** Evaluate an expression (either a vector or a scalar expression) and store
4010 ** the result in contiguous temporary registers. Return the index of
4011 ** the first register used to store the result.
4012 **
4013 ** If the returned result register is a temporary scalar, then also write
4014 ** that register number into *piFreeable. If the returned result register
4015 ** is not a temporary or if the expression is a vector set *piFreeable
4016 ** to 0.
4017 */
4026 #if SQLITE_OMIT_SUBQUERY
4028 #else
4030 #endif
4038 }
4039 }
4040 }
4042 }
4044 /*
4045 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
4046 ** so that a subsequent copy will not be merged into this one.
4047 */
4051 }
4052 }
4054 /*
4055 ** Generate code to implement special SQL functions that are implemented
4056 ** in-line rather than by using the usual callbacks.
4057 */
4063 ){
4072 /* Attempt a direct implementation of the built-in COALESCE() and
4073 ** IFNULL() functions. This avoids unnecessary evaluation of
4074 ** arguments past the first non-NULL argument.
4075 */
4084 }
4088 }
4090 Expr caseExpr;
4095 }
4096 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4103 }
4105 }
4106 #endif
4108 /* The UNLIKELY() function is a no-op. The result is the value
4109 ** of the first argument.
4110 */
4114 }
4116 /***********************************************************************
4117 ** Test-only SQL functions that are only usable if enabled
4118 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
4119 */
4120 #if !defined(SQLITE_UNTESTABLE)
4122 /* Compare two expressions using sqlite3ExprCompare() */
4126 target);
4128 }
4131 /* Compare two expressions using sqlite3ExprImpliesExpr() */
4135 target);
4137 }
4140 /* Result of sqlite3ExprImpliesNonNullRow() */
4147 target);
4150 }
4152 }
4155 /* The AFFINITY() function evaluates to a string that describes
4156 ** the type affinity of the argument. This is used for testing of
4157 ** the SQLite type logic.
4158 */
4169 }
4171 }
4173 }
4175 /*
4176 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
4177 ** If it is, then resolve the expression by reading from the index and
4178 ** return the register into which the value has been read. If pExpr is
4179 ** not an indexed expression, then return negative.
4180 */
4185 ){
4189 u8 exprAff;
4195 }
4202 ){
4203 /* Affinity mismatch on a generated column */
4205 }
4210 /* If the index is on a NULL row due to an outer join, then we
4211 ** cannot extract the value from the index. The value must be
4212 ** computed using the original expression. */
4227 }
4229 }
4231 }
4234 /*
4235 ** Generate code into the current Vdbe to evaluate the given
4236 ** expression. Attempt to store the results in register "target".
4237 ** Return the register where results are stored.
4238 **
4239 ** With this routine, there is no guarantee that results will
4240 ** be stored in target. The result might be stored in some other
4241 ** register if it is convenient to do so. The calling function
4242 ** must check the return code and move the results to the desired
4243 ** register.
4244 */
4258 expr_code_doover:
4264 ){
4269 }
4277 /* Happens when the left table of a RIGHT JOIN is null and
4278 ** is using an expression index */
4280 #ifdef SQLITE_VDBE_COVERAGE
4281 /* Verify that the OP_Null above is exercised by tests
4282 ** tag-20230325-2 */
4285 #endif
4287 }
4296 /* No comment added */
4304 }
4305 }
4308 /* This case happens when the argument to an aggregate function
4309 ** is rewritten by aggregateConvertIndexedExprRefToColumn() */
4312 }
4313 /* Otherwise, fall thru into the TK_COLUMN case */
4314 /* no break */ deliberate_fall_through
4315 }
4320 /* This COLUMN expression is really a constant due to WHERE clause
4321 ** constraints, and that constant is coded by the pExpr->pLeft
4322 ** expression. However, make sure the constant has the correct
4323 ** datatype by applying the Affinity of the table column to the
4324 ** constant.
4325 */
4337 }
4339 }
4342 /* Other columns in the same row for CHECK constraints or
4343 ** generated columns or for inserting into partial index.
4344 ** The row is unpacked into registers beginning at
4345 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4346 ** immediately prior to the first column.
4347 */
4359 }
4363 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4369 }
4373 }
4384 }
4386 /* Coding an expression that is part of an index where column names
4387 ** in the index refer to the table to which the index belongs */
4389 }
4390 }
4397 }
4401 }
4405 }
4406 #ifndef SQLITE_OMIT_FLOATING_POINT
4411 }
4412 #endif
4417 }
4419 /* Make NULL the default case so that if a bug causes an illegal
4420 ** Expr node to be passed into this function, it will be handled
4421 ** sanely and not crash. But keep the assert() to bring the problem
4422 ** to the attention of the developers. */
4426 }
4427 #ifndef SQLITE_OMIT_BLOB_LITERAL
4441 }
4442 #endif
4453 }
4455 }
4458 }
4459 #ifndef SQLITE_OMIT_CAST
4461 /* Expressions of the form: CAST(pLeft AS token) */
4468 }
4474 /* fall-through */
4501 }
4504 }
4506 }
4536 }
4543 #ifndef SQLITE_OMIT_FLOATING_POINT
4548 #endif
4558 }
4560 }
4569 }
4581 }
4596 }
4602 ){
4607 }
4609 }
4621 #ifndef SQLITE_OMIT_WINDOWFUNC
4624 }
4625 #endif
4628 /* SQL functions can be expensive. So try to avoid running them
4629 ** multiple times if we know they always give the same result */
4631 }
4639 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4642 }
4643 #endif
4647 }
4655 }
4661 }
4664 }
4665 }
4672 }
4674 /* For length() and typeof() and octet_length() functions,
4675 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4676 ** or OPFLAG_TYPEOFARG or OPFLAG_BYTELENARG respectively, to avoid
4677 ** unnecessary data loading.
4678 */
4680 u8 exprOp;
4693 }
4694 }
4699 }
4700 #ifndef SQLITE_OMIT_VIRTUALTABLE
4701 /* Possibly overload the function if the first argument is
4702 ** a virtual table column.
4703 **
4704 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4705 ** second argument, not the first, as the argument to test to
4706 ** see if it is a column in a virtual table. This is done because
4707 ** the left operand of infix functions (the operand we want to
4708 ** control overloading) ends up as the second argument to the
4709 ** function. The expression "A glob B" is equivalent to
4710 ** "glob(B,A). We want to use the A in "A glob B" to test
4711 ** for function overloading. But we use the B term in "glob(B,A)".
4712 */
4717 }
4718 #endif
4722 }
4730 }
4731 }
4733 }
4734 #ifndef SQLITE_OMIT_SUBQUERY
4745 ){
4749 }
4751 }
4758 }
4764 }
4766 }
4777 }
4781 /*
4782 ** x BETWEEN y AND z
4783 **
4784 ** This is equivalent to
4785 **
4786 ** x>=y AND x<=z
4787 **
4788 ** X is stored in pExpr->pLeft.
4789 ** Y is stored in pExpr->pList->a[0].pExpr.
4790 ** Z is stored in pExpr->pList->a[1].pExpr.
4791 */
4795 }
4798 /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
4799 ** "SOFT-COLLATE" that is added to constraints that are pushed down
4800 ** from outer queries into sub-queries by the push-down optimization.
4801 ** Clear subtypes as subtypes may not cross a subquery boundary.
4802 */
4810 }
4811 }
4816 }
4819 /* If the opcode is TK_TRIGGER, then the expression is a reference
4820 ** to a column in the new.* or old.* pseudo-tables available to
4821 ** trigger programs. In this case Expr.iTable is set to 1 for the
4822 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4823 ** is set to the column of the pseudo-table to read, or to -1 to
4824 ** read the rowid field.
4825 **
4826 ** The expression is implemented using an OP_Param opcode. The p1
4827 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4828 ** to reference another column of the old.* pseudo-table, where
4829 ** i is the index of the column. For a new.rowid reference, p1 is
4830 ** set to (n+1), where n is the number of columns in each pseudo-table.
4831 ** For a reference to any other column in the new.* pseudo-table, p1
4832 ** is set to (n+2+i), where n and i are as defined previously. For
4833 ** example, if the table on which triggers are being fired is
4834 ** declared as:
4835 **
4836 ** CREATE TABLE t1(a, b);
4837 **
4838 ** Then p1 is interpreted as follows:
4839 **
4840 ** p1==0 -> old.rowid p1==3 -> new.rowid
4841 ** p1==1 -> old.a p1==4 -> new.a
4842 ** p1==2 -> old.b p1==5 -> new.b
4843 */
4863 ));
4865 #ifndef SQLITE_OMIT_FLOATING_POINT
4866 /* If the column has REAL affinity, it may currently be stored as an
4867 ** integer. Use OP_RealAffinity to make sure it is really real.
4868 **
4869 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4870 ** floating point when extracting it from the record. */
4873 }
4874 #endif
4876 }
4881 }
4883 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
4884 ** that derive from the right-hand table of a LEFT JOIN. The
4885 ** Expr.iTable value is the table number for the right-hand table.
4886 ** The expression is only evaluated if that table is not currently
4887 ** on a LEFT JOIN NULL row.
4888 */
4898 }
4902 target);
4905 }
4906 }
4908 /* The OP_IfNullRow opcode above can overwrite the result register with
4909 ** NULL. So we have to ensure that the result register is not a value
4910 ** that is suppose to be a constant. Two defenses are needed:
4911 ** (1) Temporarily disable factoring of constant expressions
4912 ** (2) Make sure the computed value really is stored in register
4913 ** "target" and not someplace else.
4914 */
4921 }
4923 /*
4924 ** Form A:
4925 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4926 **
4927 ** Form B:
4928 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4929 **
4930 ** Form A is can be transformed into the equivalent form B as follows:
4931 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4932 ** WHEN x=eN THEN rN ELSE y END
4933 **
4934 ** X (if it exists) is in pExpr->pLeft.
4935 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4936 ** odd. The Y is also optional. If the number of elements in x.pList
4937 ** is even, then Y is omitted and the "otherwise" result is NULL.
4938 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4939 **
4940 ** The result of the expression is the Ri for the first matching Ei,
4941 ** or if there is no matching Ei, the ELSE term Y, or if there is
4942 ** no ELSE term, NULL.
4943 */
4968 }
4976 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4977 ** The value in regFree1 might get SCopy-ed into the file result.
4978 ** So make sure that the regFree1 register is not reused for other
4979 ** purposes and possibly overwritten. */
4981 }
4988 }
4996 }
5001 }
5006 }
5007 #ifndef SQLITE_OMIT_TRIGGER
5013 );
5018 }
5021 }
5031 }
5034 }
5035 #endif
5036 }
5040 }
5042 /*
5043 ** Generate code that will evaluate expression pExpr just one time
5044 ** per prepared statement execution.
5045 **
5046 ** If the expression uses functions (that might throw an exception) then
5047 ** guard them with an OP_Once opcode to ensure that the code is only executed
5048 ** once. If no functions are involved, then factor the code out and put it at
5049 ** the end of the prepared statement in the initialization section.
5050 **
5051 ** If regDest>=0 then the result is always stored in that register and the
5052 ** result is not reusable. If regDest<0 then this routine is free to
5053 ** store the value wherever it wants. The register where the expression
5054 ** is stored is returned. When regDest<0, two identical expressions might
5055 ** code to the same register, if they do not contain function calls and hence
5056 ** are factored out into the initialization section at the end of the
5057 ** prepared statement.
5058 */
5063 ){
5073 ){
5075 }
5076 }
5077 }
5088 }
5099 }
5101 }
5103 }
5105 /*
5106 ** Generate code to evaluate an expression and store the results
5107 ** into a register. Return the register number where the results
5108 ** are stored.
5109 **
5110 ** If the register is a temporary register that can be deallocated,
5111 ** then write its number into *pReg. If the result register is not
5112 ** a temporary, then set *pReg to zero.
5113 **
5114 ** If pExpr is a constant, then this routine might generate this
5115 ** code to fill the register in the initialization section of the
5116 ** VDBE program, in order to factor it out of the evaluation loop.
5117 */
5125 ){
5136 }
5137 }
5139 }
5141 /*
5142 ** Generate code that will evaluate expression pExpr and store the
5143 ** results in register target. The results are guaranteed to appear
5144 ** in register target.
5145 */
5155 u8 op;
5158 ){
5162 }
5164 }
5165 }
5167 /*
5168 ** Make a transient copy of expression pExpr and then code it using
5169 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
5170 ** except that the input expression is guaranteed to be unchanged.
5171 */
5177 }
5179 /*
5180 ** Generate code that will evaluate expression pExpr and store the
5181 ** results in register target. The results are guaranteed to appear
5182 ** in register target. If the expression is constant, then this routine
5183 ** might choose to code the expression at initialization time.
5184 */
5190 }
5191 }
5193 /*
5194 ** Generate code that pushes the value of every element of the given
5195 ** expression list into a sequence of registers beginning at target.
5196 **
5197 ** Return the number of elements evaluated. The number returned will
5198 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
5199 ** is defined.
5200 **
5201 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
5202 ** filled using OP_SCopy. OP_Copy must be used instead.
5203 **
5204 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
5205 ** factored out into initialization code.
5206 **
5207 ** The SQLITE_ECEL_REF flag means that expressions in the list with
5208 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
5209 ** in registers at srcReg, and so the value can be copied from there.
5210 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
5211 ** are simply omitted rather than being copied from srcReg.
5212 */
5218 u8 flags /* SQLITE_ECEL_* flags */
5219 ){
5231 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
5233 i--;
5234 n--;
5236 #endif
5239 i--;
5240 n--;
5243 }
5246 ){
5257 ){
5261 }
5262 }
5263 }
5264 }
5266 }
5268 /*
5269 ** Generate code for a BETWEEN operator.
5270 **
5271 ** x BETWEEN y AND z
5272 **
5273 ** The above is equivalent to
5274 **
5275 ** x>=y AND x<=z
5276 **
5277 ** Code it as such, taking care to do the common subexpression
5278 ** elimination of x.
5279 **
5280 ** The xJumpIf parameter determines details:
5281 **
5282 ** NULL: Store the boolean result in reg[dest]
5283 ** sqlite3ExprIfTrue: Jump to dest if true
5284 ** sqlite3ExprIfFalse: Jump to dest if false
5285 **
5286 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
5287 */
5294 ){
5322 /* Mark the expression is being from the ON or USING clause of a join
5323 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5324 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5325 ** for clarity, but we are out of bits in the Expr.flags field so we
5326 ** have to reuse the EP_OuterON bit. Bummer. */
5329 }
5331 }
5334 /* Ensure adequate test coverage */
5344 }
5346 /*
5347 ** Generate code for a boolean expression such that a jump is made
5348 ** to the label "dest" if the expression is true but execution
5349 ** continues straight thru if the expression is false.
5350 **
5351 ** If the expression evaluates to NULL (neither true nor false), then
5352 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5353 **
5354 ** This code depends on the fact that certain token values (ex: TK_EQ)
5355 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5356 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5357 ** the make process cause these values to align. Assert()s in the code
5358 ** below verify that the numbers are aligned correctly.
5359 */
5389 }
5391 }
5396 }
5411 }
5413 }
5420 /* no break */ deliberate_fall_through
5446 }
5458 }
5463 }
5464 #ifndef SQLITE_OMIT_SUBQUERY
5472 }
5473 #endif
5475 default_expr:
5479 /* No-op */
5486 }
5488 }
5489 }
5492 }
5494 /*
5495 ** Generate code for a boolean expression such that a jump is made
5496 ** to the label "dest" if the expression is false but execution
5497 ** continues straight thru if the expression is true.
5498 **
5499 ** If the expression evaluates to NULL (neither true nor false) then
5500 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5501 ** is 0.
5502 */
5515 /* The value of pExpr->op and op are related as follows:
5516 **
5517 ** pExpr->op op
5518 ** --------- ----------
5519 ** TK_ISNULL OP_NotNull
5520 ** TK_NOTNULL OP_IsNull
5521 ** TK_NE OP_Eq
5522 ** TK_EQ OP_Ne
5523 ** TK_GT OP_Le
5524 ** TK_LE OP_Gt
5525 ** TK_GE OP_Lt
5526 ** TK_LT OP_Ge
5527 **
5528 ** For other values of pExpr->op, op is undefined and unused.
5529 ** The value of TK_ and OP_ constants are arranged such that we
5530 ** can compute the mapping above using the following expression.
5531 ** Assert()s verify that the computation is correct.
5532 */
5535 /* Verify correct alignment of TK_ and OP_ constants
5536 */
5563 }
5565 }
5570 }
5580 /* IS TRUE and IS NOT FALSE */
5585 /* IS FALSE and IS NOT TRUE */
5588 }
5590 }
5597 /* no break */ deliberate_fall_through
5623 }
5633 }
5638 }
5639 #ifndef SQLITE_OMIT_SUBQUERY
5647 }
5649 }
5650 #endif
5652 default_expr:
5656 /* no-op */
5663 }
5665 }
5666 }
5669 }
5671 /*
5672 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5673 ** code generation, and that copy is deleted after code generation. This
5674 ** ensures that the original pExpr is unchanged.
5675 */
5681 }
5683 }
5685 /*
5686 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5687 ** type of expression.
5688 **
5689 ** If pExpr is a simple SQL value - an integer, real, string, blob
5690 ** or NULL value - then the VDBE currently being prepared is configured
5691 ** to re-prepare each time a new value is bound to variable pVar.
5692 **
5693 ** Additionally, if pExpr is a simple SQL value and the value is the
5694 ** same as that currently bound to variable pVar, non-zero is returned.
5695 ** Otherwise, if the values are not the same or if pExpr is not a simple
5696 ** SQL value, zero is returned.
5697 */
5702 ){
5715 }
5717 }
5720 }
5723 }
5725 /*
5726 ** Do a deep comparison of two expression trees. Return 0 if the two
5727 ** expressions are completely identical. Return 1 if they differ only
5728 ** by a COLLATE operator at the top level. Return 2 if there are differences
5729 ** other than the top-level COLLATE operator.
5730 **
5731 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5732 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5733 **
5734 ** The pA side might be using TK_REGISTER. If that is the case and pB is
5735 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
5736 **
5737 ** Sometimes this routine will return 2 even if the two expressions
5738 ** really are equivalent. If we cannot prove that the expressions are
5739 ** identical, we return 2 just to be safe. So if this routine
5740 ** returns 2, then you do not really know for certain if the two
5741 ** expressions are the same. But if you get a 0 or 1 return, then you
5742 ** can be sure the expressions are the same. In the places where
5743 ** this routine is used, it does not hurt to get an extra 2 - that
5744 ** just might result in some slightly slower code. But returning
5745 ** an incorrect 0 or 1 could lead to a malfunction.
5746 **
5747 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
5748 ** pParse->pReprepare can be matched against literals in pB. The
5749 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
5750 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
5751 ** Argument pParse should normally be NULL. If it is not NULL and pA or
5752 ** pB causes a return value of 2.
5753 */
5758 int iTab
5759 ){
5760 u32 combinedFlags;
5763 }
5766 }
5771 }
5773 }
5777 }
5780 }
5783 ){
5784 /* fall through */
5787 }
5788 }
5794 #ifndef SQLITE_OMIT_WINDOWFUNC
5798 }
5802 }
5803 }
5804 #endif
5814 ){
5816 }
5817 }
5829 ){
5834 }
5835 }
5836 }
5838 }
5840 /*
5841 ** Compare two ExprList objects. Return 0 if they are identical, 1
5842 ** if they are certainly different, or 2 if it is not possible to
5843 ** determine if they are identical or not.
5844 **
5845 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5846 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5847 **
5848 ** This routine might return non-zero for equivalent ExprLists. The
5849 ** only consequence will be disabled optimizations. But this routine
5850 ** must never return 0 if the two ExprList objects are different, or
5851 ** a malfunction will result.
5852 **
5853 ** Two NULL pointers are considered to be the same. But a NULL pointer
5854 ** always differs from a non-NULL pointer.
5855 */
5867 }
5869 }
5871 /*
5872 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
5873 ** are ignored.
5874 */
5879 iTab);
5880 }
5882 /*
5883 ** Return non-zero if Expr p can only be true if pNN is not NULL.
5884 **
5885 ** Or if seenNot is true, return non-zero if Expr p can only be
5886 ** non-NULL if pNN is not NULL
5887 */
5894 ){
5899 }
5905 }
5915 ){
5917 }
5919 }
5933 /* no break */ deliberate_fall_through
5939 /* no break */ deliberate_fall_through
5940 }
5946 }
5951 }
5955 }
5956 }
5958 }
5960 /*
5961 ** Return true if we can prove the pE2 will always be true if pE1 is
5962 ** true. Return false if we cannot complete the proof or if pE2 might
5963 ** be false. Examples:
5964 **
5965 ** pE1: x==5 pE2: x==5 Result: true
5966 ** pE1: x>0 pE2: x==5 Result: false
5967 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
5968 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
5969 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
5970 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
5971 ** pE1: x IS ?2 pE2: x IS NOT NULL Result: false
5972 **
5973 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
5974 ** Expr.iTable<0 then assume a table number given by iTab.
5975 **
5976 ** If pParse is not NULL, then the values of bound variables in pE1 are
5977 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
5978 ** modified to record which bound variables are referenced. If pParse
5979 ** is NULL, then false will be returned if pE1 contains any bound variables.
5980 **
5981 ** When in doubt, return false. Returning true might give a performance
5982 ** improvement. Returning false might cause a performance reduction, but
5983 ** it will always give the correct answer and is hence always safe.
5984 */
5989 int iTab
5990 ){
5993 }
5997 ){
5999 }
6002 ){
6004 }
6006 }
6008 /* This is a helper function to impliesNotNullRow(). In this routine,
6009 ** set pWalker->eCode to one only if *both* of the input expressions
6010 ** separately have the implies-not-null-row property.
6011 */
6018 }
6019 }
6020 }
6022 /*
6023 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
6024 ** If the expression node requires that the table at pWalker->iCur
6025 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
6026 **
6027 ** pWalker->mWFlags is non-zero if this inquiry is being undertaking on
6028 ** behalf of a RIGHT JOIN (or FULL JOIN). That makes a difference when
6029 ** evaluating terms in the ON clause of an inner join.
6030 **
6031 ** This routine controls an optimization. False positives (setting
6032 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
6033 ** (never setting pWalker->eCode) is a harmless missed optimization.
6034 */
6040 /* If iCur is used in an inner-join ON clause to the left of a
6041 ** RIGHT JOIN, that does *not* mean that the table must be non-null.
6042 ** But it is difficult to check for that condition precisely.
6043 ** To keep things simple, any use of iCur from any inner-join is
6044 ** ignored while attempting to simplify a RIGHT JOIN. */
6046 }
6070 }
6075 /* Both sides of an AND or OR must separately imply non-null-row.
6076 ** Consider these cases:
6077 ** 1. NOT (x AND y)
6078 ** 2. x OR y
6079 ** If only one of x or y is non-null-row, then the overall expression
6080 ** can be true if the other arm is false (case 1) or true (case 2).
6081 */
6088 /* Beware of "x NOT IN ()" and "x NOT IN (SELECT 1 WHERE false)",
6089 ** both of which can be true. But apart from these cases, if
6090 ** the left-hand side of the IN is NULL then the IN itself will be
6091 ** NULL. */
6094 }
6098 /* In "x NOT BETWEEN y AND z" either x must be non-null-row or else
6099 ** both y and z must be non-null row */
6107 /* Virtual tables are allowed to use constraints like x=NULL. So
6108 ** a term of the form x=y does not prove that y is not null if x
6109 ** is the column of a virtual table */
6124 /* The y.pTab=0 assignment in wherecode.c always happens after the
6125 ** impliesNotNullRow() test */
6134 ){
6136 }
6137 /* no break */ deliberate_fall_through
6138 }
6141 }
6142 }
6144 /*
6145 ** Return true (non-zero) if expression p can only be true if at least
6146 ** one column of table iTab is non-null. In other words, return true
6147 ** if expression p will always be NULL or false if every column of iTab
6148 ** is NULL.
6149 **
6150 ** False negatives are acceptable. In other words, it is ok to return
6151 ** zero even if expression p will never be true of every column of iTab
6152 ** is NULL. A false negative is merely a missed optimization opportunity.
6153 **
6154 ** False positives are not allowed, however. A false positive may result
6155 ** in an incorrect answer.
6156 **
6157 ** Terms of p that are marked with EP_OuterON (and hence that come from
6158 ** the ON or USING clauses of OUTER JOINS) are excluded from the analysis.
6159 **
6160 ** This routine is used to check if a LEFT JOIN can be converted into
6161 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
6162 ** clause requires that some column of the right table of the LEFT JOIN
6163 ** be non-NULL, then the LEFT JOIN can be safely converted into an
6164 ** ordinary join.
6165 */
6167 Walker w;
6176 }
6177 }
6186 }
6188 /*
6189 ** An instance of the following structure is used by the tree walker
6190 ** to determine if an expression can be evaluated by reference to the
6191 ** index only, without having to do a search for the corresponding
6192 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
6193 ** is the cursor for the table.
6194 */
6198 };
6200 /*
6201 ** Check to see if there are references to columns in table
6202 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
6203 ** pWalker->u.pIdxCover->pIdx.
6204 */
6209 ){
6212 }
6214 }
6216 /*
6217 ** Determine if an index pIdx on table with cursor iCur contains will
6218 ** the expression pExpr. Return true if the index does cover the
6219 ** expression and false if the pExpr expression references table columns
6220 ** that are not found in the index pIdx.
6221 **
6222 ** An index covering an expression means that the expression can be
6223 ** evaluated using only the index and without having to lookup the
6224 ** corresponding table entry.
6225 */
6230 ){
6231 Walker w;
6240 }
6243 /* Structure used to pass information throughout the Walker in order to
6244 ** implement sqlite3ReferencesSrcList().
6245 */
6251 };
6253 /*
6254 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
6255 **
6256 ** When entering a new subquery on the pExpr argument, add all FROM clause
6257 ** entries for that subquery to the exclude list.
6258 **
6259 ** When leaving the subquery, remove those entries from the exclude list.
6260 */
6275 }
6278 }
6280 }
6287 }
6288 }
6290 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
6291 **
6292 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
6293 ** of the tables shown in RefSrcList.pRef.
6294 **
6295 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
6296 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
6297 */
6301 ){
6310 }
6311 }
6315 }
6316 }
6318 }
6320 /*
6321 ** Check to see if pExpr references any tables in pSrcList.
6322 ** Possible return values:
6323 **
6324 ** 1 pExpr does references a table in pSrcList.
6325 **
6326 ** 0 pExpr references some table that is not defined in either
6327 ** pSrcList or in subqueries of pExpr itself.
6328 **
6329 ** -1 pExpr only references no tables at all, or it only
6330 ** references tables defined in subqueries of pExpr itself.
6331 **
6332 ** As currently used, pExpr is always an aggregate function call. That
6333 ** fact is exploited for efficiency.
6334 */
6336 Walker w;
6350 #ifndef SQLITE_OMIT_WINDOWFUNC
6353 }
6354 #endif
6362 }
6363 }
6365 /*
6366 ** This is a Walker expression node callback.
6367 **
6368 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6369 ** object that is referenced does not refer directly to the Expr. If
6370 ** it does, make a copy. This is done because the pExpr argument is
6371 ** subject to change.
6372 **
6373 ** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete()
6374 ** which builds on the sqlite3ParserAddCleanup() mechanism.
6375 */
6379 ){
6388 ){
6393 }
6394 }
6399 ){
6404 }
6405 }
6406 }
6407 }
6409 }
6411 /*
6412 ** Initialize a Walker object so that will persist AggInfo entries referenced
6413 ** by the tree that is walked.
6414 */
6420 }
6422 /*
6423 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6424 ** the new element. Return a negative number if malloc fails.
6425 */
6429 db,
6433 &i
6434 );
6436 }
6438 /*
6439 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6440 ** the new element. Return a negative number if malloc fails.
6441 */
6445 db,
6449 &i
6450 );
6452 }
6454 /*
6455 ** Search the AggInfo object for an aCol[] entry that has iTable and iColumn.
6456 ** Return the index in aCol[] of the entry that describes that column.
6457 **
6458 ** If no prior entry is found, create a new one and return -1. The
6459 ** new column will have an index of pAggInfo->nColumn-1.
6460 */
6465 ){
6476 ){
6478 }
6479 }
6482 /* OOM on resize */
6485 }
6503 ){
6506 }
6507 }
6508 }
6511 }
6512 fix_up_expr:
6518 }
6520 }
6522 /*
6523 ** This is the xExprCallback for a tree walker. It is used to
6524 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
6525 ** for additional information.
6526 */
6539 Expr tmp;
6547 }
6552 }
6557 /* If we reach this point, it means that expression pExpr can be
6558 ** translated into a reference to an index column as described by
6559 ** pIEpr.
6560 */
6573 }
6580 /* Check to see if the column is in one of the tables in the FROM
6581 ** clause of the aggregate query */
6591 }
6593 }
6597 ){
6598 /* Check to see if pExpr is a duplicate of another aggregate
6599 ** function that is already in the pAggInfo structure
6600 */
6606 }
6607 }
6609 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
6610 */
6625 }
6626 }
6627 }
6628 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
6629 */
6637 }
6638 }
6639 }
6641 }
6643 /*
6644 ** Analyze the pExpr expression looking for aggregate functions and
6645 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
6646 ** points to. Additional entries are made on the AggInfo object as
6647 ** necessary.
6648 **
6649 ** This routine should only be called after the expression has been
6650 ** analyzed by sqlite3ResolveExprNames().
6651 */
6653 Walker w;
6662 }
6664 /*
6665 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
6666 ** expression list. Return the number of errors.
6667 **
6668 ** If an error is found, the analysis is cut short.
6669 */
6676 }
6677 }
6678 }
6680 /*
6681 ** Allocate a single new register for use to hold some intermediate result.
6682 */
6686 }
6688 }
6690 /*
6691 ** Deallocate a register, making available for reuse for some other
6692 ** purpose.
6693 */
6699 }
6700 }
6701 }
6703 /*
6704 ** Allocate or deallocate a block of nReg consecutive registers.
6705 */
6717 }
6719 }
6724 }
6729 }
6730 }
6732 /*
6733 ** Mark all temporary registers as being unavailable for reuse.
6734 **
6735 ** Always invoke this procedure after coding a subroutine or co-routine
6736 ** that might be invoked from other parts of the code, to ensure that
6737 ** the sub/co-routine does not use registers in common with the code that
6738 ** invokes the sub/co-routine.
6739 */
6743 }
6745 /*
6746 ** Make sure sufficient registers have been allocated so that
6747 ** iReg is a valid register number.
6748 */
6751 }
6753 #if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG)
6754 /*
6755 ** Return the latest reusable register in the set of all registers.
6756 ** The value returned is no less than iMin. If any register iMin or
6757 ** greater is in permanent use, then return one more than that last
6758 ** permanent register.
6759 */
6767 }
6768 }
6769 }
6773 }
6776 /*
6777 ** Validate that no temporary register falls within the range of
6778 ** iFirst..iLast, inclusive. This routine is only call from within assert()
6779 ** statements.
6780 */
6781 #ifdef SQLITE_DEBUG
6787 ){
6789 }
6793 }
6794 }
6801 }
6802 }
6804 }