SQL - Funciones de cadena
Las funciones de cadena SQL se utilizan principalmente para la manipulación de cadenas. La siguiente tabla detalla las funciones importantes de las cadenas:
| No Señor. | Función descriptiva |
|---|---|
| 1 | ASCII () Devuelve el valor numérico del carácter más a la izquierda |
| 2 | COMPARTIMIENTO() Devuelve una representación de cadena del argumento. |
| 3 | BIT_LENGTH () Devuelve la longitud del argumento en bits |
| 4 | CHAR_LENGTH () Devuelve el número de caracteres del argumento. |
| 5 | CARBONIZARSE() Devuelve el carácter de cada entero pasado |
| 6 | CHARACTER_LENGTH () Un sinónimo de CHAR_LENGTH () |
| 7 | CONCAT_WS () Devuelve concatenar con separador |
| 8 | CONCAT () Devuelve una cadena concatenada |
| 9 | CONV () Convierte números entre diferentes bases numéricas |
| 10 | ELT () Devuelve la cadena en el número de índice |
| 11 | EXPORT_SET () Devuelve una cadena de modo que por cada bit establecido en los bits de valor, obtiene una cadena de encendido y por cada bit no establecido, obtiene una cadena de apagado |
| 12 | CAMPO() Devuelve el índice (posición) del primer argumento en los argumentos siguientes. |
| 13 | FIND_IN_SET () Devuelve la posición de índice del primer argumento dentro del segundo argumento |
| 14 | FORMATO() Devuelve un número formateado al número especificado de decimales |
| 15 | MALEFICIO() Devuelve una representación de cadena de un valor hexadecimal |
| dieciséis | INSERTAR() Inserta una subcadena en la posición especificada hasta el número especificado de caracteres |
| 17 | INSTR () Devuelve el índice de la primera aparición de subcadena. |
| 18 | LCASE () Sinónimo de LOWER () |
| 19 | IZQUIERDA() Devuelve el número de caracteres más a la izquierda según lo especificado |
| 20 | LONGITUD() Devuelve la longitud de una cadena en bytes. |
| 21 | CARGAR ARCHIVO() Carga el archivo nombrado |
| 22 | LOCALIZAR() Devuelve la posición de la primera aparición de subcadena. |
| 23 | INFERIOR() Devuelve el argumento en minúsculas. |
| 24 | LPAD () Devuelve el argumento de cadena, relleno a la izquierda con la cadena especificada |
| 25 | LTRIM () Elimina los espacios iniciales |
| 26 | MAKE_SET () Devuelve un conjunto de cadenas separadas por comas que tienen el bit correspondiente en bits establecido |
| 27 | MEDIO() Devuelve una subcadena a partir de la posición especificada. |
| 28 | OCT() Devuelve una representación de cadena del argumento octal |
| 29 | OCTET_LENGTH () Un sinónimo de LENGTH () |
| 30 | ORD () Si el carácter más a la izquierda del argumento es un carácter multibyte, devuelve el código para ese carácter |
| 31 | POSICIÓN() Un sinónimo de LOCATE () |
| 32 | CITAR() Escapa del argumento para su uso en una declaración SQL |
| 33 | REGEXP Coincidencia de patrones usando expresiones regulares |
| 34 | REPETIR() Repite una cadena el número de veces especificado |
| 35 | REEMPLAZAR() Reemplaza las ocurrencias de una cadena especificada |
| 36 | CONTRARRESTAR() Invierte los caracteres en una cadena |
| 37 | DERECHO() Devuelve el número de caracteres especificado más a la derecha |
| 38 | RPAD () Agrega la cadena el número de veces especificado |
| 39 | RTRIM () Elimina los espacios finales |
| 40 | SOUNDEX () Devuelve una cadena soundex |
| 41 | SUENA COMO Compara sonidos |
| 42 | ESPACIO() Devuelve una cadena del número especificado de espacios. |
| 43 | STRCMP () Compara dos cadenas |
| 44 | SUBSTRING_INDEX () Devuelve una subcadena de una cadena antes del número especificado de apariciones del delimitador |
| 45 | SUBSTRING (), SUBSTR () Devuelve la subcadena como se especifica |
| 46 | PODAR() Elimina los espacios iniciales y finales |
| 47 | UCASE () Sinónimo de UPPER () |
| 48 | UNHEX () Convierte cada par de dígitos hexadecimales en un carácter |
| 49 | SUPERIOR() Convierte a mayúsculas |
ASCII (str)
Devuelve el valor numérico del carácter situado más a la izquierda de la cadena str. Devuelve 0 si str es la cadena vacía. Devuelve NULL si str es NULL. ASCII () funciona para caracteres con valores numéricos de 0 a 255.
SQL> SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx') |
+---------------------------------------------------------+
| 100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIN (N)
Devuelve una representación de cadena del valor binario de N, donde N es un número largo (BIGINT). Esto es equivalente a CONV (N, 10,2). Devuelve NULL si N es NULL.
SQL> SELECT BIN(12);
+---------------------------------------------------------+
| BIN(12) |
+---------------------------------------------------------+
| 1100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_LENGTH (str)
Devuelve la longitud de la cadena str en bits.
SQL> SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR (N, ... [USANDO charset_name])
CHAR () interpreta cada argumento N como un número entero y devuelve una cadena que consta de los caracteres dados por los valores de código de esos números enteros. Los valores NULL se omiten.
SQL> SELECT CHAR(77,121,83,81,'76');
+---------------------------------------------------------+
| CHAR(77,121,83,81,'76') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR_LENGTH (str)
Devuelve la longitud de la cadena str medida en caracteres. Un carácter de varios bytes cuenta como un solo carácter. Esto significa que para una cadena que contiene cinco caracteres de dos bytes, LENGTH () devuelve 10, mientras que CHAR_LENGTH () devuelve 5.
SQL> SELECT CHAR_LENGTH("text");
+---------------------------------------------------------+
| CHAR_LENGTH("text") |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHARACTER_LENGTH (str)
CHARACTER_LENGTH () es un sinónimo de CHAR_LENGTH ().
CONCAT (cadena1, cadena2, ...)
Devuelve la cadena que resulta de concatenar los argumentos. 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 cadenas binarias, el resultado es una cadena binaria. Un argumento numérico se convierte a su forma de cadena binaria equivalente; si desea evitar eso, puede usar un tipo de conversión explícito, como en este ejemplo:
SQL> SELECT CONCAT('My', 'S', 'QL');
+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONCAT_WS (separador, cadena1, cadena2, ...)
CONCAT_WS () significa Concatenate With Separator y es una forma especial de CONCAT (). El primer argumento es el separador del resto de argumentos. El separador se agrega entre las cadenas que se van a concatenar. El separador puede ser una cadena, al igual que el resto de los argumentos. Si el separador es NULL, el resultado es NULL.
SQL> SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' ) |
+---------------------------------------------------------+
| First name,Last Name |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONV (N, from_base, to_base)
Convierte números entre diferentes bases numéricas. Devuelve una representación de cadena del número N, convertido de base from_base a to_base. Devuelve NULL si algún argumento es NULL. El argumento N se interpreta como un número entero, pero puede especificarse como un número entero o una cadena. La base mínima es 2 y la base máxima es 36. Si to_base es un número negativo, N se considera un número con signo. De lo contrario, N se trata como sin firmar. CONV () funciona con precisión de 64 bits.
SQL> SELECT CONV('a',16,2);
+---------------------------------------------------------+
| CONV('a',16,2) |
+---------------------------------------------------------+
| 1010 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ELT (N, cadena1, cadena2, cadena3, ...)
Devuelve str1 si N = 1, str2 si N = 2, y así sucesivamente. Devuelve NULL si N es menor que 1 o mayor que el número de argumentos. ELT () es el complemento de FIELD ().
SQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| ELT(1, 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| ej |
+---------------------------------------------------------+
1 row in set (0.00 sec)EXPORT_SET (bits, activado, desactivado [, separador [, número_de_bits]])
Devuelve una cadena de modo que por cada bit establecido en los bits de valor, obtiene una cadena de encendido y por cada bit no establecido en el valor, obtiene una cadena de apagado. Los bits en bits se examinan de derecha a izquierda (desde bits de orden inferior a superior). Las cadenas se agregan al resultado de izquierda a derecha, separadas por la cadena de separación (el carácter predeterminado es la coma.,.). El número de bits examinados viene dado por number_of_bits (por defecto es 64).
SQL> SELECT EXPORT_SET(5,'Y','N',',',4);
+---------------------------------------------------------+
| EXPORT_SET(5,'Y','N',',',4) |
+---------------------------------------------------------+
| Y,N,Y,N |
+---------------------------------------------------------+
1 row in set (0.00 sec)CAMPO (cadena, cadena1, cadena2, cadena3, ...)
Devuelve el índice (posición que comienza con 1) de str en la lista str1, str2, str3, ... Devuelve 0 si no se encuentra str.
SQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FIND_IN_SET (str, strlist)
Devuelve un valor en el rango de 1 a N si la cadena str está en la lista de cadenas strlist que consta de N subcadenas.
SQL> SELECT FIND_IN_SET('b','a,b,c,d');
+---------------------------------------------------------+
| SELECT FIND_IN_SET('b','a,b,c,d') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FORMATO (X, D)
Formatea el número X a un formato como '#, ###, ###. ##', redondeado a D lugares decimales, y devuelve el resultado como una cadena. Si D es 0, el resultado no tiene punto decimal ni parte fraccionaria.
SQL> SELECT FORMAT(12332.123456, 4);
+---------------------------------------------------------+
| FORMAT(12332.123456, 4) |
+---------------------------------------------------------+
| 12,332.1235 |
+---------------------------------------------------------+
1 row in set (0.00 sec)HEX (N_o_S)
Si N_or_S es un número, devuelve una representación de cadena del valor hexadecimal de N, donde N es un número largo (BIGINT). Esto es equivalente a CONV (N, 10,16).
Si N_or_S es una cadena, devuelve una representación de cadena hexadecimal de N_or_S donde cada carácter en N_or_S se convierte en dos dígitos hexadecimales.
SQL> SELECT HEX(255);
+---------------------------------------------------------+
| HEX(255) |
+---------------------------------------------------------+
| FF |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT 0x616263;
+---------------------------------------------------------+
| 0x616263 |
+---------------------------------------------------------+
| abc |
+---------------------------------------------------------+
1 row in set (0.00 sec)INSERTAR (str, pos, len, newstr)
Devuelve la cadena str, con la subcadena que comienza en la posición pos y len caracteres reemplazados por la cadena newstr. Devuelve la cadena original si pos no está dentro de la longitud de la cadena. Reemplaza el resto de la cuerda desde la posición pos si len no está dentro de la longitud del resto de la cuerda. Devuelve NULL si algún argumento es NULL.
SQL> SELECT INSERT('Quadratic', 3, 4, 'What');
+---------------------------------------------------------+
| INSERT('Quadratic', 3, 4, 'What') |
+---------------------------------------------------------+
| QuWhattic |
+---------------------------------------------------------+
1 row in set (0.00 sec)INSTR (str, substr)
Devuelve la posición de la primera aparición de subcadena substr en la cadena str. Es lo mismo que la forma de dos argumentos de LOCATE (), excepto que el orden de los argumentos se invierte.
SQL> SELECT INSTR('foobarbar', 'bar');
+---------------------------------------------------------+
| INSTR('foobarbar', 'bar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LCASE (str)
LCASE () es un sinónimo de LOWER ().
IZQUIERDA (str, len)
Devuelve los caracteres len más a la izquierda de la cadena str, o NULL si algún argumento es NULL.
SQL> SELECT LEFT('foobarbar', 5);
+---------------------------------------------------------+
| LEFT('foobarbar', 5) |
+---------------------------------------------------------+
| fooba |
+---------------------------------------------------------+
1 row in set (0.00 sec)LONGITUD (str)
Devuelve la longitud de la cadena str, medida en bytes. Un carácter de varios bytes cuenta como varios bytes. Esto significa que para una cadena que contiene cinco caracteres de dos bytes, LENGTH () devuelve 10, mientras que CHAR_LENGTH () devuelve 5.
SQL> SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOAD_FILE (nombre_archivo)
Lee el archivo y devuelve el contenido del archivo como una cadena. Para usar esta función, el archivo debe estar ubicado en el host del servidor, debe especificar el nombre de ruta completo al archivo y debe tener el privilegio FILE. El archivo debe ser legible para todos y su tamaño debe ser menor que max_allowed_packet bytes.
Si el archivo no existe o no se puede leer porque no se cumple una de las condiciones anteriores, la función devuelve NULL.
A partir de SQL 5.0.19, la variable de sistema character_set_filesystem controla la interpretación de los nombres de archivo que se dan como cadenas literales.
SQL> UPDATE table_test
-> SET blob_col=LOAD_FILE('/tmp/picture')
-> WHERE id=1;
...........................................................UBICAR (substr, str), UBICAR (substr, str, pos)
La primera sintaxis devuelve la posición de la primera aparición de subcadena substr en la cadena str. La segunda sintaxis devuelve la posición de la primera aparición de subcadena substr en la cadena str, comenzando en la posición pos. Devuelve 0 si substr no está en str.
SQL> SELECT LOCATE('bar', 'foobarbar');
+---------------------------------------------------------+
| LOCATE('bar', 'foobarbar') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INFERIOR (str)
Devuelve la cadena str con todos los caracteres cambiados a minúsculas de acuerdo con la asignación del juego de caracteres actual.
SQL> SELECT LOWER('QUADRATICALLY');
+---------------------------------------------------------+
| LOWER('QUADRATICALLY') |
+---------------------------------------------------------+
| quadratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)LPAD (str, len, padstr)
Devuelve la cadena str, rellenada a la izquierda con la cadena padstr hasta una longitud de len caracteres. Si str es más largo que len, el valor de retorno se acorta a len caracteres.
SQL> SELECT LPAD('hi',4,'??');
+---------------------------------------------------------+
| LPAD('hi',4,'??') |
+---------------------------------------------------------+
| ??hi |
+---------------------------------------------------------+
1 row in set (0.00 sec)LTRIM (str)
Devuelve la cadena str con los espacios iniciales eliminados.
SQL> SELECT LTRIM(' barbar');
+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)MAKE_SET (bits, str1, str2, ...)
Devuelve un valor establecido (una cadena que contiene subcadenas separadas por.,. Caracteres) que consta de las cadenas que tienen establecido el bit correspondiente en bits. str1 corresponde al bit 0, str2 al bit 1 y así sucesivamente. Los valores NULL en str1, str2, ... no se agregan al resultado.
SQL> SELECT MAKE_SET(1,'a','b','c');
+---------------------------------------------------------+
| MAKE_SET(1,'a','b','c') |
+---------------------------------------------------------+
| a |
+---------------------------------------------------------+
1 row in set (0.00 sec)MID (str, pos, len)
MID (str, pos, len) es sinónimo de SUBSTRING (str, pos, len).
OCT (N)
Devuelve una representación de cadena del valor octal de N, donde N es un número largo (BIGINT). Esto es equivalente a CONV (N, 10,8). Devuelve NULL si N es NULL.
SQL> SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12) |
+---------------------------------------------------------+
| 14 |
+---------------------------------------------------------+
1 row in set (0.00 sec)OCTET_LENGTH (str)
OCTET_LENGTH () es un sinónimo de LENGTH ().
ORD (str)
Si el carácter situado más a la izquierda de la cadena str es un carácter de varios bytes, devuelve el código para ese carácter, calculado a partir de los valores numéricos de los bytes que lo constituyen utilizando esta fórmula:
(1st byte code)
+ (2nd byte code . 256)
+ (3rd byte code . 2562) ...Si el carácter de la izquierda no es un carácter de varios bytes, ORD () devuelve el mismo valor que la función ASCII ().
SQL> SELECT ORD('2');
+---------------------------------------------------------+
| ORD('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)POSICIÓN (substr IN str)
POSITION (substr IN str) es un sinónimo de LOCATE (substr, str).
CITA (str)
Cita una cadena para producir un resultado que se puede utilizar como un valor de datos correctamente escapado en una declaración SQL. La cadena se devuelve entre comillas simples y con cada instancia de comillas simples ('), barra invertida (' \ '), ASCII NUL y Control-Z precedidas por una barra invertida. Si el argumento es NULL, el valor de retorno es la palabra 'NULL' sin entre comillas simples.
SQL> SELECT QUOTE('Don\'t!');
+---------------------------------------------------------+
| QUOTE('Don\'t!') |
+---------------------------------------------------------+
| 'Don\'t!' |
+---------------------------------------------------------+
1 row in set (0.00 sec)NOTE - Por favor, compruebe si su instalación tiene algún error con esta función y no utilice esta función.
expr patrón REGEXP
Esta función realiza una coincidencia de patrón de expr contra patrón. Devuelve 1 si expr coincide con pat; de lo contrario, devuelve 0. Si expr o pat es NULL, el resultado es NULL. REGEXP no distingue entre mayúsculas y minúsculas, excepto cuando se utiliza con cadenas binarias.
SQL> SELECT 'ABCDEF' REGEXP 'A%C%%';
+---------------------------------------------------------+
| 'ABCDEF' REGEXP 'A%C%%' |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Otro ejemplo es:
SQL> SELECT 'ABCDE' REGEXP '.*';
+---------------------------------------------------------+
| 'ABCDE' REGEXP '.*' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Veamos un ejemplo más:
SQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
+---------------------------------------------------------+
| 'new*\n*line' REGEXP 'new\\*.\\*line' |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)REPETIR (str, count)
Devuelve una cadena que consta de la cadena str repetidas veces. Si el recuento es menor que 1, devuelve una cadena vacía. Devuelve NULL si str o count son NULL.
SQL> SELECT REPEAT('SQL', 3);
+---------------------------------------------------------+
| REPEAT('SQL', 3) |
+---------------------------------------------------------+
| SQLSQLSQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)REEMPLAZAR (str, from_str, to_str)
Devuelve la cadena str con todas las apariciones de la cadena from_str reemplazada por la cadena to_str. REPLACE () realiza una coincidencia que distingue entre mayúsculas y minúsculas al buscar from_str.
SQL> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
+---------------------------------------------------------+
| REPLACE('www.mysql.com', 'w', 'Ww') |
+---------------------------------------------------------+
| WwWwWw.mysql.com |
+---------------------------------------------------------+
1 row in set (0.00 sec)REVERSE (str)
Devuelve la cadena str con el orden de los caracteres invertido.
SQL> SELECT REVERSE('abcd');
+---------------------------------------------------------+
| REVERSE('abcd') |
+---------------------------------------------------------+
| dcba |
+---------------------------------------------------------+
1 row in set (0.00 sec)DERECHA (str, len)
Devuelve los caracteres len más a la derecha de la cadena str, o NULL si algún argumento es NULL.
SQL> SELECT RIGHT('foobarbar', 4);
+---------------------------------------------------------+
| RIGHT('foobarbar', 4) |
+---------------------------------------------------------+
| rbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)RPAD (str, len, padstr)
Devuelve la cadena str, rellenada a la derecha con la cadena padstr hasta una longitud de len caracteres. Si str es más largo que len, el valor de retorno se acorta a len caracteres.
SQL> SELECT RPAD('hi',5,'?');
+---------------------------------------------------------+
| RPAD('hi',5,'?') |
+---------------------------------------------------------+
| hi??? |
+---------------------------------------------------------+
1 row in set (0.00 sec)RTRIM (str)
Devuelve la cadena str con los espacios finales eliminados.
SQL> SELECT RTRIM('barbar ');
+---------------------------------------------------------+
| RTRIM('barbar ') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)SOUNDEX (str)
Devuelve una cadena soundex de str. Dos cuerdas que suenan casi igual deben tener cuerdas soundex idénticas. Una cadena soundex estándar tiene cuatro caracteres, pero la función SOUNDEX () devuelve una cadena arbitrariamente larga. Puede usar SUBSTRING () en el resultado para obtener una cadena soundex estándar. Todos los caracteres no alfabéticos de str se ignoran. Todos los caracteres alfabéticos internacionales fuera del rango AZ se tratan como vocales.
SQL> SELECT SOUNDEX('Hello');
+---------------------------------------------------------+
| SOUNDEX('Hello') |
+---------------------------------------------------------+
| H400 |
+---------------------------------------------------------+
1 row in set (0.00 sec)expr1 suena como expr2
Esto es lo mismo que SOUNDEX (expr1) = SOUNDEX (expr2).
ESPACIO (N)
Devuelve una cadena que consta de N caracteres de espacio.
SQL> SELECT SPACE(6);
+---------------------------------------------------------+
| SELECT SPACE(6) |
+---------------------------------------------------------+
| ' ' |
+---------------------------------------------------------+
1 row in set (0.00 sec)STRCMP (cadena1, cadena2)
Compara dos cadenas y devuelve 0 si ambas cadenas son iguales, devuelve -1 si el primer argumento es más pequeño que el segundo según el orden de clasificación actual; de lo contrario, devuelve 1.
SQL> SELECT STRCMP('MOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'MOHD') |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Otro ejemplo es:
SQL> SELECT STRCMP('AMOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('AMOHD', 'MOHD') |
+---------------------------------------------------------+
| -1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Veamos un ejemplo más:
SQL> SELECT STRCMP('MOHD', 'AMOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'AMOHD') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBSTRING (str, pos)
SUBSTRING (str FROM pos)
SUBSTRING (str, pos, len)
SUBSTRING (str FROM pos FOR len)
Las formas sin un argumento len devuelven una subcadena de la cadena str comenzando en la posición pos. Las formas con un argumento len devuelven una subcadena len caracteres largos desde la cadena str, comenzando en la posición pos. Los formularios que utilizan FROM son sintaxis SQL estándar. También es posible utilizar un valor negativo para pos. En este caso, el comienzo de la subcadena son los caracteres pos del final de la cadena, en lugar del comienzo. Se puede utilizar un valor negativo para pos en cualquiera de las formas de esta función.
SQL> SELECT SUBSTRING('Quadratically',5);
+---------------------------------------------------------+
| SSUBSTRING('Quadratically',5) |
+---------------------------------------------------------+
| ratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT SUBSTRING('foobarbar' FROM 4);
+---------------------------------------------------------+
| SUBSTRING('foobarbar' FROM 4) |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT SUBSTRING('Quadratically',5,6);
+---------------------------------------------------------+
| SUBSTRING('Quadratically',5,6) |
+---------------------------------------------------------+
| ratica |
+---------------------------------------------------------+
1 row in set (0.00 sec)SUBSTRING_INDEX (str, delim, count)
Devuelve la subcadena de la cadena str antes de contar las apariciones del delimitador delim. Si el recuento es positivo, se devuelve todo lo que está a la izquierda del delimitador final (contando desde la izquierda). Si el recuento es negativo, se devuelve todo lo que está a la derecha del delimitador final (contando desde la derecha). SUBSTRING_INDEX () realiza una coincidencia que distingue entre mayúsculas y minúsculas cuando busca delim.
SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
+---------------------------------------------------------+
| SUBSTRING_INDEX('www.mysql.com', '.', 2) |
+---------------------------------------------------------+
| www.mysql |
+---------------------------------------------------------+
1 row in set (0.00 sec)TRIM ([{BOTH | LEADING | TRAILING} [remstr] FROM] str)
RECORTAR ([remstr FROM] str)
Devuelve la cadena str con todos los prefijos o sufijos remstr eliminados. Si no se da ninguno de los especificadores BOTH, LEADING o TRAILING, se asume AMBOS. remstr es opcional y, si no se especifica, se eliminan los espacios.
SQL> SELECT TRIM(' bar ');
+---------------------------------------------------------+
| TRIM(' bar ') |
+---------------------------------------------------------+
| bar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(LEADING 'x' FROM 'xxxbarxxx') |
+---------------------------------------------------------+
| barxxx |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(BOTH 'x' FROM 'xxxbarxxx') |
+---------------------------------------------------------+
| bar |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
+---------------------------------------------------------+
| TRIM(TRAILING 'xyz' FROM 'barxxyz') |
+---------------------------------------------------------+
| barx |
+---------------------------------------------------------+
1 row in set (0.00 sec)UCASE (str)
UCASE () es un sinónimo de UPPER ().
UNHEX (str)
Realiza la operación inversa de HEX (str). Es decir, interpreta cada par de dígitos hexadecimales del argumento como un número y lo convierte al carácter representado por el número. Los caracteres resultantes se devuelven como una cadena binaria.
SQL> SELECT UNHEX('4D7953514C');
+---------------------------------------------------------+
| UNHEX('4D7953514C') |
+---------------------------------------------------------+
| SQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)Los caracteres de la cadena de argumentos deben ser dígitos hexadecimales legales: '0' .. '9', 'A' .. 'F', 'a' .. 'f'. Si UNHEX () encuentra dígitos no hexadecimales en el argumento, devuelve NULL.
SUPERIOR (str)
Devuelve la cadena str con todos los caracteres cambiados a mayúsculas de acuerdo con la asignación del juego de caracteres actual.
SQL> SELECT UPPER('Allah-hus-samad');
+---------------------------------------------------------+
| UPPER('Allah-hus-samad') |
+---------------------------------------------------------+
| ALLAH-HUS-SAMAD |
+---------------------------------------------------------+
1 row in set (0.00 sec)