[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
String-valued functions return NULL
if the length of the result would
be greater than the max_allowed_packet
server parameter. See section 7.5.2 Tuning Server Parameters.
For functions that operate on string positions, the first position is numbered 1.
ASCII(str)
str
. Returns 0
if str
is the empty string. Returns
NULL
if str
is NULL
:
mysql> SELECT ASCII('2'); -> 50 mysql> SELECT ASCII(2); -> 50 mysql> SELECT ASCII('dx'); -> 100 |
See also the ORD()
function.
BIN(N)
N
, where
N
is a longlong (BIGINT
) number. This is equivalent to
CONV(N,10,2)
. Returns NULL
if N
is NULL
:
mysql> SELECT BIN(12); -> '1100' |
BIT_LENGTH(str)
str
in bits:
mysql> SELECT BIT_LENGTH('text'); -> 32 |
CHAR(N,...)
CHAR()
interprets the arguments as integers and returns a string
consisting of the characters given by the ASCII code values of those
integers. NULL
values are skipped:
mysql> SELECT CHAR(77,121,83,81,'76'); -> 'MySQL' mysql> SELECT CHAR(77,77.3,'77.3'); -> 'MMM' |
CHAR_LENGTH(str)
Returns the length of the string str
, measured in characters.
A multi-byte character counts as a single character.
This means that for a string containing five two-byte characters,
LENGTH()
returns 10
, whereas CHAR_LENGTH()
returns
5
.
CHARACTER_LENGTH(str)
CHARACTER_LENGTH()
is a synonym for CHAR_LENGTH()
.
COMPRESS(string_to_compress)
mysql> SELECT LENGTH(COMPRESS(REPEAT("a",1000))); -> 21 mysql> SELECT LENGTH(COMPRESS("")); -> 0 mysql> SELECT LENGTH(COMPRESS("a")); -> 13 mysql> SELECT LENGTH(COMPRESS(REPEAT("a",16))); -> 15 |
COMPRESS()
was added in MySQL version 4.1.1.
It requires MySQL to have been compiled with a compression library such as
zlib
. Otherwise, the return value is always NULL
.
The compressed string contents are stored the following way:
CHAR
or VARCHAR
column. Use of CHAR
or VARCHAR
to store compressed strings is
not recommended. It is better to use a BLOB
column instead.
CONCAT(str1,str2,...)
NULL
if any argument is NULL
. May have more than two arguments.
A numeric argument is converted to its equivalent string form:
mysql> SELECT CONCAT('My', 'S', 'QL'); -> 'MySQL' mysql> SELECT CONCAT('My', NULL, 'QL'); -> NULL mysql> SELECT CONCAT(14.3); -> '14.3' |
CONCAT_WS(separator, str1, str2,...)
CONCAT_WS()
stands for CONCAT With Separator and is a special form of
CONCAT()
. The first argument is the separator for the rest of the
arguments.
The separator is added between the strings to be concatenated:
The separator can be a string as can the rest of the
arguments. If the separator is NULL
, the result is NULL
.
The function skips any NULL
values after the
separator argument.
mysql> SELECT CONCAT_WS(",","First name","Second name","Last Name"); -> 'First name,Second name,Last Name' mysql> SELECT CONCAT_WS(",","First name",NULL,"Last Name"); -> 'First name,Last Name' |
Before MySQL 4.0.14, CONCAT_WS()
skips empty strings as well as
NULL
values.
CONV(N,from_base,to_base)
N
, converted from base from_base
to base to_base
. Returns NULL
if any argument is NULL
.
The argument N
is interpreted as an integer, but may be specified as
an integer or a string. The minimum base is 2
and the maximum base is
36
. If to_base
is a negative number, N
is regarded as a
signed number. Otherwise, N
is treated as unsigned. CONV
works
with 64-bit precision:
mysql> SELECT CONV("a",16,2); -> '1010' mysql> SELECT CONV("6E",18,8); -> '172' mysql> SELECT CONV(-17,10,-18); -> '-H' mysql> SELECT CONV(10+"10"+'10'+0xa,10,10); -> '40' |
ELT(N,str1,str2,str3,...)
str1
if N
= 1
, str2
if N
=
2
, and so on. Returns NULL
if N
is less than 1
or greater than the number of arguments. ELT()
is the complement of
FIELD()
:
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo'); -> 'ej' mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo'); -> 'foo' |
EXPORT_SET(bits,on,off,[separator,[number_of_bits]])
bits
, you get an on
string and for every reset bit you get an off
string. Each string is
separated by separator
(default ,
), and only
number_of_bits
(default 64) of bits
is used:
mysql> SELECT EXPORT_SET(5,'Y','N',',',4) -> Y,N,Y,N |
FIELD(str,str1,str2,str3,...)
str
in the str1
, str2
,
str3
, ...
list.
Returns 0
if str
is not found.
FIELD()
is the complement of ELT()
:
mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 2 mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 0 |
FIND_IN_SET(str,strlist)
1
to N
if the string str
is in the list
strlist
consisting of N
substrings. A string list is a string
composed of substrings separated by `,' characters. If the first
argument is a constant string and the second is a column of type SET
,
the FIND_IN_SET()
function is optimized to use bit arithmetic!
Returns 0
if str
is not in strlist
or if strlist
is the empty string. Returns NULL
if either argument is NULL
.
This function will not work properly if the first argument contains a comma
`,':
mysql> SELECT FIND_IN_SET('b','a,b,c,d'); -> 2 |
HEX(N_or_S)
If N_OR_S is a number, returns a string representation of the hexadecimal
value of N
, where N
is a longlong (BIGINT
) number.
This is equivalent to CONV(N,10,16)
.
If N_OR_S is a string, returns a hexadecimal string of N_OR_S where each
character in N_OR_S is converted to two hexadecimal digits. This is the
inverse of the 0xff
strings.
mysql> SELECT HEX(255); -> 'FF' mysql> SELECT HEX("abc"); -> 616263 mysql> SELECT 0x616263; -> "abc" |
INSERT(str,pos,len,newstr)
str
, with the substring beginning at position
pos
and len
characters long replaced by the string
newstr
:
mysql> SELECT INSERT('Quadratic', 3, 4, 'What'); -> 'QuWhattic' |
This function is multi-byte safe.
INSTR(str,substr)
substr
in
string str
. This is the same as the two-argument form of
LOCATE()
, except that the arguments are swapped:
mysql> SELECT INSTR('foobarbar', 'bar'); -> 4 mysql> SELECT INSTR('xbar', 'foobar'); -> 0 |
This function is multi-byte safe. In MySQL 3.23 this function is case sensitive, while in 4.0 it's only case sensitive if either argument is a binary string.
LCASE(str)
LCASE()
is a synonym for LOWER()
.
LEFT(str,len)
len
characters from the string str
:
mysql> SELECT LEFT('foobarbar', 5); -> 'fooba' |
LENGTH(str)
str
, measured in bytes.
A multi-byte character counts as multiple bytes.
This means that for a string containing five two-byte characters,
LENGTH()
returns 10
, whereas CHAR_LENGTH()
returns
5
.
mysql> SELECT LENGTH('text'); -> 4 |
LOAD_FILE(file_name)
FILE
privilege. The file must
be readable by all and be smaller than max_allowed_packet
.
If the file doesn't exist or can't be read due to one of these reasons,
the function returns NULL
:
mysql> UPDATE tbl_name SET blob_column=LOAD_FILE("/tmp/picture") WHERE id=1; |
If you are not using MySQL Version 3.23, you have to do the reading
of the file inside your application and create an INSERT
statement
to update the database with the file information. One way to do this, if
you are using the MySQL++ library, can be found at
http://www.mysql.com/documentation/mysql++/mysql++-examples.html.
LOCATE(substr,str)
LOCATE(substr,str,pos)
The first syntax
returns the position of the first occurrence of substring substr
in string str
.
The second syntax
returns the position of the first occurrence of substring substr
in
string str
, starting at position pos
.
Returns 0
if substr
is not in str
.
mysql> SELECT LOCATE('bar', 'foobarbar'); -> 4 mysql> SELECT LOCATE('xbar', 'foobar'); -> 0 mysql> SELECT LOCATE('bar', 'foobarbar',5); -> 7 |
This function is multi-byte safe. In MySQL 3.23 this function is case sensitive, while in 4.0 it's only case sensitive if either argument is a binary string.
LOWER(str)
str
with all characters changed to lowercase
according to the current character set mapping (the default is ISO-8859-1
Latin1):
mysql> SELECT LOWER('QUADRATICALLY'); -> 'quadratically' |
This function is multi-byte safe.
LPAD(str,len,padstr)
str
, left-padded with the string padstr
to a length of len
characters. If str
is longer
than len
, the return value is shortened to len
characters.
mysql> SELECT LPAD('hi',4,'??'); -> '??hi' |
LTRIM(str)
str
with leading space characters removed:
mysql> SELECT LTRIM(' barbar'); -> 'barbar' |
MAKE_SET(bits,str1,str2,...)
bits
set. str1
corresponds to bit 0, str2
to bit 1,
etc. NULL
strings in str1
, str2
, ...
are not appended to the result:
mysql> SELECT MAKE_SET(1,'a','b','c'); -> 'a' mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world'); -> 'hello,world' mysql> SELECT MAKE_SET(0,'a','b','c'); -> '' |
MID(str,pos,len)
MID(str,pos,len)
is a synonym for SUBSTRING(str,pos,len)
.
OCT(N)
N
, where
N
is a longlong number. This is equivalent to CONV(N,10,8)
.
Returns NULL
if N
is NULL
:
mysql> SELECT OCT(12); -> '14' |
OCTET_LENGTH(str)
OCTET_LENGTH()
is a synonym for LENGTH()
.
ORD(str)
str
is a multi-byte character,
returns the code for that character, calculated from the ASCII code values
of its constituent characters using this formula:
((first byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code...]
.
If the leftmost character is not a multi-byte character, returns the same
value that the ASCII()
function does:
mysql> SELECT ORD('2'); -> 50 |
POSITION(substr IN str)
POSITION(substr IN str)
is a synonym for LOCATE(substr,str)
.
QUOTE(str)
NULL
, the return value is the word "NULL" without surrounding
single quotes.
The QUOTE()
function was added in MySQL version 4.0.3.
mysql> SELECT QUOTE("Don't"); -> 'Don\'t!' mysql> SELECT QUOTE(NULL); -> NULL |
REPEAT(str,count)
str
repeated count
times. If count <= 0
, returns an empty string. Returns NULL
if
str
or count
are NULL
:
mysql> SELECT REPEAT('MySQL', 3); -> 'MySQLMySQLMySQL' |
REPLACE(str,from_str,to_str)
str
with all occurrences of the string
from_str
replaced by the string to_str
:
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); -> 'WwWwWw.mysql.com' |
This function is multi-byte safe.
REVERSE(str)
str
with the order of the characters reversed:
mysql> SELECT REVERSE('abc'); -> 'cba' |
This function is multi-byte safe.
RIGHT(str,len)
len
characters from the string str
:
mysql> SELECT RIGHT('foobarbar', 4); -> 'rbar' |
This function is multi-byte safe.
RPAD(str,len,padstr)
str
, right-padded with the string padstr
to a length of len
characters. If str
is longer
than len
, the return value is shortened to len
characters.
mysql> SELECT RPAD('hi',5,'?'); -> 'hi???' |
This function is multi-byte safe.
RTRIM(str)
str
with trailing space characters removed:
mysql> SELECT RTRIM('barbar '); -> 'barbar' |
This function is multi-byte safe.
SOUNDEX(str)
str
. Two strings that sound almost the
same should have identical soundex strings. A standard soundex string
is 4 characters long, but the SOUNDEX()
function returns an
arbitrarily long string. You can use SUBSTRING()
on the result to get
a standard soundex string. All non-alphanumeric characters are ignored
in the given string. All international alpha characters outside the A-Z range
are treated as vowels:
mysql> SELECT SOUNDEX('Hello'); -> 'H400' mysql> SELECT SOUNDEX('Quadratically'); -> 'Q36324' |
expr1 SOUNDS LIKE expr2
Same as SOUNDEX(expr1)=SOUNDEX(expr2)
(available only in version 4.1 or later).
SPACE(N)
N
space characters:
mysql> SELECT SPACE(6); -> ' ' |
SUBSTRING(str,pos)
SUBSTRING(str FROM pos)
SUBSTRING(str,pos,len)
SUBSTRING(str FROM pos FOR len)
The forms without a len
argument
return a substring from string str
starting at position pos
.
The forms with a len
argument
return a substring len
characters long from string str
,
starting at position pos
.
The forms that use FROM
are SQL-92 syntax.
mysql> SELECT SUBSTRING('Quadratically',5); -> 'ratically' mysql> SELECT SUBSTRING('foobarbar' FROM 4); -> 'barbar' mysql> SELECT SUBSTRING('Quadratically',5,6); -> 'ratica' |
This function is multi-byte safe.
SUBSTRING_INDEX(str,delim,count)
str
before count
occurrences of the delimiter delim
.
If count
is positive, everything to the left of the final delimiter
(counting from the left) is returned.
If count
is negative, everything to the right of the final delimiter
(counting from the right) is returned:
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2); -> 'www.mysql' mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2); -> 'mysql.com' |
This function is multi-byte safe.
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
str
with all remstr
prefixes and/or suffixes
removed. If none of the specifiers BOTH
, LEADING
or
TRAILING
is given, BOTH
is assumed. If remstr
is not
specified, spaces are removed:
mysql> SELECT TRIM(' bar '); -> 'bar' mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx'); -> 'barxxx' mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx'); -> 'bar' mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz'); -> 'barx' |
This function is multi-byte safe.
UCASE(str)
UCASE()
is a synonym for UPPER()
.
UNCOMPRESS(string_to_uncompress)
COMPRESS()
function.
mysql> SELECT UNCOMPRESS(COMPRESS("any string")); -> 'any string' |
UNCOMPRESS()
was added in MySQL version 4.1.1.
It requires MySQL to have been compiled with a compression library such as
zlib
. Otherwise, the return value is always NULL
.
UNCOMPRESSED_LENGTH(compressed_string)
mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT("a",30))); -> 30 |
UNCOMPRESSED_LENGTH()
was added in MySQL version 4.1.1.
UPPER(str)
str
with all characters changed to uppercase
according to the current character set mapping (the default is ISO-8859-1
Latin1):
mysql> SELECT UPPER('Hej'); -> 'HEJ' |
This function is multi-byte safe.
12.2.1 String Comparison Functions | ||
12.2.2 Case-Sensitivity |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |