SQL string functions are used primarily for string manipulation. The following table details the important string functions −
| Sr.No., SUBSTR()
Returns the substring as specified |
|
|---|---|
| 46 | TRIM()
Removes leading and trailing spaces |
| 47 | UCASE()
Synonym for UPPER() |
| 48 | UNHEX()
Converts each pair of hexadecimal digits to a character |
| 49 | UPPER()
Converts to uppercase |
ASCII(str)
Returns the numeric value of the leftmost character of the string 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 longlong (BIGINT). Esto es equivalente a P(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,…, )
CHAR () interpreta cada argumento N como un entero y devuelve una cadena que consiste en los caracteres dados por los valores de código de esos enteros. Los valores nulos 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 mide en caracteres. Un carácter multi-byte 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)
CHARAC_LENGTH (str)
CHARAC_LENGTH () es un sinónimo de CHAR_LENGTH ().,
CONCAT(str1,str2,…)
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 cualquier cadena binaria, 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 explícito cast, como en este ejemplo −
SQL> SELECT CONCAT('My', 'S', 'QL');+---------------------------------------------------------+| CONCAT('My', 'S', 'QL') |+---------------------------------------------------------+| MySQL |+---------------------------------------------------------+1 row in set (0.00 sec)
CONCAT_WS(separator,str1,str2,…,)
CONCAT_WS () significa concatenar con separador y es una forma especial de CONCAT (). El primer argumento es el separador para el resto de los argumentos. El separador se añade entre las cadenas concatenadas. 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 cualquier argumento es NULL., El argumento N se interpreta como un entero, pero se puede especificar como un 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 signo. 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, str1, str2, str3,…)
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,on,off])
devuelve una cadena tal que por cada bit establecido en los bits de valor, se obtiene una cadena on y por cada bit no establecido en el valor, se obtiene una cadena off. Los Bits en bits se examinan de derecha a izquierda (de bits de orden bajo a bits de orden alto). Las cadenas se agregan al resultado de izquierda a derecha, separadas por la cadena separador (el valor predeterminado es el carácter de 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)
FIELD (str, str1, str2, str3,…,)
devuelve el índice (posición que comienza con 1) de str en el str1, str2, str3,… lista. 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 consiste en 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)
FORMAT(X,D)
SQL> SELECT FORMAT(12332.123456, 4);+---------------------------------------------------------+| FORMAT(12332.123456, 4) |+---------------------------------------------------------+| 12,332.1235 |+---------------------------------------------------------+1 row in set (0.00 sec)
HEX(N_or_S)
Si N_or_S es un número, devuelve una representación de cadena del valor hexadecimal de N, donde N es un longlong (BIGINT) número. Esto es equivalente a P(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)
INSERT(str,pos,len,newstr)
devuelve la cadena str, con la subcadena comenzando en la posición pos y los caracteres len 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 cadena desde la posición pos si len no está dentro de la longitud del resto de la cadena. Devuelve NULL si cualquier 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 substring substr en string str. Esto 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().
LEFT (str,len)
devuelve los caracteres len más a la izquierda de la cadena str, o NULL si cualquier argumento es NULL.
SQL> SELECT LEFT('foobarbar', 5);+---------------------------------------------------------+| LEFT('foobarbar', 5) |+---------------------------------------------------------+| fooba |+---------------------------------------------------------+1 row in set (0.00 sec)
LENGTH(str)
devuelve la longitud de la cadena str, medida en bytes., Un carácter multi-byte cuenta como múltiples 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(file_name)
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 la ruta de acceso completa al archivo y debe tener el privilegio archivo. El archivo debe ser legible por todos y su tamaño 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;...........................................................
LOCATE(substr,str), LOCATE(substr,str,pos)
la primera sintaxis devuelve la posición de la primera aparición de substring substr en string str. La segunda sintaxis devuelve la posición de la primera ocurrencia de substring substr en string 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)
LOWER (str)
devuelve la cadena str con todos los caracteres cambiados a minúsculas de acuerdo con la asignación actual del conjunto de caracteres.
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 a una longitud de caracteres len. Si str es más largo que len, el valor devuelto se acorta a Caracteres len.
SQL> SELECT LPAD('hi',4,'??');+---------------------------------------------------------+| LPAD('hi',4,'??') |+---------------------------------------------------------+| ??hi |+---------------------------------------------------------+1 row in set (0.00 sec)
LTRIM(str)
devuelve la cadena str con los caracteres de espacio inicial eliminados.,
SQL> SELECT LTRIM(' barbar');+---------------------------------------------------------+| LTRIM(' barbar') |+---------------------------------------------------------+| barbar |+---------------------------------------------------------+1 row in set (0.00 sec)
MAKE_SET (bits, str1, str2,…)
devuelve un valor de conjunto (una cadena que contiene subcadenas separadas por .,. caracteres) que consiste en las cadenas que tienen el bit en bits correspondiente establecido. str1 corresponde al bit 0, str2 al bit 1, y así sucesivamente. Valores nulos en str1, str2,… no se añaden 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 un sinónimo de subcadena(str,pos, len).
OCT (n)
devuelve una representación de cadena del valor octal de N, donde N es un número longlong (BIGINT)., Esto es equivalente a P(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 sinónimo de LONGITUD().
ORD (str)
Si el carácter más a la izquierda de la cadena str es un carácter multi-byte, devuelve el código para ese carácter, calculado a partir de los valores numéricos de sus bytes constituyentes utilizando esta fórmula −
(1st byte code)+ (2nd byte code . 256)+ (3rd byte code . 2562) ...
si el carácter más a la izquierda no es un carácter multi-byte, ORD () devuelve el mismo valor que la función ASCII ().,
SQL> SELECT ORD('2');+---------------------------------------------------------+| ORD('2') |+---------------------------------------------------------+| 50 |+---------------------------------------------------------+1 row in set (0.00 sec)
POSITION(substr IN str)
POSITION(substr IN str) es un sinónimo de LOCATE (substr,str).
QUOTE (str)
cita una cadena para producir un resultado que se puede usar como un valor de datos correctamente escapado en una instrucción SQL. La cadena se devuelve encerrada entre comillas simples y con cada instancia de comilla simple (‘), barra invertida (‘\’), ASCII NUL y Control-Z precedida por una barra invertida. Si el argumento es NULL, el valor devuelto es la palabra ‘NULL’ sin encerrar comillas simples.,
SQL> SELECT QUOTE('Don\'t!');+---------------------------------------------------------+| QUOTE('Don\'t!') |+---------------------------------------------------------+| 'Don\'t!' |+---------------------------------------------------------+1 row in set (0.00 sec)
Nota: Compruebe si su instalación tiene algún error con esta función y no utilice esta función.
expr REGEXP pattern
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 usa 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)
Vamos a ver 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 consistente en la cadena str repite un número de veces. Si count 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)
REPLACE(str,from_str,to_str)
devuelve la cadena str con todas las ocurrencias de la cadena from_str reemplazadas 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 invertidos.
SQL> SELECT REVERSE('abcd');+---------------------------------------------------------+| REVERSE('abcd') |+---------------------------------------------------------+| dcba |+---------------------------------------------------------+1 row in set (0.00 sec)
RIGHT(str,len)
devuelve los caracteres len más a la derecha de la cadena str, o NULL si cualquier 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 a una longitud de caracteres len. Si str es más largo que len, el valor devuelto se acorta a Caracteres len.,
SQL> SELECT RPAD('hi',5,'?');+---------------------------------------------------------+| RPAD('hi',5,'?') |+---------------------------------------------------------+| hi??? |+---------------------------------------------------------+1 row in set (0.00 sec)
RTRIM(str)
devuelve la cadena str con caracteres de espacio final eliminados.
SQL> SELECT RTRIM('barbar ');+---------------------------------------------------------+| RTRIM('barbar ') |+---------------------------------------------------------+| barbar |+---------------------------------------------------------+1 row in set (0.00 sec)
SOUNDEX(str)
devuelve una cadena soundex desde str. Dos cuerdas que suenan casi iguales deben tener cuerdas soundex idénticas. Una cadena soundex estándar tiene cuatro caracteres, pero la función SOUNDEX () devuelve una cadena arbitrariamente larga. Puedes usar SUBSTRING () en el resultado para obtener una cadena soundex estándar. Todos los caracteres no alfabéticos en str son ignorados., Todos los caracteres alfabéticos internacionales fuera del rango A-Z 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).
SPACE (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(str1, str2)
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 de acuerdo con 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)
subcadena(str desde pos)
subcadena(str desde pos para 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 caracteres len largos desde string str, comenzando en la posición pos. Las formas que usan FROM Son sintaxis SQL estándar. También es posible utilizar un valor negativo para pos., En este caso, el principio de la subcadena son caracteres pos del final de la cadena, en lugar del principio. Un valor negativo puede ser utilizado para pos en cualquiera de las formas de esta función.
SUBSTRING_INDEX (str,delim,count)
devuelve la subcadena de string antes de contar las ocurrencias 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 al buscar 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( 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.
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 en el argumento como un número y lo convierte en el 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)
UPPER(str)
devuelve la cadena str con todos los caracteres cambiados a mayúsculas de acuerdo con la asignación actual del conjunto de caracteres.
SQL> SELECT UPPER('Allah-hus-samad');+---------------------------------------------------------+| UPPER('Allah-hus-samad') |+---------------------------------------------------------+| ALLAH-HUS-SAMAD |+---------------------------------------------------------+1 row in set (0.00 sec)