| blob | a81b4595bb8e456673dd038bfd3f9c66394bb9c8 |
1 /*
2 ** 2001 September 15
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains routines used for analyzing expressions and
13 ** for generating VDBE code that evaluates expressions in SQLite.
14 */
17 /* Forward declarations */
21 /*
22 ** Return the affinity character for a single column of a table.
23 */
27 }
29 /*
30 ** Return the 'affinity' of the expression pExpr if any.
31 **
32 ** If pExpr is a column, a reference to a column via an 'AS' alias,
33 ** or a sub-select with a column as the return value, then the
34 ** affinity of that column is returned. Otherwise, 0x00 is returned,
35 ** indicating no affinity for the expression.
36 **
37 ** i.e. the WHERE clause expressions in the following statements all
38 ** have an affinity:
39 **
40 ** CREATE TABLE t1(a);
41 ** SELECT * FROM t1 WHERE a;
42 ** SELECT a AS b FROM t1 WHERE b;
43 ** SELECT * FROM t1 WHERE (select a from t1);
44 */
53 }
60 }
61 #ifndef SQLITE_OMIT_CAST
65 }
66 #endif
73 );
74 }
78 }
86 }
88 }
90 }
92 /*
93 ** Make a guess at all the possible datatypes of the result that could
94 ** be returned by an expression. Return a bitmask indicating the answer:
95 **
96 ** 0x01 Numeric
97 ** 0x02 Text
98 ** 0x04 Blob
99 **
100 ** If the expression must return NULL, then 0x00 is returned.
101 */
110 }
114 }
117 }
120 }
123 }
128 }
139 }
148 }
151 }
153 }
156 }
160 }
162 /*
163 ** Set the collating sequence for expression pExpr to be the collating
164 ** sequence named by pToken. Return a pointer to a new Expr node that
165 ** implements the COLLATE operator.
166 **
167 ** If a memory allocation error occurs, that fact is recorded in pParse->db
168 ** and the pExpr parameter is returned unchanged.
169 */
175 ){
182 }
183 }
185 }
190 ){
191 Token s;
195 }
197 /*
198 ** Skip over any TK_COLLATE operators.
199 */
204 }
206 }
208 /*
209 ** Skip over any TK_COLLATE operators and/or any unlikely()
210 ** or likelihood() or likely() functions at the root of an
211 ** expression.
212 */
223 }
224 }
226 }
228 /*
229 ** Return the collation sequence for the expression pExpr. If
230 ** there is no defined collating sequence, return NULL.
231 **
232 ** See also: sqlite3ExprNNCollSeq()
233 **
234 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
235 ** default collation if pExpr has no defined collation.
236 **
237 ** The collating sequence might be determined by a COLLATE operator
238 ** or by the presence of a column with a defined collating sequence.
239 ** COLLATE operators take first precedence. Left operands take
240 ** precedence over right operands.
241 */
251 ){
258 }
260 }
264 }
269 }
274 }
280 /* The Expr.x union is never used at the same time as Expr.pRight */
288 }
289 }
290 }
292 }
295 }
296 }
299 }
301 }
303 /*
304 ** Return the collation sequence for the expression pExpr. If
305 ** there is no defined collating sequence, return a pointer to the
306 ** defautl collation sequence.
307 **
308 ** See also: sqlite3ExprCollSeq()
309 **
310 ** The sqlite3ExprCollSeq() routine works the same except that it
311 ** returns NULL if there is no defined collation.
312 */
318 }
320 /*
321 ** Return TRUE if the two expressions have equivalent collating sequences.
322 */
327 }
329 /*
330 ** pExpr is an operand of a comparison operator. aff2 is the
331 ** type affinity of the other operand. This routine returns the
332 ** type affinity that should be used for the comparison operator.
333 */
337 /* Both sides of the comparison are columns. If one has numeric
338 ** affinity, use that. Otherwise use no affinity.
339 */
344 }
346 /* One side is a column, the other is not. Use the columns affinity. */
349 }
350 }
352 /*
353 ** pExpr is a comparison operator. Return the type affinity that should
354 ** be applied to both operands prior to doing the comparison.
355 */
369 }
371 }
373 /*
374 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
375 ** idx_affinity is the affinity of an indexed column. Return true
376 ** if the index with affinity idx_affinity may be used to implement
377 ** the comparison in pExpr.
378 */
383 }
386 }
388 }
390 /*
391 ** Return the P5 value that should be used for a binary comparison
392 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
393 */
398 ){
402 }
404 /*
405 ** Return a pointer to the collation sequence that should be used by
406 ** a binary comparison operator comparing pLeft and pRight.
407 **
408 ** If the left hand expression has a collating sequence type, then it is
409 ** used. Otherwise the collation sequence for the right hand expression
410 ** is used, or the default (BINARY) if neither expression has a collating
411 ** type.
412 **
413 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
414 ** it is not considered.
415 */
420 ){
431 }
432 }
434 }
436 /* Expresssion p is a comparison operator. Return a collation sequence
437 ** appropriate for the comparison operator.
438 **
439 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
440 ** However, if the OP_Commuted flag is set, then the order of the operands
441 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
442 ** correct collating sequence is found.
443 */
449 }
450 }
452 /*
453 ** Generate code for a comparison operator.
454 */
464 ){
474 }
480 }
482 /*
483 ** Return true if expression pExpr is a vector, or false otherwise.
484 **
485 ** A vector is defined as any expression that results in two or more
486 ** columns of result. Every TK_VECTOR node is an vector because the
487 ** parser will not generate a TK_VECTOR with fewer than two entries.
488 ** But a TK_SELECT might be either a vector or a scalar. It is only
489 ** considered a vector if it has two or more result columns.
490 */
493 }
495 /*
496 ** If the expression passed as the only argument is of type TK_VECTOR
497 ** return the number of expressions in the vector. Or, if the expression
498 ** is a sub-select, return the number of columns in the sub-select. For
499 ** any other type of expression, return 1.
500 */
512 }
513 }
515 /*
516 ** Return a pointer to a subexpression of pVector that is the i-th
517 ** column of the vector (numbered starting with 0). The caller must
518 ** ensure that i is within range.
519 **
520 ** If pVector is really a scalar (and "scalar" here includes subqueries
521 ** that return a single column!) then return pVector unmodified.
522 **
523 ** pVector retains ownership of the returned subexpression.
524 **
525 ** If the vector is a (SELECT ...) then the expression returned is
526 ** just the expression for the i-th term of the result set, and may
527 ** not be ready for evaluation because the table cursor has not yet
528 ** been positioned.
529 */
540 }
541 }
543 }
545 /*
546 ** Compute and return a new Expr object which when passed to
547 ** sqlite3ExprCode() will generate all necessary code to compute
548 ** the iField-th column of the vector expression pVector.
549 **
550 ** It is ok for pVector to be a scalar (as long as iField==0).
551 ** In that case, this routine works like sqlite3ExprDup().
552 **
553 ** The caller owns the returned Expr object and is responsible for
554 ** ensuring that the returned value eventually gets freed.
555 **
556 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
557 ** then the returned object will reference pVector and so pVector must remain
558 ** valid for the life of the returned object. If pVector is a TK_VECTOR
559 ** or a scalar expression, then it can be deleted as soon as this routine
560 ** returns.
561 **
562 ** A trick to cause a TK_SELECT pVector to be deleted together with
563 ** the returned Expr object is to attach the pVector to the pRight field
564 ** of the returned TK_SELECT_COLUMN Expr object.
565 */
571 ){
575 /* The TK_SELECT_COLUMN Expr node:
576 **
577 ** pLeft: pVector containing TK_SELECT. Not deleted.
578 ** pRight: not used. But recursively deleted.
579 ** iColumn: Index of a column in pVector
580 ** iTable: 0 or the number of columns on the LHS of an assignment
581 ** pLeft->iTable: First in an array of register holding result, or 0
582 ** if the result is not yet computed.
583 **
584 ** sqlite3ExprDelete() specifically skips the recursive delete of
585 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
586 ** can be attached to pRight to cause this node to take ownership of
587 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
588 ** with the same pLeft pointer to the pVector, but only one of them
589 ** will own the pVector.
590 */
596 }
604 /* This must be a vector UPDATE inside a trigger */
607 }
608 }
610 }
612 }
614 /*
615 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
616 ** it. Return the register in which the result is stored (or, if the
617 ** sub-select returns more than one column, the first in an array
618 ** of registers in which the result is stored).
619 **
620 ** If pExpr is not a TK_SELECT expression, return 0.
621 */
624 #ifndef SQLITE_OMIT_SUBQUERY
627 }
628 #endif
630 }
632 /*
633 ** Argument pVector points to a vector expression - either a TK_VECTOR
634 ** or TK_SELECT that returns more than one column. This function returns
635 ** the register number of a register that contains the value of
636 ** element iField of the vector.
637 **
638 ** If pVector is a TK_SELECT expression, then code for it must have
639 ** already been generated using the exprCodeSubselect() routine. In this
640 ** case parameter regSelect should be the first in an array of registers
641 ** containing the results of the sub-select.
642 **
643 ** If pVector is of type TK_VECTOR, then code for the requested field
644 ** is generated. In this case (*pRegFree) may be set to the number of
645 ** a temporary register to be freed by the caller before returning.
646 **
647 ** Before returning, output parameter (*ppExpr) is set to point to the
648 ** Expr object corresponding to element iElem of the vector.
649 */
657 ){
663 }
668 }
673 }
675 }
677 /*
678 ** Expression pExpr is a comparison between two vector values. Compute
679 ** the result of the comparison (1, 0, or NULL) and write that
680 ** result into register dest.
681 **
682 ** The caller must satisfy the following preconditions:
683 **
684 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
685 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
686 ** otherwise: op==pExpr->op and p5==0
687 */
693 u8 p5 /* SQLITE_NULLEQ or zero */
694 ){
712 }
717 );
753 }
758 }
761 }
768 }
769 }
774 }
775 }
777 #if SQLITE_MAX_EXPR_DEPTH>0
778 /*
779 ** Check that argument nHeight is less than or equal to the maximum
780 ** expression depth allowed. If it is not, leave an error message in
781 ** pParse.
782 */
789 );
791 }
793 }
795 /* The following three functions, heightOfExpr(), heightOfExprList()
796 ** and heightOfSelect(), are used to determine the maximum height
797 ** of any expression tree referenced by the structure passed as the
798 ** first argument.
799 **
800 ** If this maximum height is greater than the current value pointed
801 ** to by pnHeight, the second parameter, then set *pnHeight to that
802 ** value.
803 */
808 }
809 }
810 }
816 }
817 }
818 }
828 }
829 }
831 /*
832 ** Set the Expr.nHeight variable in the structure passed as an
833 ** argument. An expression with no children, Expr.pList or
834 ** Expr.pSelect member has a height of 1. Any other expression
835 ** has a height equal to the maximum height of any other
836 ** referenced Expr plus one.
837 **
838 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
839 ** if appropriate.
840 */
845 }
851 }
853 }
855 /*
856 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
857 ** the height is greater than the maximum allowed expression depth,
858 ** leave an error in pParse.
859 **
860 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
861 ** Expr.flags.
862 */
867 }
869 /*
870 ** Return the maximum height of any expression tree referenced
871 ** by the select statement passed as an argument.
872 */
877 }
879 /*
880 ** Propagate all EP_Propagate flags from the Expr.x.pList into
881 ** Expr.flags.
882 */
887 }
888 }
889 #define exprSetHeight(y)
892 /*
893 ** This routine is the core allocator for Expr nodes.
894 **
895 ** Construct a new expression node and return a pointer to it. Memory
896 ** for this node and for the pToken argument is a single allocation
897 ** obtained from sqlite3DbMalloc(). The calling function
898 ** is responsible for making sure the node eventually gets freed.
899 **
900 ** If dequote is true, then the token (if it exists) is dequoted.
901 ** If dequote is false, no dequoting is performed. The deQuote
902 ** parameter is ignored if pToken is NULL or if the token does not
903 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
904 ** then the EP_DblQuoted flag is set on the expression node.
905 **
906 ** Special case: If op==TK_INTEGER and pToken points to a string that
907 ** can be translated into a 32-bit integer, then the token is not
908 ** stored in u.zToken. Instead, the integer values is written
909 ** into u.iValue and the EP_IntValue flag is set. No extra storage
910 ** is allocated to hold the integer text and the dequote flag is ignored.
911 */
917 ){
928 }
929 }
946 }
947 }
948 }
949 #if SQLITE_MAX_EXPR_DEPTH>0
951 #endif
952 }
954 }
956 /*
957 ** Allocate a new expression node from a zero-terminated token that has
958 ** already been dequoted.
959 */
964 ){
965 Token x;
969 }
971 /*
972 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
973 **
974 ** If pRoot==NULL that means that a memory allocation error has occurred.
975 ** In that case, delete the subtrees pLeft and pRight.
976 */
981 Expr *pRight
982 ){
993 #if SQLITE_MAX_EXPR_DEPTH>0
997 #endif
998 }
1002 #if SQLITE_MAX_EXPR_DEPTH>0
1005 }
1006 #endif
1007 }
1008 }
1009 }
1011 /*
1012 ** Allocate an Expr node which joins as many as two subtrees.
1013 **
1014 ** One or both of the subtrees can be NULL. Return a pointer to the new
1015 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
1016 ** free the subtrees and return NULL.
1017 */
1023 ){
1035 }
1037 }
1039 /*
1040 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
1041 ** do a memory allocation failure) then delete the pSelect object.
1042 */
1051 }
1052 }
1054 /*
1055 ** Expression list pEList is a list of vector values. This function
1056 ** converts the contents of pEList to a VALUES(...) Select statement
1057 ** returning 1 row for each element of the list. For example, the
1058 ** expression list:
1059 **
1060 ** ( (1,2), (3,4) (5,6) )
1061 **
1062 ** is translated to the equivalent of:
1063 **
1064 ** VALUES(1,2), (3,4), (5,6)
1065 **
1066 ** Each of the vector values in pEList must contain exactly nElem terms.
1067 ** If a list element that is not a vector or does not contain nElem terms,
1068 ** an error message is left in pParse.
1069 **
1070 ** This is used as part of processing IN(...) expressions with a list
1071 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
1072 */
1086 }
1090 );
1092 }
1100 }
1102 }
1103 }
1107 }
1110 }
1112 /*
1113 ** Join two expressions using an AND operator. If either expression is
1114 ** NULL, then just return the other expression.
1115 **
1116 ** If one side or the other of the AND is known to be false, and neither side
1117 ** is part of an ON clause, then instead of returning an AND expression,
1118 ** just return a constant expression with a value of false.
1119 */
1129 && !IN_RENAME_OBJECT
1130 ){
1136 }
1137 }
1138 }
1140 /*
1141 ** Construct a new expression node for a function with multiple
1142 ** arguments.
1143 */
1149 ){
1157 }
1163 ){
1165 }
1172 }
1174 /*
1175 ** Check to see if a function is usable according to current access
1176 ** rules:
1177 **
1178 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1179 **
1180 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1181 ** top-level SQL
1182 **
1183 ** If the function is not usable, create an error.
1184 */
1189 ){
1195 ){
1196 /* Functions prohibited in triggers and views if:
1197 ** (1) tagged with SQLITE_DIRECTONLY
1198 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1199 ** is tagged with SQLITE_FUNC_UNSAFE) and
1200 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1201 ** that the schema is possibly tainted).
1202 */
1204 }
1205 }
1206 }
1208 /*
1209 ** Assign a variable number to an expression that encodes a wildcard
1210 ** in the original SQL statement.
1211 **
1212 ** Wildcards consisting of a single "?" are assigned the next sequential
1213 ** variable number.
1214 **
1215 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1216 ** sure "nnn" is not too big to avoid a denial of service attack when
1217 ** the SQL statement comes from an external source.
1218 **
1219 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1220 ** as the previous instance of the same wildcard. Or if this is the first
1221 ** instance of the wildcard, the next sequential variable number is
1222 ** assigned.
1223 */
1227 ynVar x;
1236 /* Wildcard of the form "?". Assign the next variable number */
1242 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1243 ** use it as the variable number */
1244 i64 i;
1251 }
1261 }
1268 }
1270 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1271 ** number as the prior appearance of the same name, or if the name
1272 ** has never appeared before, reuse the same variable number
1273 */
1278 }
1279 }
1282 }
1283 }
1288 }
1289 }
1291 /*
1292 ** Recursively delete an expression tree.
1293 */
1301 #ifdef SQLITE_DEBUG
1307 }
1308 #endif
1310 /* The Expr.x union is never used at the same time as Expr.pRight */
1321 #ifndef SQLITE_OMIT_WINDOWFUNC
1324 }
1325 #endif
1326 }
1327 }
1330 }
1331 }
1334 }
1336 /*
1337 ** Clear both elements of an OnOrUsing object
1338 */
1341 /* Nothing to clear */
1346 }
1347 }
1349 /*
1350 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1351 ** This is similar to sqlite3ExprDelete() except that the delete is
1352 ** deferred untilthe pParse is deleted.
1353 **
1354 ** The pExpr might be deleted immediately on an OOM error.
1355 **
1356 ** The deferred delete is (currently) implemented by adding the
1357 ** pExpr to the pParse->pConstExpr list with a register number of 0.
1358 */
1362 pExpr);
1363 }
1365 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1366 ** expression.
1367 */
1372 }
1374 }
1375 }
1377 /*
1378 ** Return the number of bytes allocated for the expression structure
1379 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1380 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1381 */
1386 }
1388 /*
1389 ** The dupedExpr*Size() routines each return the number of bytes required
1390 ** to store a copy of an expression or expression tree. They differ in
1391 ** how much of the tree is measured.
1392 **
1393 ** dupedExprStructSize() Size of only the Expr structure
1394 ** dupedExprNodeSize() Size of Expr + space for token
1395 ** dupedExprSize() Expr + token + subtree components
1396 **
1397 ***************************************************************************
1398 **
1399 ** The dupedExprStructSize() function returns two values OR-ed together:
1400 ** (1) the space required for a copy of the Expr structure only and
1401 ** (2) the EP_xxx flags that indicate what the structure size should be.
1402 ** The return values is always one of:
1403 **
1404 ** EXPR_FULLSIZE
1405 ** EXPR_REDUCEDSIZE | EP_Reduced
1406 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1407 **
1408 ** The size of the structure can be found by masking the return value
1409 ** of this routine with 0xfff. The flags can be found by masking the
1410 ** return value with EP_Reduced|EP_TokenOnly.
1411 **
1412 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1413 ** (unreduced) Expr objects as they or originally constructed by the parser.
1414 ** During expression analysis, extra information is computed and moved into
1415 ** later parts of the Expr object and that extra information might get chopped
1416 ** off if the expression is reduced. Note also that it does not work to
1417 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1418 ** to reduce a pristine expression tree from the parser. The implementation
1419 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1420 ** to enforce this constraint.
1421 */
1428 #ifndef SQLITE_OMIT_WINDOWFUNC
1430 #endif
1431 ){
1442 }
1443 }
1445 }
1447 /*
1448 ** This function returns the space in bytes required to store the copy
1449 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1450 ** string is defined.)
1451 */
1456 }
1458 }
1460 /*
1461 ** Return the number of bytes required to create a duplicate of the
1462 ** expression passed as the first argument. The second argument is a
1463 ** mask containing EXPRDUP_XXX flags.
1464 **
1465 ** The value returned includes space to create a copy of the Expr struct
1466 ** itself and the buffer referred to by Expr.u.zToken, if any.
1467 **
1468 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1469 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1470 ** and Expr.pRight variables (but not for any structures pointed to or
1471 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1472 */
1479 }
1480 }
1482 }
1484 /*
1485 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1486 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1487 ** to store the copy of expression p, the copies of p->u.zToken
1488 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1489 ** if any. Before returning, *pzBuffer is set to the first byte past the
1490 ** portion of the buffer copied into by this function.
1491 */
1502 /* Figure out where to write the new Expr structure. */
1510 }
1514 /* Set nNewSize to the size allocated for the structure pointed to
1515 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1516 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1517 ** by the copy of the p->u.zToken string (if any).
1518 */
1526 }
1535 }
1536 }
1538 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1545 }
1547 /* Copy the p->u.zToken string, if any. */
1551 }
1554 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1559 }
1560 }
1562 /* Fill in pNew->pLeft and pNew->pRight. */
1570 }
1571 #ifndef SQLITE_OMIT_WINDOWFUNC
1575 }
1579 }
1588 }
1590 }
1591 }
1592 }
1594 }
1596 /*
1597 ** Create and return a deep copy of the object passed as the second
1598 ** argument. If an OOM condition is encountered, NULL is returned
1599 ** and the db->mallocFailed flag set.
1600 */
1601 #ifndef SQLITE_OMIT_CTE
1615 }
1616 }
1617 }
1619 }
1620 #else
1621 # define sqlite3WithDup(x,y) 0
1622 #endif
1624 #ifndef SQLITE_OMIT_WINDOWFUNC
1625 /*
1626 ** The gatherSelectWindows() procedure and its helper routine
1627 ** gatherSelectWindowsCallback() are used to scan all the expressions
1628 ** an a newly duplicated SELECT statement and gather all of the Window
1629 ** objects found there, assembling them onto the linked list at Select->pWin.
1630 */
1639 }
1641 }
1644 }
1646 Walker w;
1653 }
1654 #endif
1657 /*
1658 ** The following group of routines make deep copies of expressions,
1659 ** expression lists, ID lists, and select statements. The copies can
1660 ** be deleted (by being passed to their respective ...Delete() routines)
1661 ** without effecting the originals.
1662 **
1663 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1664 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1665 ** by subsequent calls to sqlite*ListAppend() routines.
1666 **
1667 ** Any tables that the SrcList might point to are not duplicated.
1668 **
1669 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1670 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1671 ** truncated version of the usual Expr structure that will be stored as
1672 ** part of the in-memory representation of the database schema.
1673 */
1677 }
1700 ){
1710 }
1712 }
1713 }
1718 }
1720 }
1722 /*
1723 ** If cursors, triggers, views and subqueries are all omitted from
1724 ** the build, then none of the following routines, except for
1725 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1726 ** called with a NULL argument.
1727 */
1728 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1729 || !defined(SQLITE_OMIT_SUBQUERY)
1754 }
1758 }
1762 }
1766 }
1773 }
1775 }
1777 }
1793 }
1795 }
1823 #ifndef SQLITE_OMIT_WINDOWFUNC
1827 #endif
1830 /* Any prior OOM might have left the Select object incomplete.
1831 ** Delete the whole thing rather than allow an incomplete Select
1832 ** to be used by the code generator. */
1836 }
1840 }
1843 }
1844 #else
1848 }
1849 #endif
1852 /*
1853 ** Add a new element to the end of an expression list. If pList is
1854 ** initially NULL, then create a new expression list.
1855 **
1856 ** The pList argument must be either NULL or a pointer to an ExprList
1857 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1858 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1859 ** Reason: This routine assumes that the number of slots in pList->a[]
1860 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1861 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1862 **
1863 ** If a memory allocation error occurs, the entire list is freed and
1864 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1865 ** that the new entry was successfully appended.
1866 */
1871 ){
1879 }
1886 }
1891 ){
1903 }
1908 }
1913 ){
1917 }
1920 }
1925 }
1927 /*
1928 ** pColumns and pExpr form a vector assignment which is part of the SET
1929 ** clause of an UPDATE statement. Like this:
1930 **
1931 ** (a,b,c) = (expr1,expr2,expr3)
1932 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1933 **
1934 ** For each term of the vector assignment, append new entries to the
1935 ** expression list pList. In the case of a subquery on the RHS, append
1936 ** TK_SELECT_COLUMN expressions.
1937 */
1943 ){
1948 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1949 ** exit prior to this routine being invoked */
1953 /* If the RHS is a vector, then we can immediately check to see that
1954 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1955 ** wildcards ("*") in the result set of the SELECT must be expanded before
1956 ** we can do the size check, so defer the size check until code generation.
1957 */
1962 }
1973 }
1974 }
1981 /* Store the SELECT statement in pRight so it will be deleted when
1982 ** sqlite3ExprListDelete() is called */
1986 /* Remember the size of the LHS in iTable so that we can check that
1987 ** the RHS and LHS sizes match during code generation. */
1989 }
1991 vector_append_error:
1995 }
1997 /*
1998 ** Set the sort order for the last element on the given ExprList.
1999 */
2009 );
2013 );
2019 }
2026 }
2027 }
2028 }
2030 /*
2031 ** Set the ExprList.a[].zEName element of the most recently added item
2032 ** on the expression list.
2033 **
2034 ** pList might be NULL following an OOM error. But pName should never be
2035 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2036 ** is set.
2037 */
2043 ){
2054 /* If dequote==0, then pName->z does not point to part of a DDL
2055 ** statement handled by the parser. And so no token need be added
2056 ** to the token-map. */
2060 }
2061 }
2062 }
2063 }
2065 /*
2066 ** Set the ExprList.a[].zSpan element of the most recently added item
2067 ** on the expression list.
2068 **
2069 ** pList might be NULL following an OOM error. But pSpan should never be
2070 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
2071 ** is set.
2072 */
2078 ){
2087 }
2088 }
2089 }
2091 /*
2092 ** If the expression list pEList contains more than iLimit elements,
2093 ** leave an error message in pParse.
2094 */
2099 ){
2105 }
2106 }
2108 /*
2109 ** Delete an entire expression list.
2110 */
2119 pItem++;
2122 }
2125 }
2127 /*
2128 ** Return the bitwise-OR of all Expr.flags fields in the given
2129 ** ExprList.
2130 */
2139 }
2141 }
2143 /*
2144 ** This is a SELECT-node callback for the expression walker that
2145 ** always "fails". By "fail" in this case, we mean set
2146 ** pWalker->eCode to zero and abort.
2147 **
2148 ** This callback is used by multiple expression walkers.
2149 */
2154 }
2156 /*
2157 ** Check the input string to see if it is "true" or "false" (in any case).
2158 **
2159 ** If the string is.... Return
2160 ** "true" EP_IsTrue
2161 ** "false" EP_IsFalse
2162 ** anything else 0
2163 */
2168 }
2171 /*
2172 ** If the input expression is an ID with the name "true" or "false"
2173 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2174 ** the conversion happened, and zero if the expression is unaltered.
2175 */
2177 u32 v;
2181 ){
2185 }
2187 }
2189 /*
2190 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2191 ** and 0 if it is FALSE.
2192 */
2200 }
2202 /*
2203 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2204 ** terms that are always true or false. Return the simplified expression.
2205 ** Or return the original expression if no simplification is possible.
2206 **
2207 ** Examples:
2208 **
2209 ** (x<10) AND true => (x<10)
2210 ** (x<10) AND false => false
2211 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2212 ** (x<10) AND (y=22 OR true) => (x<10)
2213 ** (y=22) OR true => true
2214 */
2224 }
2225 }
2227 }
2230 /*
2231 ** These routines are Walker callbacks used to check expressions to
2232 ** see if they are "constant" for some definition of constant. The
2233 ** Walker.eCode value determines the type of "constant" we are looking
2234 ** for.
2235 **
2236 ** These callback routines are used to implement the following:
2237 **
2238 ** sqlite3ExprIsConstant() pWalker->eCode==1
2239 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2240 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2241 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2242 **
2243 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2244 ** is found to not be a constant.
2245 **
2246 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2247 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2248 ** when parsing an existing schema out of the sqlite_schema table and 4
2249 ** when processing a new CREATE TABLE statement. A bound parameter raises
2250 ** an error for new statements, but is silently converted
2251 ** to NULL for existing schemas. This allows sqlite_schema tables that
2252 ** contain a bound parameter because they were generated by older versions
2253 ** of SQLite to be parsed by newer versions of SQLite without raising a
2254 ** malformed schema error.
2255 */
2258 /* If pWalker->eCode is 2 then any term of the expression that comes from
2259 ** the ON or USING clauses of an outer join disqualifies the expression
2260 ** from being considered constant. */
2264 }
2267 /* Consider functions to be constant if all their arguments are constant
2268 ** and either pWalker->eCode==4 or 5 or the function has the
2269 ** SQLITE_FUNC_CONST flag. */
2273 ){
2279 }
2281 /* Convert "true" or "false" in a DEFAULT clause into the
2282 ** appropriate TK_TRUEFALSE operator */
2285 }
2286 /* no break */ deliberate_fall_through
2296 }
2299 }
2300 /* no break */ deliberate_fall_through
2311 /* Silently convert bound parameters that appear inside of CREATE
2312 ** statements into a NULL when parsing the CREATE statement text out
2313 ** of the sqlite_schema table */
2316 /* A bound parameter in a CREATE statement that originates from
2317 ** sqlite3_prepare() causes an error */
2320 }
2321 /* no break */ deliberate_fall_through
2326 }
2327 }
2329 Walker w;
2333 #ifdef SQLITE_DEBUG
2335 #endif
2339 }
2341 /*
2342 ** Walk an expression tree. Return non-zero if the expression is constant
2343 ** and 0 if it involves variables or function calls.
2344 **
2345 ** For the purposes of this function, a double-quoted string (ex: "abc")
2346 ** is considered a variable but a single-quoted string (ex: 'abc') is
2347 ** a constant.
2348 */
2351 }
2353 /*
2354 ** Walk an expression tree. Return non-zero if
2355 **
2356 ** (1) the expression is constant, and
2357 ** (2) the expression does originate in the ON or USING clause
2358 ** of a LEFT JOIN, and
2359 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2360 ** operands created by the constant propagation optimization.
2361 **
2362 ** When this routine returns true, it indicates that the expression
2363 ** can be added to the pParse->pConstExpr list and evaluated once when
2364 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2365 */
2368 }
2370 /*
2371 ** Walk an expression tree. Return non-zero if the expression is constant
2372 ** for any single row of the table with cursor iCur. In other words, the
2373 ** expression must not refer to any non-deterministic function nor any
2374 ** table other than iCur.
2375 */
2378 }
2380 /*
2381 ** Check pExpr to see if it is an constraint on the single data source
2382 ** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr
2383 ** constrains pSrc but does not depend on any other tables or data
2384 ** sources anywhere else in the query. Return true (non-zero) if pExpr
2385 ** is a constraint on pSrc only.
2386 **
2387 ** This is an optimization. False negatives will perhaps cause slower
2388 ** queries, but false positives will yield incorrect answers. So when in
2389 ** doubt, return 0.
2390 **
2391 ** To be an single-source constraint, the following must be true:
2392 **
2393 ** (1) pExpr cannot refer to any table other than pSrc->iCursor.
2394 **
2395 ** (2) pExpr cannot use subqueries or non-deterministic functions.
2396 **
2397 ** (3) pSrc cannot be part of the left operand for a RIGHT JOIN.
2398 ** (Is there some way to relax this constraint?)
2399 **
2400 ** (4) If pSrc is the right operand of a LEFT JOIN, then...
2401 ** (4a) pExpr must come from an ON clause..
2402 ** (4b) and specifically the ON clause associated with the LEFT JOIN.
2403 **
2404 ** (5) If pSrc is not the right operand of a LEFT JOIN or the left
2405 ** operand of a RIGHT JOIN, then pExpr must be from the WHERE
2406 ** clause, not an ON clause.
2407 **
2408 ** (6) Either:
2409 **
2410 ** (6a) pExpr does not originate in an ON or USING clause, or
2411 **
2412 ** (6b) The ON or USING clause from which pExpr is derived is
2413 ** not to the left of a RIGHT JOIN (or FULL JOIN).
2414 **
2415 ** Without this restriction, accepting pExpr as a single-table
2416 ** constraint might move the the ON/USING filter expression
2417 ** from the left side of a RIGHT JOIN over to the right side,
2418 ** which leads to incorrect answers. See also restriction (9)
2419 ** on push-down.
2420 */
2425 ){
2429 }
2435 }
2438 ){
2444 }
2446 }
2447 }
2448 }
2450 }
2453 /*
2454 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2455 */
2460 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2461 ** it constant. */
2468 }
2469 }
2470 }
2472 /* Check if pExpr is a sub-select. If so, consider it variable. */
2476 }
2479 }
2481 /*
2482 ** Walk the expression tree passed as the first argument. Return non-zero
2483 ** if the expression consists entirely of constants or copies of terms
2484 ** in pGroupBy that sort with the BINARY collation sequence.
2485 **
2486 ** This routine is used to determine if a term of the HAVING clause can
2487 ** be promoted into the WHERE clause. In order for such a promotion to work,
2488 ** the value of the HAVING clause term must be the same for all members of
2489 ** a "group". The requirement that the GROUP BY term must be BINARY
2490 ** assumes that no other collating sequence will have a finer-grained
2491 ** grouping than binary. In other words (A=B COLLATE binary) implies
2492 ** A=B in every other collating sequence. The requirement that the
2493 ** GROUP BY be BINARY is stricter than necessary. It would also work
2494 ** to promote HAVING clauses that use the same alternative collating
2495 ** sequence as the GROUP BY term, but that is much harder to check,
2496 ** alternative collating sequences are uncommon, and this is only an
2497 ** optimization, so we take the easy way out and simply require the
2498 ** GROUP BY to use the BINARY collating sequence.
2499 */
2501 Walker w;
2509 }
2511 /*
2512 ** Walk an expression tree for the DEFAULT field of a column definition
2513 ** in a CREATE TABLE statement. Return non-zero if the expression is
2514 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2515 ** the expression is constant or a function call with constant arguments.
2516 ** Return and 0 if there are any variables.
2517 **
2518 ** isInit is true when parsing from sqlite_schema. isInit is false when
2519 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2520 ** (such as ? or $abc) in the expression are converted into NULL. When
2521 ** isInit is false, parameters raise an error. Parameters should not be
2522 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2523 ** allowed it, so we need to support it when reading sqlite_schema for
2524 ** backwards compatibility.
2525 **
2526 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2527 **
2528 ** For the purposes of this function, a double-quoted string (ex: "abc")
2529 ** is considered a variable but a single-quoted string (ex: 'abc') is
2530 ** a constant.
2531 */
2535 }
2537 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2538 /*
2539 ** Walk an expression tree. Return 1 if the expression contains a
2540 ** subquery of some kind. Return 0 if there are no subqueries.
2541 */
2543 Walker w;
2547 #ifdef SQLITE_DEBUG
2549 #endif
2552 }
2553 #endif
2555 /*
2556 ** If the expression p codes a constant integer that is small enough
2557 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2558 ** in *pValue. If the expression is not an integer or if it is too big
2559 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2560 */
2565 /* If an expression is an integer literal that fits in a signed 32-bit
2566 ** integer, then the EP_IntValue flag will have already been set */
2573 }
2578 }
2585 }
2587 }
2589 }
2591 }
2593 /*
2594 ** Return FALSE if there is no chance that the expression can be NULL.
2595 **
2596 ** If the expression might be NULL or if the expression is too complex
2597 ** to tell return TRUE.
2598 **
2599 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2600 ** when we know that a value cannot be NULL. Hence, a false positive
2601 ** (returning TRUE when in fact the expression can never be NULL) might
2602 ** be a small performance hit but is otherwise harmless. On the other
2603 ** hand, a false negative (returning FALSE when the result could be NULL)
2604 ** will likely result in an incorrect answer. So when in doubt, return
2605 ** TRUE.
2606 */
2608 u8 op;
2613 }
2631 }
2632 }
2634 /*
2635 ** Return TRUE if the given expression is a constant which would be
2636 ** unchanged by OP_Affinity with the affinity given in the second
2637 ** argument.
2638 **
2639 ** This routine is used to determine if the OP_Affinity operation
2640 ** can be omitted. When in doubt return FALSE. A false negative
2641 ** is harmless. A false positive, however, can result in the wrong
2642 ** answer.
2643 */
2645 u8 op;
2651 }
2657 }
2660 }
2663 }
2666 }
2670 }
2673 }
2674 }
2675 }
2677 /*
2678 ** Return TRUE if the given string is a row-id column name.
2679 */
2685 }
2687 /*
2688 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2689 ** that can be simplified to a direct table access, then return
2690 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2691 ** or if the SELECT statement needs to be materialized into a transient
2692 ** table, then return NULL.
2693 */
2694 #ifndef SQLITE_OMIT_SUBQUERY
2709 }
2723 /* All SELECT results must be columns. */
2728 }
2730 }
2733 #ifndef SQLITE_OMIT_SUBQUERY
2734 /*
2735 ** Generate code that checks the left-most column of index table iCur to see if
2736 ** it contains any NULL entries. Cause the register at regHasNull to be set
2737 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2738 ** to be set to NULL if iCur contains one or more NULL values.
2739 */
2748 }
2749 #endif
2752 #ifndef SQLITE_OMIT_SUBQUERY
2753 /*
2754 ** The argument is an IN operator with a list (not a subquery) on the
2755 ** right-hand side. Return TRUE if that list is constant.
2756 */
2766 }
2767 #endif
2769 /*
2770 ** This function is used by the implementation of the IN (...) operator.
2771 ** The pX parameter is the expression on the RHS of the IN operator, which
2772 ** might be either a list of expressions or a subquery.
2773 **
2774 ** The job of this routine is to find or create a b-tree object that can
2775 ** be used either to test for membership in the RHS set or to iterate through
2776 ** all members of the RHS set, skipping duplicates.
2777 **
2778 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2779 ** and the *piTab parameter is set to the index of that cursor.
2780 **
2781 ** The returned value of this function indicates the b-tree type, as follows:
2782 **
2783 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2784 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2785 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2786 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2787 ** populated epheremal table.
2788 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2789 ** implemented as a sequence of comparisons.
2790 **
2791 ** An existing b-tree might be used if the RHS expression pX is a simple
2792 ** subquery such as:
2793 **
2794 ** SELECT <column1>, <column2>... FROM <table>
2795 **
2796 ** If the RHS of the IN operator is a list or a more complex subquery, then
2797 ** an ephemeral table might need to be generated from the RHS and then
2798 ** pX->iTable made to point to the ephemeral table instead of an
2799 ** existing table. In this case, the creation and initialization of the
2800 ** ephmeral table might be put inside of a subroutine, the EP_Subrtn flag
2801 ** will be set on pX and the pX->y.sub fields will be set to show where
2802 ** the subroutine is coded.
2803 **
2804 ** The inFlags parameter must contain, at a minimum, one of the bits
2805 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2806 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2807 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2808 ** be used to loop over all values of the RHS of the IN operator.
2809 **
2810 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2811 ** through the set members) then the b-tree must not contain duplicates.
2812 ** An epheremal table will be created unless the selected columns are guaranteed
2813 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2814 ** a UNIQUE constraint or index.
2815 **
2816 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2817 ** for fast set membership tests) then an epheremal table must
2818 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2819 ** index can be found with the specified <columns> as its left-most.
2820 **
2821 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2822 ** if the RHS of the IN operator is a list (not a subquery) then this
2823 ** routine might decide that creating an ephemeral b-tree for membership
2824 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2825 ** calling routine should implement the IN operator using a sequence
2826 ** of Eq or Ne comparison operations.
2827 **
2828 ** When the b-tree is being used for membership tests, the calling function
2829 ** might need to know whether or not the RHS side of the IN operator
2830 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2831 ** if there is any chance that the (...) might contain a NULL value at
2832 ** runtime, then a register is allocated and the register number written
2833 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2834 ** NULL value, then *prRhsHasNull is left unchanged.
2835 **
2836 ** If a register is allocated and its location stored in *prRhsHasNull, then
2837 ** the value in that register will be NULL if the b-tree contains one or more
2838 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2839 ** NULL values.
2840 **
2841 ** If the aiMap parameter is not NULL, it must point to an array containing
2842 ** one element for each column returned by the SELECT statement on the RHS
2843 ** of the IN(...) operator. The i'th entry of the array is populated with the
2844 ** offset of the index column that matches the i'th column returned by the
2845 ** SELECT. For example, if the expression and selected index are:
2846 **
2847 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2848 ** CREATE INDEX i1 ON t1(b, c, a);
2849 **
2850 ** then aiMap[] is populated with {2, 0, 1}.
2851 */
2852 #ifndef SQLITE_OMIT_SUBQUERY
2860 ){
2871 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2872 ** whether or not the SELECT result contains NULL values, check whether
2873 ** or not NULL is actually possible (it may not be, for example, due
2874 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2875 ** set prRhsHasNull to 0 before continuing. */
2881 }
2884 }
2885 }
2887 /* Check to see if an existing table or index can be used to
2888 ** satisfy the query. This is preferable to generating a new
2889 ** ephemeral table. */
2902 /* Code an OP_Transaction and OP_TableLock for <table>. */
2910 /* The "x IN (SELECT rowid FROM table)" case */
2924 /* Check that the affinity that will be used to perform each
2925 ** comparison is the same as the affinity of each column in table
2926 ** on the RHS of the IN operator. If it not, it is not possible to
2927 ** use any index of the RHS table. */
2939 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2940 ** other has no affinity and the other side is TEXT. Hence,
2941 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2942 ** and for the term on the LHS of the IN to have no affinity. */
2947 }
2948 }
2951 /* Search for an existing index that will work for this IN operator */
2957 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2958 ** BITMASK(nExpr) without overflowing */
2965 ){
2967 }
2968 }
2982 }
2984 }
2990 }
2994 /* If we reach this point, that means the index pIdx is usable */
3005 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
3009 #endif
3013 }
3014 }
3016 }
3022 /* If no preexisting index is available for the IN clause
3023 ** and IN_INDEX_NOOP is an allowed reply
3024 ** and the RHS of the IN operator is a list, not a subquery
3025 ** and the RHS is not constant or has two or fewer terms,
3026 ** then it is not worth creating an ephemeral table to evaluate
3027 ** the IN operator so return IN_INDEX_NOOP.
3028 */
3033 ){
3037 }
3040 /* Could not find an existing table or index to use as the RHS b-tree.
3041 ** We will have to generate an ephemeral table to do the job.
3042 */
3050 }
3055 }
3057 }
3063 }
3066 }
3067 #endif
3069 #ifndef SQLITE_OMIT_SUBQUERY
3070 /*
3071 ** Argument pExpr is an (?, ?...) IN(...) expression. This
3072 ** function allocates and returns a nul-terminated string containing
3073 ** the affinities to be used for each column of the comparison.
3074 **
3075 ** It is the responsibility of the caller to ensure that the returned
3076 ** string is eventually freed using sqlite3DbFree().
3077 */
3095 }
3096 }
3098 }
3100 }
3101 #endif
3103 #ifndef SQLITE_OMIT_SUBQUERY
3104 /*
3105 ** Load the Parse object passed as the first argument with an error
3106 ** message of the form:
3107 **
3108 ** "sub-select returns N columns - expected M"
3109 */
3114 }
3115 }
3116 #endif
3118 /*
3119 ** Expression pExpr is a vector that has been used in a context where
3120 ** it is not permitted. If pExpr is a sub-select vector, this routine
3121 ** loads the Parse object with a message of the form:
3122 **
3123 ** "sub-select returns N columns - expected 1"
3124 **
3125 ** Or, if it is a regular scalar vector:
3126 **
3127 ** "row value misused"
3128 */
3130 #ifndef SQLITE_OMIT_SUBQUERY
3134 #endif
3135 {
3137 }
3138 }
3140 #ifndef SQLITE_OMIT_SUBQUERY
3141 /*
3142 ** Generate code that will construct an ephemeral table containing all terms
3143 ** in the RHS of an IN operator. The IN operator can be in either of two
3144 ** forms:
3145 **
3146 ** x IN (4,5,11) -- IN operator with list on right-hand side
3147 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
3148 **
3149 ** The pExpr parameter is the IN operator. The cursor number for the
3150 ** constructed ephermeral table is returned. The first time the ephemeral
3151 ** table is computed, the cursor number is also stored in pExpr->iTable,
3152 ** however the cursor number returned might not be the same, as it might
3153 ** have been duplicated using OP_OpenDup.
3154 **
3155 ** If the LHS expression ("x" in the examples) is a column value, or
3156 ** the SELECT statement returns a column value, then the affinity of that
3157 ** column is used to build the index keys. If both 'x' and the
3158 ** SELECT... statement are columns, then numeric affinity is used
3159 ** if either column has NUMERIC or INTEGER affinity. If neither
3160 ** 'x' nor the SELECT... statement are columns, then numeric affinity
3161 ** is used.
3162 */
3167 ){
3178 /* The evaluation of the IN must be repeated every time it
3179 ** is encountered if any of the following is true:
3180 **
3181 ** * The right-hand side is a correlated subquery
3182 ** * The right-hand side is an expression list containing variables
3183 ** * We are inside a trigger
3184 **
3185 ** If all of the above are false, then we can compute the RHS just once
3186 ** and reuse it many names.
3187 */
3189 /* Reuse of the RHS is allowed */
3190 /* If this routine has already been coded, but the previous code
3191 ** might not have been invoked yet, so invoke it now as a subroutine.
3192 */
3198 }
3206 }
3208 /* Begin coding the subroutine */
3217 }
3219 /* Check to see if this is a vector IN operator */
3223 /* Construct the ephemeral table that will contain the content of
3224 ** RHS of the IN operator.
3225 */
3228 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3233 }
3234 #endif
3238 /* Case 1: expr IN (SELECT ...)
3239 **
3240 ** Generate code to write the results of the select into the temporary
3241 ** table allocated and opened above.
3242 */
3248 ));
3249 /* If the LHS and RHS of the IN operator do not match, that
3250 ** error will have been caught long before we reach this point. */
3253 SelectDest dest;
3268 }
3277 );
3278 }
3279 }
3281 /* Case 2: expr IN (exprlist)
3282 **
3283 ** For each expression, build an index key from the evaluation and
3284 ** store it in the temporary table. If <expr> is a column, then use
3285 ** that columns affinity when building index keys. If <expr> is not
3286 ** a column, use numeric affinity.
3287 */
3298 }
3302 }
3304 /* Loop through each expression in <exprlist>. */
3310 /* If the expression is not constant then we will need to
3311 ** disable the test that was generated above that makes sure
3312 ** this code only executes once. Because for a non-constant
3313 ** expression we need to rerun this code each time.
3314 */
3320 }
3322 /* Evaluate the expression and insert it into the temp table */
3326 }
3329 }
3332 }
3336 /* Subroutine return */
3344 }
3345 }
3348 /*
3349 ** Generate code for scalar subqueries used as a subquery expression
3350 ** or EXISTS operator:
3351 **
3352 ** (SELECT a FROM b) -- subquery
3353 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3354 **
3355 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3356 **
3357 ** Return the register that holds the result. For a multi-column SELECT,
3358 ** the result is stored in a contiguous array of registers and the
3359 ** return value is the register of the left-most result column.
3360 ** Return 0 if an error occurs.
3361 */
3362 #ifndef SQLITE_OMIT_SUBQUERY
3370 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
3372 #endif
3383 /* If this routine has already been coded, then invoke it as a
3384 ** subroutine. */
3391 }
3393 /* Begin coding the subroutine */
3401 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3402 ** is encountered if any of the following is true:
3403 **
3404 ** * The right-hand side is a correlated subquery
3405 ** * The right-hand side is an expression list containing variables
3406 ** * We are inside a trigger
3407 **
3408 ** If all of the above are false, then we can run this code just once
3409 ** save the results, and reuse the same result on subsequent invocations.
3410 */
3413 }
3415 /* For a SELECT, generate code to put the values for all columns of
3416 ** the first row into an array of registers and return the index of
3417 ** the first register.
3418 **
3419 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3420 ** into a register and return that register number.
3421 **
3422 ** In both cases, the query is augmented with "LIMIT 1". Any
3423 ** preexisting limit is discarded in place of the new LIMIT 1.
3424 */
3441 }
3443 /* The subquery already has a limit. If the pre-existing limit is X
3444 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3451 }
3455 /* If there is no pre-existing limit add a limit of 1 */
3458 }
3464 }
3469 }
3472 /* Subroutine return */
3481 }
3484 #ifndef SQLITE_OMIT_SUBQUERY
3485 /*
3486 ** Expr pIn is an IN(...) expression. This function checks that the
3487 ** sub-select on the RHS of the IN() operator has the same number of
3488 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3489 ** a sub-query, that the LHS is a vector of size 1.
3490 */
3497 }
3501 }
3503 }
3504 #endif
3506 #ifndef SQLITE_OMIT_SUBQUERY
3507 /*
3508 ** Generate code for an IN expression.
3509 **
3510 ** x IN (SELECT ...)
3511 ** x IN (value, value, ...)
3512 **
3513 ** The left-hand side (LHS) is a scalar or vector expression. The
3514 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3515 ** subquery. If the RHS is a subquery, the number of result columns must
3516 ** match the number of columns in the vector on the LHS. If the RHS is
3517 ** a list of values, the LHS must be a scalar.
3518 **
3519 ** The IN operator is true if the LHS value is contained within the RHS.
3520 ** The result is false if the LHS is definitely not in the RHS. The
3521 ** result is NULL if the presence of the LHS in the RHS cannot be
3522 ** determined due to NULLs.
3523 **
3524 ** This routine generates code that jumps to destIfFalse if the LHS is not
3525 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3526 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3527 ** within the RHS then fall through.
3528 **
3529 ** See the separate in-operator.md documentation file in the canonical
3530 ** SQLite source tree for additional information.
3531 */
3537 ){
3564 );
3567 /* Attempt to compute the RHS. After this step, if anything other than
3568 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3569 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3570 ** the RHS has not yet been coded. */
3581 );
3582 #ifdef SQLITE_DEBUG
3583 /* Confirm that aiMap[] contains nVector integer values between 0 and
3584 ** nVector-1. */
3589 }
3590 #endif
3592 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3593 ** vector, then it is stored in an array of nVector registers starting
3594 ** at r1.
3595 **
3596 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3597 ** so that the fields are in the same order as an existing index. The
3598 ** aiMap[] array contains a mapping from the original LHS field order to
3599 ** the field order that matches the RHS index.
3600 **
3601 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3602 ** even if it is constant, as OP_Affinity may be used on the register
3603 ** by code generated below. */
3610 /* LHS fields are not reordered */
3613 /* Need to reorder the LHS fields according to aiMap */
3617 }
3618 }
3620 /* If sqlite3FindInIndex() did not find or create an index that is
3621 ** suitable for evaluating the IN operator, then evaluate using a
3622 ** sequence of comparisons.
3623 **
3624 ** This is step (1) in the in-operator.md optimized algorithm.
3625 */
3639 }
3644 }
3663 }
3664 }
3668 }
3672 }
3674 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3675 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3676 ** We will then skip the binary search of the RHS.
3677 */
3682 }
3689 }
3690 }
3692 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3693 ** of the RHS using the LHS as a probe. If found, the result is
3694 ** true.
3695 */
3697 /* In this case, the RHS is the ROWID of table b-tree and so we also
3698 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3699 ** into a single opcode. */
3706 /* Combine Step 3 and Step 5 into a single opcode */
3710 }
3711 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3714 }
3716 /* Step 4. If the RHS is known to be non-NULL and we did not find
3717 ** an match on the search above, then the result must be FALSE.
3718 */
3722 }
3724 /* Step 5. If we do not care about the difference between NULL and
3725 ** FALSE, then just return false.
3726 */
3729 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3730 ** If any comparison is NULL, then the result is NULL. If all
3731 ** comparisons are FALSE then the final result is FALSE.
3732 **
3733 ** For a scalar LHS, it is sufficient to check just the first row
3734 ** of the RHS.
3735 */
3742 /* For nVector==1, combine steps 6 and 7 by immediately returning
3743 ** FALSE if the first comparison is not NULL */
3745 }
3757 }
3764 /* Step 7: If we reach this point, we know that the result must
3765 ** be false. */
3767 }
3769 /* Jumps here in order to return true. */
3772 sqlite3ExprCodeIN_finished:
3775 sqlite3ExprCodeIN_oom_error:
3778 }
3781 #ifndef SQLITE_OMIT_FLOATING_POINT
3782 /*
3783 ** Generate an instruction that will put the floating point
3784 ** value described by z[0..n-1] into register iMem.
3785 **
3786 ** The z[] string will probably not be zero-terminated. But the
3787 ** z[n] character is guaranteed to be something that does not look
3788 ** like the continuation of the number.
3789 */
3797 }
3798 }
3799 #endif
3802 /*
3803 ** Generate an instruction that will put the integer describe by
3804 ** text z[0..n-1] into register iMem.
3805 **
3806 ** Expr.u.zToken is always UTF8 and zero-terminated.
3807 */
3817 i64 value;
3822 #ifdef SQLITE_OMIT_FLOATING_POINT
3824 #else
3825 #ifndef SQLITE_OMIT_HEX_INTEGER
3830 #endif
3831 {
3833 }
3834 #endif
3838 }
3839 }
3840 }
3843 /* Generate code that will load into register regOut a value that is
3844 ** appropriate for the iIdxCol-th column of index pIdx.
3845 */
3852 ){
3863 }
3864 }
3866 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3867 /*
3868 ** Generate code that will compute the value of generated column pCol
3869 ** and store the result in register regOut
3870 */
3876 ){
3886 }
3890 }
3893 }
3896 /*
3897 ** Generate code to extract the value of the iCol-th column of a table.
3898 */
3905 ){
3919 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3932 }
3934 #endif
3943 }
3946 }
3947 }
3949 /*
3950 ** Generate code that will extract the iColumn-th column from
3951 ** table pTab and store the column value in register iReg.
3952 **
3953 ** There must be an open cursor to pTab in iTable when this routine
3954 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3955 */
3962 u8 p5 /* P5 value for OP_Column + FLAGS */
3963 ){
3969 }
3971 }
3973 /*
3974 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3975 ** over to iTo..iTo+nReg-1.
3976 */
3979 }
3981 /*
3982 ** Convert a scalar expression node to a TK_REGISTER referencing
3983 ** register iReg. The caller must ensure that iReg already contains
3984 ** the correct value for the expression.
3985 */
3993 }
3995 /*
3996 ** Evaluate an expression (either a vector or a scalar expression) and store
3997 ** the result in continguous temporary registers. Return the index of
3998 ** the first register used to store the result.
3999 **
4000 ** If the returned result register is a temporary scalar, then also write
4001 ** that register number into *piFreeable. If the returned result register
4002 ** is not a temporary or if the expression is a vector set *piFreeable
4003 ** to 0.
4004 */
4013 #if SQLITE_OMIT_SUBQUERY
4015 #else
4017 #endif
4025 }
4026 }
4027 }
4029 }
4031 /*
4032 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
4033 ** so that a subsequent copy will not be merged into this one.
4034 */
4038 }
4039 }
4041 /*
4042 ** Generate code to implement special SQL functions that are implemented
4043 ** in-line rather than by using the usual callbacks.
4044 */
4050 ){
4059 /* Attempt a direct implementation of the built-in COALESCE() and
4060 ** IFNULL() functions. This avoids unnecessary evaluation of
4061 ** arguments past the first non-NULL argument.
4062 */
4071 }
4075 }
4077 Expr caseExpr;
4082 }
4083 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4090 }
4092 }
4093 #endif
4095 /* The UNLIKELY() function is a no-op. The result is the value
4096 ** of the first argument.
4097 */
4101 }
4103 /***********************************************************************
4104 ** Test-only SQL functions that are only usable if enabled
4105 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
4106 */
4107 #if !defined(SQLITE_UNTESTABLE)
4109 /* Compare two expressions using sqlite3ExprCompare() */
4113 target);
4115 }
4118 /* Compare two expressions using sqlite3ExprImpliesExpr() */
4122 target);
4124 }
4127 /* REsult of sqlite3ExprImpliesNonNullRow() */
4134 target);
4137 }
4139 }
4142 /* The AFFINITY() function evaluates to a string that describes
4143 ** the type affinity of the argument. This is used for testing of
4144 ** the SQLite type logic.
4145 */
4156 }
4158 }
4160 }
4162 /*
4163 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
4164 ** If it is, then resolve the expression by reading from the index and
4165 ** return the register into which the value has been read. If pExpr is
4166 ** not an indexed expression, then return negative.
4167 */
4172 ){
4176 u8 exprAff;
4182 }
4189 ){
4190 /* Affinity mismatch on a generated column */
4192 }
4197 /* If the index is on a NULL row due to an outer join, then we
4198 ** cannot extract the value from the index. The value must be
4199 ** computed using the original expression. */
4214 }
4216 }
4218 }
4221 /*
4222 ** Generate code into the current Vdbe to evaluate the given
4223 ** expression. Attempt to store the results in register "target".
4224 ** Return the register where results are stored.
4225 **
4226 ** With this routine, there is no guarantee that results will
4227 ** be stored in target. The result might be stored in some other
4228 ** register if it is convenient to do so. The calling function
4229 ** must check the return code and move the results to the desired
4230 ** register.
4231 */
4245 expr_code_doover:
4251 ){
4256 }
4264 /* Happens when the left table of a RIGHT JOIN is null and
4265 ** is using an expression index */
4267 #ifdef SQLITE_VDBE_COVERAGE
4268 /* Verify that the OP_Null above is exercised by tests
4269 ** tag-20230325-2 */
4272 #endif
4274 }
4283 /* No comment added */
4291 }
4292 }
4295 /* This case happens when the argument to an aggregate function
4296 ** is rewritten by aggregateConvertIndexedExprRefToColumn() */
4299 }
4300 /* Otherwise, fall thru into the TK_COLUMN case */
4301 /* no break */ deliberate_fall_through
4302 }
4307 /* This COLUMN expression is really a constant due to WHERE clause
4308 ** constraints, and that constant is coded by the pExpr->pLeft
4309 ** expresssion. However, make sure the constant has the correct
4310 ** datatype by applying the Affinity of the table column to the
4311 ** constant.
4312 */
4324 }
4326 }
4329 /* Other columns in the same row for CHECK constraints or
4330 ** generated columns or for inserting into partial index.
4331 ** The row is unpacked into registers beginning at
4332 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4333 ** immediately prior to the first column.
4334 */
4346 }
4350 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4356 }
4360 }
4371 }
4373 /* Coding an expression that is part of an index where column names
4374 ** in the index refer to the table to which the index belongs */
4376 }
4377 }
4384 }
4388 }
4392 }
4393 #ifndef SQLITE_OMIT_FLOATING_POINT
4398 }
4399 #endif
4404 }
4406 /* Make NULL the default case so that if a bug causes an illegal
4407 ** Expr node to be passed into this function, it will be handled
4408 ** sanely and not crash. But keep the assert() to bring the problem
4409 ** to the attention of the developers. */
4413 }
4414 #ifndef SQLITE_OMIT_BLOB_LITERAL
4428 }
4429 #endif
4440 }
4442 }
4445 }
4446 #ifndef SQLITE_OMIT_CAST
4448 /* Expressions of the form: CAST(pLeft AS token) */
4455 }
4461 /* fall-through */
4488 }
4491 }
4493 }
4523 }
4530 #ifndef SQLITE_OMIT_FLOATING_POINT
4535 #endif
4545 }
4547 }
4556 }
4568 }
4583 }
4589 ){
4594 }
4596 }
4608 #ifndef SQLITE_OMIT_WINDOWFUNC
4611 }
4612 #endif
4615 /* SQL functions can be expensive. So try to avoid running them
4616 ** multiple times if we know they always give the same result */
4618 }
4626 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4629 }
4630 #endif
4634 }
4642 }
4648 }
4651 }
4652 }
4659 }
4661 /* For length() and typeof() functions with a column argument,
4662 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4663 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
4664 ** loading.
4665 */
4667 u8 exprOp;
4677 }
4678 }
4684 }
4685 #ifndef SQLITE_OMIT_VIRTUALTABLE
4686 /* Possibly overload the function if the first argument is
4687 ** a virtual table column.
4688 **
4689 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4690 ** second argument, not the first, as the argument to test to
4691 ** see if it is a column in a virtual table. This is done because
4692 ** the left operand of infix functions (the operand we want to
4693 ** control overloading) ends up as the second argument to the
4694 ** function. The expression "A glob B" is equivalent to
4695 ** "glob(B,A). We want to use the A in "A glob B" to test
4696 ** for function overloading. But we use the B term in "glob(B,A)".
4697 */
4702 }
4703 #endif
4707 }
4715 }
4716 }
4718 }
4719 #ifndef SQLITE_OMIT_SUBQUERY
4730 ){
4734 }
4736 }
4743 }
4749 }
4751 }
4762 }
4766 /*
4767 ** x BETWEEN y AND z
4768 **
4769 ** This is equivalent to
4770 **
4771 ** x>=y AND x<=z
4772 **
4773 ** X is stored in pExpr->pLeft.
4774 ** Y is stored in pExpr->pList->a[0].pExpr.
4775 ** Z is stored in pExpr->pList->a[1].pExpr.
4776 */
4780 }
4783 /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called
4784 ** "SOFT-COLLATE" that is added to constraints that are pushed down
4785 ** from outer queries into sub-queries by the push-down optimization.
4786 ** Clear subtypes as subtypes may not cross a subquery boundary.
4787 */
4795 }
4796 }
4801 }
4804 /* If the opcode is TK_TRIGGER, then the expression is a reference
4805 ** to a column in the new.* or old.* pseudo-tables available to
4806 ** trigger programs. In this case Expr.iTable is set to 1 for the
4807 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4808 ** is set to the column of the pseudo-table to read, or to -1 to
4809 ** read the rowid field.
4810 **
4811 ** The expression is implemented using an OP_Param opcode. The p1
4812 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4813 ** to reference another column of the old.* pseudo-table, where
4814 ** i is the index of the column. For a new.rowid reference, p1 is
4815 ** set to (n+1), where n is the number of columns in each pseudo-table.
4816 ** For a reference to any other column in the new.* pseudo-table, p1
4817 ** is set to (n+2+i), where n and i are as defined previously. For
4818 ** example, if the table on which triggers are being fired is
4819 ** declared as:
4820 **
4821 ** CREATE TABLE t1(a, b);
4822 **
4823 ** Then p1 is interpreted as follows:
4824 **
4825 ** p1==0 -> old.rowid p1==3 -> new.rowid
4826 ** p1==1 -> old.a p1==4 -> new.a
4827 ** p1==2 -> old.b p1==5 -> new.b
4828 */
4848 ));
4850 #ifndef SQLITE_OMIT_FLOATING_POINT
4851 /* If the column has REAL affinity, it may currently be stored as an
4852 ** integer. Use OP_RealAffinity to make sure it is really real.
4853 **
4854 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4855 ** floating point when extracting it from the record. */
4858 }
4859 #endif
4861 }
4866 }
4868 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
4869 ** that derive from the right-hand table of a LEFT JOIN. The
4870 ** Expr.iTable value is the table number for the right-hand table.
4871 ** The expression is only evaluated if that table is not currently
4872 ** on a LEFT JOIN NULL row.
4873 */
4883 }
4887 target);
4890 }
4891 }
4893 /* The OP_IfNullRow opcode above can overwrite the result register with
4894 ** NULL. So we have to ensure that the result register is not a value
4895 ** that is suppose to be a constant. Two defenses are needed:
4896 ** (1) Temporarily disable factoring of constant expressions
4897 ** (2) Make sure the computed value really is stored in register
4898 ** "target" and not someplace else.
4899 */
4906 }
4908 /*
4909 ** Form A:
4910 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4911 **
4912 ** Form B:
4913 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4914 **
4915 ** Form A is can be transformed into the equivalent form B as follows:
4916 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4917 ** WHEN x=eN THEN rN ELSE y END
4918 **
4919 ** X (if it exists) is in pExpr->pLeft.
4920 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4921 ** odd. The Y is also optional. If the number of elements in x.pList
4922 ** is even, then Y is omitted and the "otherwise" result is NULL.
4923 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4924 **
4925 ** The result of the expression is the Ri for the first matching Ei,
4926 ** or if there is no matching Ei, the ELSE term Y, or if there is
4927 ** no ELSE term, NULL.
4928 */
4953 }
4961 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4962 ** The value in regFree1 might get SCopy-ed into the file result.
4963 ** So make sure that the regFree1 register is not reused for other
4964 ** purposes and possibly overwritten. */
4966 }
4973 }
4981 }
4986 }
4991 }
4992 #ifndef SQLITE_OMIT_TRIGGER
4998 );
5003 }
5006 }
5016 }
5019 }
5020 #endif
5021 }
5025 }
5027 /*
5028 ** Generate code that will evaluate expression pExpr just one time
5029 ** per prepared statement execution.
5030 **
5031 ** If the expression uses functions (that might throw an exception) then
5032 ** guard them with an OP_Once opcode to ensure that the code is only executed
5033 ** once. If no functions are involved, then factor the code out and put it at
5034 ** the end of the prepared statement in the initialization section.
5035 **
5036 ** If regDest>=0 then the result is always stored in that register and the
5037 ** result is not reusable. If regDest<0 then this routine is free to
5038 ** store the value whereever it wants. The register where the expression
5039 ** is stored is returned. When regDest<0, two identical expressions might
5040 ** code to the same register, if they do not contain function calls and hence
5041 ** are factored out into the initialization section at the end of the
5042 ** prepared statement.
5043 */
5048 ){
5058 ){
5060 }
5061 }
5062 }
5073 }
5084 }
5086 }
5088 }
5090 /*
5091 ** Generate code to evaluate an expression and store the results
5092 ** into a register. Return the register number where the results
5093 ** are stored.
5094 **
5095 ** If the register is a temporary register that can be deallocated,
5096 ** then write its number into *pReg. If the result register is not
5097 ** a temporary, then set *pReg to zero.
5098 **
5099 ** If pExpr is a constant, then this routine might generate this
5100 ** code to fill the register in the initialization section of the
5101 ** VDBE program, in order to factor it out of the evaluation loop.
5102 */
5110 ){
5121 }
5122 }
5124 }
5126 /*
5127 ** Generate code that will evaluate expression pExpr and store the
5128 ** results in register target. The results are guaranteed to appear
5129 ** in register target.
5130 */
5140 u8 op;
5143 ){
5147 }
5149 }
5150 }
5152 /*
5153 ** Make a transient copy of expression pExpr and then code it using
5154 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
5155 ** except that the input expression is guaranteed to be unchanged.
5156 */
5162 }
5164 /*
5165 ** Generate code that will evaluate expression pExpr and store the
5166 ** results in register target. The results are guaranteed to appear
5167 ** in register target. If the expression is constant, then this routine
5168 ** might choose to code the expression at initialization time.
5169 */
5175 }
5176 }
5178 /*
5179 ** Generate code that pushes the value of every element of the given
5180 ** expression list into a sequence of registers beginning at target.
5181 **
5182 ** Return the number of elements evaluated. The number returned will
5183 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
5184 ** is defined.
5185 **
5186 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
5187 ** filled using OP_SCopy. OP_Copy must be used instead.
5188 **
5189 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
5190 ** factored out into initialization code.
5191 **
5192 ** The SQLITE_ECEL_REF flag means that expressions in the list with
5193 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
5194 ** in registers at srcReg, and so the value can be copied from there.
5195 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
5196 ** are simply omitted rather than being copied from srcReg.
5197 */
5203 u8 flags /* SQLITE_ECEL_* flags */
5204 ){
5216 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
5218 i--;
5219 n--;
5221 #endif
5224 i--;
5225 n--;
5228 }
5231 ){
5242 ){
5246 }
5247 }
5248 }
5249 }
5251 }
5253 /*
5254 ** Generate code for a BETWEEN operator.
5255 **
5256 ** x BETWEEN y AND z
5257 **
5258 ** The above is equivalent to
5259 **
5260 ** x>=y AND x<=z
5261 **
5262 ** Code it as such, taking care to do the common subexpression
5263 ** elimination of x.
5264 **
5265 ** The xJumpIf parameter determines details:
5266 **
5267 ** NULL: Store the boolean result in reg[dest]
5268 ** sqlite3ExprIfTrue: Jump to dest if true
5269 ** sqlite3ExprIfFalse: Jump to dest if false
5270 **
5271 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
5272 */
5279 ){
5307 /* Mark the expression is being from the ON or USING clause of a join
5308 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5309 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5310 ** for clarity, but we are out of bits in the Expr.flags field so we
5311 ** have to reuse the EP_OuterON bit. Bummer. */
5314 }
5316 }
5319 /* Ensure adequate test coverage */
5329 }
5331 /*
5332 ** Generate code for a boolean expression such that a jump is made
5333 ** to the label "dest" if the expression is true but execution
5334 ** continues straight thru if the expression is false.
5335 **
5336 ** If the expression evaluates to NULL (neither true nor false), then
5337 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5338 **
5339 ** This code depends on the fact that certain token values (ex: TK_EQ)
5340 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5341 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5342 ** the make process cause these values to align. Assert()s in the code
5343 ** below verify that the numbers are aligned correctly.
5344 */
5374 }
5376 }
5381 }
5396 }
5398 }
5405 /* no break */ deliberate_fall_through
5431 }
5443 }
5448 }
5449 #ifndef SQLITE_OMIT_SUBQUERY
5457 }
5458 #endif
5460 default_expr:
5464 /* No-op */
5471 }
5473 }
5474 }
5477 }
5479 /*
5480 ** Generate code for a boolean expression such that a jump is made
5481 ** to the label "dest" if the expression is false but execution
5482 ** continues straight thru if the expression is true.
5483 **
5484 ** If the expression evaluates to NULL (neither true nor false) then
5485 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5486 ** is 0.
5487 */
5500 /* The value of pExpr->op and op are related as follows:
5501 **
5502 ** pExpr->op op
5503 ** --------- ----------
5504 ** TK_ISNULL OP_NotNull
5505 ** TK_NOTNULL OP_IsNull
5506 ** TK_NE OP_Eq
5507 ** TK_EQ OP_Ne
5508 ** TK_GT OP_Le
5509 ** TK_LE OP_Gt
5510 ** TK_GE OP_Lt
5511 ** TK_LT OP_Ge
5512 **
5513 ** For other values of pExpr->op, op is undefined and unused.
5514 ** The value of TK_ and OP_ constants are arranged such that we
5515 ** can compute the mapping above using the following expression.
5516 ** Assert()s verify that the computation is correct.
5517 */
5520 /* Verify correct alignment of TK_ and OP_ constants
5521 */
5548 }
5550 }
5555 }
5565 /* IS TRUE and IS NOT FALSE */
5570 /* IS FALSE and IS NOT TRUE */
5573 }
5575 }
5582 /* no break */ deliberate_fall_through
5608 }
5618 }
5623 }
5624 #ifndef SQLITE_OMIT_SUBQUERY
5632 }
5634 }
5635 #endif
5637 default_expr:
5641 /* no-op */
5648 }
5650 }
5651 }
5654 }
5656 /*
5657 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5658 ** code generation, and that copy is deleted after code generation. This
5659 ** ensures that the original pExpr is unchanged.
5660 */
5666 }
5668 }
5670 /*
5671 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5672 ** type of expression.
5673 **
5674 ** If pExpr is a simple SQL value - an integer, real, string, blob
5675 ** or NULL value - then the VDBE currently being prepared is configured
5676 ** to re-prepare each time a new value is bound to variable pVar.
5677 **
5678 ** Additionally, if pExpr is a simple SQL value and the value is the
5679 ** same as that currently bound to variable pVar, non-zero is returned.
5680 ** Otherwise, if the values are not the same or if pExpr is not a simple
5681 ** SQL value, zero is returned.
5682 */
5687 ){
5700 }
5702 }
5705 }
5708 }
5710 /*
5711 ** Do a deep comparison of two expression trees. Return 0 if the two
5712 ** expressions are completely identical. Return 1 if they differ only
5713 ** by a COLLATE operator at the top level. Return 2 if there are differences
5714 ** other than the top-level COLLATE operator.
5715 **
5716 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5717 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5718 **
5719 ** The pA side might be using TK_REGISTER. If that is the case and pB is
5720 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
5721 **
5722 ** Sometimes this routine will return 2 even if the two expressions
5723 ** really are equivalent. If we cannot prove that the expressions are
5724 ** identical, we return 2 just to be safe. So if this routine
5725 ** returns 2, then you do not really know for certain if the two
5726 ** expressions are the same. But if you get a 0 or 1 return, then you
5727 ** can be sure the expressions are the same. In the places where
5728 ** this routine is used, it does not hurt to get an extra 2 - that
5729 ** just might result in some slightly slower code. But returning
5730 ** an incorrect 0 or 1 could lead to a malfunction.
5731 **
5732 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
5733 ** pParse->pReprepare can be matched against literals in pB. The
5734 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
5735 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
5736 ** Argument pParse should normally be NULL. If it is not NULL and pA or
5737 ** pB causes a return value of 2.
5738 */
5743 int iTab
5744 ){
5745 u32 combinedFlags;
5748 }
5751 }
5756 }
5758 }
5762 }
5765 }
5768 ){
5769 /* fall through */
5772 }
5773 }
5779 #ifndef SQLITE_OMIT_WINDOWFUNC
5783 }
5787 }
5788 }
5789 #endif
5799 ){
5801 }
5802 }
5814 ){
5819 }
5820 }
5821 }
5823 }
5825 /*
5826 ** Compare two ExprList objects. Return 0 if they are identical, 1
5827 ** if they are certainly different, or 2 if it is not possible to
5828 ** determine if they are identical or not.
5829 **
5830 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5831 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5832 **
5833 ** This routine might return non-zero for equivalent ExprLists. The
5834 ** only consequence will be disabled optimizations. But this routine
5835 ** must never return 0 if the two ExprList objects are different, or
5836 ** a malfunction will result.
5837 **
5838 ** Two NULL pointers are considered to be the same. But a NULL pointer
5839 ** always differs from a non-NULL pointer.
5840 */
5852 }
5854 }
5856 /*
5857 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
5858 ** are ignored.
5859 */
5864 iTab);
5865 }
5867 /*
5868 ** Return non-zero if Expr p can only be true if pNN is not NULL.
5869 **
5870 ** Or if seenNot is true, return non-zero if Expr p can only be
5871 ** non-NULL if pNN is not NULL
5872 */
5879 ){
5884 }
5890 }
5900 ){
5902 }
5904 }
5918 /* no break */ deliberate_fall_through
5924 /* no break */ deliberate_fall_through
5925 }
5931 }
5936 }
5940 }
5941 }
5943 }
5945 /*
5946 ** Return true if we can prove the pE2 will always be true if pE1 is
5947 ** true. Return false if we cannot complete the proof or if pE2 might
5948 ** be false. Examples:
5949 **
5950 ** pE1: x==5 pE2: x==5 Result: true
5951 ** pE1: x>0 pE2: x==5 Result: false
5952 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
5953 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
5954 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
5955 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
5956 ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false
5957 **
5958 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
5959 ** Expr.iTable<0 then assume a table number given by iTab.
5960 **
5961 ** If pParse is not NULL, then the values of bound variables in pE1 are
5962 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
5963 ** modified to record which bound variables are referenced. If pParse
5964 ** is NULL, then false will be returned if pE1 contains any bound variables.
5965 **
5966 ** When in doubt, return false. Returning true might give a performance
5967 ** improvement. Returning false might cause a performance reduction, but
5968 ** it will always give the correct answer and is hence always safe.
5969 */
5974 int iTab
5975 ){
5978 }
5982 ){
5984 }
5987 ){
5989 }
5991 }
5993 /*
5994 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
5995 ** If the expression node requires that the table at pWalker->iCur
5996 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
5997 **
5998 ** This routine controls an optimization. False positives (setting
5999 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
6000 ** (never setting pWalker->eCode) is a harmless missed optimization.
6001 */
6032 }
6041 }
6042 }
6049 }
6052 /* Virtual tables are allowed to use constraints like x=NULL. So
6053 ** a term of the form x=y does not prove that y is not null if x
6054 ** is the column of a virtual table */
6069 /* The y.pTab=0 assignment in wherecode.c always happens after the
6070 ** impliesNotNullRow() test */
6079 ){
6081 }
6082 /* no break */ deliberate_fall_through
6083 }
6086 }
6087 }
6089 /*
6090 ** Return true (non-zero) if expression p can only be true if at least
6091 ** one column of table iTab is non-null. In other words, return true
6092 ** if expression p will always be NULL or false if every column of iTab
6093 ** is NULL.
6094 **
6095 ** False negatives are acceptable. In other words, it is ok to return
6096 ** zero even if expression p will never be true of every column of iTab
6097 ** is NULL. A false negative is merely a missed optimization opportunity.
6098 **
6099 ** False positives are not allowed, however. A false positive may result
6100 ** in an incorrect answer.
6101 **
6102 ** Terms of p that are marked with EP_OuterON (and hence that come from
6103 ** the ON or USING clauses of OUTER JOINS) are excluded from the analysis.
6104 **
6105 ** This routine is used to check if a LEFT JOIN can be converted into
6106 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
6107 ** clause requires that some column of the right table of the LEFT JOIN
6108 ** be non-NULL, then the LEFT JOIN can be safely converted into an
6109 ** ordinary join.
6110 */
6112 Walker w;
6121 }
6122 }
6130 }
6132 /*
6133 ** An instance of the following structure is used by the tree walker
6134 ** to determine if an expression can be evaluated by reference to the
6135 ** index only, without having to do a search for the corresponding
6136 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
6137 ** is the cursor for the table.
6138 */
6142 };
6144 /*
6145 ** Check to see if there are references to columns in table
6146 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
6147 ** pWalker->u.pIdxCover->pIdx.
6148 */
6153 ){
6156 }
6158 }
6160 /*
6161 ** Determine if an index pIdx on table with cursor iCur contains will
6162 ** the expression pExpr. Return true if the index does cover the
6163 ** expression and false if the pExpr expression references table columns
6164 ** that are not found in the index pIdx.
6165 **
6166 ** An index covering an expression means that the expression can be
6167 ** evaluated using only the index and without having to lookup the
6168 ** corresponding table entry.
6169 */
6174 ){
6175 Walker w;
6184 }
6187 /* Structure used to pass information throught the Walker in order to
6188 ** implement sqlite3ReferencesSrcList().
6189 */
6195 };
6197 /*
6198 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
6199 **
6200 ** When entering a new subquery on the pExpr argument, add all FROM clause
6201 ** entries for that subquery to the exclude list.
6202 **
6203 ** When leaving the subquery, remove those entries from the exclude list.
6204 */
6219 }
6222 }
6224 }
6231 }
6232 }
6234 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
6235 **
6236 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
6237 ** of the tables shown in RefSrcList.pRef.
6238 **
6239 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
6240 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
6241 */
6245 ){
6254 }
6255 }
6259 }
6260 }
6262 }
6264 /*
6265 ** Check to see if pExpr references any tables in pSrcList.
6266 ** Possible return values:
6267 **
6268 ** 1 pExpr does references a table in pSrcList.
6269 **
6270 ** 0 pExpr references some table that is not defined in either
6271 ** pSrcList or in subqueries of pExpr itself.
6272 **
6273 ** -1 pExpr only references no tables at all, or it only
6274 ** references tables defined in subqueries of pExpr itself.
6275 **
6276 ** As currently used, pExpr is always an aggregate function call. That
6277 ** fact is exploited for efficiency.
6278 */
6280 Walker w;
6294 #ifndef SQLITE_OMIT_WINDOWFUNC
6297 }
6298 #endif
6306 }
6307 }
6309 /*
6310 ** This is a Walker expression node callback.
6311 **
6312 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6313 ** object that is referenced does not refer directly to the Expr. If
6314 ** it does, make a copy. This is done because the pExpr argument is
6315 ** subject to change.
6316 **
6317 ** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete()
6318 ** which builds on the sqlite3ParserAddCleanup() mechanism.
6319 */
6323 ){
6332 ){
6337 }
6338 }
6343 ){
6348 }
6349 }
6350 }
6351 }
6353 }
6355 /*
6356 ** Initialize a Walker object so that will persist AggInfo entries referenced
6357 ** by the tree that is walked.
6358 */
6364 }
6366 /*
6367 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6368 ** the new element. Return a negative number if malloc fails.
6369 */
6373 db,
6377 &i
6378 );
6380 }
6382 /*
6383 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6384 ** the new element. Return a negative number if malloc fails.
6385 */
6389 db,
6393 &i
6394 );
6396 }
6398 /*
6399 ** Search the AggInfo object for an aCol[] entry that has iTable and iColumn.
6400 ** Return the index in aCol[] of the entry that describes that column.
6401 **
6402 ** If no prior entry is found, create a new one and return -1. The
6403 ** new column will have an idex of pAggInfo->nColumn-1.
6404 */
6409 ){
6419 ){
6421 }
6422 }
6425 /* OOM on resize */
6428 }
6446 ){
6449 }
6450 }
6451 }
6454 }
6455 fix_up_expr:
6461 }
6463 }
6465 /*
6466 ** This is the xExprCallback for a tree walker. It is used to
6467 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
6468 ** for additional information.
6469 */
6482 Expr tmp;
6490 }
6495 }
6500 /* If we reach this point, it means that expression pExpr can be
6501 ** translated into a reference to an index column as described by
6502 ** pIEpr.
6503 */
6516 }
6523 /* Check to see if the column is in one of the tables in the FROM
6524 ** clause of the aggregate query */
6534 }
6536 }
6540 ){
6541 /* Check to see if pExpr is a duplicate of another aggregate
6542 ** function that is already in the pAggInfo structure
6543 */
6549 }
6550 }
6552 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
6553 */
6568 }
6569 }
6570 }
6571 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
6572 */
6580 }
6581 }
6582 }
6584 }
6586 /*
6587 ** Analyze the pExpr expression looking for aggregate functions and
6588 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
6589 ** points to. Additional entries are made on the AggInfo object as
6590 ** necessary.
6591 **
6592 ** This routine should only be called after the expression has been
6593 ** analyzed by sqlite3ResolveExprNames().
6594 */
6596 Walker w;
6605 }
6607 /*
6608 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
6609 ** expression list. Return the number of errors.
6610 **
6611 ** If an error is found, the analysis is cut short.
6612 */
6619 }
6620 }
6621 }
6623 /*
6624 ** Allocate a single new register for use to hold some intermediate result.
6625 */
6629 }
6631 }
6633 /*
6634 ** Deallocate a register, making available for reuse for some other
6635 ** purpose.
6636 */
6642 }
6643 }
6644 }
6646 /*
6647 ** Allocate or deallocate a block of nReg consecutive registers.
6648 */
6660 }
6662 }
6667 }
6672 }
6673 }
6675 /*
6676 ** Mark all temporary registers as being unavailable for reuse.
6677 **
6678 ** Always invoke this procedure after coding a subroutine or co-routine
6679 ** that might be invoked from other parts of the code, to ensure that
6680 ** the sub/co-routine does not use registers in common with the code that
6681 ** invokes the sub/co-routine.
6682 */
6686 }
6688 /*
6689 ** Make sure sufficient registers have been allocated so that
6690 ** iReg is a valid register number.
6691 */
6694 }
6696 #if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG)
6697 /*
6698 ** Return the latest reusable register in the set of all registers.
6699 ** The value returned is no less than iMin. If any register iMin or
6700 ** greater is in permanent use, then return one more than that last
6701 ** permanent register.
6702 */
6710 }
6711 }
6712 }
6716 }
6719 /*
6720 ** Validate that no temporary register falls within the range of
6721 ** iFirst..iLast, inclusive. This routine is only call from within assert()
6722 ** statements.
6723 */
6724 #ifdef SQLITE_DEBUG
6730 ){
6732 }
6736 }
6737 }
6744 }
6745 }
6747 }