Cast function and operator of mysql function

BINARY

The BINARY operator throws the following string into a binary string. This is a simple way to force column comparisons to be done byte-by-byte rather than character-by-character. This makes the comparison case-sensitive, even if the column is not defined as a BINARY or BLOB. BINARY also produces trailing whitespace, making it more conspicuous.

mysql> SELECT 'a' = 'A';
-> 1
mysql> SELECT BINARY 'a' = 'A';
-> 0
mysql> SELECT 'a' = 'a ';
-> 1
mysql> SELECT BINARY 'a' = 'a ';
-> 0

BINARY affects the entire comparison; it can be given before any operand and produce the same result.

BINARY str is the abbreviation of CAST (str AS BINARY).

Note that in some contexts, if you assign an indexed column to a BINARY, MySQL will not be able to effectively use the index.

If you want to do a case-sensitive comparison of a BLOB value or other binary string, you can do this by taking advantage of the fact that binary strings do not have character sets, so there is no concept of folders. To perform a case-sensitive comparison, use the CONVERT() function to convert a string value to a case-insensitive character set. The result is a non-binary string, so the LIKE operation is not case-sensitive:

SELECT 'A' LIKE CONVERT(blob_col USING latin1) FROM tbl_name;

To use a different character set, replace its latin1 name in the above statement.

CONVERT() can generally be used to compare strings that appear in different character sets.

CAST(expr AS type), CONVERT(expr,type) , CONVERT(expr USING transcoding_name)

CAST() and CONVERT() functions can be used to get a value of one type and produce a value of another type.

This type can be one of the following values:

BINARY[(N)]

CHAR[(N)]

DATE

DATETIME

DECIMAL

SIGNED [INTEGER]

TIME

UNSIGNED [ INTEGER]

BINARY generates a binary string. See the BINARY operator entry in this chapter for a description of how it affects the comparison result.

If an arbitrary length N is given, BINARY[N] causes the cast to use no more than N bytes for this parameter. Likewise, CHAR[N] will cause the cast to use no more than N characters with that argument.

CAST() and CONVERT(... USING...) are standard SQL syntax. The non-USING format of CONVERT() is ofis ODBC syntax.

CONVERT() with USING is used to convert data between different character sets. In MySQL, the auto-decoding name is the same as the corresponding character set name. For example. This statement converts the string 'abc' in the server's default character set into the corresponding string in the utf8 character set:

SELECT CONVERT('abc' USING utf8);

When you want to create a special type of column in a CREATE ... SELECT statement, the cast function Will be useful:

CREATE TABLE new_table SELECT CAST('2000-01-01' AS DATE);

This function is also used to sort ENUM columns in lexical order. Normally sorting of ENUM columns occurs when using internal numeric values. Assigning these values ​​to CHAR in lexical order results:

SELECT enum_col FROM tbl_name ORDER BY CAST(enum_col AS CHAR);

CAST(str AS BINARY) is the same as BINARY str. CAST(expr AS CHAR) treats the expression as a string with the default character set.

If used as part of a more complex expression such as CONCAT('Date: ',CAST(NOW() AS DATE)), CAST() will also change the result.

You should not use CAST() to extract data in different formats, but you can use string functions such as LEFT() or EXTRACT() instead. See "Date and Time Functions".

To assign a string to a numeric value in a numeric context, normally you don’t need to do anything except use the string value as a number:

mysql> SELECT 1+'1';
-> 2

To assign a string value in a numeric context When using a number, the number will be automatically converted into a BINARY string.

mysql> SELECT CONCAT('hello you ',2);
-> 'hello you 2'

MySQL supports operations on signed and unsigned 64-bit values. If you are using a numeric operator (such as +) and one of the operands is an unsigned integer, the result is unsigned. This can be overridden using the SIGNED and UNSIGNED cast operators. Dispatches operations to signed or unsigned 64-bit integers respectively.

mysql> SELECT CAST(1-2 AS UNSIGNED)
-> 18446744073709551615
mysql> SELECT CAST(CAST(1-2 AS UNSIGNED) AS SIGNED);
-> -1

Note that if either operand is a floating point value, the result will be a floating point value and will not be affected by the above rules (for this point, DECIMAL column values ​​are treated as floating point values).

mysql> SELECT CAST(1 AS UNSIGNED) - 2.0;
-> -1.0

If you use a string in an arithmetic operation, it will be converted to a floating point number.