12.4 Operators

Menu:
operator-precedence:: Operator Precedence
comparison-operators:: Comparison Functions and Operators
logical-operators:: Logical Operators
assignment-operators:: Assignment Operators

Operators

Name Description Introduced

'&'

Bitwise AND

'>'

Greater than operator

'>>'

Right shift

'>='

Greater than or equal operator

'<'

Less than operator

'<>', '!='

Not equal operator

'<<'

Left shift

'<='

Less than or equal operator

'<=>'

NULL-safe equal to operator

'%', 'MOD'

Modulo operator

'*'

Multiplication operator

'+'

Addition operator

'-'

Minus operator

'-'

Change the sign of the argument

'->'

Return value from JSON column after evaluating path; equivalent to JSON_EXTRACT().

'->>'

Return value 5.7.13 from JSON column
after evaluating path and unquoting the result; equivalent to JSON_UNQUOTE(JSON_EXTRACT()).

'/'

Division operator

':='

Assign a value

'='

Assign a value (as part of a note 'SET': set-variable. statement, or as part of the 'SET' clause in an note 'UPDATE': update. statement)

'='

Equal operator

'^'

Bitwise XOR

'AND', '&&'

Logical AND

'BETWEEN ... AND ...'

Whether a value is within a range of values

'BINARY'

Cast a string to a binary string

'CASE'

Case operator

'DIV'

Integer division

'EXISTS()'

Whether the result of a query contains any rows

'IN()'

Whether a value is within a set of values

'IS'

Test a value against a boolean

'IS NOT'

Test a value against a boolean

'IS NOT NULL'

NOT NULL value test

'IS NULL'

NULL value test

'LIKE'

Simple pattern matching

'NOT', '!'

Negates value

'NOT BETWEEN ... AND ...'

Whether a value is not within a range of values

'NOT EXISTS()'

Whether the result of a query contains no rows

'NOT IN()'

Whether a value is not within a set of values

'NOT LIKE'

Negation of simple pattern matching

'NOT REGEXP'

Negation of REGEXP

'OR', '||'

Logical OR

'REGEXP'

Whether string matches regular expression

'RLIKE'

Whether string matches regular expression

'SOUNDS LIKE'

Compare sounds

'XOR'

Logical XOR

'|'

Bitwise OR

'~'

Bitwise inversion

File: manual.info.tmp, Node: operator-precedence, Next: comparison-operators, Prev: non-typed-operators, Up: non-typed-operators

12.4.1 Operator Precedence

Operator precedences are shown in the following list, from highest precedence to the lowest. Operators that are shown together on a line have the same precedence.

 INTERVAL
 BINARY, COLLATE
 !
 - (unary minus), ~ (unary bit inversion)
 ^
 *, /, DIV, %, MOD
 -, +
 <<, >>
 &
 |
 = (comparison), <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
 BETWEEN, CASE, WHEN, THEN, ELSE
 NOT
 AND, &&
 XOR
 OR, ||
 = (assignment), :=

The precedence of '=' depends on whether it is used as a comparison operator ('=') or as an assignment operator ('='). When used as a comparison operator, it has the same precedence as '<=>', '>=', '>', '<=', '<', '<>', '!=', 'IS', 'LIKE', 'REGEXP', and 'IN()'. When used as an assignment operator, it has the same precedence as ':='. note set-variable::, and note user-variables::, explain how MySQL determines which interpretation of '=' should apply.

For operators that occur at the same precedence level within an expression, evaluation proceeds left to right, with the exception that assignments evaluate right to left.

The precedence and meaning of some operators depends on the SQL mode:

By default, '||' is a logical 'OR' operator. With 'PIPES_AS_CONCAT' enabled, '||' is string concatenation, with a precedence between '^' and the unary operators.
By default, '!' has a higher precedence than 'NOT'. With 'HIGH_NOT_PRECEDENCE' enabled, '!' and 'NOT' have the same precedence.

See *note sql-mode::.

The precedence of operators determines the order of evaluation of terms in an expression. To override this order and group terms explicitly, use parentheses. For example:

 mysql> SELECT 1+2*3;
         -> 7
 mysql> SELECT (1+2)*3;
         -> 9

File: manual.info.tmp, Node: comparison-operators, Next: logical-operators, Prev: operator-precedence, Up: non-typed-operators

12.4.2 Comparison Functions and Operators

Comparison Operators

Name Description

'>' Greater than operator

'>=' Greater than or equal operator

'<' Less than operator

'<>', '!=' Not equal operator

'<=' Less than or equal operator

'<=>' NULL-safe equal to operator

'=' Equal operator

'BETWEEN ... AND Whether a value is within a range of values ...'

'COALESCE()' Return the first non-NULL argument

'EXISTS()' Whether the result of a query contains any rows

'GREATEST()' Return the largest argument

'IN()' Whether a value is within a set of values

'INTERVAL()' Return the index of the argument that is less than the first argument

'IS' Test a value against a boolean

'IS NOT' Test a value against a boolean

'IS NOT NULL' NOT NULL value test

'IS NULL' NULL value test

'ISNULL()' Test whether the argument is NULL

'LEAST()' Return the smallest argument

'LIKE' Simple pattern matching

'NOT BETWEEN ... Whether a value is not within a range of values AND ...'

'NOT EXISTS()' Whether the result of a query contains no rows

'NOT IN()' Whether a value is not within a set of values

'NOT LIKE' Negation of simple pattern matching

'STRCMP()' Compare two strings

Comparison operations result in a value of '1' ('TRUE'), '0' ('FALSE'), or 'NULL'. These operations work for both numbers and strings. Strings are automatically converted to numbers and numbers to strings as necessary.

The following relational comparison operators can be used to compare not only scalar operands, but row operands:

 =  >  <  >=  <=  <>  !=

The descriptions for those operators later in this section detail how they work with row operands. For additional examples of row comparisons in the context of row subqueries, see *note row-subqueries::.

Some of the functions in this section return values other than '1' ('TRUE'), '0' ('FALSE'), or 'NULL'. 'LEAST()' and 'GREATEST()' are examples of such functions; *note type-conversion::, describes the rules for comparison operations performed by these and similar functions for determining their return values.

To convert a value to a specific type for comparison purposes, you can use the 'CAST()' function. String values can be converted to a different character set using 'CONVERT()'. See *note cast-functions::.

By default, string comparisons are not case-sensitive and use the current character set. The default is 'latin1' (cp1252 West European), which also works well for English.

'='

Equal:

  mysql> SELECT 1 = 0;
          -> 0
  mysql> SELECT '0' = 0;
          -> 1
  mysql> SELECT '0.0' = 0;
          -> 1
  mysql> SELECT '0.01' = 0;
          -> 0
  mysql> SELECT '.01' = 0.01;
          -> 1

For row comparisons, '(a, b) = (x, y)' is equivalent to:

  (a = x) AND (b = y)

'<=>'

'NULL'-safe equal. This operator performs an equality comparison like the '=' operator, but returns '1' rather than 'NULL' if both operands are 'NULL', and '0' rather than 'NULL' if one operand is 'NULL'.

The '<=>' operator is equivalent to the standard SQL 'IS NOT DISTINCT FROM' operator.
```
  mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
          -> 1, 1, 0
  mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;
          -> 1, NULL, NULL
```
For row comparisons, '(a, b) <=> (x, y)' is equivalent to:
```
  (a <=> x) AND (b <=> y)
```

'<>', '!='

Not equal:

  mysql> SELECT '.01' <> '0.01';
          -> 1
  mysql> SELECT .01 <> '0.01';
          -> 0
  mysql> SELECT 'zapp' <> 'zappp';
          -> 1

For row comparisons, '(a, b) <> (x, y)' and '(a, b) != (x, y)' are equivalent to:

  (a <> x) OR (b <> y)

'<='

Less than or equal:
```
  mysql> SELECT 0.1 <= 2;
          -> 1
```
For row comparisons, '(a, b) <= (x, y)' is equivalent to:
```
  (a < x) OR ((a = x) AND (b <= y))
```

'<'

Less than:

  mysql> SELECT 2 < 2;
          -> 0

For row comparisons, '(a, b) < (x, y)' is equivalent to:

  (a < x) OR ((a = x) AND (b < y))

'>='

Greater than or equal:
```
  mysql> SELECT 2 >= 2;
          -> 1
```
For row comparisons, '(a, b) >= (x, y)' is equivalent to:
```
  (a > x) OR ((a = x) AND (b >= y))
```

'>'

Greater than:

  mysql> SELECT 2 > 2;
          -> 0

For row comparisons, '(a, b) > (x, y)' is equivalent to:

  (a > x) OR ((a = x) AND (b > y))

'EXPR BETWEEN MIN AND MAX'

If EXPR is greater than or equal to MIN and EXPR is less than or equal to MAX, 'BETWEEN' returns '1', otherwise it returns '0'. This is equivalent to the expression '(MIN <= EXPR AND EXPR <= MAX)' if all the arguments are of the same type. Otherwise type conversion takes place according to the rules described in *note type-conversion::, but applied to all the three arguments.
```
  mysql> SELECT 2 BETWEEN 1 AND 3, 2 BETWEEN 3 and 1;
          -> 1, 0
  mysql> SELECT 1 BETWEEN 2 AND 3;
          -> 0
  mysql> SELECT 'b' BETWEEN 'a' AND 'c';
          -> 1
  mysql> SELECT 2 BETWEEN 2 AND '3';
          -> 1
  mysql> SELECT 2 BETWEEN 2 AND 'x-3';
          -> 0
```
For best results when using 'BETWEEN' with date or time values, use 'CAST()' to explicitly convert the values to the desired data type. Examples: If you compare a note 'DATETIME': datetime. to two note 'DATE': datetime. values, convert the note 'DATE': datetime. values to note 'DATETIME': datetime. values. If you use a string constant such as ''2001-1-1'' in a comparison to a note 'DATE': datetime, cast the string to a note 'DATE': datetime.
'EXPR NOT BETWEEN MIN AND MAX'

This is the same as 'NOT (EXPR BETWEEN MIN AND MAX)'.
'COALESCE(VALUE,...)'

Returns the first non-'NULL' value in the list, or 'NULL' if there are no non-'NULL' values.

The return type of 'COALESCE()' is the aggregated type of the argument types.
```
  mysql> SELECT COALESCE(NULL,1);
          -> 1
  mysql> SELECT COALESCE(NULL,NULL,NULL);
          -> NULL
```

'EXISTS(QUERY)'

Whether the result of a query contains any rows.

  CREATE TABLE t (col VARCHAR(3));
  INSERT INTO t VALUES ('aaa', 'bbb', 'ccc', 'eee');

  SELECT EXISTS (SELECT * FROM t WHERE col LIKE 'c%');
          -> 1

  SELECT EXISTS (SELECT * FROM t WHERE col LIKE 'd%');
          -> 0

'NOT EXISTS(QUERY)'

Whether the result of a query contains no rows:

  SELECT NOT EXISTS (SELECT * FROM t WHERE col LIKE 'c%');
          -> 0

  SELECT NOT EXISTS (SELECT * FROM t WHERE col LIKE 'd%');
          -> 1

'GREATEST(VALUE1,VALUE2,...)'

With two or more arguments, returns the largest (maximum-valued) argument. The arguments are compared using the same rules as for 'LEAST()'.
```
  mysql> SELECT GREATEST(2,0);
          -> 2
  mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
          -> 767.0
  mysql> SELECT GREATEST('B','A','C');
          -> 'C'
```
'GREATEST()' returns 'NULL' if any argument is 'NULL'.
'EXPR IN (VALUE,...)'

Returns '1' (true) if EXPR is equal to any of the values in the 'IN()' list, else returns '0' (false).

Type conversion takes place according to the rules described in *note type-conversion::, applied to all the arguments. If no type conversion is needed for the values in the 'IN()' list, they are all constants of the same type, and EXPR can be compared to each of them as a value of the same type (possibly after type conversion), an optimization takes place. The values the list are sorted and the search for EXPR is done using a binary search, which makes the 'IN()' operation very quick.
```
  mysql> SELECT 2 IN (0,3,5,7);
          -> 0
  mysql> SELECT 'wefwf' IN ('wee','wefwf','weg');
          -> 1
```
'IN()' can be used to compare row constructors:
```
  mysql> SELECT (3,4) IN ((1,2), (3,4));
          -> 1
  mysql> SELECT (3,4) IN ((1,2), (3,5));
          -> 0
```
You should never mix quoted and unquoted values in an 'IN()' list because the comparison rules for quoted values (such as strings) and unquoted values (such as numbers) differ. Mixing types may therefore lead to inconsistent results. For example, do not write an 'IN()' expression like this:
```
  SELECT val1 FROM tbl1 WHERE val1 IN (1,2,'a');
```
Instead, write it like this:
```
  SELECT val1 FROM tbl1 WHERE val1 IN ('1','2','a');
```
Implicit type conversion may produce nonintuitive results:
```
  mysql> SELECT 'a' IN (0), 0 IN ('b');
          -> 1, 1
```
In both cases, the comparison values are converted to floating-point values, yielding 0.0 in each case, and a comparison result of 1 (true).

The number of values in the 'IN()' list is only limited by the 'max_allowed_packet' value.

To comply with the SQL standard, 'IN()' returns 'NULL' not only if the expression on the left hand side is 'NULL', but also if no match is found in the list and one of the expressions in the list is 'NULL'.

'IN()' syntax can also be used to write certain types of subqueries. See *note any-in-some-subqueries::.
'EXPR NOT IN (VALUE,...)'

This is the same as 'NOT (EXPR IN (VALUE,...))'.
'INTERVAL(N,N1,N2,N3,...)'

Returns '0' if N <= N1, '1' if N <= N2 and so on, or '-1' if N is 'NULL'. All arguments are treated as integers. It is required that N1 <= N2 <= N3 <= '...' <= NN for this function to work correctly. This is because a binary search is used (very fast).
```
  mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
          -> 3
  mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
          -> 2
  mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
          -> 0
```
'IS BOOLEAN_VALUE'

Tests a value against a boolean value, where BOOLEAN_VALUE can be 'TRUE', 'FALSE', or 'UNKNOWN'.
```
  mysql> SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;
          -> 1, 1, 1
```
'IS NOT BOOLEAN_VALUE'

Tests a value against a boolean value, where BOOLEAN_VALUE can be 'TRUE', 'FALSE', or 'UNKNOWN'.
```
  mysql> SELECT 1 IS NOT UNKNOWN, 0 IS NOT UNKNOWN, NULL IS NOT UNKNOWN;
          -> 1, 1, 0
```

'IS NULL'

Tests whether a value is 'NULL'.

  mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
          -> 0, 0, 1

To work well with ODBC programs, MySQL supports the following extra features when using 'IS NULL':

* If 'sql_auto_is_null' variable is set to 1, then after a
  statement that successfully inserts an automatically generated
  'AUTO_INCREMENT' value, you can find that value by issuing a
  statement of the following form:

       SELECT * FROM TBL_NAME WHERE AUTO_COL IS NULL

  If the statement returns a row, the value returned is the same
  as if you invoked the 'LAST_INSERT_ID()' function.  For
  details, including the return value after a multiple-row
  insert, see *note information-functions::.  If no
  'AUTO_INCREMENT' value was successfully inserted, the *note
  'SELECT': select. statement returns no row.

  The behavior of retrieving an 'AUTO_INCREMENT' value by using
  an 'IS NULL' comparison can be disabled by setting
  'sql_auto_is_null = 0'.  See *note server-system-variables::.

  The default value of 'sql_auto_is_null' is 0.

* For *note 'DATE': datetime. and *note 'DATETIME': datetime.
  columns that are declared as 'NOT NULL', you can find the
  special date ''0000-00-00'' by using a statement like this:

       SELECT * FROM TBL_NAME WHERE DATE_COLUMN IS NULL

  This is needed to get some ODBC applications to work because
  ODBC does not support a ''0000-00-00'' date value.

  See Obtaining Auto-Increment Values
  (https://dev.mysql.com/doc/connector-odbc/en/connector-odbc-usagenotes-functionality-last-insert-id.html),
  and the description for the 'FLAG_AUTO_IS_NULL' option at
  Connector/ODBC Connection Parameters
  (https://dev.mysql.com/doc/connector-odbc/en/connector-odbc-configuration-connection-parameters.html).

'IS NOT NULL'

Tests whether a value is not 'NULL'.

  mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
          -> 1, 1, 0

'ISNULL(EXPR)'

If EXPR is 'NULL', 'ISNULL()' returns '1', otherwise it returns '0'.
```
  mysql> SELECT ISNULL(1+1);
          -> 0
  mysql> SELECT ISNULL(1/0);
          -> 1
```
'ISNULL()' can be used instead of '=' to test whether a value is 'NULL'. (Comparing a value to 'NULL' using '=' always yields 'NULL'.)

The 'ISNULL()' function shares some special behaviors with the 'IS NULL' comparison operator. See the description of 'IS NULL'.

'LEAST(VALUE1,VALUE2,...)'

With two or more arguments, returns the smallest (minimum-valued) argument. The arguments are compared using the following rules:

* If any argument is 'NULL', the result is 'NULL'.  No
  comparison is needed.

* If all arguments are integer-valued, they are compared as
  integers.

* If at least one argument is double precision, they are
  compared as double-precision values.  Otherwise, if at least
  one argument is a *note 'DECIMAL': fixed-point-types. value,
  they are compared as *note 'DECIMAL': fixed-point-types.
  values.

* If the arguments comprise a mix of numbers and strings, they
  are compared as numbers.

* If any argument is a nonbinary (character) string, the
  arguments are compared as nonbinary strings.

* In all other cases, the arguments are compared as binary
  strings.

The return type of 'LEAST()' is the aggregated type of the comparison argument types.

  mysql> SELECT LEAST(2,0);
          -> 0
  mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
          -> 3.0
  mysql> SELECT LEAST('B','A','C');
          -> 'A'

File: manual.info.tmp, Node: logical-operators, Next: assignment-operators, Prev: comparison-operators, Up: non-typed-operators

12.4.3 Logical Operators

Logical Operators

Name Description

'AND', '&&' Logical AND

'NOT', '!' Negates value

'OR', '||' Logical OR

'XOR' Logical XOR

In SQL, all logical operators evaluate to 'TRUE', 'FALSE', or 'NULL' ('UNKNOWN'). In MySQL, these are implemented as 1 ('TRUE'), 0 ('FALSE'), and 'NULL'. Most of this is common to different SQL database servers, although some servers may return any nonzero value for 'TRUE'.

MySQL evaluates any nonzero, non-'NULL' value to 'TRUE'. For example, the following statements all assess to 'TRUE':

 mysql> SELECT 10 IS TRUE;
 -> 1
 mysql> SELECT -10 IS TRUE;
 -> 1
 mysql> SELECT 'string' IS NOT NULL;
 -> 1

'NOT', '!'

Logical NOT. Evaluates to '1' if the operand is '0', to '0' if the operand is nonzero, and 'NOT NULL' returns 'NULL'.
```
  mysql> SELECT NOT 10;
          -> 0
  mysql> SELECT NOT 0;
          -> 1
  mysql> SELECT NOT NULL;
          -> NULL
  mysql> SELECT ! (1+1);
          -> 0
  mysql> SELECT ! 1+1;
          -> 1
```
The last example produces '1' because the expression evaluates the same way as '(!1)+1'.

'AND', '&&'

Logical AND. Evaluates to '1' if all operands are nonzero and not 'NULL', to '0' if one or more operands are '0', otherwise 'NULL' is returned.

  mysql> SELECT 1 AND 1;
          -> 1
  mysql> SELECT 1 AND 0;
          -> 0
  mysql> SELECT 1 AND NULL;
          -> NULL
  mysql> SELECT 0 AND NULL;
          -> 0
  mysql> SELECT NULL AND 0;
          -> 0

'OR', '||'

Logical OR. When both operands are non-'NULL', the result is '1' if any operand is nonzero, and '0' otherwise. With a 'NULL' operand, the result is '1' if the other operand is nonzero, and 'NULL' otherwise. If both operands are 'NULL', the result is 'NULL'.
```
  mysql> SELECT 1 OR 1;
          -> 1
  mysql> SELECT 1 OR 0;
          -> 1
  mysql> SELECT 0 OR 0;
          -> 0
  mysql> SELECT 0 OR NULL;
          -> NULL
  mysql> SELECT 1 OR NULL;
          -> 1
```
Note:

If the 'PIPES_AS_CONCAT' SQL mode is enabled, '||' signifies the SQL-standard string concatenation operator (like 'CONCAT()').
'XOR'

Logical XOR. Returns 'NULL' if either operand is 'NULL'. For non-'NULL' operands, evaluates to '1' if an odd number of operands is nonzero, otherwise '0' is returned.
```
  mysql> SELECT 1 XOR 1;
          -> 0
  mysql> SELECT 1 XOR 0;
          -> 1
  mysql> SELECT 1 XOR NULL;
          -> NULL
  mysql> SELECT 1 XOR 1 XOR 1;
          -> 1
```
'a XOR b' is mathematically equal to '(a AND (NOT b)) OR ((NOT a) and b)'.

File: manual.info.tmp, Node: assignment-operators, Prev: logical-operators, Up: non-typed-operators

12.4.4 Assignment Operators

Assignment Operators

Name Description

':=' Assign a value

'=' Assign a value (as part of a note 'SET': set-variable. statement, or as part of the 'SET' clause in an note 'UPDATE': update. statement)

':='

Assignment operator. Causes the user variable on the left hand side of the operator to take on the value to its right. The value on the right hand side may be a literal value, another variable storing a value, or any legal expression that yields a scalar value, including the result of a query (provided that this value is a scalar value). You can perform multiple assignments in the same *note 'SET': set-variable. statement. You can perform multiple assignments in the same statement.

Unlike '=', the ':=' operator is never interpreted as a comparison operator. This means you can use ':=' in any valid SQL statement (not just in *note 'SET': set-variable. statements) to assign a value to a variable.
```
  mysql> SELECT @var1, @var2;
          -> NULL, NULL
  mysql> SELECT @var1 := 1, @var2;
          -> 1, NULL
  mysql> SELECT @var1, @var2;
          -> 1, NULL
  mysql> SELECT @var1, @var2 := @var1;
          -> 1, 1
  mysql> SELECT @var1, @var2;
          -> 1, 1

  mysql> SELECT @var1:=COUNT(*) FROM t1;
          -> 4
  mysql> SELECT @var1;
          -> 4
```
You can make value assignments using ':=' in other statements besides note 'SELECT': select, such as note 'UPDATE': update, as shown here:
```
  mysql> SELECT @var1;
          -> 4
  mysql> SELECT * FROM t1;
          -> 1, 3, 5, 7

  mysql> UPDATE t1 SET c1 = 2 WHERE c1 = @var1:= 1;
  Query OK, 1 row affected (0.00 sec)
  Rows matched: 1  Changed: 1  Warnings: 0

  mysql> SELECT @var1;
          -> 1
  mysql> SELECT * FROM t1;
          -> 2, 3, 5, 7
```
While it is also possible both to set and to read the value of the same variable in a single SQL statement using the ':=' operator, this is not recommended. *note user-variables::, explains why you should avoid doing this.
'='

This operator is used to perform value assignments in two cases, described in the next two paragraphs.

Within a note 'SET': set-variable. statement, '=' is treated as an assignment operator that causes the user variable on the left hand side of the operator to take on the value to its right. (In other words, when used in a note 'SET': set-variable. statement, '=' is treated identically to ':='.) The value on the right hand side may be a literal value, another variable storing a value, or any legal expression that yields a scalar value, including the result of a query (provided that this value is a scalar value). You can perform multiple assignments in the same *note 'SET': set-variable. statement.

In the 'SET' clause of an note 'UPDATE': update. statement, '=' also acts as an assignment operator; in this case, however, it causes the column named on the left hand side of the operator to assume the value given to the right, provided any 'WHERE' conditions that are part of the note 'UPDATE': update. are met. You can make multiple assignments in the same 'SET' clause of an *note 'UPDATE': update. statement.

In any other context, '=' is treated as a comparison operator.
```
  mysql> SELECT @var1, @var2;
          -> NULL, NULL
  mysql> SELECT @var1 := 1, @var2;
          -> 1, NULL
  mysql> SELECT @var1, @var2;
          -> 1, NULL
  mysql> SELECT @var1, @var2 := @var1;
          -> 1, 1
  mysql> SELECT @var1, @var2;
          -> 1, 1
```
For more information, see note set-variable::, note update::, and *note subqueries::.

File: manual.info.tmp, Node: flow-control-functions, Next: numeric-functions, Prev: non-typed-operators, Up: functions