| blob | 019bf17b994843452c14e9d0fb4edb002a06bd4e |
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 }
55 #ifndef SQLITE_OMIT_CAST
59 }
60 #endif
63 }
68 );
69 }
71 }
73 /*
74 ** Set the collating sequence for expression pExpr to be the collating
75 ** sequence named by pToken. Return a pointer to a new Expr node that
76 ** implements the COLLATE operator.
77 **
78 ** If a memory allocation error occurs, that fact is recorded in pParse->db
79 ** and the pExpr parameter is returned unchanged.
80 */
86 ){
93 }
94 }
96 }
98 Token s;
102 }
104 /*
105 ** Skip over any TK_COLLATE operators and any unlikely()
106 ** or likelihood() function at the root of an expression.
107 */
118 }
119 }
121 }
123 /*
124 ** Return the collation sequence for the expression pExpr. If
125 ** there is no defined collating sequence, return NULL.
126 **
127 ** See also: sqlite3ExprNNCollSeq()
128 **
129 ** The sqlite3ExprNNCollSeq() works the same exact that it returns the
130 ** default collation if pExpr has no defined collation.
131 **
132 ** The collating sequence might be determined by a COLLATE operator
133 ** or by the presence of a column with a defined collating sequence.
134 ** COLLATE operators take first precedence. Left operands take
135 ** precedence over right operands.
136 */
147 }
151 }
155 ){
156 /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
157 ** a TK_COLUMN but was previously evaluated and cached in a register */
162 }
164 }
170 /* The Expr.x union is never used at the same time as Expr.pRight */
172 /* p->flags holds EP_Collate and p->pLeft->flags does not. And
173 ** p->x.pSelect cannot. So if p->x.pLeft exists, it must hold at
174 ** least one EP_Collate. Thus the following two ALWAYS. */
181 }
182 }
183 }
185 }
188 }
189 }
192 }
194 }
196 /*
197 ** Return the collation sequence for the expression pExpr. If
198 ** there is no defined collating sequence, return a pointer to the
199 ** defautl collation sequence.
200 **
201 ** See also: sqlite3ExprCollSeq()
202 **
203 ** The sqlite3ExprCollSeq() routine works the same except that it
204 ** returns NULL if there is no defined collation.
205 */
211 }
213 /*
214 ** Return TRUE if the two expressions have equivalent collating sequences.
215 */
220 }
222 /*
223 ** pExpr is an operand of a comparison operator. aff2 is the
224 ** type affinity of the other operand. This routine returns the
225 ** type affinity that should be used for the comparison operator.
226 */
230 /* Both sides of the comparison are columns. If one has numeric
231 ** affinity, use that. Otherwise use no affinity.
232 */
237 }
239 /* Neither side of the comparison is a column. Compare the
240 ** results directly.
241 */
244 /* One side is a column, the other is not. Use the columns affinity. */
247 }
248 }
250 /*
251 ** pExpr is a comparison operator. Return the type affinity that should
252 ** be applied to both operands prior to doing the comparison.
253 */
267 }
269 }
271 /*
272 ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
273 ** idx_affinity is the affinity of an indexed column. Return true
274 ** if the index with affinity idx_affinity may be used to implement
275 ** the comparison in pExpr.
276 */
286 }
287 }
289 /*
290 ** Return the P5 value that should be used for a binary comparison
291 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
292 */
297 }
299 /*
300 ** Return a pointer to the collation sequence that should be used by
301 ** a binary comparison operator comparing pLeft and pRight.
302 **
303 ** If the left hand expression has a collating sequence type, then it is
304 ** used. Otherwise the collation sequence for the right hand expression
305 ** is used, or the default (BINARY) if neither expression has a collating
306 ** type.
307 **
308 ** Argument pRight (but not pLeft) may be a null pointer. In this case,
309 ** it is not considered.
310 */
314 Expr *pRight
315 ){
326 }
327 }
329 }
331 /*
332 ** Generate code for a comparison operator.
333 */
342 ){
353 }
355 /*
356 ** Return true if expression pExpr is a vector, or false otherwise.
357 **
358 ** A vector is defined as any expression that results in two or more
359 ** columns of result. Every TK_VECTOR node is an vector because the
360 ** parser will not generate a TK_VECTOR with fewer than two entries.
361 ** But a TK_SELECT might be either a vector or a scalar. It is only
362 ** considered a vector if it has two or more result columns.
363 */
366 }
368 /*
369 ** If the expression passed as the only argument is of type TK_VECTOR
370 ** return the number of expressions in the vector. Or, if the expression
371 ** is a sub-select, return the number of columns in the sub-select. For
372 ** any other type of expression, return 1.
373 */
383 }
384 }
386 /*
387 ** Return a pointer to a subexpression of pVector that is the i-th
388 ** column of the vector (numbered starting with 0). The caller must
389 ** ensure that i is within range.
390 **
391 ** If pVector is really a scalar (and "scalar" here includes subqueries
392 ** that return a single column!) then return pVector unmodified.
393 **
394 ** pVector retains ownership of the returned subexpression.
395 **
396 ** If the vector is a (SELECT ...) then the expression returned is
397 ** just the expression for the i-th term of the result set, and may
398 ** not be ready for evaluation because the table cursor has not yet
399 ** been positioned.
400 */
409 }
410 }
412 }
414 /*
415 ** Compute and return a new Expr object which when passed to
416 ** sqlite3ExprCode() will generate all necessary code to compute
417 ** the iField-th column of the vector expression pVector.
418 **
419 ** It is ok for pVector to be a scalar (as long as iField==0).
420 ** In that case, this routine works like sqlite3ExprDup().
421 **
422 ** The caller owns the returned Expr object and is responsible for
423 ** ensuring that the returned value eventually gets freed.
424 **
425 ** The caller retains ownership of pVector. If pVector is a TK_SELECT,
426 ** then the returned object will reference pVector and so pVector must remain
427 ** valid for the life of the returned object. If pVector is a TK_VECTOR
428 ** or a scalar expression, then it can be deleted as soon as this routine
429 ** returns.
430 **
431 ** A trick to cause a TK_SELECT pVector to be deleted together with
432 ** the returned Expr object is to attach the pVector to the pRight field
433 ** of the returned TK_SELECT_COLUMN Expr object.
434 */
439 ){
443 /* The TK_SELECT_COLUMN Expr node:
444 **
445 ** pLeft: pVector containing TK_SELECT. Not deleted.
446 ** pRight: not used. But recursively deleted.
447 ** iColumn: Index of a column in pVector
448 ** iTable: 0 or the number of columns on the LHS of an assignment
449 ** pLeft->iTable: First in an array of register holding result, or 0
450 ** if the result is not yet computed.
451 **
452 ** sqlite3ExprDelete() specifically skips the recursive delete of
453 ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector
454 ** can be attached to pRight to cause this node to take ownership of
455 ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes
456 ** with the same pLeft pointer to the pVector, but only one of them
457 ** will own the pVector.
458 */
463 }
468 }
470 }
472 /*
473 ** If expression pExpr is of type TK_SELECT, generate code to evaluate
474 ** it. Return the register in which the result is stored (or, if the
475 ** sub-select returns more than one column, the first in an array
476 ** of registers in which the result is stored).
477 **
478 ** If pExpr is not a TK_SELECT expression, return 0.
479 */
482 #ifndef SQLITE_OMIT_SUBQUERY
485 }
486 #endif
488 }
490 /*
491 ** Argument pVector points to a vector expression - either a TK_VECTOR
492 ** or TK_SELECT that returns more than one column. This function returns
493 ** the register number of a register that contains the value of
494 ** element iField of the vector.
495 **
496 ** If pVector is a TK_SELECT expression, then code for it must have
497 ** already been generated using the exprCodeSubselect() routine. In this
498 ** case parameter regSelect should be the first in an array of registers
499 ** containing the results of the sub-select.
500 **
501 ** If pVector is of type TK_VECTOR, then code for the requested field
502 ** is generated. In this case (*pRegFree) may be set to the number of
503 ** a temporary register to be freed by the caller before returning.
504 **
505 ** Before returning, output parameter (*ppExpr) is set to point to the
506 ** Expr object corresponding to element iElem of the vector.
507 */
515 ){
521 }
525 }
528 }
530 /*
531 ** Expression pExpr is a comparison between two vector values. Compute
532 ** the result of the comparison (1, 0, or NULL) and write that
533 ** result into register dest.
534 **
535 ** The caller must satisfy the following preconditions:
536 **
537 ** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ
538 ** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ
539 ** otherwise: op==pExpr->op and p5==0
540 */
546 u8 p5 /* SQLITE_NULLEQ or zero */
547 ){
561 }
566 );
599 }
614 }
615 }
617 }
619 #if SQLITE_MAX_EXPR_DEPTH>0
620 /*
621 ** Check that argument nHeight is less than or equal to the maximum
622 ** expression depth allowed. If it is not, leave an error message in
623 ** pParse.
624 */
631 );
633 }
635 }
637 /* The following three functions, heightOfExpr(), heightOfExprList()
638 ** and heightOfSelect(), are used to determine the maximum height
639 ** of any expression tree referenced by the structure passed as the
640 ** first argument.
641 **
642 ** If this maximum height is greater than the current value pointed
643 ** to by pnHeight, the second parameter, then set *pnHeight to that
644 ** value.
645 */
650 }
651 }
652 }
658 }
659 }
660 }
670 }
671 }
673 /*
674 ** Set the Expr.nHeight variable in the structure passed as an
675 ** argument. An expression with no children, Expr.pList or
676 ** Expr.pSelect member has a height of 1. Any other expression
677 ** has a height equal to the maximum height of any other
678 ** referenced Expr plus one.
679 **
680 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
681 ** if appropriate.
682 */
692 }
694 }
696 /*
697 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
698 ** the height is greater than the maximum allowed expression depth,
699 ** leave an error in pParse.
700 **
701 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
702 ** Expr.flags.
703 */
708 }
710 /*
711 ** Return the maximum height of any expression tree referenced
712 ** by the select statement passed as an argument.
713 */
718 }
720 /*
721 ** Propagate all EP_Propagate flags from the Expr.x.pList into
722 ** Expr.flags.
723 */
727 }
728 }
729 #define exprSetHeight(y)
732 /*
733 ** This routine is the core allocator for Expr nodes.
734 **
735 ** Construct a new expression node and return a pointer to it. Memory
736 ** for this node and for the pToken argument is a single allocation
737 ** obtained from sqlite3DbMalloc(). The calling function
738 ** is responsible for making sure the node eventually gets freed.
739 **
740 ** If dequote is true, then the token (if it exists) is dequoted.
741 ** If dequote is false, no dequoting is performed. The deQuote
742 ** parameter is ignored if pToken is NULL or if the token does not
743 ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
744 ** then the EP_DblQuoted flag is set on the expression node.
745 **
746 ** Special case: If op==TK_INTEGER and pToken points to a string that
747 ** can be translated into a 32-bit integer, then the token is not
748 ** stored in u.zToken. Instead, the integer values is written
749 ** into u.iValue and the EP_IntValue flag is set. No extra storage
750 ** is allocated to hold the integer text and the dequote flag is ignored.
751 */
757 ){
768 }
769 }
787 }
788 }
789 }
790 #if SQLITE_MAX_EXPR_DEPTH>0
792 #endif
793 }
795 }
797 /*
798 ** Allocate a new expression node from a zero-terminated token that has
799 ** already been dequoted.
800 */
805 ){
806 Token x;
810 }
812 /*
813 ** Attach subtrees pLeft and pRight to the Expr node pRoot.
814 **
815 ** If pRoot==NULL that means that a memory allocation error has occurred.
816 ** In that case, delete the subtrees pLeft and pRight.
817 */
822 Expr *pRight
823 ){
832 }
836 }
838 }
839 }
841 /*
842 ** Allocate an Expr node which joins as many as two subtrees.
843 **
844 ** One or both of the subtrees can be NULL. Return a pointer to the new
845 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
846 ** free the subtrees and return NULL.
847 */
853 ){
856 /* Take advantage of short-circuit false optimization for AND */
864 }
866 }
869 }
871 }
873 /*
874 ** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due
875 ** do a memory allocation failure) then delete the pSelect object.
876 */
885 }
886 }
889 /*
890 ** If the expression is always either TRUE or FALSE (respectively),
891 ** then return 1. If one cannot determine the truth value of the
892 ** expression at compile-time return 0.
893 **
894 ** This is an optimization. If is OK to return 0 here even if
895 ** the expression really is always false or false (a false negative).
896 ** But it is a bug to return 1 if the expression might have different
897 ** boolean values in different circumstances (a false positive.)
898 **
899 ** Note that if the expression is part of conditional for a
900 ** LEFT JOIN, then we cannot determine at compile-time whether or not
901 ** is it true or false, so always return 0.
902 */
908 }
914 }
916 /*
917 ** Join two expressions using an AND operator. If either expression is
918 ** NULL, then just return the other expression.
919 **
920 ** If one side or the other of the AND is known to be false, then instead
921 ** of returning an AND expression, just return a constant expression with
922 ** a value of false.
923 */
937 }
938 }
940 /*
941 ** Construct a new expression node for a function with multiple
942 ** arguments.
943 */
952 }
958 }
960 /*
961 ** Assign a variable number to an expression that encodes a wildcard
962 ** in the original SQL statement.
963 **
964 ** Wildcards consisting of a single "?" are assigned the next sequential
965 ** variable number.
966 **
967 ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
968 ** sure "nnn" is not too big to avoid a denial of service attack when
969 ** the SQL statement comes from an external source.
970 **
971 ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
972 ** as the previous instance of the same wildcard. Or if this is the first
973 ** instance of the wildcard, the next sequential variable number is
974 ** assigned.
975 */
979 ynVar x;
988 /* Wildcard of the form "?". Assign the next variable number */
994 /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
995 ** use it as the variable number */
996 i64 i;
1003 }
1012 }
1019 }
1021 /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
1022 ** number as the prior appearance of the same name, or if the name
1023 ** has never appeared before, reuse the same variable number
1024 */
1029 }
1030 }
1033 }
1034 }
1038 }
1039 }
1041 /*
1042 ** Recursively delete an expression tree.
1043 */
1046 /* Sanity check: Assert that the IntValue is non-negative if it exists */
1048 #ifdef SQLITE_DEBUG
1053 }
1054 #endif
1056 /* The Expr.x union is never used at the same time as Expr.pRight */
1065 }
1068 }
1069 }
1073 }
1074 }
1077 }
1079 /*
1080 ** Return the number of bytes allocated for the expression structure
1081 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
1082 ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
1083 */
1088 }
1090 /*
1091 ** The dupedExpr*Size() routines each return the number of bytes required
1092 ** to store a copy of an expression or expression tree. They differ in
1093 ** how much of the tree is measured.
1094 **
1095 ** dupedExprStructSize() Size of only the Expr structure
1096 ** dupedExprNodeSize() Size of Expr + space for token
1097 ** dupedExprSize() Expr + token + subtree components
1098 **
1099 ***************************************************************************
1100 **
1101 ** The dupedExprStructSize() function returns two values OR-ed together:
1102 ** (1) the space required for a copy of the Expr structure only and
1103 ** (2) the EP_xxx flags that indicate what the structure size should be.
1104 ** The return values is always one of:
1105 **
1106 ** EXPR_FULLSIZE
1107 ** EXPR_REDUCEDSIZE | EP_Reduced
1108 ** EXPR_TOKENONLYSIZE | EP_TokenOnly
1109 **
1110 ** The size of the structure can be found by masking the return value
1111 ** of this routine with 0xfff. The flags can be found by masking the
1112 ** return value with EP_Reduced|EP_TokenOnly.
1113 **
1114 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
1115 ** (unreduced) Expr objects as they or originally constructed by the parser.
1116 ** During expression analysis, extra information is computed and moved into
1117 ** later parts of the Expr object and that extra information might get chopped
1118 ** off if the expression is reduced. Note also that it does not work to
1119 ** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal
1120 ** to reduce a pristine expression tree from the parser. The implementation
1121 ** of dupedExprStructSize() contain multiple assert() statements that attempt
1122 ** to enforce this constraint.
1123 */
1130 #ifndef SQLITE_OMIT_WINDOWFUNC
1132 #endif
1133 ){
1145 }
1146 }
1148 }
1150 /*
1151 ** This function returns the space in bytes required to store the copy
1152 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
1153 ** string is defined.)
1154 */
1159 }
1161 }
1163 /*
1164 ** Return the number of bytes required to create a duplicate of the
1165 ** expression passed as the first argument. The second argument is a
1166 ** mask containing EXPRDUP_XXX flags.
1167 **
1168 ** The value returned includes space to create a copy of the Expr struct
1169 ** itself and the buffer referred to by Expr.u.zToken, if any.
1170 **
1171 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
1172 ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
1173 ** and Expr.pRight variables (but not for any structures pointed to or
1174 ** descended from the Expr.x.pList or Expr.x.pSelect variables).
1175 */
1182 }
1183 }
1185 }
1187 /*
1188 ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
1189 ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
1190 ** to store the copy of expression p, the copies of p->u.zToken
1191 ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
1192 ** if any. Before returning, *pzBuffer is set to the first byte past the
1193 ** portion of the buffer copied into by this function.
1194 */
1205 /* Figure out where to write the new Expr structure. */
1212 }
1216 /* Set nNewSize to the size allocated for the structure pointed to
1217 ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
1218 ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
1219 ** by the copy of the p->u.zToken string (if any).
1220 */
1228 }
1237 }
1238 }
1240 /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
1245 /* Copy the p->u.zToken string, if any. */
1249 }
1252 /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
1257 }
1258 }
1260 /* Fill in pNew->pLeft and pNew->pRight. */
1268 }
1271 }
1273 #ifndef SQLITE_OMIT_WINDOWFUNC
1278 }
1287 }
1289 }
1290 }
1291 }
1293 }
1295 /*
1296 ** Create and return a deep copy of the object passed as the second
1297 ** argument. If an OOM condition is encountered, NULL is returned
1298 ** and the db->mallocFailed flag set.
1299 */
1300 #ifndef SQLITE_OMIT_CTE
1313 }
1314 }
1315 }
1317 }
1318 #else
1319 # define withDup(x,y) 0
1320 #endif
1322 /*
1323 ** The following group of routines make deep copies of expressions,
1324 ** expression lists, ID lists, and select statements. The copies can
1325 ** be deleted (by being passed to their respective ...Delete() routines)
1326 ** without effecting the originals.
1327 **
1328 ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
1329 ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
1330 ** by subsequent calls to sqlite*ListAppend() routines.
1331 **
1332 ** Any tables that the SrcList might point to are not duplicated.
1333 **
1334 ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
1335 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
1336 ** truncated version of the usual Expr structure that will be stored as
1337 ** part of the in-memory representation of the database schema.
1338 */
1342 }
1362 ){
1373 }
1374 }
1382 }
1384 }
1386 /*
1387 ** If cursors, triggers, views and subqueries are all omitted from
1388 ** the build, then none of the following routines, except for
1389 ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
1390 ** called with a NULL argument.
1391 */
1392 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
1393 || !defined(SQLITE_OMIT_SUBQUERY)
1418 }
1423 }
1427 }
1432 }
1434 }
1447 }
1448 /* Note that because the size of the allocation for p->a[] is not
1449 ** necessarily a power of two, sqlite3IdListAppend() may not be called
1450 ** on the duplicate created by this function. */
1456 }
1458 }
1486 #ifndef SQLITE_OMIT_WINDOWFUNC
1489 #endif
1494 }
1497 }
1498 #else
1502 }
1503 #endif
1506 /*
1507 ** Add a new element to the end of an expression list. If pList is
1508 ** initially NULL, then create a new expression list.
1509 **
1510 ** The pList argument must be either NULL or a pointer to an ExprList
1511 ** obtained from a prior call to sqlite3ExprListAppend(). This routine
1512 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
1513 ** Reason: This routine assumes that the number of slots in pList->a[]
1514 ** is a power of two. That is true for sqlite3ExprListAppend() returns
1515 ** but is not necessarily true from the return value of sqlite3ExprListDup().
1516 **
1517 ** If a memory allocation error occurs, the entire list is freed and
1518 ** NULL is returned. If non-NULL is returned, then it is guaranteed
1519 ** that the new entry was successfully appended.
1520 */
1525 ){
1533 }
1541 }
1543 }
1551 no_mem:
1552 /* Avoid leaking memory if malloc has failed. */
1556 }
1558 /*
1559 ** pColumns and pExpr form a vector assignment which is part of the SET
1560 ** clause of an UPDATE statement. Like this:
1561 **
1562 ** (a,b,c) = (expr1,expr2,expr3)
1563 ** Or: (a,b,c) = (SELECT x,y,z FROM ....)
1564 **
1565 ** For each term of the vector assignment, append new entries to the
1566 ** expression list pList. In the case of a subquery on the RHS, append
1567 ** TK_SELECT_COLUMN expressions.
1568 */
1574 ){
1579 /* pColumns can only be NULL due to an OOM but an OOM will cause an
1580 ** exit prior to this routine being invoked */
1584 /* If the RHS is a vector, then we can immediately check to see that
1585 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
1586 ** wildcards ("*") in the result set of the SELECT must be expanded before
1587 ** we can do the size check, so defer the size check until code generation.
1588 */
1593 }
1602 }
1603 }
1610 /* Store the SELECT statement in pRight so it will be deleted when
1611 ** sqlite3ExprListDelete() is called */
1615 /* Remember the size of the LHS in iTable so that we can check that
1616 ** the RHS and LHS sizes match during code generation. */
1618 }
1620 vector_append_error:
1624 }
1626 /*
1627 ** Set the sort order for the last element on the given ExprList.
1628 */
1636 }
1638 }
1640 /*
1641 ** Set the ExprList.a[].zName element of the most recently added item
1642 ** on the expression list.
1643 **
1644 ** pList might be NULL following an OOM error. But pName should never be
1645 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1646 ** is set.
1647 */
1653 ){
1662 }
1663 }
1665 /*
1666 ** Set the ExprList.a[].zSpan element of the most recently added item
1667 ** on the expression list.
1668 **
1669 ** pList might be NULL following an OOM error. But pSpan should never be
1670 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
1671 ** is set.
1672 */
1678 ){
1686 }
1687 }
1689 /*
1690 ** If the expression list pEList contains more than iLimit elements,
1691 ** leave an error message in pParse.
1692 */
1697 ){
1703 }
1704 }
1706 /*
1707 ** Delete an entire expression list.
1708 */
1717 pItem++;
1720 }
1723 }
1725 /*
1726 ** Return the bitwise-OR of all Expr.flags fields in the given
1727 ** ExprList.
1728 */
1737 }
1739 }
1741 /*
1742 ** This is a SELECT-node callback for the expression walker that
1743 ** always "fails". By "fail" in this case, we mean set
1744 ** pWalker->eCode to zero and abort.
1745 **
1746 ** This callback is used by multiple expression walkers.
1747 */
1752 }
1754 /*
1755 ** If the input expression is an ID with the name "true" or "false"
1756 ** then convert it into an TK_TRUEFALSE term. Return non-zero if
1757 ** the conversion happened, and zero if the expression is unaltered.
1758 */
1763 ){
1766 }
1768 }
1770 /*
1771 ** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE
1772 ** and 0 if it is FALSE.
1773 */
1779 }
1782 /*
1783 ** These routines are Walker callbacks used to check expressions to
1784 ** see if they are "constant" for some definition of constant. The
1785 ** Walker.eCode value determines the type of "constant" we are looking
1786 ** for.
1787 **
1788 ** These callback routines are used to implement the following:
1789 **
1790 ** sqlite3ExprIsConstant() pWalker->eCode==1
1791 ** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2
1792 ** sqlite3ExprIsTableConstant() pWalker->eCode==3
1793 ** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5
1794 **
1795 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
1796 ** is found to not be a constant.
1797 **
1798 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating expressions
1799 ** in a CREATE TABLE statement. The Walker.eCode value is 5 when parsing
1800 ** an existing schema and 4 when processing a new statement. A bound
1801 ** parameter raises an error for new statements, but is silently converted
1802 ** to NULL for existing schemas. This allows sqlite_master tables that
1803 ** contain a bound parameter because they were generated by older versions
1804 ** of SQLite to be parsed by newer versions of SQLite without raising a
1805 ** malformed schema error.
1806 */
1809 /* If pWalker->eCode is 2 then any term of the expression that comes from
1810 ** the ON or USING clauses of a left join disqualifies the expression
1811 ** from being considered constant. */
1815 }
1818 /* Consider functions to be constant if all their arguments are constant
1819 ** and either pWalker->eCode==4 or 5 or the function has the
1820 ** SQLITE_FUNC_CONST flag. */
1827 }
1829 /* Convert "true" or "false" in a DEFAULT clause into the
1830 ** appropriate TK_TRUEFALSE operator */
1833 }
1834 /* Fall thru */
1844 }
1845 /* Fall through */
1854 /* Silently convert bound parameters that appear inside of CREATE
1855 ** statements into a NULL when parsing the CREATE statement text out
1856 ** of the sqlite_master table */
1859 /* A bound parameter in a CREATE statement that originates from
1860 ** sqlite3_prepare() causes an error */
1863 }
1864 /* Fall through */
1869 }
1870 }
1872 Walker w;
1876 #ifdef SQLITE_DEBUG
1878 #endif
1882 }
1884 /*
1885 ** Walk an expression tree. Return non-zero if the expression is constant
1886 ** and 0 if it involves variables or function calls.
1887 **
1888 ** For the purposes of this function, a double-quoted string (ex: "abc")
1889 ** is considered a variable but a single-quoted string (ex: 'abc') is
1890 ** a constant.
1891 */
1894 }
1896 /*
1897 ** Walk an expression tree. Return non-zero if the expression is constant
1898 ** that does no originate from the ON or USING clauses of a join.
1899 ** Return 0 if it involves variables or function calls or terms from
1900 ** an ON or USING clause.
1901 */
1904 }
1906 /*
1907 ** Walk an expression tree. Return non-zero if the expression is constant
1908 ** for any single row of the table with cursor iCur. In other words, the
1909 ** expression must not refer to any non-deterministic function nor any
1910 ** table other than iCur.
1911 */
1914 }
1917 /*
1918 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
1919 */
1924 /* Check if pExpr is identical to any GROUP BY term. If so, consider
1925 ** it constant. */
1932 }
1933 }
1934 }
1936 /* Check if pExpr is a sub-select. If so, consider it variable. */
1940 }
1943 }
1945 /*
1946 ** Walk the expression tree passed as the first argument. Return non-zero
1947 ** if the expression consists entirely of constants or copies of terms
1948 ** in pGroupBy that sort with the BINARY collation sequence.
1949 **
1950 ** This routine is used to determine if a term of the HAVING clause can
1951 ** be promoted into the WHERE clause. In order for such a promotion to work,
1952 ** the value of the HAVING clause term must be the same for all members of
1953 ** a "group". The requirement that the GROUP BY term must be BINARY
1954 ** assumes that no other collating sequence will have a finer-grained
1955 ** grouping than binary. In other words (A=B COLLATE binary) implies
1956 ** A=B in every other collating sequence. The requirement that the
1957 ** GROUP BY be BINARY is stricter than necessary. It would also work
1958 ** to promote HAVING clauses that use the same alternative collating
1959 ** sequence as the GROUP BY term, but that is much harder to check,
1960 ** alternative collating sequences are uncommon, and this is only an
1961 ** optimization, so we take the easy way out and simply require the
1962 ** GROUP BY to use the BINARY collating sequence.
1963 */
1965 Walker w;
1973 }
1975 /*
1976 ** Walk an expression tree. Return non-zero if the expression is constant
1977 ** or a function call with constant arguments. Return and 0 if there
1978 ** are any variables.
1979 **
1980 ** For the purposes of this function, a double-quoted string (ex: "abc")
1981 ** is considered a variable but a single-quoted string (ex: 'abc') is
1982 ** a constant.
1983 */
1987 }
1989 #ifdef SQLITE_ENABLE_CURSOR_HINTS
1990 /*
1991 ** Walk an expression tree. Return 1 if the expression contains a
1992 ** subquery of some kind. Return 0 if there are no subqueries.
1993 */
1995 Walker w;
1999 #ifdef SQLITE_DEBUG
2001 #endif
2004 }
2005 #endif
2007 /*
2008 ** If the expression p codes a constant integer that is small enough
2009 ** to fit in a 32-bit integer, return 1 and put the value of the integer
2010 ** in *pValue. If the expression is not an integer or if it is too big
2011 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
2012 */
2017 /* If an expression is an integer literal that fits in a signed 32-bit
2018 ** integer, then the EP_IntValue flag will have already been set */
2025 }
2030 }
2037 }
2039 }
2041 }
2043 }
2045 /*
2046 ** Return FALSE if there is no chance that the expression can be NULL.
2047 **
2048 ** If the expression might be NULL or if the expression is too complex
2049 ** to tell return TRUE.
2050 **
2051 ** This routine is used as an optimization, to skip OP_IsNull opcodes
2052 ** when we know that a value cannot be NULL. Hence, a false positive
2053 ** (returning TRUE when in fact the expression can never be NULL) might
2054 ** be a small performance hit but is otherwise harmless. On the other
2055 ** hand, a false negative (returning FALSE when the result could be NULL)
2056 ** will likely result in an incorrect answer. So when in doubt, return
2057 ** TRUE.
2058 */
2060 u8 op;
2076 }
2077 }
2079 /*
2080 ** Return TRUE if the given expression is a constant which would be
2081 ** unchanged by OP_Affinity with the affinity given in the second
2082 ** argument.
2083 **
2084 ** This routine is used to determine if the OP_Affinity operation
2085 ** can be omitted. When in doubt return FALSE. A false negative
2086 ** is harmless. A false positive, however, can result in the wrong
2087 ** answer.
2088 */
2090 u8 op;
2098 }
2101 }
2104 }
2107 }
2112 }
2115 }
2116 }
2117 }
2119 /*
2120 ** Return TRUE if the given string is a row-id column name.
2121 */
2127 }
2129 /*
2130 ** pX is the RHS of an IN operator. If pX is a SELECT statement
2131 ** that can be simplified to a direct table access, then return
2132 ** a pointer to the SELECT statement. If pX is not a SELECT statement,
2133 ** or if the SELECT statement needs to be manifested into a transient
2134 ** table, then return NULL.
2135 */
2136 #ifndef SQLITE_OMIT_SUBQUERY
2151 }
2165 /* All SELECT results must be columns. */
2170 }
2172 }
2175 #ifndef SQLITE_OMIT_SUBQUERY
2176 /*
2177 ** Generate code that checks the left-most column of index table iCur to see if
2178 ** it contains any NULL entries. Cause the register at regHasNull to be set
2179 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
2180 ** to be set to NULL if iCur contains one or more NULL values.
2181 */
2190 }
2191 #endif
2194 #ifndef SQLITE_OMIT_SUBQUERY
2195 /*
2196 ** The argument is an IN operator with a list (not a subquery) on the
2197 ** right-hand side. Return TRUE if that list is constant.
2198 */
2208 }
2209 #endif
2211 /*
2212 ** This function is used by the implementation of the IN (...) operator.
2213 ** The pX parameter is the expression on the RHS of the IN operator, which
2214 ** might be either a list of expressions or a subquery.
2215 **
2216 ** The job of this routine is to find or create a b-tree object that can
2217 ** be used either to test for membership in the RHS set or to iterate through
2218 ** all members of the RHS set, skipping duplicates.
2219 **
2220 ** A cursor is opened on the b-tree object that is the RHS of the IN operator
2221 ** and pX->iTable is set to the index of that cursor.
2222 **
2223 ** The returned value of this function indicates the b-tree type, as follows:
2224 **
2225 ** IN_INDEX_ROWID - The cursor was opened on a database table.
2226 ** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index.
2227 ** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index.
2228 ** IN_INDEX_EPH - The cursor was opened on a specially created and
2229 ** populated epheremal table.
2230 ** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be
2231 ** implemented as a sequence of comparisons.
2232 **
2233 ** An existing b-tree might be used if the RHS expression pX is a simple
2234 ** subquery such as:
2235 **
2236 ** SELECT <column1>, <column2>... FROM <table>
2237 **
2238 ** If the RHS of the IN operator is a list or a more complex subquery, then
2239 ** an ephemeral table might need to be generated from the RHS and then
2240 ** pX->iTable made to point to the ephemeral table instead of an
2241 ** existing table.
2242 **
2243 ** The inFlags parameter must contain, at a minimum, one of the bits
2244 ** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains
2245 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
2246 ** membership test. When the IN_INDEX_LOOP bit is set, the IN index will
2247 ** be used to loop over all values of the RHS of the IN operator.
2248 **
2249 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
2250 ** through the set members) then the b-tree must not contain duplicates.
2251 ** An epheremal table will be created unless the selected columns are guaranteed
2252 ** to be unique - either because it is an INTEGER PRIMARY KEY or due to
2253 ** a UNIQUE constraint or index.
2254 **
2255 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
2256 ** for fast set membership tests) then an epheremal table must
2257 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
2258 ** index can be found with the specified <columns> as its left-most.
2259 **
2260 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
2261 ** if the RHS of the IN operator is a list (not a subquery) then this
2262 ** routine might decide that creating an ephemeral b-tree for membership
2263 ** testing is too expensive and return IN_INDEX_NOOP. In that case, the
2264 ** calling routine should implement the IN operator using a sequence
2265 ** of Eq or Ne comparison operations.
2266 **
2267 ** When the b-tree is being used for membership tests, the calling function
2268 ** might need to know whether or not the RHS side of the IN operator
2269 ** contains a NULL. If prRhsHasNull is not a NULL pointer and
2270 ** if there is any chance that the (...) might contain a NULL value at
2271 ** runtime, then a register is allocated and the register number written
2272 ** to *prRhsHasNull. If there is no chance that the (...) contains a
2273 ** NULL value, then *prRhsHasNull is left unchanged.
2274 **
2275 ** If a register is allocated and its location stored in *prRhsHasNull, then
2276 ** the value in that register will be NULL if the b-tree contains one or more
2277 ** NULL values, and it will be some non-NULL value if the b-tree contains no
2278 ** NULL values.
2279 **
2280 ** If the aiMap parameter is not NULL, it must point to an array containing
2281 ** one element for each column returned by the SELECT statement on the RHS
2282 ** of the IN(...) operator. The i'th entry of the array is populated with the
2283 ** offset of the index column that matches the i'th column returned by the
2284 ** SELECT. For example, if the expression and selected index are:
2285 **
2286 ** (?,?,?) IN (SELECT a, b, c FROM t1)
2287 ** CREATE INDEX i1 ON t1(b, c, a);
2288 **
2289 ** then aiMap[] is populated with {2, 0, 1}.
2290 */
2291 #ifndef SQLITE_OMIT_SUBQUERY
2298 ){
2308 /* If the RHS of this IN(...) operator is a SELECT, and if it matters
2309 ** whether or not the SELECT result contains NULL values, check whether
2310 ** or not NULL is actually possible (it may not be, for example, due
2311 ** to NOT NULL constraints in the schema). If no NULL values are possible,
2312 ** set prRhsHasNull to 0 before continuing. */
2318 }
2321 }
2322 }
2324 /* Check to see if an existing table or index can be used to
2325 ** satisfy the query. This is preferable to generating a new
2326 ** ephemeral table. */
2339 /* Code an OP_Transaction and OP_TableLock for <table>. */
2346 /* The "x IN (SELECT rowid FROM table)" case */
2359 /* Check that the affinity that will be used to perform each
2360 ** comparison is the same as the affinity of each column in table
2361 ** on the RHS of the IN operator. If it not, it is not possible to
2362 ** use any index of the RHS table. */
2374 /* sqlite3CompareAffinity() only returns TEXT if one side or the
2375 ** other has no affinity and the other side is TEXT. Hence,
2376 ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
2377 ** and for the term on the LHS of the IN to have no affinity. */
2382 }
2383 }
2386 /* Search for an existing index that will work for this IN operator */
2391 /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
2392 ** BITMASK(nExpr) without overflowing */
2399 ){
2401 }
2402 }
2417 }
2419 }
2425 }
2429 /* If we reach this point, that means the index pIdx is usable */
2440 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
2444 #endif
2448 }
2449 }
2451 }
2457 /* If no preexisting index is available for the IN clause
2458 ** and IN_INDEX_NOOP is an allowed reply
2459 ** and the RHS of the IN operator is a list, not a subquery
2460 ** and the RHS is not constant or has two or fewer terms,
2461 ** then it is not worth creating an ephemeral table to evaluate
2462 ** the IN operator so return IN_INDEX_NOOP.
2463 */
2468 ){
2470 }
2473 /* Could not find an existing table or index to use as the RHS b-tree.
2474 ** We will have to generate an ephemeral table to do the job.
2475 */
2483 }
2486 }
2491 }
2497 }
2499 }
2500 #endif
2502 #ifndef SQLITE_OMIT_SUBQUERY
2503 /*
2504 ** Argument pExpr is an (?, ?...) IN(...) expression. This
2505 ** function allocates and returns a nul-terminated string containing
2506 ** the affinities to be used for each column of the comparison.
2507 **
2508 ** It is the responsibility of the caller to ensure that the returned
2509 ** string is eventually freed using sqlite3DbFree().
2510 */
2528 }
2529 }
2531 }
2533 }
2534 #endif
2536 #ifndef SQLITE_OMIT_SUBQUERY
2537 /*
2538 ** Load the Parse object passed as the first argument with an error
2539 ** message of the form:
2540 **
2541 ** "sub-select returns N columns - expected M"
2542 */
2546 }
2547 #endif
2549 /*
2550 ** Expression pExpr is a vector that has been used in a context where
2551 ** it is not permitted. If pExpr is a sub-select vector, this routine
2552 ** loads the Parse object with a message of the form:
2553 **
2554 ** "sub-select returns N columns - expected 1"
2555 **
2556 ** Or, if it is a regular scalar vector:
2557 **
2558 ** "row value misused"
2559 */
2561 #ifndef SQLITE_OMIT_SUBQUERY
2565 #endif
2566 {
2568 }
2569 }
2571 /*
2572 ** Generate code for scalar subqueries used as a subquery expression, EXISTS,
2573 ** or IN operators. Examples:
2574 **
2575 ** (SELECT a FROM b) -- subquery
2576 ** EXISTS (SELECT a FROM b) -- EXISTS subquery
2577 ** x IN (4,5,11) -- IN operator with list on right-hand side
2578 ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
2579 **
2580 ** The pExpr parameter describes the expression that contains the IN
2581 ** operator or subquery.
2582 **
2583 ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
2584 ** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
2585 ** to some integer key column of a table B-Tree. In this case, use an
2586 ** intkey B-Tree to store the set of IN(...) values instead of the usual
2587 ** (slower) variable length keys B-Tree.
2588 **
2589 ** If rMayHaveNull is non-zero, that means that the operation is an IN
2590 ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
2591 ** All this routine does is initialize the register given by rMayHaveNull
2592 ** to NULL. Calling routines will take care of changing this register
2593 ** value to non-NULL if the RHS is NULL-free.
2594 **
2595 ** For a SELECT or EXISTS operator, return the register that holds the
2596 ** result. For a multi-column SELECT, the result is stored in a contiguous
2597 ** array of registers and the return value is the register of the left-most
2598 ** result column. Return 0 for IN operators or if an error occurs.
2599 */
2600 #ifndef SQLITE_OMIT_SUBQUERY
2606 ){
2613 /* The evaluation of the IN/EXISTS/SELECT must be repeated every time it
2614 ** is encountered if any of the following is true:
2615 **
2616 ** * The right-hand side is a correlated subquery
2617 ** * The right-hand side is an expression list containing variables
2618 ** * We are inside a trigger
2619 **
2620 ** If all of the above are false, then we can run this code just once
2621 ** save the results, and reuse the same result on subsequent invocations.
2622 */
2625 }
2637 /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
2638 ** expression it is handled the same way. An ephemeral table is
2639 ** filled with index keys representing the results from the
2640 ** SELECT or the <exprlist>.
2641 **
2642 ** If the 'x' expression is a column value, or the SELECT...
2643 ** statement returns a column value, then the affinity of that
2644 ** column is used to build the index keys. If both 'x' and the
2645 ** SELECT... statement are columns, then numeric affinity is used
2646 ** if either column has NUMERIC or INTEGER affinity. If neither
2647 ** 'x' nor the SELECT... statement are columns, then numeric affinity
2648 ** is used.
2649 */
2656 /* Case 1: expr IN (SELECT ...)
2657 **
2658 ** Generate code to write the results of the select into the temporary
2659 ** table allocated and opened above.
2660 */
2666 ));
2668 /* If the LHS and RHS of the IN operator do not match, that
2669 ** error will have been caught long before we reach this point. */
2671 SelectDest dest;
2682 }
2692 );
2693 }
2694 }
2696 /* Case 2: expr IN (exprlist)
2697 **
2698 ** For each expression, build an index key from the evaluation and
2699 ** store it in the temporary table. If <expr> is a column, then use
2700 ** that columns affinity when building index keys. If <expr> is not
2701 ** a column, use numeric affinity.
2702 */
2711 }
2715 }
2717 /* Loop through each expression in <exprlist>. */
2725 /* If the expression is not constant then we will need to
2726 ** disable the test that was generated above that makes sure
2727 ** this code only executes once. Because for a non-constant
2728 ** expression we need to rerun this code each time.
2729 */
2733 }
2735 /* Evaluate the expression and insert it into the temp table */
2749 }
2750 }
2751 }
2754 }
2757 }
2759 }
2764 /* Case 3: (SELECT ... FROM ...)
2765 ** or: EXISTS(SELECT ... FROM ...)
2766 **
2767 ** For a SELECT, generate code to put the values for all columns of
2768 ** the first row into an array of registers and return the index of
2769 ** the first register.
2770 **
2771 ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
2772 ** into a register and return that register number.
2773 **
2774 ** In both cases, the query is augmented with "LIMIT 1". Any
2775 ** preexisting limit is discarded in place of the new LIMIT 1.
2776 */
2803 }
2810 }
2814 }
2818 }
2819 }
2823 }
2827 }
2831 }
2834 #ifndef SQLITE_OMIT_SUBQUERY
2835 /*
2836 ** Expr pIn is an IN(...) expression. This function checks that the
2837 ** sub-select on the RHS of the IN() operator has the same number of
2838 ** columns as the vector on the LHS. Or, if the RHS of the IN() is not
2839 ** a sub-query, that the LHS is a vector of size 1.
2840 */
2847 }
2851 }
2853 }
2854 #endif
2856 #ifndef SQLITE_OMIT_SUBQUERY
2857 /*
2858 ** Generate code for an IN expression.
2859 **
2860 ** x IN (SELECT ...)
2861 ** x IN (value, value, ...)
2862 **
2863 ** The left-hand side (LHS) is a scalar or vector expression. The
2864 ** right-hand side (RHS) is an array of zero or more scalar values, or a
2865 ** subquery. If the RHS is a subquery, the number of result columns must
2866 ** match the number of columns in the vector on the LHS. If the RHS is
2867 ** a list of values, the LHS must be a scalar.
2868 **
2869 ** The IN operator is true if the LHS value is contained within the RHS.
2870 ** The result is false if the LHS is definitely not in the RHS. The
2871 ** result is NULL if the presence of the LHS in the RHS cannot be
2872 ** determined due to NULLs.
2873 **
2874 ** This routine generates code that jumps to destIfFalse if the LHS is not
2875 ** contained within the RHS. If due to NULLs we cannot determine if the LHS
2876 ** is contained in the RHS then jump to destIfNull. If the LHS is contained
2877 ** within the RHS then fall through.
2878 **
2879 ** See the separate in-operator.md documentation file in the canonical
2880 ** SQLite source tree for additional information.
2881 */
2887 ){
2911 );
2914 /* Attempt to compute the RHS. After this step, if anything other than
2915 ** IN_INDEX_NOOP is returned, the table opened ith cursor pExpr->iTable
2916 ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
2917 ** the RHS has not yet been coded. */
2927 );
2928 #ifdef SQLITE_DEBUG
2929 /* Confirm that aiMap[] contains nVector integer values between 0 and
2930 ** nVector-1. */
2935 }
2936 #endif
2938 /* Code the LHS, the <expr> from "<expr> IN (...)". If the LHS is a
2939 ** vector, then it is stored in an array of nVector registers starting
2940 ** at r1.
2941 **
2942 ** sqlite3FindInIndex() might have reordered the fields of the LHS vector
2943 ** so that the fields are in the same order as an existing index. The
2944 ** aiMap[] array contains a mapping from the original LHS field order to
2945 ** the field order that matches the RHS index.
2946 */
2951 /* LHS fields are not reordered */
2954 /* Need to reorder the LHS fields according to aiMap */
2958 }
2959 }
2961 /* If sqlite3FindInIndex() did not find or create an index that is
2962 ** suitable for evaluating the IN operator, then evaluate using a
2963 ** sequence of comparisons.
2964 **
2965 ** This is step (1) in the in-operator.md optimized algorithm.
2966 */
2978 }
2983 }
2995 }
2997 }
3001 }
3005 }
3007 /* Step 2: Check to see if the LHS contains any NULL columns. If the
3008 ** LHS does contain NULLs then the result must be either FALSE or NULL.
3009 ** We will then skip the binary search of the RHS.
3010 */
3015 }
3021 }
3022 }
3024 /* Step 3. The LHS is now known to be non-NULL. Do the binary search
3025 ** of the RHS using the LHS as a probe. If found, the result is
3026 ** true.
3027 */
3029 /* In this case, the RHS is the ROWID of table b-tree and so we also
3030 ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4
3031 ** into a single opcode. */
3038 /* Combine Step 3 and Step 5 into a single opcode */
3042 }
3043 /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
3046 }
3048 /* Step 4. If the RHS is known to be non-NULL and we did not find
3049 ** an match on the search above, then the result must be FALSE.
3050 */
3054 }
3056 /* Step 5. If we do not care about the difference between NULL and
3057 ** FALSE, then just return false.
3058 */
3061 /* Step 6: Loop through rows of the RHS. Compare each row to the LHS.
3062 ** If any comparison is NULL, then the result is NULL. If all
3063 ** comparisons are FALSE then the final result is FALSE.
3064 **
3065 ** For a scalar LHS, it is sufficient to check just the first row
3066 ** of the RHS.
3067 */
3074 /* For nVector==1, combine steps 6 and 7 by immediately returning
3075 ** FALSE if the first comparison is not NULL */
3077 }
3089 }
3096 /* Step 7: If we reach this point, we know that the result must
3097 ** be false. */
3099 }
3101 /* Jumps here in order to return true. */
3104 sqlite3ExprCodeIN_finished:
3108 sqlite3ExprCodeIN_oom_error:
3111 }
3114 #ifndef SQLITE_OMIT_FLOATING_POINT
3115 /*
3116 ** Generate an instruction that will put the floating point
3117 ** value described by z[0..n-1] into register iMem.
3118 **
3119 ** The z[] string will probably not be zero-terminated. But the
3120 ** z[n] character is guaranteed to be something that does not look
3121 ** like the continuation of the number.
3122 */
3130 }
3131 }
3132 #endif
3135 /*
3136 ** Generate an instruction that will put the integer describe by
3137 ** text z[0..n-1] into register iMem.
3138 **
3139 ** Expr.u.zToken is always UTF8 and zero-terminated.
3140 */
3150 i64 value;
3155 #ifdef SQLITE_OMIT_FLOATING_POINT
3157 #else
3158 #ifndef SQLITE_OMIT_HEX_INTEGER
3162 #endif
3163 {
3165 }
3166 #endif
3170 }
3171 }
3172 }
3174 /*
3175 ** Erase column-cache entry number i
3176 */
3181 }
3182 }
3186 }
3187 }
3190 /*
3191 ** Record in the column cache that a particular column from a
3192 ** particular table is stored in a particular register.
3193 */
3200 /* Unless an error has occurred, register numbers are always positive. */
3204 /* The SQLITE_ColumnCache flag disables the column cache. This is used
3205 ** for testing only - to verify that SQLite always gets the same answer
3206 ** with and without the column cache.
3207 */
3210 /* First replace any existing entry.
3211 **
3212 ** Actually, the way the column cache is currently used, we are guaranteed
3213 ** that the object will never already be in cache. Verify this guarantee.
3214 */
3215 #ifndef NDEBUG
3218 }
3219 #endif
3221 #ifdef SQLITE_DEBUG_COLUMNCACHE
3222 /* Add a SetTabCol opcode for run-time verification that the column
3223 ** cache is working correctly.
3224 */
3226 #endif
3228 /* If the cache is already full, delete the least recently used entry */
3236 }
3237 }
3241 }
3243 /* Add the new entry to the end of the cache */
3250 }
3252 /*
3253 ** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
3254 ** Purge the range of registers from the column cache.
3255 */
3263 i++;
3264 }
3265 }
3266 }
3268 /*
3269 ** Remember the current column cache context. Any new entries added
3270 ** added to the column cache after this call are removed when the
3271 ** corresponding pop occurs.
3272 */
3275 #ifdef SQLITE_DEBUG
3278 }
3279 #endif
3280 }
3282 /*
3283 ** Remove from the column cache any entries that were added since the
3284 ** the previous sqlite3ExprCachePush operation. In other words, restore
3285 ** the cache to the state it was in prior the most recent Push.
3286 */
3291 #ifdef SQLITE_DEBUG
3294 }
3295 #endif
3300 i++;
3301 }
3302 }
3303 }
3305 /*
3306 ** When a cached column is reused, make sure that its register is
3307 ** no longer available as a temp register. ticket #3879: that same
3308 ** register might be in the cache in multiple places, so be sure to
3309 ** get them all.
3310 */
3317 }
3318 }
3319 }
3321 /* Generate code that will load into register regOut a value that is
3322 ** appropriate for the iIdxCol-th column of index pIdx.
3323 */
3330 ){
3341 }
3342 }
3344 /*
3345 ** Generate code to extract the value of the iCol-th column of a table.
3346 */
3353 ){
3357 }
3365 }
3367 }
3370 }
3371 }
3373 /*
3374 ** Generate code that will extract the iColumn-th column from
3375 ** table pTab and store the column value in a register.
3376 **
3377 ** An effort is made to store the column value in register iReg. This
3378 ** is not garanteeed for GetColumn() - the result can be stored in
3379 ** any register. But the result is guaranteed to land in register iReg
3380 ** for GetColumnToReg().
3381 **
3382 ** There must be an open cursor to pTab in iTable when this routine
3383 ** is called. If iColumn<0 then code is generated that extracts the rowid.
3384 */
3391 u8 p5 /* P5 value for OP_Column + FLAGS */
3392 ){
3401 #ifdef SQLITE_DEBUG_COLUMNCACHE
3403 #endif
3405 }
3406 }
3413 }
3415 }
3422 ){
3425 }
3428 /*
3429 ** Clear all column cache entries.
3430 */
3434 #ifdef SQLITE_DEBUG
3437 }
3438 #endif
3442 ){
3444 }
3445 }
3447 }
3449 /*
3450 ** Record the fact that an affinity change has occurred on iCount
3451 ** registers starting with iStart.
3452 */
3455 }
3457 /*
3458 ** Generate code to move content from registers iFrom...iFrom+nReg-1
3459 ** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
3460 */
3465 }
3467 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
3468 /*
3469 ** Return true if any register in the range iFrom..iTo (inclusive)
3470 ** is used as part of the column cache.
3471 **
3472 ** This routine is used within assert() and testcase() macros only
3473 ** and does not appear in a normal build.
3474 */
3481 }
3483 }
3487 /*
3488 ** Convert a scalar expression node to a TK_REGISTER referencing
3489 ** register iReg. The caller must ensure that iReg already contains
3490 ** the correct value for the expression.
3491 */
3497 }
3499 /*
3500 ** Evaluate an expression (either a vector or a scalar expression) and store
3501 ** the result in continguous temporary registers. Return the index of
3502 ** the first register used to store the result.
3503 **
3504 ** If the returned result register is a temporary scalar, then also write
3505 ** that register number into *piFreeable. If the returned result register
3506 ** is not a temporary or if the expression is a vector set *piFreeable
3507 ** to 0.
3508 */
3517 #if SQLITE_OMIT_SUBQUERY
3519 #else
3521 #endif
3528 }
3529 }
3530 }
3532 }
3535 /*
3536 ** Generate code into the current Vdbe to evaluate the given
3537 ** expression. Attempt to store the results in register "target".
3538 ** Return the register where results are stored.
3539 **
3540 ** With this routine, there is no guarantee that results will
3541 ** be stored in target. The result might be stored in some other
3542 ** register if it is convenient to do so. The calling function
3543 ** must check the return code and move the results to the desired
3544 ** register.
3545 */
3560 }
3562 expr_code_doover:
3567 }
3579 }
3580 /* Otherwise, fall thru into the TK_COLUMN case */
3581 }
3586 /* Generating CHECK constraints or inserting into partial index */
3589 /* Coding an expression that is part of an index where column names
3590 ** in the index refer to the table to which the index belongs */
3592 }
3593 }
3597 }
3601 }
3605 }
3606 #ifndef SQLITE_OMIT_FLOATING_POINT
3611 }
3612 #endif
3617 }
3621 }
3622 #ifndef SQLITE_OMIT_BLOB_LITERAL
3636 }
3637 #endif
3648 }
3650 }
3653 }
3654 #ifndef SQLITE_OMIT_CAST
3656 /* Expressions of the form: CAST(pLeft AS token) */
3661 }
3667 }
3673 /* fall-through */
3696 }
3698 }
3728 }
3735 #ifndef SQLITE_OMIT_FLOATING_POINT
3740 #endif
3749 }
3751 }
3760 }
3772 }
3787 }
3795 }
3797 }
3809 #ifndef SQLITE_OMIT_WINDOWFUNC
3812 }
3813 #endif
3816 /* SQL functions can be expensive. So try to move constant functions
3817 ** out of the inner loop, even if that means an extra OP_Copy. */
3819 }
3825 }
3830 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
3833 }
3834 #endif
3838 }
3840 /* Attempt a direct implementation of the built-in COALESCE() and
3841 ** IFNULL() functions. This avoids unnecessary evaluation of
3842 ** arguments past the first non-NULL argument.
3843 */
3855 }
3858 }
3860 /* The UNLIKELY() function is a no-op. The result is the value
3861 ** of the first argument.
3862 */
3866 }
3868 #ifdef SQLITE_DEBUG
3869 /* The AFFINITY() function evaluates to a string that describes
3870 ** the type affinity of the argument. This is used for testing of
3871 ** the SQLite type logic.
3872 */
3881 }
3882 #endif
3888 }
3891 }
3892 }
3899 }
3901 /* For length() and typeof() functions with a column argument,
3902 ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
3903 ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data
3904 ** loading.
3905 */
3907 u8 exprOp;
3917 }
3918 }
3926 }
3927 #ifndef SQLITE_OMIT_VIRTUALTABLE
3928 /* Possibly overload the function if the first argument is
3929 ** a virtual table column.
3930 **
3931 ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
3932 ** second argument, not the first, as the argument to test to
3933 ** see if it is a column in a virtual table. This is done because
3934 ** the left operand of infix functions (the operand we want to
3935 ** control overloading) ends up as the second argument to the
3936 ** function. The expression "A glob B" is equivalent to
3937 ** "glob(B,A). We want to use the A in "A glob B" to test
3938 ** for function overloading. But we use the B term in "glob(B,A)".
3939 */
3944 }
3945 #endif
3949 }
3950 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
3957 }
3959 #endif
3960 {
3964 }
3967 }
3969 }
3970 #ifndef SQLITE_OMIT_SUBQUERY
3980 }
3982 }
3987 }
3991 ){
3994 }
3996 }
4007 }
4011 /*
4012 ** x BETWEEN y AND z
4013 **
4014 ** This is equivalent to
4015 **
4016 ** x>=y AND x<=z
4017 **
4018 ** X is stored in pExpr->pLeft.
4019 ** Y is stored in pExpr->pList->a[0].pExpr.
4020 ** Z is stored in pExpr->pList->a[1].pExpr.
4021 */
4025 }
4031 }
4034 /* If the opcode is TK_TRIGGER, then the expression is a reference
4035 ** to a column in the new.* or old.* pseudo-tables available to
4036 ** trigger programs. In this case Expr.iTable is set to 1 for the
4037 ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
4038 ** is set to the column of the pseudo-table to read, or to -1 to
4039 ** read the rowid field.
4040 **
4041 ** The expression is implemented using an OP_Param opcode. The p1
4042 ** parameter is set to 0 for an old.rowid reference, or to (i+1)
4043 ** to reference another column of the old.* pseudo-table, where
4044 ** i is the index of the column. For a new.rowid reference, p1 is
4045 ** set to (n+1), where n is the number of columns in each pseudo-table.
4046 ** For a reference to any other column in the new.* pseudo-table, p1
4047 ** is set to (n+2+i), where n and i are as defined previously. For
4048 ** example, if the table on which triggers are being fired is
4049 ** declared as:
4050 **
4051 ** CREATE TABLE t1(a, b);
4052 **
4053 ** Then p1 is interpreted as follows:
4054 **
4055 ** p1==0 -> old.rowid p1==3 -> new.rowid
4056 ** p1==1 -> old.a p1==4 -> new.a
4057 ** p1==2 -> old.b p1==5 -> new.b
4058 */
4071 ));
4073 #ifndef SQLITE_OMIT_FLOATING_POINT
4074 /* If the column has REAL affinity, it may currently be stored as an
4075 ** integer. Use OP_RealAffinity to make sure it is really real.
4076 **
4077 ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to
4078 ** floating point when extracting it from the record. */
4081 ){
4083 }
4084 #endif
4086 }
4091 }
4102 }
4104 /*
4105 ** Form A:
4106 ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4107 **
4108 ** Form B:
4109 ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
4110 **
4111 ** Form A is can be transformed into the equivalent form B as follows:
4112 ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
4113 ** WHEN x=eN THEN rN ELSE y END
4114 **
4115 ** X (if it exists) is in pExpr->pLeft.
4116 ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is
4117 ** odd. The Y is also optional. If the number of elements in x.pList
4118 ** is even, then Y is omitted and the "otherwise" result is NULL.
4119 ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
4120 **
4121 ** The result of the expression is the Ri for the first matching Ei,
4122 ** or if there is no matching Ei, the ELSE term Y, or if there is
4123 ** no ELSE term, NULL.
4124 */
4152 /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
4153 ** The value in regFree1 might get SCopy-ed into the file result.
4154 ** So make sure that the regFree1 register is not reused for other
4155 ** purposes and possibly overwritten. */
4157 }
4165 }
4174 }
4181 }
4186 }
4187 #ifndef SQLITE_OMIT_TRIGGER
4193 );
4198 }
4201 }
4210 }
4213 }
4214 #endif
4215 }
4219 }
4221 /*
4222 ** Factor out the code of the given expression to initialization time.
4223 **
4224 ** If regDest>=0 then the result is always stored in that register and the
4225 ** result is not reusable. If regDest<0 then this routine is free to
4226 ** store the value whereever it wants. The register where the expression
4227 ** is stored is returned. When regDest<0, two identical expressions will
4228 ** code to the same register.
4229 */
4234 ){
4244 }
4245 }
4246 }
4254 }
4257 }
4259 /*
4260 ** Generate code to evaluate an expression and store the results
4261 ** into a register. Return the register number where the results
4262 ** are stored.
4263 **
4264 ** If the register is a temporary register that can be deallocated,
4265 ** then write its number into *pReg. If the result register is not
4266 ** a temporary, then set *pReg to zero.
4267 **
4268 ** If pExpr is a constant, then this routine might generate this
4269 ** code to fill the register in the initialization section of the
4270 ** VDBE program, in order to factor it out of the evaluation loop.
4271 */
4278 ){
4289 }
4290 }
4292 }
4294 /*
4295 ** Generate code that will evaluate expression pExpr and store the
4296 ** results in register target. The results are guaranteed to appear
4297 ** in register target.
4298 */
4310 }
4311 }
4312 }
4314 /*
4315 ** Make a transient copy of expression pExpr and then code it using
4316 ** sqlite3ExprCode(). This routine works just like sqlite3ExprCode()
4317 ** except that the input expression is guaranteed to be unchanged.
4318 */
4324 }
4326 /*
4327 ** Generate code that will evaluate expression pExpr and store the
4328 ** results in register target. The results are guaranteed to appear
4329 ** in register target. If the expression is constant, then this routine
4330 ** might choose to code the expression at initialization time.
4331 */
4337 }
4338 }
4340 /*
4341 ** Generate code that evaluates the given expression and puts the result
4342 ** in register target.
4343 **
4344 ** Also make a copy of the expression results into another "cache" register
4345 ** and modify the expression so that the next time it is evaluated,
4346 ** the result is a copy of the cache register.
4347 **
4348 ** This routine is used for expressions that are used multiple
4349 ** times. They are evaluated once and the results of the expression
4350 ** are reused.
4351 */
4362 }
4364 /*
4365 ** Generate code that pushes the value of every element of the given
4366 ** expression list into a sequence of registers beginning at target.
4367 **
4368 ** Return the number of elements evaluated. The number returned will
4369 ** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF
4370 ** is defined.
4371 **
4372 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
4373 ** filled using OP_SCopy. OP_Copy must be used instead.
4374 **
4375 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
4376 ** factored out into initialization code.
4377 **
4378 ** The SQLITE_ECEL_REF flag means that expressions in the list with
4379 ** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored
4380 ** in registers at srcReg, and so the value can be copied from there.
4381 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
4382 ** are simply omitted rather than being copied from srcReg.
4383 */
4389 u8 flags /* SQLITE_ECEL_* flags */
4390 ){
4402 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
4404 i--;
4405 n--;
4407 #endif
4410 i--;
4411 n--;
4414 }
4425 ){
4429 }
4430 }
4431 }
4432 }
4434 }
4436 /*
4437 ** Generate code for a BETWEEN operator.
4438 **
4439 ** x BETWEEN y AND z
4440 **
4441 ** The above is equivalent to
4442 **
4443 ** x>=y AND x<=z
4444 **
4445 ** Code it as such, taking care to do the common subexpression
4446 ** elimination of x.
4447 **
4448 ** The xJumpIf parameter determines details:
4449 **
4450 ** NULL: Store the boolean result in reg[dest]
4451 ** sqlite3ExprIfTrue: Jump to dest if true
4452 ** sqlite3ExprIfFalse: Jump to dest if false
4453 **
4454 ** The jumpIfNull parameter is ignored if xJumpIf is NULL.
4455 */
4462 ){
4489 /* Mark the expression is being from the ON or USING clause of a join
4490 ** so that the sqlite3ExprCodeTarget() routine will not attempt to move
4491 ** it into the Parse.pConstExpr list. We should use a new bit for this,
4492 ** for clarity, but we are out of bits in the Expr.flags field so we
4493 ** have to reuse the EP_FromJoin bit. Bummer. */
4496 }
4499 /* Ensure adequate test coverage */
4509 }
4511 /*
4512 ** Generate code for a boolean expression such that a jump is made
4513 ** to the label "dest" if the expression is true but execution
4514 ** continues straight thru if the expression is false.
4515 **
4516 ** If the expression evaluates to NULL (neither true nor false), then
4517 ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
4518 **
4519 ** This code depends on the fact that certain token values (ex: TK_EQ)
4520 ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
4521 ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
4522 ** the make process cause these values to align. Assert()s in the code
4523 ** below verify that the numbers are aligned correctly.
4524 */
4546 }
4554 }
4559 }
4574 }
4576 }
4583 /* Fall thru */
4609 }
4620 }
4625 }
4626 #ifndef SQLITE_OMIT_SUBQUERY
4634 }
4635 #endif
4637 default_expr:
4641 /* No-op */
4648 }
4650 }
4651 }
4654 }
4656 /*
4657 ** Generate code for a boolean expression such that a jump is made
4658 ** to the label "dest" if the expression is false but execution
4659 ** continues straight thru if the expression is true.
4660 **
4661 ** If the expression evaluates to NULL (neither true nor false) then
4662 ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
4663 ** is 0.
4664 */
4676 /* The value of pExpr->op and op are related as follows:
4677 **
4678 ** pExpr->op op
4679 ** --------- ----------
4680 ** TK_ISNULL OP_NotNull
4681 ** TK_NOTNULL OP_IsNull
4682 ** TK_NE OP_Eq
4683 ** TK_EQ OP_Ne
4684 ** TK_GT OP_Le
4685 ** TK_LE OP_Gt
4686 ** TK_GE OP_Lt
4687 ** TK_LT OP_Ge
4688 **
4689 ** For other values of pExpr->op, op is undefined and unused.
4690 ** The value of TK_ and OP_ constants are arranged such that we
4691 ** can compute the mapping above using the following expression.
4692 ** Assert()s verify that the computation is correct.
4693 */
4696 /* Verify correct alignment of TK_ and OP_ constants
4697 */
4715 }
4725 }
4730 }
4740 /* IS TRUE and IS NOT FALSE */
4745 /* IS FALSE and IS NOT TRUE */
4748 }
4750 }
4757 /* Fall thru */
4783 }
4792 }
4797 }
4798 #ifndef SQLITE_OMIT_SUBQUERY
4806 }
4808 }
4809 #endif
4811 default_expr:
4815 /* no-op */
4822 }
4824 }
4825 }
4828 }
4830 /*
4831 ** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before
4832 ** code generation, and that copy is deleted after code generation. This
4833 ** ensures that the original pExpr is unchanged.
4834 */
4840 }
4842 }
4844 /*
4845 ** Expression pVar is guaranteed to be an SQL variable. pExpr may be any
4846 ** type of expression.
4847 **
4848 ** If pExpr is a simple SQL value - an integer, real, string, blob
4849 ** or NULL value - then the VDBE currently being prepared is configured
4850 ** to re-prepare each time a new value is bound to variable pVar.
4851 **
4852 ** Additionally, if pExpr is a simple SQL value and the value is the
4853 ** same as that currently bound to variable pVar, non-zero is returned.
4854 ** Otherwise, if the values are not the same or if pExpr is not a simple
4855 ** SQL value, zero is returned.
4856 */
4870 }
4872 }
4875 }
4878 }
4880 /*
4881 ** Do a deep comparison of two expression trees. Return 0 if the two
4882 ** expressions are completely identical. Return 1 if they differ only
4883 ** by a COLLATE operator at the top level. Return 2 if there are differences
4884 ** other than the top-level COLLATE operator.
4885 **
4886 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
4887 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
4888 **
4889 ** The pA side might be using TK_REGISTER. If that is the case and pB is
4890 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
4891 **
4892 ** Sometimes this routine will return 2 even if the two expressions
4893 ** really are equivalent. If we cannot prove that the expressions are
4894 ** identical, we return 2 just to be safe. So if this routine
4895 ** returns 2, then you do not really know for certain if the two
4896 ** expressions are the same. But if you get a 0 or 1 return, then you
4897 ** can be sure the expressions are the same. In the places where
4898 ** this routine is used, it does not hurt to get an extra 2 - that
4899 ** just might result in some slightly slower code. But returning
4900 ** an incorrect 0 or 1 could lead to a malfunction.
4901 **
4902 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
4903 ** pParse->pReprepare can be matched against literals in pB. The
4904 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
4905 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
4906 ** Argument pParse should normally be NULL. If it is not NULL and pA or
4907 ** pB causes a return value of 2.
4908 */
4910 u32 combinedFlags;
4913 }
4916 }
4921 }
4923 }
4927 }
4930 }
4932 }
4940 }
4941 }
4953 }
4954 #ifndef SQLITE_OMIT_WINDOWFUNC
4955 /* Justification for the assert():
4956 ** window functions have p->op==TK_FUNCTION but aggregate functions
4957 ** have p->op==TK_AGG_FUNCTION. So any comparison between an aggregate
4958 ** function and a window function should have failed before reaching
4959 ** this point. And, it is not possible to have a window function and
4960 ** a scalar function with the same name and number of arguments. So
4961 ** if we reach this point, either A and B both window functions or
4962 ** neither are a window functions. */
4967 }
4968 #endif
4969 }
4971 }
4973 /*
4974 ** Compare two ExprList objects. Return 0 if they are identical and
4975 ** non-zero if they differ in any way.
4976 **
4977 ** If any subelement of pB has Expr.iTable==(-1) then it is allowed
4978 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
4979 **
4980 ** This routine might return non-zero for equivalent ExprLists. The
4981 ** only consequence will be disabled optimizations. But this routine
4982 ** must never return 0 if the two ExprList objects are different, or
4983 ** a malfunction will result.
4984 **
4985 ** Two NULL pointers are considered to be the same. But a NULL pointer
4986 ** always differs from a non-NULL pointer.
4987 */
4998 }
5000 }
5002 /*
5003 ** Like sqlite3ExprCompare() except COLLATE operators at the top-level
5004 ** are ignored.
5005 */
5010 iTab);
5011 }
5013 /*
5014 ** Return true if we can prove the pE2 will always be true if pE1 is
5015 ** true. Return false if we cannot complete the proof or if pE2 might
5016 ** be false. Examples:
5017 **
5018 ** pE1: x==5 pE2: x==5 Result: true
5019 ** pE1: x>0 pE2: x==5 Result: false
5020 ** pE1: x=21 pE2: x=21 OR y=43 Result: true
5021 ** pE1: x!=123 pE2: x IS NOT NULL Result: true
5022 ** pE1: x!=?1 pE2: x IS NOT NULL Result: true
5023 ** pE1: x IS NULL pE2: x IS NOT NULL Result: false
5024 ** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false
5025 **
5026 ** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has
5027 ** Expr.iTable<0 then assume a table number given by iTab.
5028 **
5029 ** If pParse is not NULL, then the values of bound variables in pE1 are
5030 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
5031 ** modified to record which bound variables are referenced. If pParse
5032 ** is NULL, then false will be returned if pE1 contains any bound variables.
5033 **
5034 ** When in doubt, return false. Returning true might give a performance
5035 ** improvement. Returning false might cause a performance reduction, but
5036 ** it will always give the correct answer and is hence always safe.
5037 */
5041 }
5045 ){
5047 }
5052 }
5054 }
5056 /*
5057 ** This is the Expr node callback for sqlite3ExprImpliesNotNullRow().
5058 ** If the expression node requires that the table at pWalker->iCur
5059 ** have a non-NULL column, then set pWalker->eCode to 1 and abort.
5060 */
5062 /* This routine is only called for WHERE clause expressions and so it
5063 ** cannot have any TK_AGG_COLUMN entries because those are only found
5064 ** in HAVING clauses. We can get a TK_AGG_FUNCTION in a WHERE clause,
5065 ** but that is an illegal construct and the query will be rejected at
5066 ** a later stage of processing, so the TK_AGG_FUNCTION case does not
5067 ** need to be considered here. */
5094 }
5097 /* Virtual tables are allowed to use constraints like x=NULL. So
5098 ** a term of the form x=y does not prove that y is not null if x
5099 ** is the column of a virtual table */
5114 ){
5116 }
5119 }
5120 }
5122 /*
5123 ** Return true (non-zero) if expression p can only be true if at least
5124 ** one column of table iTab is non-null. In other words, return true
5125 ** if expression p will always be NULL or false if every column of iTab
5126 ** is NULL.
5127 **
5128 ** False negatives are acceptable. In other words, it is ok to return
5129 ** zero even if expression p will never be true of every column of iTab
5130 ** is NULL. A false negative is merely a missed optimization opportunity.
5131 **
5132 ** False positives are not allowed, however. A false positive may result
5133 ** in an incorrect answer.
5134 **
5135 ** Terms of p that are marked with EP_FromJoin (and hence that come from
5136 ** the ON or USING clauses of LEFT JOINS) are excluded from the analysis.
5137 **
5138 ** This routine is used to check if a LEFT JOIN can be converted into
5139 ** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE
5140 ** clause requires that some column of the right table of the LEFT JOIN
5141 ** be non-NULL, then the LEFT JOIN can be safely converted into an
5142 ** ordinary join.
5143 */
5145 Walker w;
5153 }
5155 /*
5156 ** An instance of the following structure is used by the tree walker
5157 ** to determine if an expression can be evaluated by reference to the
5158 ** index only, without having to do a search for the corresponding
5159 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
5160 ** is the cursor for the table.
5161 */
5165 };
5167 /*
5168 ** Check to see if there are references to columns in table
5169 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
5170 ** pWalker->u.pIdxCover->pIdx.
5171 */
5176 ){
5179 }
5181 }
5183 /*
5184 ** Determine if an index pIdx on table with cursor iCur contains will
5185 ** the expression pExpr. Return true if the index does cover the
5186 ** expression and false if the pExpr expression references table columns
5187 ** that are not found in the index pIdx.
5188 **
5189 ** An index covering an expression means that the expression can be
5190 ** evaluated using only the index and without having to lookup the
5191 ** corresponding table entry.
5192 */
5197 ){
5198 Walker w;
5207 }
5210 /*
5211 ** An instance of the following structure is used by the tree walker
5212 ** to count references to table columns in the arguments of an
5213 ** aggregate function, in order to implement the
5214 ** sqlite3FunctionThisSrc() routine.
5215 */
5220 };
5222 /*
5223 ** Count the number of references to columns.
5224 */
5226 /* The NEVER() on the second term is because sqlite3FunctionUsesThisSrc()
5227 ** is always called before sqlite3ExprAnalyzeAggregates() and so the
5228 ** TK_COLUMNs have not yet been converted into TK_AGG_COLUMN. If
5229 ** sqlite3FunctionUsesThisSrc() is used differently in the future, the
5230 ** NEVER() will need to be removed. */
5238 }
5243 }
5244 }
5246 }
5248 /*
5249 ** Determine if any of the arguments to the pExpr Function reference
5250 ** pSrcList. Return true if they do. Also return true if the function
5251 ** has no arguments or has only constant arguments. Return false if pExpr
5252 ** references columns but not columns of tables found in pSrcList.
5253 */
5255 Walker w;
5266 }
5268 /*
5269 ** Add a new element to the pAggInfo->aCol[] array. Return the index of
5270 ** the new element. Return a negative number if malloc fails.
5271 */
5275 db,
5279 &i
5280 );
5282 }
5284 /*
5285 ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
5286 ** the new element. Return a negative number if malloc fails.
5287 */
5291 db,
5295 &i
5296 );
5298 }
5300 /*
5301 ** This is the xExprCallback for a tree walker. It is used to
5302 ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
5303 ** for additional information.
5304 */
5318 /* Check to see if the column is in one of the tables in the FROM
5319 ** clause of the aggregate query */
5326 /* If we reach this point, it means that pExpr refers to a table
5327 ** that is in the FROM clause of the aggregate query.
5328 **
5329 ** Make an entry for the column in pAggInfo->aCol[] if there
5330 ** is not an entry there already.
5331 */
5338 }
5339 }
5342 ){
5361 }
5362 }
5363 }
5366 }
5367 }
5368 /* There is now an entry for pExpr in pAggInfo->aCol[] (either
5369 ** because it was there before or because we just created it).
5370 ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
5371 ** pAggInfo->aCol[] entry.
5372 */
5380 }
5382 }
5386 ){
5387 /* Check to see if pExpr is a duplicate of another aggregate
5388 ** function that is already in the pAggInfo structure
5389 */
5394 }
5395 }
5397 /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
5398 */
5414 }
5415 }
5416 }
5417 /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
5418 */
5426 }
5427 }
5428 }
5430 }
5435 }
5439 }
5441 /*
5442 ** Analyze the pExpr expression looking for aggregate functions and
5443 ** for variables that need to be added to AggInfo object that pNC->pAggInfo
5444 ** points to. Additional entries are made on the AggInfo object as
5445 ** necessary.
5446 **
5447 ** This routine should only be called after the expression has been
5448 ** analyzed by sqlite3ResolveExprNames().
5449 */
5451 Walker w;
5459 }
5461 /*
5462 ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
5463 ** expression list. Return the number of errors.
5464 **
5465 ** If an error is found, the analysis is cut short.
5466 */
5473 }
5474 }
5475 }
5477 /*
5478 ** Allocate a single new register for use to hold some intermediate result.
5479 */
5483 }
5485 }
5487 /*
5488 ** Deallocate a register, making available for reuse for some other
5489 ** purpose.
5490 **
5491 ** If a register is currently being used by the column cache, then
5492 ** the deallocation is deferred until the column cache line that uses
5493 ** the register becomes stale.
5494 */
5503 }
5504 }
5506 }
5507 }
5509 /*
5510 ** Allocate or deallocate a block of nReg consecutive registers.
5511 */
5524 }
5526 }
5531 }
5536 }
5537 }
5539 /*
5540 ** Mark all temporary registers as being unavailable for reuse.
5541 */
5545 }
5547 /*
5548 ** Validate that no temporary register falls within the range of
5549 ** iFirst..iLast, inclusive. This routine is only call from within assert()
5550 ** statements.
5551 */
5552 #ifdef SQLITE_DEBUG
5558 ){
5560 }
5564 }
5565 }
5567 }