12.3. Funciones para cadenas de caracetres

MySQL 5.0

12.3. Funciones para cadenas de caracetres

Las funciones de cadenas de carácteres retornan NULL si la longitud del resultado es mayor que el valor de la variable de sistema max_allowed_packet . Consulte Sección 7.5.2, “Afinar parámetros del servidor”.

Para funciones que operan en posiciones de cadenas de carácteres, la primera posición es la 1.

ASCII(str)

Retorna el valor numérico del carácter más a la izquierda de la cadena de carácteres str. Retorna 0 si str es la cadena vacía. Retorna NULL si str es NULL. ASCII() funciona para carácteres con valores numéricos de 0 a 255.

mysql> SELECT ASCII('2'); -> 50 mysql> SELECT ASCII(2); -> 50 mysql> SELECT ASCII('dx'); -> 100

Consulte la función ORD() .

BIN(N)

Retorna una representación de cadena de carácteres del valor binario de N, donde N es un número muy largo (BIGINT) . Esto es equivalente a CONV(N,10,2). Retorna NULL si N es NULL.

mysql> SELECT BIN(12); -> '1100'

BIT_LENGTH(str)

Retorna la longitud de la cadena de carácteres str en bits.

mysql> SELECT BIT_LENGTH('text'); -> 32

CHAR(N,...)

CHAR() interpreta los argumentos como enteros y retorna la cadena de carácteres que consiste en los carácteres dados por los códigos de tales enteros. Los valores NULL no se tienen en cuenta.

mysql> SELECT CHAR(77,121,83,81,'76'); -> 'MySQL' mysql> SELECT CHAR(77,77.3,'77.3'); -> 'MMM'

CHAR_LENGTH(str)

Retorna la longitud de la cadena de carácteres str, medida en carácteres. Un carácter de múltiples bytes cuenta como un sólo carácter. Esto significa que para una cadena de carácteres que contiene cinco carácteres de dos bytes, LENGTH() retorna 10, mientras CHAR_LENGTH() returna 5.

CHARACTER_LENGTH(str)

CHARACTER_LENGTH() es sinónimo de CHAR_LENGTH().

COMPRESS(string_to_compress)

Comprime una cadena de carácteres. Esta función necesita que MySQL se compile con una biblioteca de compresión como zlib. De otro modo, el valor retornado siempre es NULL. La cadena comprimida puede descomprimirse con UNCOMPRESS().

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

Los contenidos comprimidos se almacenan de la siguiente forma:

Cadenas vacías se almacenan como cadenas vacías.

Cadenas no vacías se almacenan como longitud de cuatros bytes de la cadena descomprimida (los bytes más bajos primero), seguido de la cadena comprimida. Si la cadena acaba con un espacio, se añade un carácter '.' para evitar problemas con eliminación de espacios finales al almacenar en una columna CHAR o VARCHAR . (El uso de CHAR o VARCHAR para almacenar cadenas comprimidas no se recomienda. Es mejor usar una columna BLOB .)

CONCAT(str1,str2,...)

Retorna la cadena resultado de concatenar los argumentos. Retorna NULL si algúna argumento es NULL. Puede tener uno o más argumentos. Si todos los argumentos son cadenas no binarias, el resultado es una cadena no binaria. Si los argumentos incluyen cualquier cadena binaria, el resultado es una cadena binaria. Un argumento numérico se convierte a su forma de cadena binaria equivalente; si quiere evitarlo puede usar conversión de tipos explícita, como en este ejemplo: SELECT CONCAT(CAST(int_col AS CHAR), char_col)

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() significa CONCAT With Separator (CONCAT con separador) y es una forma especial de CONCAT(). El primer argumento es el separador para el resto de argumentos. El separador se añade entre las cadenas a concatenar. El separador puede ser una cadena como el resto de argumentos. Si el separador es NULL, el resultado es NULL. La función evita valores NULL tras el argumento separador.

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'

En MySQL 5.0, CONCAT_WS() no evita cadenas vacías. (Sin embargo, evita NULLs.)

CONV(N,from_base,to_base)

Convierte números entre diferentes bases numéricas. Retorna una representación de cadena de carácters para el número N, convertido de base from_base a base to_base. Retorna NULL si algún argumento es NULL. El argumento N se interpreta como entero, pero puede especificarse como un entero o cadena. La base mínima es 2 y la máxima es 36. Su to_base es un número negativo, N se trata como un número con signo. De otro modo, N se trata como sin signo. CONV() funciona con precisión de 64-bit.

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,...)

Retorna str1 si N = 1, str2 if N = 2, y así. Retorna NULL si N es menor que 1 o mayor que el número de argumentos. ELT() es el complemento de 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]])

Retorna una cadena en que para cada bit del valor bits, puede obtener una cadena on y para cada bit reasignado obtiene una cadena off . Los bits en bits se examinan de derecha a izquierda (de bits menores a mayores). Las cadenas se añaden al resultado de izquierda a derecha, separados por la cadena separator (siendo el carácter por defecto la coma ','). El número de bits examinados se obtiene por number_of_bits (por defecto 64).

mysql> SELECT EXPORT_SET(5,'Y','N',',',4); -> 'Y,N,Y,N' mysql> SELECT EXPORT_SET(6,'1','0',',',10); -> '0,1,1,0,0,0,0,0,0,0'

FIELD(str,str1,str2,str3,...)

Retorna el índice de str en la lista str1, str2, str3, ... . Retorna 0 si no se encuentra str.

Si todos los argumentos de FIELD() son cadenas, todos los argumentos se comparan como cadenas. Si todos los argumentos son números, se comparan como números. De otro modo, los argumentos se comparan como números con doble precisión.

Si str es NULL, el valor retornado es 0 porque NULL falla en comparaciones de comparación con cualquier valor. FIELD() es el complemento de 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)

Retorna un valor en el rango de 1 a N si la cadena str está en la lista de cadenas strlist consistente de N subcadenas. Una lista de cadenas es una cadena compuesta de subcadenas separadas por carácteres ',' . Si el primer argumento es una cadena constante y el segundo es una columna de tipo SET, la función FIND_IN_SET() está optimizada para usar aritmética de bit. Retorna 0 si str no está en strlist o si strlist es la cadena vacía. Retorna NULL si algún argumento es NULL. Esta función no funciona apropiadamente si el primer argumento contiene un carácter de coma (',') .

mysql> SELECT FIND_IN_SET('b','a,b,c,d'); -> 2

HEX(N_or_S)

Si N_OR_S es un número, retorna una cadena representación del valor hexadecimal de N, donde N es un número muy grande (BIGINT) . Esto es equivalente a CONV(N,10,16).

Si N_OR_S es una cadena, esta función retorna una cadena hexadecimal de N_OR_S carácteres, donde cada carácter en N_OR_S se convierte a dos dígitos hexadecimales.

mysql> SELECT HEX(255); -> 'FF' mysql> SELECT 0x616263; -> 'abc' mysql> SELECT HEX('abc'); -> 616263

INSERT(str,pos,len,newstr)

Retorna la cadena str, con la subcadena comenzando en la posición pos y len carácteres reemplazados por la cadena newstr. Retorna la cadena original si pos no está entre la longitud de la cadena. Replaza el resto de la cadena a partir de la posición pos si len no está dentro de la longitud del resto de la cadena. Retorna NULL si cualquier argumento es nulo.

mysql> SELECT INSERT('Quadratic', 3, 4, 'What'); -> 'QuWhattic' mysql> SELECT INSERT('Quadratic', -1, 4, 'What'); -> 'Quadratic' mysql> SELECT INSERT('Quadratic', 3, 100, 'What'); -> 'QuWhat'

Esta función está preparada para funcionar con múltiples bytes.

INSTR(str,substr)

Retorna la posición de la primera ocurrencia de la subcadena substr en la cadena str. Es lo mismo que la forma de dos argumentos de LOCATE(), excepto que el orden de los argumentos es inverso.

mysql> SELECT INSTR('foobarbar', 'bar'); -> 4 mysql> SELECT INSTR('xbar', 'foobar'); -> 0

Esta función puede trabajar con múltiples bytes. En MySQL 5.0, sólo es sensible a mayúsculas si uno de los argumentos es una cadena binaria.

LCASE(str)

LCASE() es sinónimo de LOWER().

LEFT(str,len)

Retorna los len carácteres empezando por la izquierda de la cadena str.

mysql> SELECT LEFT('foobarbar', 5); -> 'fooba'

LENGTH(str)

Retorna la longitud de la cadena str, medida en bytes.Un carácter multi-byte cuenta como múltiples bytes. Esto significa que para cadenas que contengan cinco carácteres de dos bytes, LENGTH() retorna 10, mientras que CHAR_LENGTH() retorna 5.

mysql> SELECT LENGTH('text'); -> 4

LOAD_FILE(file_name)

Lee el fichero y retorna el contenido como cadena de carácteres. El fichero debe estar localizado en el servidor, debe especificar la ruta completa al fichero, y debe tener el privilegio FILE . El fichero debe ser legible por todo el mundo y su tamaño menor a max_allowed_packet bytes.

Si el fichero no existe o no puede ser leído debido a que una de las anteriores condiciones no se cumple, la función retorna NULL.

mysql> UPDATE tbl_name SET blob_column=LOAD_FILE('/tmp/picture') WHERE id=1;

LOCATE(substr,str) , LOCATE(substr,str,pos)

La primera sintaxis retorna la posición de la primera ocurrencia de la subcadena substr en la cadena str. La segunda sintaxis retorna la posición de la primera ocurrencia de la subcadena substr en la cadena str, comanzando en la posición pos. Retorna 0 si substr no está en str.

mysql> SELECT LOCATE('bar', 'foobarbar'); -> 4 mysql> SELECT LOCATE('xbar', 'foobar'); -> 0 mysql> SELECT LOCATE('bar', 'foobarbar',5); -> 7

Esta función trabaja con múltiples bytes. En MySQL 5.0, es sensible a mayúsculas sólo si algún argumento es una cadena binaria.

LOWER(str)

Retorna la cadena str con todos los carácteres cambiados a minúsculas según el mapeo del conjunto de carácteres actual (por defecto es ISO-8859-1 Latin1).

mysql> SELECT LOWER('QUADRATICALLY'); -> 'quadratically'

Esta función funciona con múltiples bytes.

LPAD(str,len,padstr)

Retorna la cadena str, alineado a la izquierda con la cadena padstr a una longitud de len carácteres. Si str es mayor que len, el valor retornado se acorta a len carácteres.

mysql> SELECT LPAD('hi',4,'??'); -> '??hi' mysql> SELECT LPAD('hi',1,'??'); -> 'h'

LTRIM(str)

Retorna la cadena str con los carácteres en blanco iniciales eliminados.

mysql> SELECT LTRIM(' barbar'); -> 'barbar'

Esta función trabaja con múltiples bytes.

MAKE_SET(bits,str1,str2,...)

Retorna un conjunto de valores (una cadena conteniendo subcadenas separadas por carácteres ',' ) consistiendo en cadenas que tienen el bit correspondiente en bits asignado. str1 se corresponde al bit 0, str2 al bit 1, y así. Los valores NULL en str1, str2, ... no se añaden al resultado.

mysql> SELECT MAKE_SET(1,'a','b','c'); -> 'a' mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world'); -> 'hello,world' mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world'); -> 'hello' mysql> SELECT MAKE_SET(0,'a','b','c'); -> ''

MID(str,pos,len)

MID(str,pos,len) es sinónimo de SUBSTRING(str,pos,len).

OCT(N)

Retorna una representación en cadena del valor octal de N, donde N es un número largo (BIGINT). Es equivalente a CONV(N,10,8). Retorna NULL si N es NULL.

mysql> SELECT OCT(12); -> '14'

OCTET_LENGTH(str)

OCTET_LENGTH() es sinónimo de LENGTH().

ORD(str)

Si el carácter más a la izquierda de la cadena str es un carácter multi-byte , retorna el código de ese carácter, calculado a partir del valor numérico de sus bytes usando esta fórmula:

(1st byte code) + (2nd byte code * 256) + (3rd byte code * 256^2) ...

Si el caráctar más a la izquierda no es multi-byte , ORD() retorna el mismo valor que la función ASCII() .

mysql> SELECT ORD('2'); -> 50

POSITION(substr IN str)

POSITION(substr IN str) es sinónimo de LOCATE(substr,str).

QUOTE(str)

Acota una cadena para producir un resultado que puede usarse como un valor con carácteres de escape en un comando SQL. La cadena se retorna rodeado por comillas sencillas y con cada instancia de comilla sencilla ('''), antibarra ('\'), ASCII NUL, y Control-Z predecidos por una antibarra. Si el argumento es NULL, el valor de retorno es la palabra “NULL” sin comillas alrededor.

mysql> SELECT QUOTE('Don\'t!'); -> 'Don\'t!' mysql> SELECT QUOTE(NULL); -> NULL

REPEAT(str,count)

Retorna una cadena consistente de la cadena str repetida count veces. Si count <= 0, retorna una cadena vacía. Retorna NULL si str o count son NULL.

mysql> SELECT REPEAT('MySQL', 3); -> 'MySQLMySQLMySQL'

REPLACE(str,from_str,to_str)

Retorna la cadena str con todas las ocurrencias de la cadena from_str reemplazadas con la cadena to_str.

mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); -> 'WwWwWw.mysql.com'

Esta función trabaja con múltiples bytes.

REVERSE(str)

Retorna la cadena str con el orden de los carácteres invertido.

mysql> SELECT REVERSE('abc'); -> 'cba'

Esta función trabaja con múltiples bytes.

RIGHT(str,len)

Retorna los len carácteres de la derecha de la cadena str.

mysql> SELECT RIGHT('foobarbar', 4); -> 'rbar'

Esta función trabaja con múltiples bytes.

RPAD(str,len,padstr)

Retorna la cadena str, alineada a la derecha con la cadena padstr con una longitud de len carácteres. Si str es mayor que len, el valor de retorno se corta a len carácteres.

mysql> SELECT RPAD('hi',5,'?'); -> 'hi???' mysql> SELECT RPAD('hi',1,'?'); -> 'h'

Esta función trabaja con múltiples bytes.

RTRIM(str)

Retorna la cadena str con los espacios precedentes eliminados.

mysql> SELECT RTRIM('barbar '); -> 'barbar'

Esta función trabaja con múltiples bytes.

SOUNDEX(str)

Retorna una cadena soudex de str. Dos cadenas que suenen igual deben tener cadenas soundex idénticas. Una cadena soundex estándar tiene cuatro carácteres de longitud, pero la función SOUNDEX() retorna una cadena arbitráriamente larga. Puede usar SUBSTRING() en el resultado para obtener una cadena soundex estándar. Todos los carácteres no alfabéticos en str se ignoran. Todos los carácteres alfabéticos internacionales fuera del rango A-Z se tratan como vocales.

mysql> SELECT SOUNDEX('Hello'); -> 'H400' mysql> SELECT SOUNDEX('Quadratically'); -> 'Q36324'

Nota: Esta función implementa el algoritmo Soundex original, no la versión más popular (descrita por D. Hnuth). La diferencia es que la versión original descarta vocales primero y luego duplicados, mientras que la versión mejorada descarta primero los duplicados y luego las vocales.

expr1 SOUNDS LIKE expr2

Es lo mismo que SOUNDEX(expr1) = SOUNDEX(expr2).

SPACE(N)

Retorna la cadena consistente en N carácteres blancos.

mysql> SELECT SPACE(6); -> ' '

SUBSTRING(str,pos) , SUBSTRING(str FROM pos), SUBSTRING(str,pos,len) , SUBSTRING(str FROM pos FOR len)

Las formas sin el arguemnto len retornan una subcadena de la cadena str comenzando en la posición pos. Las formas con el argumento len retornan una subcadena de longitud len a partir de la cadena str, comenzando en la posición pos.Las formas que usan FROM son sintaxis SQL estándard. En MySQL 5.0, es posible usar valores negativos para pos. En este caso, el inicio de la subcadena son pos carácteres a partir del final de la cadena, en lugar del principio. Un valor negativo puede usarse para pos en cualquier de las formas de esta función.

mysql> SELECT SUBSTRING('Quadratically',5); -> 'ratically' mysql> SELECT SUBSTRING('foobarbar' FROM 4); -> 'barbar' mysql> SELECT SUBSTRING('Quadratically',5,6); -> 'ratica' mysql> SELECT SUBSTRING('Sakila', -3); -> 'ila' mysql> SELECT SUBSTRING('Sakila', -5, 3); -> 'aki' mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2); -> 'ki'

Esta función trabaja con múltiples bytes.

Tenga en cuenta que si usa un valor menor a 1 para len, el resultado siempre es una cadena vacía.

SUBSTR() es sinónimo de SUBSTRING().

SUBSTRING_INDEX(str,delim,count)

Retorna la subcadena de la cadena str antes de count ocurrencias del delimitador delim. Si count es positivo, todo a la izquierda del delimitador final (contando desde la izquierda) se retorna. Si count es negativo, todo a la derecha del delimitador final (contando desde la derecha) se retorna.

mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2); -> 'www.mysql' mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2); -> 'mysql.com'

Esta función trabaja con múltiples bytes.

TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM(remstr FROM] str)

Retorna la cadena str con todos los prefijos y/o sufijos remstr eliminados. Si ninguno de los especificadores BOTH, LEADING, o se daTRAILING, BOTH se asumen. Si remstr es opcional y no se especifica, los espacios se eliminan.

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'

Esta función trabaja con múltiples bytes.

UCASE(str)

UCASE() es sinónimo de UPPER().

UNCOMPRESS(string_to_uncompress)

Descomprime una cadena comprimida con la función COMPRESS() . Si el argumento no es un valor comprimido, el resultado es NULL. Esta función necesita que MySQL se compile con una biblioteca de compresión tal como zlib. De otro modo, el valor de retorno siempre es NULL.

mysql> SELECT UNCOMPRESS(COMPRESS('any string')); -> 'any string' mysql> SELECT UNCOMPRESS('any string'); -> NULL

UNCOMPRESSED_LENGTH(compressed_string)

Retorna la longitud de una cadena comprimida antes de la compresión.

mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30))); -> 30

UNHEX(str)

Realiza la operación opuesta a HEX(str). Esto es, interpreta cada par de dígitos hexadecimales en el argumento como números y los convierte al carácter representado por el número. El carácteres resultantes se retornan como cadena binaria.

mysql> SELECT UNHEX('4D7953514C'); -> 'MySQL' mysql> SELECT 0x4D7953514C; -> 'MySQL' mysql> SELECT UNHEX(HEX('string')); -> 'string' mysql> SELECT HEX(UNHEX('1267')); -> '1267'

UPPER(str)

Retorna la cadena str con todos los carácteres cambiados a mayúsculas según el mapeo del conjunto de carácteres actual (por defecto es ISO-8859-1 Latin1).

mysql> SELECT UPPER('Hej'); -> 'HEJ'

Esta función trabaja con múltiples bytes.

12.3.1. Funciones de comparación de cadenas de caracteres

MySQL convierte automáticamente números a cadenas según es necesario y viceversa.

mysql> SELECT 1+'1'; -> 2 mysql> SELECT CONCAT(2,' test'); -> '2 test'

Si quiere convertir un número a cadena explícitamente, use la función CAST() :

mysql> SELECT 38.8, CAST(38.8 AS CHAR); -> 38.8, '38.8'

Si una función de cadenas da una cadena binaria como argumento, la cadena resultante también es binaria. Un número convertido a cadena se trata como cadena binaria (esto es, es sensible a mayúsculas en comparaciones). Esto afecta sólo a comparaciones.

Normalmente, si una expresión en una comparación de cadenas es sensible a mayúsculas, la comparación se realiza con sensibilidad a mayúsculas.

expr LIKE pat [ESCAPE 'escape-char']

Coincidencia de patrones usando comparación mediante expresiones regulares SQL. Retorna 1 (TRUE) o 0 (FALSE). Si expr o pat es NULL, el resultado es NULL.

El patrón no puede ser una cadena literal. Por ejemplo, puede especificarse como expresión de cadena o columna.

Con LIKE puede usar los siguientes dos carácteres comodín en el patrón:

Carácter Descrición

% Coincidencia de cualquier número de carácteres, incluso cero carácteres

_ Coincide exactemente un carácter

mysql> SELECT 'David!' LIKE 'David_'; -> 1 mysql> SELECT 'David!' LIKE '%D%v%'; -> 1

Para testear instancias literales de un carácter comodín, preceda el carácter con el carácter de escape. Si no especifica el carácter ESCAPE , se asume '\' .

Cadena Descrición

\% Coincide un carácter '%'

\_ Coincide un carácter '_'

mysql> SELECT 'David!' LIKE 'David\_'; -> 0 mysql> SELECT 'David_' LIKE 'David\_'; -> 1

Para especificar un carácter de escape distinto, use la cláusula ESCAPE :

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|'; -> 1

Los siguientes dos comandos ilustran que la comparación de cadenas no son sensibles a mayúsculas a no ser que uno de los operandos sea una cadena binaria:

mysql> SELECT 'abc' LIKE 'ABC'; -> 1 mysql> SELECT 'abc' LIKE BINARY 'ABC'; -> 0

En MySQL, LIKE se permite en expresiones numéricas. (Esta es una extensión del SQL estándar LIKE.)

mysql> SELECT 10 LIKE '1%'; -> 1

Nota: Debido a que MySQL usa sintaxis de escape C en cadenas (por ejemplo, '\n' para representar carácter de nueva línea), debe doblar cualquier '\' que use en cadenas LIKE . Por ejemplo, para buscar '\n', especifíquelo como '\\n'. Para buscar '\', especifíquelo como '\\\\'; esto es debido a que las antibarras se eliminan una vez por el parser y otra vez cuando la coincidencia con el patrón se realiza, dejando una única antibarra para comparar.

expr NOT LIKE pat [ESCAPE 'escape-char']

Es lo mismo que NOT (expr LIKE pat [ESCAPE 'escape-char']).

expr NOT REGEXP pat, expr NOT RLIKE pat

Es lo mismo que NOT (expr REGEXP pat).

expr REGEXP pat, expr RLIKE pat

Realiza una comparación de patrones de una expresión de cadena de carácteres expr contra un patrón pat. El patrón puede ser una expresión regular extendida. La sintaxis para expresiones regulares se discute en Apéndice F, Expresiones regulares en MySQL. Retorna 1 si expr coincide con pat, de otro modo retorna 0. Si expr o pat es NULL, el resultado es NULL. RLIKE es un sinónimo de REGEXP, debido a compatibilidad con mSQL.

El patrón no necesita ser una cadena literal. Por ejemplo, puede especificarse como una expresión de cadena o columna.

Nota: Debido a que MySQL usa la sintaxis de escape de C en cadenas (por ejemplo, '\n' para representar una nueva línea), de doblar cualquier '\' que use en sus cadenas REGEXP .

REGEXP no es sensible a mayúsculas, excepto cuando se usa con cadenas binarias.

mysql> SELECT 'Monty!' REGEXP 'm%y%%'; -> 0 mysql> SELECT 'Monty!' REGEXP '.*'; -> 1 mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line'; -> 1 mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A'; -> 1 0 mysql> SELECT 'a' REGEXP '^[a-d]'; -> 1

REGEXP y RLIKE usan el conjunto de carácteres actual (ISO-8859-1 Latin1 por defecto) al decidir el tipo de un carácter. Atención: Estos operadores no pueden trabajar con múltiples bytes.

STRCMP(expr1,expr2)

STRCMP() retorna 0 si las cadenas son idénticas, -1 si el primer argumento es menor que el segundo según el orden actual, y 1 en cualquier otro caso.

mysql> SELECT STRCMP('text', 'text2'); -> -1 mysql> SELECT STRCMP('text2', 'text'); -> 1 mysql> SELECT STRCMP('text', 'text'); -> 0

En MySQL 5.0, STRCMP() usa el conjunto de carácteres actual cuando realizac comparaciones. Esto hace el comportamiento de comparaciones por defecto insensible a mayúsculas a no ser que alguno de los operandos sea una cadena binaria.

previous page start next page

Carácter	Descrición
`%`	Coincidencia de cualquier número de carácteres, incluso cero carácteres
`_`	Coincide exactemente un carácter

Cadena	Descrición
`\%`	Coincide un carácter '`%`'
`\_`	Coincide un carácter '`_`'