| blob | a51d37a7b700c907f2b8ae2eeb22a6ecdff55c67 |
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 }
68 }
69 #ifndef SQLITE_OMIT_CAST
73 }
74 #endif
81 );
82 }
86 }
88 }
90 /*
91 ** Set the collating sequence for expression pExpr to be the collating
92 ** sequence named by pToken. Return a pointer to a new Expr node that
93 ** implements the COLLATE operator.
94 **
95 ** If a memory allocation error occurs, that fact is recorded in pParse->db
96 ** and the pExpr parameter is returned unchanged.
97 */
103 ){
110 }
111 }
113 }
118 ){
119 Token s;
123 }
125 /*
126 ** Skip over any TK_COLLATE operators.
127 */
132 }
134 }
136 /*
137 ** Skip over any TK_COLLATE operators and/or any unlikely()
138 ** or likelihood() or likely() functions at the root of an
139 ** expression.
140 */
151 }
152 }
154 }
156 /*
157 ** Return the collation sequence for the expression pExpr. If
158 ** there is no defined collating sequence, return NULL.
159 **
160 ** See also: sqlite3ExprNNCollSeq()
161 **
162 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
163 ** default collation if pExpr has no defined collation.
164 **
165 ** The collating sequence might be determined by a COLLATE operator
166 ** or by the presence of a column with a defined collating sequence.
167 ** COLLATE operators take first precedence. Left operands take
168 ** precedence over right operands.
169 */
180 /* op==TK_REGISTER && p->y.pTab!=0 happens when pExpr was originally
181 ** a TK_COLUMN but was previously evaluated and cached in a register */
186 }
188 }
189 }
193 }
198 }
203 }
209 /* The Expr.x union is never used at the same time as Expr.pRight */
218 }
219 }
220 }
222 }
225 }
226 }
229 }
231 }
233 /*
234 ** Return the collation sequence for the expression pExpr. If
235 ** there is no defined collating sequence, return a pointer to the
236 ** defautl collation sequence.
237 **
238 ** See also: sqlite3ExprCollSeq()
239 **
240 ** The sqlite3ExprCollSeq() routine works the same except that it
241 ** returns NULL if there is no defined collation.
242 */
248 }
250 /*
251 ** Return TRUE if the two expressions have equivalent collating sequences.
252 */
257 }
259 /*
260 ** pExpr is an operand of a comparison operator. aff2 is the
261 ** type affinity of the other operand. This routine returns the
262 ** type affinity that should be used for the comparison operator.
263 */
267 /* Both sides of the comparison are columns. If one has numeric
268 ** affinity, use that. Otherwise use no affinity.
269 */
274 }
276 /* One side is a column, the other is not. Use the columns affinity. */
279 }
280 }
282 /*
283 ** pExpr is a comparison operator. Return the type affinity that should
284 ** be applied to both operands prior to doing the comparison.
285 */
299 }
301 }
303 /*
304 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
305 ** idx_affinity is the affinity of an indexed column. Return true
306 ** if the index with affinity idx_affinity may be used to implement
307 ** the comparison in pExpr.
308 */
313 }
316 }
318 }
320 /*
321 ** Return the P5 value that should be used for a binary comparison
322 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
323 */
328 ){
332 }
334 /*
335 ** Return a pointer to the collation sequence that should be used by
336 ** a binary comparison operator comparing pLeft and pRight.
337 **
338 ** If the left hand expression has a collating sequence type, then it is
339 ** used. Otherwise the collation sequence for the right hand expression
340 ** is used, or the default (BINARY) if neither expression has a collating
341 ** type.
342 **
343 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
344 ** it is not considered.
345 */
350 ){
361 }
362 }
364 }
366 /* Expresssion p is a comparison operator. Return a collation sequence
367 ** appropriate for the comparison operator.
368 **
369 ** This is normally just a wrapper around sqlite3BinaryCompareCollSeq().
370 ** However, if the OP_Commuted flag is set, then the order of the operands
371 ** is reversed in the sqlite3BinaryCompareCollSeq() call so that the
372 ** correct collating sequence is found.
373 */
379 }
380 }
382 /*
383 ** Generate code for a comparison operator.
384 */
394 ){
404 }
410 }
412 /*
413 ** Return true if expression pExpr is a vector, or false otherwise.
414 **
415 ** A vector is defined as any expression that results in two or more
416 ** columns of result. Every TK_VECTOR node is an vector because the
417 ** parser will not generate a TK_VECTOR with fewer than two entries.
418 ** But a TK_SELECT might be either a vector or a scalar. It is only
419 ** considered a vector if it has two or more result columns.
420 */
423 }
425 /*
426 ** If the expression passed as the only argument is of type TK_VECTOR
427 ** return the number of expressions in the vector. Or, if the expression
428 ** is a sub-select, return the number of columns in the sub-select. For
429 ** any other type of expression, return 1.
430 */
442 }
443 }
445 /*
446 ** Return a pointer to a subexpression of pVector that is the i-th
447 ** column of the vector (numbered starting with 0). The caller must
448 ** ensure that i is within range.
449 **
450 ** If pVector is really a scalar (and "scalar" here includes subqueries
451 ** that return a single column!) then return pVector unmodified.
452 **
453 ** pVector retains ownership of the returned subexpression.
454 **
455 ** If the vector is a (SELECT ...) then the expression returned is
456 ** just the expression for the i-th term of the result set, and may
457 ** not be ready for evaluation because the table cursor has not yet
458 ** been positioned.
459 */
470 }
471 }
473 }
475 /*
476 ** Compute and return a new Expr object which when passed to
477 ** sqlite3ExprCode() will generate all necessary code to compute
478 ** the iField-th column of the vector expression pVector.
479 **
480 ** It is ok for pVector to be a scalar (as long as iField==0).
481 ** In that case, this routine works like sqlite3ExprDup().
482 **
483 ** The caller owns the returned Expr object and is responsible for
484 ** ensuring that the returned value eventually gets freed.
485 **
486 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
487 ** then the returned object will reference pVector and so pVector must remain
488 ** valid for the life of the returned object. If pVector is a TK_VECTOR
489 ** or a scalar expression, then it can be deleted as soon as this routine
490 ** returns.
491 **
492 ** A trick to cause a TK_SELECT pVector to be deleted together with
493 ** the returned Expr object is to attach the pVector to the pRight field
494 ** of the returned TK_SELECT_COLUMN Expr object.
495 */
501 ){
505 /* The TK_SELECT_COLUMN Expr node:
506 **
507 ** pLeft: pVector containing TK_SELECT. Not deleted.
508 ** pRight: not used. But recursively deleted.
509 ** iColumn: Index of a column in pVector
510 ** iTable: 0 or the number of columns on the LHS of an assignment
511 ** pLeft->iTable: First in an array of register holding result, or 0
512 ** if the result is not yet computed.
513 **
514 ** sqlite3ExprDelete() specifically skips the recursive delete of
515 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
516 ** can be attached to pRight to cause this node to take ownership of
517 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
518 ** with the same pLeft pointer to the pVector, but only one of them
519 ** will own the pVector.
520 */
526 }
534 /* This must be a vector UPDATE inside a trigger */
537 }
538 }
540 }
542 }
544 /*
545 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
546 ** it. Return the register in which the result is stored (or, if the
547 ** sub-select returns more than one column, the first in an array
548 ** of registers in which the result is stored).
549 **
550 ** If pExpr is not a TK_SELECT expression, return 0.
551 */
554 #ifndef SQLITE_OMIT_SUBQUERY
557 }
558 #endif
560 }
562 /*
563 ** Argument pVector points to a vector expression - either a TK_VECTOR
564 ** or TK_SELECT that returns more than one column. This function returns
565 ** the register number of a register that contains the value of
566 ** element iField of the vector.
567 **
568 ** If pVector is a TK_SELECT expression, then code for it must have
569 ** already been generated using the exprCodeSubselect() routine. In this
570 ** case parameter regSelect should be the first in an array of registers
571 ** containing the results of the sub-select.
572 **
573 ** If pVector is of type TK_VECTOR, then code for the requested field
574 ** is generated. In this case (*pRegFree) may be set to the number of
575 ** a temporary register to be freed by the caller before returning.
576 **
577 ** Before returning, output parameter (*ppExpr) is set to point to the
578 ** Expr object corresponding to element iElem of the vector.
579 */
587 ){
593 }
598 }
603 }
605 }
607 /*
608 ** Expression pExpr is a comparison between two vector values. Compute
609 ** the result of the comparison (1, 0, or NULL) and write that
610 ** result into register dest.
611 **
612 ** The caller must satisfy the following preconditions:
613 **
614 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
615 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
616 ** otherwise: op==pExpr->op and p5==0
617 */
623 u8 p5 /* SQLITE_NULLEQ or zero */
624 ){
642 }
647 );
683 }
688 }
691 }
698 }
699 }
704 }
705 }
707 #if SQLITE_MAX_EXPR_DEPTH>0
708 /*
709 ** Check that argument nHeight is less than or equal to the maximum
710 ** expression depth allowed. If it is not, leave an error message in
711 ** pParse.
712 */
719 );
721 }
723 }
725 /* The following three functions, heightOfExpr(), heightOfExprList()
726 ** and heightOfSelect(), are used to determine the maximum height
727 ** of any expression tree referenced by the structure passed as the
728 ** first argument.
729 **
730 ** If this maximum height is greater than the current value pointed
731 ** to by pnHeight, the second parameter, then set *pnHeight to that
732 ** value.
733 */
738 }
739 }
740 }
746 }
747 }
748 }
758 }
759 }
761 /*
762 ** Set the Expr.nHeight variable in the structure passed as an
763 ** argument. An expression with no children, Expr.pList or
764 ** Expr.pSelect member has a height of 1. Any other expression
765 ** has a height equal to the maximum height of any other
766 ** referenced Expr plus one.
767 **
768 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
769 ** if appropriate.
770 */
780 }
782 }
784 /*
785 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
786 ** the height is greater than the maximum allowed expression depth,
787 ** leave an error in pParse.
788 **
789 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
790 ** Expr.flags.
791 */
796 }
798 /*
799 ** Return the maximum height of any expression tree referenced
800 ** by the select statement passed as an argument.
801 */
806 }
808 /*
809 ** Propagate all EP_Propagate flags from the Expr.x.pList into
810 ** Expr.flags.
811 */
816 }
817 }
818 #define exprSetHeight(y)
821 /*
822 ** This routine is the core allocator for Expr nodes.
823 **
824 ** Construct a new expression node and return a pointer to it. Memory
825 ** for this node and for the pToken argument is a single allocation
826 ** obtained from sqlite3DbMalloc(). The calling function
827 ** is responsible for making sure the node eventually gets freed.
828 **
829 ** If dequote is true, then the token (if it exists) is dequoted.
830 ** If dequote is false, no dequoting is performed. The deQuote
831 ** parameter is ignored if pToken is NULL or if the token does not
832 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
833 ** then the EP_DblQuoted flag is set on the expression node.
834 **
835 ** Special case: If op==TK_INTEGER and pToken points to a string that
836 ** can be translated into a 32-bit integer, then the token is not
837 ** stored in u.zToken. Instead, the integer values is written
838 ** into u.iValue and the EP_IntValue flag is set. No extra storage
839 ** is allocated to hold the integer text and the dequote flag is ignored.
840 */
846 ){
857 }
858 }
875 }
876 }
877 }
878 #if SQLITE_MAX_EXPR_DEPTH>0
880 #endif
881 }
883 }
885 /*
886 ** Allocate a new expression node from a zero-terminated token that has
887 ** already been dequoted.
888 */
893 ){
894 Token x;
898 }
900 /*
901 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
902 **
903 ** If pRoot==NULL that means that a memory allocation error has occurred.
904 ** In that case, delete the subtrees pLeft and pRight.
905 */
910 Expr *pRight
911 ){
920 }
924 }
926 }
927 }
929 /*
930 ** Allocate an Expr node which joins as many as two subtrees.
931 **
932 ** One or both of the subtrees can be NULL. Return a pointer to the new
933 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
934 ** free the subtrees and return NULL.
935 */
941 ){
953 }
955 }
957 /*
958 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
959 ** do a memory allocation failure) then delete the pSelect object.
960 */
969 }
970 }
972 /*
973 ** Expression list pEList is a list of vector values. This function
974 ** converts the contents of pEList to a VALUES(...) Select statement
975 ** returning 1 row for each element of the list. For example, the
976 ** expression list:
977 **
978 ** ( (1,2), (3,4) (5,6) )
979 **
980 ** is translated to the equivalent of:
981 **
982 ** VALUES(1,2), (3,4), (5,6)
983 **
984 ** Each of the vector values in pEList must contain exactly nElem terms.
985 ** If a list element that is not a vector or does not contain nElem terms,
986 ** an error message is left in pParse.
987 **
988 ** This is used as part of processing IN(...) expressions with a list
989 ** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
990 */
1004 }
1008 );
1010 }
1018 }
1020 }
1021 }
1025 }
1028 }
1030 /*
1031 ** Join two expressions using an AND operator. If either expression is
1032 ** NULL, then just return the other expression.
1033 **
1034 ** If one side or the other of the AND is known to be false, then instead
1035 ** of returning an AND expression, just return a constant expression with
1036 ** a value of false.
1037 */
1045 && !IN_RENAME_OBJECT
1046 ){
1052 }
1053 }
1055 /*
1056 ** Construct a new expression node for a function with multiple
1057 ** arguments.
1058 */
1064 ){
1072 }
1076 ){
1078 }
1085 }
1087 /*
1088 ** Check to see if a function is usable according to current access
1089 ** rules:
1090 **
1091 ** SQLITE_FUNC_DIRECT - Only usable from top-level SQL
1092 **
1093 ** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from
1094 ** top-level SQL
1095 **
1096 ** If the function is not usable, create an error.
1097 */
1102 ){
1108 ){
1109 /* Functions prohibited in triggers and views if:
1110 ** (1) tagged with SQLITE_DIRECTONLY
1111 ** (2) not tagged with SQLITE_INNOCUOUS (which means it
1112 ** is tagged with SQLITE_FUNC_UNSAFE) and
1113 ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
1114 ** that the schema is possibly tainted).
1115 */
1117 }
1118 }
1119 }
1121 /*
1122 ** Assign a variable number to an expression that encodes a wildcard
1123 ** in the original SQL statement.
1124 **
1125 ** Wildcards consisting of a single "?" are assigned the next sequential
1126 ** variable number.
1127 **
1128 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
1129 ** sure "nnn" is not too big to avoid a denial of service attack when
1130 ** the SQL statement comes from an external source.
1131 **
1132 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
1133 ** as the previous instance of the same wildcard. Or if this is the first
1134 ** instance of the wildcard, the next sequential variable number is
1135 ** assigned.
1136 */
1140 ynVar x;
1149 /* Wildcard of the form "?". Assign the next variable number */
1155 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
1156 ** use it as the variable number */
1157 i64 i;
1164 }
1173 }
1180 }
1182 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1183 ** number as the prior appearance of the same name, or if the name
1184 ** has never appeared before, reuse the same variable number
1185 */
1190 }
1191 }
1194 }
1195 }
1199 }
1200 }
1202 /*
1203 ** Recursively delete an expression tree.
1204 */
1211 #ifdef SQLITE_DEBUG
1217 }
1218 #endif
1220 /* The Expr.x union is never used at the same time as Expr.pRight */
1231 #ifndef SQLITE_OMIT_WINDOWFUNC
1234 }
1235 #endif
1236 }
1237 }
1241 }
1244 }
1245 }
1248 }
1251 /*
1252 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
1253 ** This is similar to sqlite3ExprDelete() except that the delete is
1254 ** deferred untilthe pParse is deleted.
1255 **
1256 ** The pExpr might be deleted immediately on an OOM error.
1257 **
1258 ** The deferred delete is (currently) implemented by adding the
1259 ** pExpr to the pParse->pConstExpr list with a register number of 0.
1260 */
1264 }
1266 /* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
1267 ** expression.
1268 */
1273 }
1275 }
1276 }
1278 /*
1279 ** Return the number of bytes allocated for the expression structure
1280 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1281 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1282 */
1287 }
1289 /*
1290 ** The dupedExpr*Size() routines each return the number of bytes required
1291 ** to store a copy of an expression or expression tree. They differ in
1292 ** how much of the tree is measured.
1293 **
1294 ** dupedExprStructSize() Size of only the Expr structure
1295 ** dupedExprNodeSize() Size of Expr + space for token
1296 ** dupedExprSize() Expr + token + subtree components
1297 **
1298 ***************************************************************************
1299 **
1300 ** The dupedExprStructSize() function returns two values OR-ed together:
1301 ** (1) the space required for a copy of the Expr structure only and
1302 ** (2) the EP_xxx flags that indicate what the structure size should be.
1303 ** The return values is always one of:
1304 **
1305 ** EXPR_FULLSIZE
1306 ** EXPR_REDUCEDSIZE | EP_Reduced
1307 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1308 **
1309 ** The size of the structure can be found by masking the return value
1310 ** of this routine with 0xfff. The flags can be found by masking the
1311 ** return value with EP_Reduced|EP_TokenOnly.
1312 **
1313 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1314 ** (unreduced) Expr objects as they or originally constructed by the parser.
1315 ** During expression analysis, extra information is computed and moved into
1316 ** later parts of the Expr object and that extra information might get chopped
1317 ** off if the expression is reduced. Note also that it does not work to
1318 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1319 ** to reduce a pristine expression tree from the parser. The implementation
1320 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1321 ** to enforce this constraint.
1322 */
1329 #ifndef SQLITE_OMIT_WINDOWFUNC
1331 #endif
1332 ){
1344 }
1345 }
1347 }
1349 /*
1350 ** This function returns the space in bytes required to store the copy
1351 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1352 ** string is defined.)
1353 */
1358 }
1360 }
1362 /*
1363 ** Return the number of bytes required to create a duplicate of the
1364 ** expression passed as the first argument. The second argument is a
1365 ** mask containing EXPRDUP_XXX flags.
1366 **
1367 ** The value returned includes space to create a copy of the Expr struct
1368 ** itself and the buffer referred to by Expr.u.zToken, if any.
1369 **
1370 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1371 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1372 ** and Expr.pRight variables (but not for any structures pointed to or
1373 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1374 */
1381 }
1382 }
1384 }
1386 /*
1387 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1388 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1389 ** to store the copy of expression p, the copies of p->u.zToken
1390 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1391 ** if any. Before returning, *pzBuffer is set to the first byte past the
1392 ** portion of the buffer copied into by this function.
1393 */
1404 /* Figure out where to write the new Expr structure. */
1412 }
1416 /* Set nNewSize to the size allocated for the structure pointed to
1417 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1418 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1419 ** by the copy of the p->u.zToken string (if any).
1420 */
1428 }
1437 }
1438 }
1440 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1447 }
1449 /* Copy the p->u.zToken string, if any. */
1453 }
1456 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1461 }
1462 }
1464 /* Fill in pNew->pLeft and pNew->pRight. */
1472 }
1473 #ifndef SQLITE_OMIT_WINDOWFUNC
1477 }
1481 }
1490 }
1492 }
1493 }
1494 }
1496 }
1498 /*
1499 ** Create and return a deep copy of the object passed as the second
1500 ** argument. If an OOM condition is encountered, NULL is returned
1501 ** and the db->mallocFailed flag set.
1502 */
1503 #ifndef SQLITE_OMIT_CTE
1516 }
1517 }
1518 }
1520 }
1521 #else
1522 # define sqlite3WithDup(x,y) 0
1523 #endif
1525 #ifndef SQLITE_OMIT_WINDOWFUNC
1526 /*
1527 ** The gatherSelectWindows() procedure and its helper routine
1528 ** gatherSelectWindowsCallback() are used to scan all the expressions
1529 ** an a newly duplicated SELECT statement and gather all of the Window
1530 ** objects found there, assembling them onto the linked list at Select->pWin.
1531 */
1540 }
1542 }
1545 }
1547 Walker w;
1554 }
1555 #endif
1558 /*
1559 ** The following group of routines make deep copies of expressions,
1560 ** expression lists, ID lists, and select statements. The copies can
1561 ** be deleted (by being passed to their respective ...Delete() routines)
1562 ** without effecting the originals.
1563 **
1564 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1565 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1566 ** by subsequent calls to sqlite*ListAppend() routines.
1567 **
1568 ** Any tables that the SrcList might point to are not duplicated.
1569 **
1570 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1571 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1572 ** truncated version of the usual Expr structure that will be stored as
1573 ** part of the in-memory representation of the database schema.
1574 */
1578 }
1601 ){
1611 }
1613 }
1614 }
1622 }
1624 }
1626 /*
1627 ** If cursors, triggers, views and subqueries are all omitted from
1628 ** the build, then none of the following routines, except for
1629 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1630 ** called with a NULL argument.
1631 */
1632 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1633 || !defined(SQLITE_OMIT_SUBQUERY)
1658 }
1662 }
1666 }
1670 }
1675 }
1677 }
1690 }
1691 /* Note that because the size of the allocation for p->a[] is not
1692 ** necessarily a power of two, sqlite3IdListAppend() may not be called
1693 ** on the duplicate created by this function. */
1699 }
1701 }
1729 #ifndef SQLITE_OMIT_WINDOWFUNC
1733 #endif
1736 /* Any prior OOM might have left the Select object incomplete.
1737 ** Delete the whole thing rather than allow an incomplete Select
1738 ** to be used by the code generator. */
1742 }
1746 }
1749 }
1750 #else
1754 }
1755 #endif
1758 /*
1759 ** Add a new element to the end of an expression list. If pList is
1760 ** initially NULL, then create a new expression list.
1761 **
1762 ** The pList argument must be either NULL or a pointer to an ExprList
1763 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1764 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1765 ** Reason: This routine assumes that the number of slots in pList->a[]
1766 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1767 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1768 **
1769 ** If a memory allocation error occurs, the entire list is freed and
1770 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1771 ** that the new entry was successfully appended.
1772 */
1777 ){
1785 }
1792 }
1797 ){
1809 }
1814 }
1819 ){
1823 }
1826 }
1831 }
1833 /*
1834 ** pColumns and pExpr form a vector assignment which is part of the SET
1835 ** clause of an UPDATE statement. Like this:
1836 **
1837 ** (a,b,c) = (expr1,expr2,expr3)
1838 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1839 **
1840 ** For each term of the vector assignment, append new entries to the
1841 ** expression list pList. In the case of a subquery on the RHS, append
1842 ** TK_SELECT_COLUMN expressions.
1843 */
1849 ){
1854 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1855 ** exit prior to this routine being invoked */
1859 /* If the RHS is a vector, then we can immediately check to see that
1860 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1861 ** wildcards ("*") in the result set of the SELECT must be expanded before
1862 ** we can do the size check, so defer the size check until code generation.
1863 */
1868 }
1879 }
1880 }
1887 /* Store the SELECT statement in pRight so it will be deleted when
1888 ** sqlite3ExprListDelete() is called */
1892 /* Remember the size of the LHS in iTable so that we can check that
1893 ** the RHS and LHS sizes match during code generation. */
1895 }
1897 vector_append_error:
1901 }
1903 /*
1904 ** Set the sort order for the last element on the given ExprList.
1905 */
1915 );
1919 );
1925 }
1932 }
1933 }
1934 }
1936 /*
1937 ** Set the ExprList.a[].zEName element of the most recently added item
1938 ** on the expression list.
1939 **
1940 ** pList might be NULL following an OOM error. But pName should never be
1941 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1942 ** is set.
1943 */
1949 ){
1960 /* If dequote==0, then pName->z does not point to part of a DDL
1961 ** statement handled by the parser. And so no token need be added
1962 ** to the token-map. */
1966 }
1967 }
1968 }
1969 }
1971 /*
1972 ** Set the ExprList.a[].zSpan element of the most recently added item
1973 ** on the expression list.
1974 **
1975 ** pList might be NULL following an OOM error. But pSpan should never be
1976 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1977 ** is set.
1978 */
1984 ){
1993 }
1994 }
1995 }
1997 /*
1998 ** If the expression list pEList contains more than iLimit elements,
1999 ** leave an error message in pParse.
2000 */
2005 ){
2011 }
2012 }
2014 /*
2015 ** Delete an entire expression list.
2016 */
2024 pItem++;
2027 }
2030 }
2032 /*
2033 ** Return the bitwise-OR of all Expr.flags fields in the given
2034 ** ExprList.
2035 */
2044 }
2046 }
2048 /*
2049 ** This is a SELECT-node callback for the expression walker that
2050 ** always "fails". By "fail" in this case, we mean set
2051 ** pWalker->eCode to zero and abort.
2052 **
2053 ** This callback is used by multiple expression walkers.
2054 */
2059 }
2061 /*
2062 ** Check the input string to see if it is "true" or "false" (in any case).
2063 **
2064 ** If the string is.... Return
2065 ** "true" EP_IsTrue
2066 ** "false" EP_IsFalse
2067 ** anything else 0
2068 */
2073 }
2076 /*
2077 ** If the input expression is an ID with the name "true" or "false"
2078 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
2079 ** the conversion happened, and zero if the expression is unaltered.
2080 */
2082 u32 v;
2086 ){
2090 }
2092 }
2094 /*
2095 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
2096 ** and 0 if it is FALSE.
2097 */
2105 }
2107 /*
2108 ** If pExpr is an AND or OR expression, try to simplify it by eliminating
2109 ** terms that are always true or false. Return the simplified expression.
2110 ** Or return the original expression if no simplification is possible.
2111 **
2112 ** Examples:
2113 **
2114 ** (x<10) AND true => (x<10)
2115 ** (x<10) AND false => false
2116 ** (x<10) AND (y=22 OR false) => (x<10) AND (y=22)
2117 ** (x<10) AND (y=22 OR true) => (x<10)
2118 ** (y=22) OR true => true
2119 */
2129 }
2130 }
2132 }
2135 /*
2136 ** These routines are Walker callbacks used to check expressions to
2137 ** see if they are "constant" for some definition of constant. The
2138 ** Walker.eCode value determines the type of "constant" we are looking
2139 ** for.
2140 **
2141 ** These callback routines are used to implement the following:
2142 **
2143 ** sqlite3ExprIsConstant() pWalker->eCode==1
2144 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
2145 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
2146 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
2147 **
2148 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
2149 ** is found to not be a constant.
2150 **
2151 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
2152 ** expressions in a CREATE TABLE statement. The Walker.eCode value is 5
2153 ** when parsing an existing schema out of the sqlite_schema table and 4
2154 ** when processing a new CREATE TABLE statement. A bound parameter raises
2155 ** an error for new statements, but is silently converted
2156 ** to NULL for existing schemas. This allows sqlite_schema tables that
2157 ** contain a bound parameter because they were generated by older versions
2158 ** of SQLite to be parsed by newer versions of SQLite without raising a
2159 ** malformed schema error.
2160 */
2163 /* If pWalker->eCode is 2 then any term of the expression that comes from
2164 ** the ON or USING clauses of a left join disqualifies the expression
2165 ** from being considered constant. */
2169 }
2172 /* Consider functions to be constant if all their arguments are constant
2173 ** and either pWalker->eCode==4 or 5 or the function has the
2174 ** SQLITE_FUNC_CONST flag. */
2178 ){
2184 }
2186 /* Convert "true" or "false" in a DEFAULT clause into the
2187 ** appropriate TK_TRUEFALSE operator */
2190 }
2191 /* no break */ deliberate_fall_through
2201 }
2204 }
2205 /* no break */ deliberate_fall_through
2216 /* Silently convert bound parameters that appear inside of CREATE
2217 ** statements into a NULL when parsing the CREATE statement text out
2218 ** of the sqlite_schema table */
2221 /* A bound parameter in a CREATE statement that originates from
2222 ** sqlite3_prepare() causes an error */
2225 }
2226 /* no break */ deliberate_fall_through
2231 }
2232 }
2234 Walker w;
2238 #ifdef SQLITE_DEBUG
2240 #endif
2244 }
2246 /*
2247 ** Walk an expression tree. Return non-zero if the expression is constant
2248 ** and 0 if it involves variables or function calls.
2249 **
2250 ** For the purposes of this function, a double-quoted string (ex: "abc")
2251 ** is considered a variable but a single-quoted string (ex: 'abc') is
2252 ** a constant.
2253 */
2256 }
2258 /*
2259 ** Walk an expression tree. Return non-zero if
2260 **
2261 ** (1) the expression is constant, and
2262 ** (2) the expression does originate in the ON or USING clause
2263 ** of a LEFT JOIN, and
2264 ** (3) the expression does not contain any EP_FixedCol TK_COLUMN
2265 ** operands created by the constant propagation optimization.
2266 **
2267 ** When this routine returns true, it indicates that the expression
2268 ** can be added to the pParse->pConstExpr list and evaluated once when
2269 ** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce().
2270 */
2273 }
2275 /*
2276 ** Walk an expression tree. Return non-zero if the expression is constant
2277 ** for any single row of the table with cursor iCur. In other words, the
2278 ** expression must not refer to any non-deterministic function nor any
2279 ** table other than iCur.
2280 */
2283 }
2286 /*
2287 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
2288 */
2293 /* Check if pExpr is identical to any GROUP BY term. If so, consider
2294 ** it constant. */
2301 }
2302 }
2303 }
2305 /* Check if pExpr is a sub-select. If so, consider it variable. */
2309 }
2312 }
2314 /*
2315 ** Walk the expression tree passed as the first argument. Return non-zero
2316 ** if the expression consists entirely of constants or copies of terms
2317 ** in pGroupBy that sort with the BINARY collation sequence.
2318 **
2319 ** This routine is used to determine if a term of the HAVING clause can
2320 ** be promoted into the WHERE clause. In order for such a promotion to work,
2321 ** the value of the HAVING clause term must be the same for all members of
2322 ** a "group". The requirement that the GROUP BY term must be BINARY
2323 ** assumes that no other collating sequence will have a finer-grained
2324 ** grouping than binary. In other words (A=B COLLATE binary) implies
2325 ** A=B in every other collating sequence. The requirement that the
2326 ** GROUP BY be BINARY is stricter than necessary. It would also work
2327 ** to promote HAVING clauses that use the same alternative collating
2328 ** sequence as the GROUP BY term, but that is much harder to check,
2329 ** alternative collating sequences are uncommon, and this is only an
2330 ** optimization, so we take the easy way out and simply require the
2331 ** GROUP BY to use the BINARY collating sequence.
2332 */
2334 Walker w;
2342 }
2344 /*
2345 ** Walk an expression tree for the DEFAULT field of a column definition
2346 ** in a CREATE TABLE statement. Return non-zero if the expression is
2347 ** acceptable for use as a DEFAULT. That is to say, return non-zero if
2348 ** the expression is constant or a function call with constant arguments.
2349 ** Return and 0 if there are any variables.
2350 **
2351 ** isInit is true when parsing from sqlite_schema. isInit is false when
2352 ** processing a new CREATE TABLE statement. When isInit is true, parameters
2353 ** (such as ? or $abc) in the expression are converted into NULL. When
2354 ** isInit is false, parameters raise an error. Parameters should not be
2355 ** allowed in a CREATE TABLE statement, but some legacy versions of SQLite
2356 ** allowed it, so we need to support it when reading sqlite_schema for
2357 ** backwards compatibility.
2358 **
2359 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
2360 **
2361 ** For the purposes of this function, a double-quoted string (ex: "abc")
2362 ** is considered a variable but a single-quoted string (ex: 'abc') is
2363 ** a constant.
2364 */
2368 }
2370 #ifdef SQLITE_ENABLE_CURSOR_HINTS
2371 /*
2372 ** Walk an expression tree. Return 1 if the expression contains a
2373 ** subquery of some kind. Return 0 if there are no subqueries.
2374 */
2376 Walker w;
2380 #ifdef SQLITE_DEBUG
2382 #endif
2385 }
2386 #endif
2388 /*
2389 ** If the expression p codes a constant integer that is small enough
2390 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2391 ** in *pValue. If the expression is not an integer or if it is too big
2392 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2393 */
2398 /* If an expression is an integer literal that fits in a signed 32-bit
2399 ** integer, then the EP_IntValue flag will have already been set */
2406 }
2411 }
2418 }
2420 }
2422 }
2424 }
2426 /*
2427 ** Return FALSE if there is no chance that the expression can be NULL.
2428 **
2429 ** If the expression might be NULL or if the expression is too complex
2430 ** to tell return TRUE.
2431 **
2432 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2433 ** when we know that a value cannot be NULL. Hence, a false positive
2434 ** (returning TRUE when in fact the expression can never be NULL) might
2435 ** be a small performance hit but is otherwise harmless. On the other
2436 ** hand, a false negative (returning FALSE when the result could be NULL)
2437 ** will likely result in an incorrect answer. So when in doubt, return
2438 ** TRUE.
2439 */
2441 u8 op;
2446 }
2464 }
2465 }
2467 /*
2468 ** Return TRUE if the given expression is a constant which would be
2469 ** unchanged by OP_Affinity with the affinity given in the second
2470 ** argument.
2471 **
2472 ** This routine is used to determine if the OP_Affinity operation
2473 ** can be omitted. When in doubt return FALSE. A false negative
2474 ** is harmless. A false positive, however, can result in the wrong
2475 ** answer.
2476 */
2478 u8 op;
2484 }
2490 }
2493 }
2496 }
2499 }
2503 }
2506 }
2507 }
2508 }
2510 /*
2511 ** Return TRUE if the given string is a row-id column name.
2512 */
2518 }
2520 /*
2521 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2522 ** that can be simplified to a direct table access, then return
2523 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2524 ** or if the SELECT statement needs to be manifested into a transient
2525 ** table, then return NULL.
2526 */
2527 #ifndef SQLITE_OMIT_SUBQUERY
2542 }
2556 /* All SELECT results must be columns. */
2561 }
2563 }
2566 #ifndef SQLITE_OMIT_SUBQUERY
2567 /*
2568 ** Generate code that checks the left-most column of index table iCur to see if
2569 ** it contains any NULL entries. Cause the register at regHasNull to be set
2570 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2571 ** to be set to NULL if iCur contains one or more NULL values.
2572 */
2581 }
2582 #endif
2585 #ifndef SQLITE_OMIT_SUBQUERY
2586 /*
2587 ** The argument is an IN operator with a list (not a subquery) on the
2588 ** right-hand side. Return TRUE if that list is constant.
2589 */
2599 }
2600 #endif
2602 /*
2603 ** This function is used by the implementation of the IN (...) operator.
2604 ** The pX parameter is the expression on the RHS of the IN operator, which
2605 ** might be either a list of expressions or a subquery.
2606 **
2607 ** The job of this routine is to find or create a b-tree object that can
2608 ** be used either to test for membership in the RHS set or to iterate through
2609 ** all members of the RHS set, skipping duplicates.
2610 **
2611 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2612 ** and pX->iTable is set to the index of that cursor.
2613 **
2614 ** The returned value of this function indicates the b-tree type, as follows:
2615 **
2616 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2617 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2618 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2619 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2620 ** populated epheremal table.
2621 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2622 ** implemented as a sequence of comparisons.
2623 **
2624 ** An existing b-tree might be used if the RHS expression pX is a simple
2625 ** subquery such as:
2626 **
2627 ** SELECT <column1>, <column2>... FROM <table>
2628 **
2629 ** If the RHS of the IN operator is a list or a more complex subquery, then
2630 ** an ephemeral table might need to be generated from the RHS and then
2631 ** pX->iTable made to point to the ephemeral table instead of an
2632 ** existing table.
2633 **
2634 ** The inFlags parameter must contain, at a minimum, one of the bits
2635 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2636 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2637 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2638 ** be used to loop over all values of the RHS of the IN operator.
2639 **
2640 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2641 ** through the set members) then the b-tree must not contain duplicates.
2642 ** An epheremal table will be created unless the selected columns are guaranteed
2643 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2644 ** a UNIQUE constraint or index.
2645 **
2646 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2647 ** for fast set membership tests) then an epheremal table must
2648 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2649 ** index can be found with the specified <columns> as its left-most.
2650 **
2651 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2652 ** if the RHS of the IN operator is a list (not a subquery) then this
2653 ** routine might decide that creating an ephemeral b-tree for membership
2654 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2655 ** calling routine should implement the IN operator using a sequence
2656 ** of Eq or Ne comparison operations.
2657 **
2658 ** When the b-tree is being used for membership tests, the calling function
2659 ** might need to know whether or not the RHS side of the IN operator
2660 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2661 ** if there is any chance that the (...) might contain a NULL value at
2662 ** runtime, then a register is allocated and the register number written
2663 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2664 ** NULL value, then *prRhsHasNull is left unchanged.
2665 **
2666 ** If a register is allocated and its location stored in *prRhsHasNull, then
2667 ** the value in that register will be NULL if the b-tree contains one or more
2668 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2669 ** NULL values.
2670 **
2671 ** If the aiMap parameter is not NULL, it must point to an array containing
2672 ** one element for each column returned by the SELECT statement on the RHS
2673 ** of the IN(...) operator. The i'th entry of the array is populated with the
2674 ** offset of the index column that matches the i'th column returned by the
2675 ** SELECT. For example, if the expression and selected index are:
2676 **
2677 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2678 ** CREATE INDEX i1 ON t1(b, c, a);
2679 **
2680 ** then aiMap[] is populated with {2, 0, 1}.
2681 */
2682 #ifndef SQLITE_OMIT_SUBQUERY
2690 ){
2700 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2701 ** whether or not the SELECT result contains NULL values, check whether
2702 ** or not NULL is actually possible (it may not be, for example, due
2703 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2704 ** set prRhsHasNull to 0 before continuing. */
2710 }
2713 }
2714 }
2716 /* Check to see if an existing table or index can be used to
2717 ** satisfy the query. This is preferable to generating a new
2718 ** ephemeral table. */
2731 /* Code an OP_Transaction and OP_TableLock for <table>. */
2739 /* The "x IN (SELECT rowid FROM table)" case */
2753 /* Check that the affinity that will be used to perform each
2754 ** comparison is the same as the affinity of each column in table
2755 ** on the RHS of the IN operator. If it not, it is not possible to
2756 ** use any index of the RHS table. */
2768 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2769 ** other has no affinity and the other side is TEXT. Hence,
2770 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2771 ** and for the term on the LHS of the IN to have no affinity. */
2776 }
2777 }
2780 /* Search for an existing index that will work for this IN operator */
2786 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2787 ** BITMASK(nExpr) without overflowing */
2794 ){
2796 }
2797 }
2813 }
2815 }
2821 }
2825 /* If we reach this point, that means the index pIdx is usable */
2836 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
2840 #endif
2844 }
2845 }
2847 }
2853 /* If no preexisting index is available for the IN clause
2854 ** and IN_INDEX_NOOP is an allowed reply
2855 ** and the RHS of the IN operator is a list, not a subquery
2856 ** and the RHS is not constant or has two or fewer terms,
2857 ** then it is not worth creating an ephemeral table to evaluate
2858 ** the IN operator so return IN_INDEX_NOOP.
2859 */
2864 ){
2866 }
2869 /* Could not find an existing table or index to use as the RHS b-tree.
2870 ** We will have to generate an ephemeral table to do the job.
2871 */
2879 }
2884 }
2886 }
2892 }
2895 }
2896 #endif
2898 #ifndef SQLITE_OMIT_SUBQUERY
2899 /*
2900 ** Argument pExpr is an (?, ?...) IN(...) expression. This
2901 ** function allocates and returns a nul-terminated string containing
2902 ** the affinities to be used for each column of the comparison.
2903 **
2904 ** It is the responsibility of the caller to ensure that the returned
2905 ** string is eventually freed using sqlite3DbFree().
2906 */
2924 }
2925 }
2927 }
2929 }
2930 #endif
2932 #ifndef SQLITE_OMIT_SUBQUERY
2933 /*
2934 ** Load the Parse object passed as the first argument with an error
2935 ** message of the form:
2936 **
2937 ** "sub-select returns N columns - expected M"
2938 */
2943 }
2944 }
2945 #endif
2947 /*
2948 ** Expression pExpr is a vector that has been used in a context where
2949 ** it is not permitted. If pExpr is a sub-select vector, this routine
2950 ** loads the Parse object with a message of the form:
2951 **
2952 ** "sub-select returns N columns - expected 1"
2953 **
2954 ** Or, if it is a regular scalar vector:
2955 **
2956 ** "row value misused"
2957 */
2959 #ifndef SQLITE_OMIT_SUBQUERY
2963 #endif
2964 {
2966 }
2967 }
2969 #ifndef SQLITE_OMIT_SUBQUERY
2970 /*
2971 ** Generate code that will construct an ephemeral table containing all terms
2972 ** in the RHS of an IN operator. The IN operator can be in either of two
2973 ** forms:
2974 **
2975 ** x IN (4,5,11) -- IN operator with list on right-hand side
2976 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
2977 **
2978 ** The pExpr parameter is the IN operator. The cursor number for the
2979 ** constructed ephermeral table is returned. The first time the ephemeral
2980 ** table is computed, the cursor number is also stored in pExpr->iTable,
2981 ** however the cursor number returned might not be the same, as it might
2982 ** have been duplicated using OP_OpenDup.
2983 **
2984 ** If the LHS expression ("x" in the examples) is a column value, or
2985 ** the SELECT statement returns a column value, then the affinity of that
2986 ** column is used to build the index keys. If both 'x' and the
2987 ** SELECT... statement are columns, then numeric affinity is used
2988 ** if either column has NUMERIC or INTEGER affinity. If neither
2989 ** 'x' nor the SELECT... statement are columns, then numeric affinity
2990 ** is used.
2991 */
2996 ){
3007 /* The evaluation of the IN must be repeated every time it
3008 ** is encountered if any of the following is true:
3009 **
3010 ** * The right-hand side is a correlated subquery
3011 ** * The right-hand side is an expression list containing variables
3012 ** * We are inside a trigger
3013 **
3014 ** If all of the above are false, then we can compute the RHS just once
3015 ** and reuse it many names.
3016 */
3018 /* Reuse of the RHS is allowed */
3019 /* If this routine has already been coded, but the previous code
3020 ** might not have been invoked yet, so invoke it now as a subroutine.
3021 */
3027 }
3034 }
3036 /* Begin coding the subroutine */
3046 }
3048 /* Check to see if this is a vector IN operator */
3052 /* Construct the ephemeral table that will contain the content of
3053 ** RHS of the IN operator.
3054 */
3057 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
3062 }
3063 #endif
3067 /* Case 1: expr IN (SELECT ...)
3068 **
3069 ** Generate code to write the results of the select into the temporary
3070 ** table allocated and opened above.
3071 */
3077 ));
3078 /* If the LHS and RHS of the IN operator do not match, that
3079 ** error will have been caught long before we reach this point. */
3082 SelectDest dest;
3097 }
3106 );
3107 }
3108 }
3110 /* Case 2: expr IN (exprlist)
3111 **
3112 ** For each expression, build an index key from the evaluation and
3113 ** store it in the temporary table. If <expr> is a column, then use
3114 ** that columns affinity when building index keys. If <expr> is not
3115 ** a column, use numeric affinity.
3116 */
3127 }
3131 }
3133 /* Loop through each expression in <exprlist>. */
3139 /* If the expression is not constant then we will need to
3140 ** disable the test that was generated above that makes sure
3141 ** this code only executes once. Because for a non-constant
3142 ** expression we need to rerun this code each time.
3143 */
3148 }
3150 /* Evaluate the expression and insert it into the temp table */
3154 }
3157 }
3160 }
3163 /* Subroutine return */
3168 }
3169 }
3172 /*
3173 ** Generate code for scalar subqueries used as a subquery expression
3174 ** or EXISTS operator:
3175 **
3176 ** (SELECT a FROM b) -- subquery
3177 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
3178 **
3179 ** The pExpr parameter is the SELECT or EXISTS operator to be coded.
3180 **
3181 ** Return the register that holds the result. For a multi-column SELECT,
3182 ** the result is stored in a contiguous array of registers and the
3183 ** return value is the register of the left-most result column.
3184 ** Return 0 if an error occurs.
3185 */
3186 #ifndef SQLITE_OMIT_SUBQUERY
3204 /* If this routine has already been coded, then invoke it as a
3205 ** subroutine. */
3212 }
3214 /* Begin coding the subroutine */
3224 /* The evaluation of the EXISTS/SELECT must be repeated every time it
3225 ** is encountered if any of the following is true:
3226 **
3227 ** * The right-hand side is a correlated subquery
3228 ** * The right-hand side is an expression list containing variables
3229 ** * We are inside a trigger
3230 **
3231 ** If all of the above are false, then we can run this code just once
3232 ** save the results, and reuse the same result on subsequent invocations.
3233 */
3236 }
3238 /* For a SELECT, generate code to put the values for all columns of
3239 ** the first row into an array of registers and return the index of
3240 ** the first register.
3241 **
3242 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
3243 ** into a register and return that register number.
3244 **
3245 ** In both cases, the query is augmented with "LIMIT 1". Any
3246 ** preexisting limit is discarded in place of the new LIMIT 1.
3247 */
3263 }
3265 /* The subquery already has a limit. If the pre-existing limit is X
3266 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
3273 }
3277 /* If there is no pre-existing limit add a limit of 1 */
3280 }
3286 }
3288 }
3293 }
3295 /* Subroutine return */
3301 }
3304 #ifndef SQLITE_OMIT_SUBQUERY
3305 /*
3306 ** Expr pIn is an IN(...) expression. This function checks that the
3307 ** sub-select on the RHS of the IN() operator has the same number of
3308 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
3309 ** a sub-query, that the LHS is a vector of size 1.
3310 */
3317 }
3321 }
3323 }
3324 #endif
3326 #ifndef SQLITE_OMIT_SUBQUERY
3327 /*
3328 ** Generate code for an IN expression.
3329 **
3330 ** x IN (SELECT ...)
3331 ** x IN (value, value, ...)
3332 **
3333 ** The left-hand side (LHS) is a scalar or vector expression. The
3334 ** right-hand side (RHS) is an array of zero or more scalar values, or a
3335 ** subquery. If the RHS is a subquery, the number of result columns must
3336 ** match the number of columns in the vector on the LHS. If the RHS is
3337 ** a list of values, the LHS must be a scalar.
3338 **
3339 ** The IN operator is true if the LHS value is contained within the RHS.
3340 ** The result is false if the LHS is definitely not in the RHS. The
3341 ** result is NULL if the presence of the LHS in the RHS cannot be
3342 ** determined due to NULLs.
3343 **
3344 ** This routine generates code that jumps to destIfFalse if the LHS is not
3345 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
3346 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
3347 ** within the RHS then fall through.
3348 **
3349 ** See the separate in-operator.md documentation file in the canonical
3350 ** SQLite source tree for additional information.
3351 */
3357 ){
3384 );
3387 /* Attempt to compute the RHS. After this step, if anything other than
3388 ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
3389 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
3390 ** the RHS has not yet been coded. */
3401 );
3402 #ifdef SQLITE_DEBUG
3403 /* Confirm that aiMap[] contains nVector integer values between 0 and
3404 ** nVector-1. */
3409 }
3410 #endif
3412 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
3413 ** vector, then it is stored in an array of nVector registers starting
3414 ** at r1.
3415 **
3416 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
3417 ** so that the fields are in the same order as an existing index. The
3418 ** aiMap[] array contains a mapping from the original LHS field order to
3419 ** the field order that matches the RHS index.
3420 **
3421 ** Avoid factoring the LHS of the IN(...) expression out of the loop,
3422 ** even if it is constant, as OP_Affinity may be used on the register
3423 ** by code generated below. */
3430 /* LHS fields are not reordered */
3433 /* Need to reorder the LHS fields according to aiMap */
3437 }
3438 }
3440 /* If sqlite3FindInIndex() did not find or create an index that is
3441 ** suitable for evaluating the IN operator, then evaluate using a
3442 ** sequence of comparisons.
3443 **
3444 ** This is step (1) in the in-operator.md optimized algorithm.
3445 */
3459 }
3464 }
3483 }
3484 }
3488 }
3492 }
3494 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3495 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3496 ** We will then skip the binary search of the RHS.
3497 */
3502 }
3510 }
3511 }
3513 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3514 ** of the RHS using the LHS as a probe. If found, the result is
3515 ** true.
3516 */
3518 /* In this case, the RHS is the ROWID of table b-tree and so we also
3519 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3520 ** into a single opcode. */
3527 /* Combine Step 3 and Step 5 into a single opcode */
3531 }
3532 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3535 }
3537 /* Step 4. If the RHS is known to be non-NULL and we did not find
3538 ** an match on the search above, then the result must be FALSE.
3539 */
3543 }
3545 /* Step 5. If we do not care about the difference between NULL and
3546 ** FALSE, then just return false.
3547 */
3550 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3551 ** If any comparison is NULL, then the result is NULL. If all
3552 ** comparisons are FALSE then the final result is FALSE.
3553 **
3554 ** For a scalar LHS, it is sufficient to check just the first row
3555 ** of the RHS.
3556 */
3563 /* For nVector==1, combine steps 6 and 7 by immediately returning
3564 ** FALSE if the first comparison is not NULL */
3566 }
3578 }
3585 /* Step 7: If we reach this point, we know that the result must
3586 ** be false. */
3588 }
3590 /* Jumps here in order to return true. */
3593 sqlite3ExprCodeIN_finished:
3596 sqlite3ExprCodeIN_oom_error:
3599 }
3602 #ifndef SQLITE_OMIT_FLOATING_POINT
3603 /*
3604 ** Generate an instruction that will put the floating point
3605 ** value described by z[0..n-1] into register iMem.
3606 **
3607 ** The z[] string will probably not be zero-terminated. But the
3608 ** z[n] character is guaranteed to be something that does not look
3609 ** like the continuation of the number.
3610 */
3618 }
3619 }
3620 #endif
3623 /*
3624 ** Generate an instruction that will put the integer describe by
3625 ** text z[0..n-1] into register iMem.
3626 **
3627 ** Expr.u.zToken is always UTF8 and zero-terminated.
3628 */
3638 i64 value;
3643 #ifdef SQLITE_OMIT_FLOATING_POINT
3645 #else
3646 #ifndef SQLITE_OMIT_HEX_INTEGER
3650 #endif
3651 {
3653 }
3654 #endif
3658 }
3659 }
3660 }
3663 /* Generate code that will load into register regOut a value that is
3664 ** appropriate for the iIdxCol-th column of index pIdx.
3665 */
3672 ){
3683 }
3684 }
3686 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3687 /*
3688 ** Generate code that will compute the value of generated column pCol
3689 ** and store the result in register regOut
3690 */
3696 ){
3705 }
3709 }
3711 }
3714 /*
3715 ** Generate code to extract the value of the iCol-th column of a table.
3716 */
3723 ){
3729 }
3738 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
3751 }
3753 #endif
3762 }
3765 }
3766 }
3768 /*
3769 ** Generate code that will extract the iColumn-th column from
3770 ** table pTab and store the column value in register iReg.
3771 **
3772 ** There must be an open cursor to pTab in iTable when this routine
3773 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3774 */
3781 u8 p5 /* P5 value for OP_Column + FLAGS */
3782 ){
3788 }
3790 }
3792 /*
3793 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3794 ** over to iTo..iTo+nReg-1.
3795 */
3798 }
3800 /*
3801 ** Convert a scalar expression node to a TK_REGISTER referencing
3802 ** register iReg. The caller must ensure that iReg already contains
3803 ** the correct value for the expression.
3804 */
3812 }
3814 /*
3815 ** Evaluate an expression (either a vector or a scalar expression) and store
3816 ** the result in continguous temporary registers. Return the index of
3817 ** the first register used to store the result.
3818 **
3819 ** If the returned result register is a temporary scalar, then also write
3820 ** that register number into *piFreeable. If the returned result register
3821 ** is not a temporary or if the expression is a vector set *piFreeable
3822 ** to 0.
3823 */
3832 #if SQLITE_OMIT_SUBQUERY
3834 #else
3836 #endif
3844 }
3845 }
3846 }
3848 }
3850 /*
3851 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
3852 ** so that a subsequent copy will not be merged into this one.
3853 */
3857 }
3858 }
3860 /*
3861 ** Generate code to implement special SQL functions that are implemented
3862 ** in-line rather than by using the usual callbacks.
3863 */
3869 ){
3878 /* Attempt a direct implementation of the built-in COALESCE() and
3879 ** IFNULL() functions. This avoids unnecessary evaluation of
3880 ** arguments past the first non-NULL argument.
3881 */
3890 }
3894 }
3896 Expr caseExpr;
3901 }
3904 /* The UNLIKELY() function is a no-op. The result is the value
3905 ** of the first argument.
3906 */
3910 }
3912 /***********************************************************************
3913 ** Test-only SQL functions that are only usable if enabled
3914 ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
3915 */
3916 #if !defined(SQLITE_UNTESTABLE)
3918 /* Compare two expressions using sqlite3ExprCompare() */
3922 target);
3924 }
3927 /* Compare two expressions using sqlite3ExprImpliesExpr() */
3931 target);
3933 }
3936 /* REsult of sqlite3ExprImpliesNonNullRow() */
3943 target);
3946 }
3948 }
3951 /* The AFFINITY() function evaluates to a string that describes
3952 ** the type affinity of the argument. This is used for testing of
3953 ** the SQLite type logic.
3954 */
3962 }
3964 }
3966 }
3969 /*
3970 ** Generate code into the current Vdbe to evaluate the given
3971 ** expression. Attempt to store the results in register "target".
3972 ** Return the register where results are stored.
3973 **
3974 ** With this routine, there is no guarantee that results will
3975 ** be stored in target. The result might be stored in some other
3976 ** register if it is convenient to do so. The calling function
3977 ** must check the return code and move the results to the desired
3978 ** register.
3979 */
3993 expr_code_doover:
3999 }
4021 }
4022 }
4024 }
4025 /* Otherwise, fall thru into the TK_COLUMN case */
4026 /* no break */ deliberate_fall_through
4027 }
4032 /* This COLUMN expression is really a constant due to WHERE clause
4033 ** constraints, and that constant is coded by the pExpr->pLeft
4034 ** expresssion. However, make sure the constant has the correct
4035 ** datatype by applying the Affinity of the table column to the
4036 ** constant.
4037 */
4045 }
4052 }
4054 }
4057 /* Other columns in the same row for CHECK constraints or
4058 ** generated columns or for inserting into partial index.
4059 ** The row is unpacked into registers beginning at
4060 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
4061 ** immediately prior to the first column.
4062 */
4074 }
4078 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
4084 }
4088 }
4099 }
4101 /* Coding an expression that is part of an index where column names
4102 ** in the index refer to the table to which the index belongs */
4104 }
4105 }
4112 }
4114 }
4118 }
4122 }
4123 #ifndef SQLITE_OMIT_FLOATING_POINT
4128 }
4129 #endif
4134 }
4136 /* Make NULL the default case so that if a bug causes an illegal
4137 ** Expr node to be passed into this function, it will be handled
4138 ** sanely and not crash. But keep the assert() to bring the problem
4139 ** to the attention of the developers. */
4143 }
4144 #ifndef SQLITE_OMIT_BLOB_LITERAL
4158 }
4159 #endif
4170 }
4172 }
4175 }
4176 #ifndef SQLITE_OMIT_CAST
4178 /* Expressions of the form: CAST(pLeft AS token) */
4183 }
4188 }
4194 /* fall-through */
4221 }
4224 }
4226 }
4256 }
4263 #ifndef SQLITE_OMIT_FLOATING_POINT
4268 #endif
4278 }
4280 }
4289 }
4301 }
4316 }
4322 ){
4327 }
4329 }
4341 #ifndef SQLITE_OMIT_WINDOWFUNC
4344 }
4345 #endif
4348 /* SQL functions can be expensive. So try to avoid running them
4349 ** multiple times if we know they always give the same result */
4351 }
4359 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
4362 }
4363 #endif
4367 }
4375 }
4381 }
4384 }
4385 }
4392 }
4394 /* For length() and typeof() functions with a column argument,
4395 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
4396 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
4397 ** loading.
4398 */
4400 u8 exprOp;
4410 }
4411 }
4417 }
4418 #ifndef SQLITE_OMIT_VIRTUALTABLE
4419 /* Possibly overload the function if the first argument is
4420 ** a virtual table column.
4421 **
4422 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
4423 ** second argument, not the first, as the argument to test to
4424 ** see if it is a column in a virtual table. This is done because
4425 ** the left operand of infix functions (the operand we want to
4426 ** control overloading) ends up as the second argument to the
4427 ** function. The expression "A glob B" is equivalent to
4428 ** "glob(B,A). We want to use the A in "A glob B" to test
4429 ** for function overloading. But we use the B term in "glob(B,A)".
4430 */
4435 }
4436 #endif
4440 }
4441 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
4448 }
4450 #endif
4451 {
4454 }
4460 }
4461 }
4463 }
4464 #ifndef SQLITE_OMIT_SUBQUERY
4475 ){
4479 }
4481 }
4486 }
4492 }
4494 }
4505 }
4509 /*
4510 ** x BETWEEN y AND z
4511 **
4512 ** This is equivalent to
4513 **
4514 ** x>=y AND x<=z
4515 **
4516 ** X is stored in pExpr->pLeft.
4517 ** Y is stored in pExpr->pList->a[0].pExpr.
4518 ** Z is stored in pExpr->pList->a[1].pExpr.
4519 */
4523 }
4529 }
4532 /* If the opcode is TK_TRIGGER, then the expression is a reference
4533 ** to a column in the new.* or old.* pseudo-tables available to
4534 ** trigger programs. In this case Expr.iTable is set to 1 for the
4535 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4536 ** is set to the column of the pseudo-table to read, or to -1 to
4537 ** read the rowid field.
4538 **
4539 ** The expression is implemented using an OP_Param opcode. The p1
4540 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4541 ** to reference another column of the old.* pseudo-table, where
4542 ** i is the index of the column. For a new.rowid reference, p1 is
4543 ** set to (n+1), where n is the number of columns in each pseudo-table.
4544 ** For a reference to any other column in the new.* pseudo-table, p1
4545 ** is set to (n+2+i), where n and i are as defined previously. For
4546 ** example, if the table on which triggers are being fired is
4547 ** declared as:
4548 **
4549 ** CREATE TABLE t1(a, b);
4550 **
4551 ** Then p1 is interpreted as follows:
4552 **
4553 ** p1==0 -> old.rowid p1==3 -> new.rowid
4554 ** p1==1 -> old.a p1==4 -> new.a
4555 ** p1==2 -> old.b p1==5 -> new.b
4556 */
4576 ));
4578 #ifndef SQLITE_OMIT_FLOATING_POINT
4579 /* If the column has REAL affinity, it may currently be stored as an
4580 ** integer. Use OP_RealAffinity to make sure it is really real.
4581 **
4582 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4583 ** floating point when extracting it from the record. */
4586 }
4587 #endif
4589 }
4594 }
4596 /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions
4597 ** that derive from the right-hand table of a LEFT JOIN. The
4598 ** Expr.iTable value is the table number for the right-hand table.
4599 ** The expression is only evaluated if that table is not currently
4600 ** on a LEFT JOIN NULL row.
4601 */
4606 /* Temporarily disable factoring of constant expressions, since
4607 ** even though expressions may appear to be constant, they are not
4608 ** really constant because they originate from the right-hand side
4609 ** of a LEFT JOIN. */
4616 }
4618 /*
4619 ** Form A:
4620 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4621 **
4622 ** Form B:
4623 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4624 **
4625 ** Form A is can be transformed into the equivalent form B as follows:
4626 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4627 ** WHEN x=eN THEN rN ELSE y END
4628 **
4629 ** X (if it exists) is in pExpr->pLeft.
4630 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4631 ** odd. The Y is also optional. If the number of elements in x.pList
4632 ** is even, then Y is omitted and the "otherwise" result is NULL.
4633 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4634 **
4635 ** The result of the expression is the Ri for the first matching Ei,
4636 ** or if there is no matching Ei, the ELSE term Y, or if there is
4637 ** no ELSE term, NULL.
4638 */
4663 }
4671 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4672 ** The value in regFree1 might get SCopy-ed into the file result.
4673 ** So make sure that the regFree1 register is not reused for other
4674 ** purposes and possibly overwritten. */
4676 }
4683 }
4691 }
4696 }
4701 }
4702 #ifndef SQLITE_OMIT_TRIGGER
4708 );
4713 }
4716 }
4726 }
4729 }
4730 #endif
4731 }
4735 }
4737 /*
4738 ** Generate code that will evaluate expression pExpr just one time
4739 ** per prepared statement execution.
4740 **
4741 ** If the expression uses functions (that might throw an exception) then
4742 ** guard them with an OP_Once opcode to ensure that the code is only executed
4743 ** once. If no functions are involved, then factor the code out and put it at
4744 ** the end of the prepared statement in the initialization section.
4745 **
4746 ** If regDest>=0 then the result is always stored in that register and the
4747 ** result is not reusable. If regDest<0 then this routine is free to
4748 ** store the value whereever it wants. The register where the expression
4749 ** is stored is returned. When regDest<0, two identical expressions might
4750 ** code to the same register, if they do not contain function calls and hence
4751 ** are factored out into the initialization section at the end of the
4752 ** prepared statement.
4753 */
4758 ){
4768 }
4769 }
4770 }
4781 }
4792 }
4794 }
4796 }
4798 /*
4799 ** Generate code to evaluate an expression and store the results
4800 ** into a register. Return the register number where the results
4801 ** are stored.
4802 **
4803 ** If the register is a temporary register that can be deallocated,
4804 ** then write its number into *pReg. If the result register is not
4805 ** a temporary, then set *pReg to zero.
4806 **
4807 ** If pExpr is a constant, then this routine might generate this
4808 ** code to fill the register in the initialization section of the
4809 ** VDBE program, in order to factor it out of the evaluation loop.
4810 */
4818 ){
4829 }
4830 }
4832 }
4834 /*
4835 ** Generate code that will evaluate expression pExpr and store the
4836 ** results in register target. The results are guaranteed to appear
4837 ** in register target.
4838 */
4848 u8 op;
4853 }
4855 }
4856 }
4858 /*
4859 ** Make a transient copy of expression pExpr and then code it using
4860 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
4861 ** except that the input expression is guaranteed to be unchanged.
4862 */
4868 }
4870 /*
4871 ** Generate code that will evaluate expression pExpr and store the
4872 ** results in register target. The results are guaranteed to appear
4873 ** in register target. If the expression is constant, then this routine
4874 ** might choose to code the expression at initialization time.
4875 */
4881 }
4882 }
4884 /*
4885 ** Generate code that pushes the value of every element of the given
4886 ** expression list into a sequence of registers beginning at target.
4887 **
4888 ** Return the number of elements evaluated. The number returned will
4889 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
4890 ** is defined.
4891 **
4892 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
4893 ** filled using OP_SCopy. OP_Copy must be used instead.
4894 **
4895 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
4896 ** factored out into initialization code.
4897 **
4898 ** The SQLITE_ECEL_REF flag means that expressions in the list with
4899 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
4900 ** in registers at srcReg, and so the value can be copied from there.
4901 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
4902 ** are simply omitted rather than being copied from srcReg.
4903 */
4909 u8 flags /* SQLITE_ECEL_* flags */
4910 ){
4922 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
4924 i--;
4925 n--;
4927 #endif
4930 i--;
4931 n--;
4934 }
4937 ){
4948 ){
4952 }
4953 }
4954 }
4955 }
4957 }
4959 /*
4960 ** Generate code for a BETWEEN operator.
4961 **
4962 ** x BETWEEN y AND z
4963 **
4964 ** The above is equivalent to
4965 **
4966 ** x>=y AND x<=z
4967 **
4968 ** Code it as such, taking care to do the common subexpression
4969 ** elimination of x.
4970 **
4971 ** The xJumpIf parameter determines details:
4972 **
4973 ** NULL: Store the boolean result in reg[dest]
4974 ** sqlite3ExprIfTrue: Jump to dest if true
4975 ** sqlite3ExprIfFalse: Jump to dest if false
4976 **
4977 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
4978 */
4985 ){
5013 /* Mark the expression is being from the ON or USING clause of a join
5014 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
5015 ** it into the Parse.pConstExpr list. We should use a new bit for this,
5016 ** for clarity, but we are out of bits in the Expr.flags field so we
5017 ** have to reuse the EP_FromJoin bit. Bummer. */
5020 }
5022 }
5025 /* Ensure adequate test coverage */
5035 }
5037 /*
5038 ** Generate code for a boolean expression such that a jump is made
5039 ** to the label "dest" if the expression is true but execution
5040 ** continues straight thru if the expression is false.
5041 **
5042 ** If the expression evaluates to NULL (neither true nor false), then
5043 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
5044 **
5045 ** This code depends on the fact that certain token values (ex: TK_EQ)
5046 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
5047 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
5048 ** the make process cause these values to align. Assert()s in the code
5049 ** below verify that the numbers are aligned correctly.
5050 */
5080 }
5082 }
5087 }
5102 }
5104 }
5111 /* no break */ deliberate_fall_through
5137 }
5148 }
5153 }
5154 #ifndef SQLITE_OMIT_SUBQUERY
5162 }
5163 #endif
5165 default_expr:
5169 /* No-op */
5176 }
5178 }
5179 }
5182 }
5184 /*
5185 ** Generate code for a boolean expression such that a jump is made
5186 ** to the label "dest" if the expression is false but execution
5187 ** continues straight thru if the expression is true.
5188 **
5189 ** If the expression evaluates to NULL (neither true nor false) then
5190 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
5191 ** is 0.
5192 */
5205 /* The value of pExpr->op and op are related as follows:
5206 **
5207 ** pExpr->op op
5208 ** --------- ----------
5209 ** TK_ISNULL OP_NotNull
5210 ** TK_NOTNULL OP_IsNull
5211 ** TK_NE OP_Eq
5212 ** TK_EQ OP_Ne
5213 ** TK_GT OP_Le
5214 ** TK_LE OP_Gt
5215 ** TK_GE OP_Lt
5216 ** TK_LT OP_Ge
5217 **
5218 ** For other values of pExpr->op, op is undefined and unused.
5219 ** The value of TK_ and OP_ constants are arranged such that we
5220 ** can compute the mapping above using the following expression.
5221 ** Assert()s verify that the computation is correct.
5222 */
5225 /* Verify correct alignment of TK_ and OP_ constants
5226 */
5253 }
5255 }
5260 }
5270 /* IS TRUE and IS NOT FALSE */
5275 /* IS FALSE and IS NOT TRUE */
5278 }
5280 }
5287 /* no break */ deliberate_fall_through
5313 }
5322 }
5327 }
5328 #ifndef SQLITE_OMIT_SUBQUERY
5336 }
5338 }
5339 #endif
5341 default_expr:
5345 /* no-op */
5352 }
5354 }
5355 }
5358 }
5360 /*
5361 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
5362 ** code generation, and that copy is deleted after code generation. This
5363 ** ensures that the original pExpr is unchanged.
5364 */
5370 }
5372 }
5374 /*
5375 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
5376 ** type of expression.
5377 **
5378 ** If pExpr is a simple SQL value - an integer, real, string, blob
5379 ** or NULL value - then the VDBE currently being prepared is configured
5380 ** to re-prepare each time a new value is bound to variable pVar.
5381 **
5382 ** Additionally, if pExpr is a simple SQL value and the value is the
5383 ** same as that currently bound to variable pVar, non-zero is returned.
5384 ** Otherwise, if the values are not the same or if pExpr is not a simple
5385 ** SQL value, zero is returned.
5386 */
5391 ){
5404 }
5406 }
5409 }
5412 }
5414 /*
5415 ** Do a deep comparison of two expression trees. Return 0 if the two
5416 ** expressions are completely identical. Return 1 if they differ only
5417 ** by a COLLATE operator at the top level. Return 2 if there are differences
5418 ** other than the top-level COLLATE operator.
5419 **
5420 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5421 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5422 **
5423 ** The pA side might be using TK_REGISTER. If that is the case and pB is
5424 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
5425 **
5426 ** Sometimes this routine will return 2 even if the two expressions
5427 ** really are equivalent. If we cannot prove that the expressions are
5428 ** identical, we return 2 just to be safe. So if this routine
5429 ** returns 2, then you do not really know for certain if the two
5430 ** expressions are the same. But if you get a 0 or 1 return, then you
5431 ** can be sure the expressions are the same. In the places where
5432 ** this routine is used, it does not hurt to get an extra 2 - that
5433 ** just might result in some slightly slower code. But returning
5434 ** an incorrect 0 or 1 could lead to a malfunction.
5435 **
5436 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
5437 ** pParse->pReprepare can be matched against literals in pB. The
5438 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
5439 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
5440 ** Argument pParse should normally be NULL. If it is not NULL and pA or
5441 ** pB causes a return value of 2.
5442 */
5447 int iTab
5448 ){
5449 u32 combinedFlags;
5452 }
5455 }
5460 }
5462 }
5466 }
5469 }
5471 }
5477 #ifndef SQLITE_OMIT_WINDOWFUNC
5481 }
5485 }
5486 }
5487 #endif
5497 ){
5499 }
5500 }
5512 ){
5517 }
5518 }
5519 }
5521 }
5523 /*
5524 ** Compare two ExprList objects. Return 0 if they are identical, 1
5525 ** if they are certainly different, or 2 if it is not possible to
5526 ** determine if they are identical or not.
5527 **
5528 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
5529 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
5530 **
5531 ** This routine might return non-zero for equivalent ExprLists. The
5532 ** only consequence will be disabled optimizations. But this routine
5533 ** must never return 0 if the two ExprList objects are different, or
5534 ** a malfunction will result.
5535 **
5536 ** Two NULL pointers are considered to be the same. But a NULL pointer
5537 ** always differs from a non-NULL pointer.
5538 */
5550 }
5552 }
5554 /*
5555 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
5556 ** are ignored.
5557 */
5562 iTab);
5563 }
5565 /*
5566 ** Return non-zero if Expr p can only be true if pNN is not NULL.
5567 **
5568 ** Or if seenNot is true, return non-zero if Expr p can only be
5569 ** non-NULL if pNN is not NULL
5570 */
5577 ){
5582 }
5588 }
5598 ){
5600 }
5602 }
5616 /* no break */ deliberate_fall_through
5622 /* no break */ deliberate_fall_through
5623 }
5629 }
5634 }
5638 }
5639 }
5641 }
5643 /*
5644 ** Return true if we can prove the pE2 will always be true if pE1 is
5645 ** true. Return false if we cannot complete the proof or if pE2 might
5646 ** be false. Examples:
5647 **
5648 ** pE1: x==5 pE2: x==5 Result: true
5649 ** pE1: x>0 pE2: x==5 Result: false
5650 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
5651 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
5652 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
5653 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
5654 ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false
5655 **
5656 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
5657 ** Expr.iTable<0 then assume a table number given by iTab.
5658 **
5659 ** If pParse is not NULL, then the values of bound variables in pE1 are
5660 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
5661 ** modified to record which bound variables are referenced. If pParse
5662 ** is NULL, then false will be returned if pE1 contains any bound variables.
5663 **
5664 ** When in doubt, return false. Returning true might give a performance
5665 ** improvement. Returning false might cause a performance reduction, but
5666 ** it will always give the correct answer and is hence always safe.
5667 */
5672 int iTab
5673 ){
5676 }
5680 ){
5682 }
5685 ){
5687 }
5689 }
5691 /*
5692 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
5693 ** If the expression node requires that the table at pWalker->iCur
5694 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
5695 **
5696 ** This routine controls an optimization. False positives (setting
5697 ** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
5698 ** (never setting pWalker->eCode) is a harmless missed optimization.
5699 */
5730 }
5739 }
5740 }
5747 }
5750 /* Virtual tables are allowed to use constraints like x=NULL. So
5751 ** a term of the form x=y does not prove that y is not null if x
5752 ** is the column of a virtual table */
5767 /* The y.pTab=0 assignment in wherecode.c always happens after the
5768 ** impliesNotNullRow() test */
5777 ){
5779 }
5780 /* no break */ deliberate_fall_through
5781 }
5784 }
5785 }
5787 /*
5788 ** Return true (non-zero) if expression p can only be true if at least
5789 ** one column of table iTab is non-null. In other words, return true
5790 ** if expression p will always be NULL or false if every column of iTab
5791 ** is NULL.
5792 **
5793 ** False negatives are acceptable. In other words, it is ok to return
5794 ** zero even if expression p will never be true of every column of iTab
5795 ** is NULL. A false negative is merely a missed optimization opportunity.
5796 **
5797 ** False positives are not allowed, however. A false positive may result
5798 ** in an incorrect answer.
5799 **
5800 ** Terms of p that are marked with EP_FromJoin (and hence that come from
5801 ** the ON or USING clauses of LEFT JOINS) are excluded from the analysis.
5802 **
5803 ** This routine is used to check if a LEFT JOIN can be converted into
5804 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
5805 ** clause requires that some column of the right table of the LEFT JOIN
5806 ** be non-NULL, then the LEFT JOIN can be safely converted into an
5807 ** ordinary join.
5808 */
5810 Walker w;
5819 }
5820 }
5828 }
5830 /*
5831 ** An instance of the following structure is used by the tree walker
5832 ** to determine if an expression can be evaluated by reference to the
5833 ** index only, without having to do a search for the corresponding
5834 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
5835 ** is the cursor for the table.
5836 */
5840 };
5842 /*
5843 ** Check to see if there are references to columns in table
5844 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
5845 ** pWalker->u.pIdxCover->pIdx.
5846 */
5851 ){
5854 }
5856 }
5858 /*
5859 ** Determine if an index pIdx on table with cursor iCur contains will
5860 ** the expression pExpr. Return true if the index does cover the
5861 ** expression and false if the pExpr expression references table columns
5862 ** that are not found in the index pIdx.
5863 **
5864 ** An index covering an expression means that the expression can be
5865 ** evaluated using only the index and without having to lookup the
5866 ** corresponding table entry.
5867 */
5872 ){
5873 Walker w;
5882 }
5885 /* Structure used to pass information throught the Walker in order to
5886 ** implement sqlite3ReferencesSrcList().
5887 */
5893 };
5895 /*
5896 ** Walker SELECT callbacks for sqlite3ReferencesSrcList().
5897 **
5898 ** When entering a new subquery on the pExpr argument, add all FROM clause
5899 ** entries for that subquery to the exclude list.
5900 **
5901 ** When leaving the subquery, remove those entries from the exclude list.
5902 */
5917 }
5920 }
5922 }
5929 }
5930 }
5932 /* This is the Walker EXPR callback for sqlite3ReferencesSrcList().
5933 **
5934 ** Set the 0x01 bit of pWalker->eCode if there is a reference to any
5935 ** of the tables shown in RefSrcList.pRef.
5936 **
5937 ** Set the 0x02 bit of pWalker->eCode if there is a reference to a
5938 ** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude.
5939 */
5943 ){
5952 }
5953 }
5957 }
5958 }
5960 }
5962 /*
5963 ** Check to see if pExpr references any tables in pSrcList.
5964 ** Possible return values:
5965 **
5966 ** 1 pExpr does references a table in pSrcList.
5967 **
5968 ** 0 pExpr references some table that is not defined in either
5969 ** pSrcList or in subqueries of pExpr itself.
5970 **
5971 ** -1 pExpr only references no tables at all, or it only
5972 ** references tables defined in subqueries of pExpr itself.
5973 **
5974 ** As currently used, pExpr is always an aggregate function call. That
5975 ** fact is exploited for efficiency.
5976 */
5978 Walker w;
5991 #ifndef SQLITE_OMIT_WINDOWFUNC
5994 }
5995 #endif
6003 }
6004 }
6006 /*
6007 ** This is a Walker expression node callback.
6008 **
6009 ** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo
6010 ** object that is referenced does not refer directly to the Expr. If
6011 ** it does, make a copy. This is done because the pExpr argument is
6012 ** subject to change.
6013 **
6014 ** The copy is stored on pParse->pConstExpr with a register number of 0.
6015 ** This will cause the expression to be deleted automatically when the
6016 ** Parse object is destroyed, but the zero register number means that it
6017 ** will not generate any code in the preamble.
6018 */
6022 ){
6035 }
6036 }
6044 }
6045 }
6046 }
6047 }
6049 }
6051 /*
6052 ** Initialize a Walker object so that will persist AggInfo entries referenced
6053 ** by the tree that is walked.
6054 */
6060 }
6062 /*
6063 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
6064 ** the new element. Return a negative number if malloc fails.
6065 */
6069 db,
6073 &i
6074 );
6076 }
6078 /*
6079 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
6080 ** the new element. Return a negative number if malloc fails.
6081 */
6085 db,
6089 &i
6090 );
6092 }
6094 /*
6095 ** This is the xExprCallback for a tree walker. It is used to
6096 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
6097 ** for additional information.
6098 */
6112 /* Check to see if the column is in one of the tables in the FROM
6113 ** clause of the aggregate query */
6120 /* If we reach this point, it means that pExpr refers to a table
6121 ** that is in the FROM clause of the aggregate query.
6122 **
6123 ** Make an entry for the column in pAggInfo->aCol[] if there
6124 ** is not an entry there already.
6125 */
6132 }
6133 }
6136 ){
6156 }
6157 }
6158 }
6161 }
6162 }
6163 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
6164 ** because it was there before or because we just created it).
6165 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
6166 ** pAggInfo->aCol[] entry.
6167 */
6175 }
6177 }
6181 ){
6182 /* Check to see if pExpr is a duplicate of another aggregate
6183 ** function that is already in the pAggInfo structure
6184 */
6190 }
6191 }
6193 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
6194 */
6210 }
6211 }
6212 }
6213 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
6214 */
6222 }
6223 }
6224 }
6226 }
6228 /*
6229 ** Analyze the pExpr expression looking for aggregate functions and
6230 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
6231 ** points to. Additional entries are made on the AggInfo object as
6232 ** necessary.
6233 **
6234 ** This routine should only be called after the expression has been
6235 ** analyzed by sqlite3ResolveExprNames().
6236 */
6238 Walker w;
6247 }
6249 /*
6250 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
6251 ** expression list. Return the number of errors.
6252 **
6253 ** If an error is found, the analysis is cut short.
6254 */
6261 }
6262 }
6263 }
6265 /*
6266 ** Allocate a single new register for use to hold some intermediate result.
6267 */
6271 }
6273 }
6275 /*
6276 ** Deallocate a register, making available for reuse for some other
6277 ** purpose.
6278 */
6284 }
6285 }
6286 }
6288 /*
6289 ** Allocate or deallocate a block of nReg consecutive registers.
6290 */
6302 }
6304 }
6309 }
6314 }
6315 }
6317 /*
6318 ** Mark all temporary registers as being unavailable for reuse.
6319 **
6320 ** Always invoke this procedure after coding a subroutine or co-routine
6321 ** that might be invoked from other parts of the code, to ensure that
6322 ** the sub/co-routine does not use registers in common with the code that
6323 ** invokes the sub/co-routine.
6324 */
6328 }
6330 /*
6331 ** Validate that no temporary register falls within the range of
6332 ** iFirst..iLast, inclusive. This routine is only call from within assert()
6333 ** statements.
6334 */
6335 #ifdef SQLITE_DEBUG
6341 ){
6343 }
6347 }
6348 }
6350 }