PostgreSQL - Función de cadena
Las funciones de cadena de PostgreSQL se utilizan principalmente para la manipulación de cadenas. La siguiente tabla detalla las funciones importantes de las cadenas:
| S. No. | Nombre y descripción |
|---|---|
| 1 | ASCII () Devuelve el valor numérico del carácter más a la izquierda |
| 2 | BIT_LENGTH () Devuelve la longitud del argumento en bits |
| 3 | CHAR_LENGTH () Devuelve el número de caracteres del argumento. |
| 4 | CHARACTER_LENGTH () Un sinónimo de CHAR_LENGTH () |
| 5 | CONCAT_WS () Devuelve concatenar con separador |
| 6 | CONCAT () Devuelve una cadena concatenada |
| 7 | LCASE () Sinónimo de LOWER () |
| 8 | IZQUIERDA() Devuelve el número de caracteres más a la izquierda según lo especificado |
| 9 | LONGITUD() Devuelve la longitud de una cadena en bytes. |
| 10 | INFERIOR() Devuelve el argumento en minúsculas. |
| 11 | LPAD () Devuelve el argumento de cadena, relleno a la izquierda con la cadena especificada |
| 12 | LTRIM () Elimina los espacios iniciales |
| 13 | MEDIO() Devuelve una subcadena a partir de la posición especificada. |
| 14 | POSICIÓN() Un sinónimo de LOCATE () |
| 15 | CITAR() Escapa del argumento para su uso en una declaración SQL |
| dieciséis | REGEXP Coincidencia de patrones usando expresiones regulares |
| 17 | REPETIR() Repite una cadena el número especificado de veces |
| 18 | REEMPLAZAR() Reemplaza las ocurrencias de una cadena especificada |
| 19 | CONTRARRESTAR() Invierta los caracteres en una cadena |
| 20 | DERECHO() Devuelve el número de caracteres especificado más a la derecha |
| 21 | RPAD () Agrega la cadena el número especificado de veces |
| 22 | RTRIM () Elimina los espacios finales |
| 24 | SUBSTRING (), SUBSTR () Devuelve la subcadena como se especifica |
| 25 | PODAR() Elimina los espacios iniciales y finales |
| 26 | UCASE () Sinónimo de UPPER () |
| 27 | 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 una cadena vacía. Devuelve NULL si str es NULL. ASCII () funciona para caracteres con valores numéricos de 0 a 255.
testdb=# SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
testdb=# SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx') |
+---------------------------------------------------------+
| 100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_LENGTH (str)
Devuelve la longitud de la cadena str en bits.
testdb=# SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
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.
testdb=# 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:
testdb=# 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.
testdb=# SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' ) |
+---------------------------------------------------------+
| First name, Last Name |
+---------------------------------------------------------+
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.
testdb=# 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.
testdb=# SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 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.
testdb=# 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.
testdb=# 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.
testdb=# SELECT LTRIM(' barbar');
+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)MID (str, pos, len)
MID (str, pos, len) es sinónimo de SUBSTRING (str, pos, len).
POSICIÓN (substr IN str)
POSITION (substr IN str) es un sinónimo de LOCATE (substr, str).
QUOTE_IDENT (texto de cadena), QUOTE_LITERAL (texto de cadena), QUOTE_LITERAL (valor de cualquier elemento), QUOTE_NULLABLE (valor de cualquier elemento)
Todas estas funciones devuelven la cadena dada adecuadamente citada para ser utilizada como un identificador en una cadena de instrucción SQL. En la función QUOTE_IDENT, las cotizaciones se agregan solo si es necesario. En la función QUOTE_LITERAL, las comillas simples y las barras invertidas incorporadas se duplican correctamente. Si se pasa un valor, convierta el valor dado en texto y luego lo cita como literal. La función QUOTE_NULLABLE, convierte el valor dado en texto y luego lo cita como literal; o, si el argumento es nulo, devuelve NULL.
Los siguientes son ejemplos de todas estas funciones:
testdb=# SELECT QUOTE_IDENT('Foo bar');
quote_ident
-------------
"Foo bar"
(1 row)
testdb=# SELECT QUOTE_LITERAL(E'O\'Reilly');
quote_literal
---------------
'O''Reilly'
(1 row)
testdb=# SELECT QUOTE_LITERAL(42.5);
quote_literal
---------------
'42.5'
(1 row)
testdb=# SELECT QUOTE_NULLABLE(42.5);
quote_nullable
----------------
'42.5'
(1 row)expr patrón REGEXP
La función REGEXP_MATCHES (texto de cadena, texto de patrón [, texto de banderas]) 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_MATCHES no distingue entre mayúsculas y minúsculas, excepto cuando se usa con cadenas binarias.
La función REGEXP_REPLACE (texto de cadena, texto de patrón, texto de reemplazo [, texto de marcas]) reemplaza la (s) subcadena (s) que coinciden con una expresión regular POSIX.
REGEXP_SPLIT_TO_ARRAY (texto de cadena, texto de patrón [, texto de marcas]), Dividir cadena usando una expresión regular POSIX como delimitador.
REGEXP_SPLIT_TO_TABLE (texto de cadena, texto de patrón [, texto de marcas]), divide la cadena utilizando una expresión regular POSIX como delimitador.
Los siguientes son ejemplos de todas estas funciones:
testdb=# SELECT REGEXP_MATCHES('ABCDEF','A%C%%');
regexp_matches
----------------
(0 rows)
testdb=# SELECT REGEXP_REPLACE('Thomas', '.[mN]a.', 'M');
regexp_replace
----------------
ThM
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_ARRAY('hello world', E'\\s+');
regexp_split_to_array
-----------------------
{hello,world}
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_TABLE('hello world', E'\\s+');
regexp_split_to_table
-----------------------
hello
world
(2 rows)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.
testdb=# SELECT REPEAT('SQL', 3);
repeat
-----------
SQLSQLSQL
(1 row)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.
testdb=# SELECT REPLACE('www.mysql.com', 'w', 'Ww');
replace
------------------
WwWwWw.mysql.com
(1 row)REVERSE (str)
Devuelve la cadena str con el orden de los caracteres invertido.
testdb=# SELECT REVERSE('abcd');
reverse
---------
dcba
(1 row)DERECHA (str, len)
Devuelve los caracteres len más a la derecha de la cadena str, o NULL si algún argumento es NULL.
testdb=# SELECT RIGHT('foobarbar', 4);
right
-------
rbar
(1 row)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.
testdb=# SELECT RPAD('hi',5,'?');
rpad
-------
hi???
(1 row)RTRIM (str)
Devuelve la cadena str con los espacios finales eliminados.
testdb=# SELECT RTRIM('barbar ');
rtrim
--------
barbar
(1 row)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.
testdb=# SELECT SUBSTRING('Quadratically',5);
substring
-----------
ratically
(1 row)
testdb=# SELECT SUBSTRING('foobarbar' FROM 4);
substring
-----------
barbar
(1 row)
testdb=# SELECT SUBSTRING('Quadratically',5,6);
substring
-----------
ratica
(1 row)TRIM ([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM ([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.
testdb=# SELECT TRIM(' bar ');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
ltrim
--------
barxxx
(1 row)
testdb=# SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
rtrim
-------
bar
(1 row)UCASE (str)
UCASE () es un sinónimo de UPPER ().
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.
testdb=# SELECT UPPER('manisha');
upper
---------
MANISHA
(1 row)