Curso de MariaDB Desde la Consola/StringFunciones
Ir a la navegación
Ir a la búsqueda
- String Funciones
- ASCII
- BIN
- BINARY OPERATOR
- BIT_LENGTH
- CAST
- CHAR
- CHARACTER_LENGTH
- CHAR_LENGTH
- CONCAT
- CONCAT_WS
- CONVERT
- ELT
- FIELD
- FIND_IN_SET
- FORMAT
- HEX
- INSERT
- INSTR
- LCASE
- LEFT
- LENGTH
- LOCATE
- LOWER
- LPAD
- QUOTE
- LTRIM
- MID
- POSITION
- REPEAT
- REPLACE
- REVERSE
- RIGHT
- RPAD
- RTRIM
- STRCMP
- TRIM
- UCASE
- UPPER
String Funciones
ASCII
Sintaxis
ASCII(str)
Description
Devuelve el valor ASCII carácter más a la izquierda en la cadena str.
Devuelve 0 si str está vacía y NULL si str es NULL.
ASCII () funciona de caracteres de 8 bits.
Ejemplos
[rrc@Pwyr ~]$ mysql -u rrc -p
Enter password:
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MariaDB connection id is 7
Server version: 10.0.25-MariaDB Mageia MariaDB Server
Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]> SELECT ASCII(9);
+----------+
| ASCII(9) |
+----------+
| 57 |
+----------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT ASCII('9');
+------------+
| ASCII('9') |
+------------+
| 57 |
+------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT ASCII('abc');
+--------------+
| ASCII('abc') |
+--------------+
| 97 |
+--------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT ASCII("Char ¡");
+------------------+
| ASCII("Char ¡") |
+------------------+
| 67 |
+------------------+
1 row in set (0.00 sec)
ASCII is the American Standard Code for Information Interchange. It is
a 7-bit code. Many 8-bit codes (e.g., ISO 8859-1) contain ASCII as
their lower half. The international counterpart of ASCII is known as
ISO 646-IRV.
The following table contains the 128 ASCII characters.
C program '\X' escapes are noted.
Oct Dec Hex Char Oct Dec Hex Char
────────────────────────────────────────────────────────────────────────
000 0 00 NUL '\0' (null character) 100 64 40 @
001 1 01 SOH (start of heading) 101 65 41 A
002 2 02 STX (start of text) 102 66 42 B
003 3 03 ETX (end of text) 103 67 43 C
004 4 04 EOT (end of transmission) 104 68 44 D
005 5 05 ENQ (enquiry) 105 69 45 E
006 6 06 ACK (acknowledge) 106 70 46 F
007 7 07 BEL '\a' (bell) 107 71 47 G
010 8 08 BS '\b' (backspace) 110 72 48 H
011 9 09 HT '\t' (horizontal tab) 111 73 49 I
012 10 0A LF '\n' (new line) 112 74 4A J
013 11 0B VT '\v' (vertical tab) 113 75 4B K
014 12 0C FF '\f' (form feed) 114 76 4C L
015 13 0D CR '\r' (carriage ret) 115 77 4D M
016 14 0E SO (shift out) 116 78 4E N
017 15 0F SI (shift in) 117 79 4F O
020 16 10 DLE (data link escape) 120 80 50 P
021 17 11 DC1 (device control 1) 121 81 51 Q
022 18 12 DC2 (device control 2) 122 82 52 R
023 19 13 DC3 (device control 3) 123 83 53 S
024 20 14 DC4 (device control 4) 124 84 54 T
025 21 15 NAK (negative ack.) 125 85 55 U
026 22 16 SYN (synchronous idle) 126 86 56 V
027 23 17 ETB (end of trans. blk) 127 87 57 W
030 24 18 CAN (cancel) 130 88 58 X
031 25 19 EM (end of medium) 131 89 59 Y
032 26 1A SUB (substitute) 132 90 5A Z
033 27 1B ESC (escape) 133 91 5B [
034 28 1C FS (file separator) 134 92 5C \ '\\'
035 29 1D GS (group separator) 135 93 5D ]
036 30 1E RS (record separator) 136 94 5E ^
037 31 1F US (unit separator) 137 95 5F _
040 32 20 SPACE 140 96 60 `
041 33 21 ! 141 97 61 a
042 34 22 " 142 98 62 b
043 35 23 # 143 99 63 c
044 36 24 $ 144 100 64 d
045 37 25 % 145 101 65 e
046 38 26 & 146 102 66 f
047 39 27 ' 147 103 67 g
050 40 28 ( 150 104 68 h
051 41 29 ) 151 105 69 i
052 42 2A * 152 106 6A j
053 43 2B + 153 107 6B k
054 44 2C , 154 108 6C l
055 45 2D - 155 109 6D m
056 46 2E . 156 110 6E n
057 47 2F / 157 111 6F o
060 48 30 0 160 112 70 p
061 49 31 1 161 113 71 q
062 50 32 2 162 114 72 r
063 51 33 3 163 115 73 s
064 52 34 4 164 116 74 t
065 53 35 5 165 117 75 u
066 54 36 6 166 118 76 v
067 55 37 7 167 119 77 w
070 56 38 8 170 120 78 x
071 57 39 9 171 121 79 y
072 58 3A : 172 122 7A z
073 59 3B ; 173 123 7B {
074 60 3C < 174 124 7C |
075 61 3D = 175 125 7D }
076 62 3E > 176 126 7E ~
077 63 3F ? 177 127 7F DEL
BIN
Sintaxis BIN( N ) Description Devuelve una cadena que representa el valor binario de N, donde N es un número longlong (BIGINT). Esto es equivalente a CONV( N, 10,2 ). N debe ser positivo. Si N es un float, se truncará. Retorna NULL si N es NULL. Ejemplos MariaDB [(none)]> SELECT BIN( 12 ); +-----------+ | BIN( 12 ) | +-----------+ | 1100 | +-----------+ 1 row in set (0.02 sec) MariaDB [(none)]> SELECT BIN( 12.3 ); +-------------+ | BIN( 12.3 ) | +-------------+ | 1100 | +-------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT BIN( -12.3 ); +------------------------------------------------------------------+ | BIN( -12.3 ) | +------------------------------------------------------------------+ | 1111111111111111111111111111111111111111111111111111111111110100 | +------------------------------------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT BIN( ); ERROR 1582 (42000): Incorrect parameter count in the call to native function 'BIN' MariaDB [(none)]> SELECT BIN( NULL ); +-------------+ | BIN( NULL ) | +-------------+ | NULL | +-------------+ 1 row in set (0.00 sec)
BINARY
Sintaxis BINARY Descripción El operador BINARY casts la cadena que sigue a una cadena binaria. Esta es una manera fácil de forzar una comparación columna para hacerse byte por byte en lugar de caracter por caracter. Esto hace que la comparación sea sensible a mayúsculas incluso si la columna no se define como binario o BLOB. BINARIO también provoca que los espacios finales sea significativa. Ejemplos MariaDB [(none)]> SELECT 'a' = 'A'; +-----------+ | 'a' = 'A' | +-----------+ | 1 | +-----------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT BINARY 'a' = 'A'; +------------------+ | BINARY 'a' = 'A' | +------------------+ | 0 | +------------------+ 1 row in set (0.01 sec) MariaDB [(none)]> SELECT 'a' = 'a '; +------------+ | 'a' = 'a ' | +------------+ | 1 | +------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT BINARY 'a' = 'a '; +-------------------+ | BINARY 'a' = 'a ' | +-------------------+ | 0 | +-------------------+ 1 row in set (0.00 sec)
BIT_LENGTH
Sintaxis
BIT_LENGTH( str )
Dexcripción
Devuelve la longitud de la cadena str en bits.
Si str no es una cadena, se convierte en cadena.
Si str es NULL, devuelve NULL.
Ejemplos
MariaDB [(none)]> SELECT BIT_LENGTH('texto');
+---------------------+
| BIT_LENGTH('texto') |
+---------------------+
| 40 |
+---------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT BIT_LENGTH('Como');
+--------------------+
| BIT_LENGTH('Como') |
+--------------------+
| 32 |
+--------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT BIT_LENGTH('Cómo');
+---------------------+
| BIT_LENGTH('Cómo') |
+---------------------+
| 40 |
+---------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT BIT_LENGTH('¿Cómo están ustedes');
+--------------------------------------+
| BIT_LENGTH('¿Cómo están ustedes') |
+--------------------------------------+
| 176 |
+--------------------------------------+
1 row in set (0.00 sec)
CAST
Sintaxis
CAST( expr AS type )
Descripción
La función CAST() toma un valor de un tipo y produce un valor de otro tipo,
similar a CONVERT().
La principal diferencia entre el CAST() y CONVERT() es que CONVERT( expr, tipo )
es la sintaxis ODBC mientras CAST( expr como tipo ) y CONVERT(... USING ...)
están SQL92 sintaxis.
Hasta MariaDB 05/05/31, X'HHHH ', la sintaxis SQL estándar para cadenas literales
binarios, erróneamente trabajado de la misma manera como 0xHHHH. En 5.5.31 se cambió
intencionadamente a comportarse como una cadena en todos los contextos (y nunca como un número).
Esto introduce una incompatibilidad con las versiones anteriores de MariaDB, y todas las
versiones de MySQL (véase el ejemplo a continuación).
Ejemplo
MariaDB [(none)]> SELECT CAST("abc" as binary);
+-----------------------+
| CAST("abc" as binary) |
+-----------------------+
| abc |
+-----------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT CAST("1" as unsigned integer);
+-------------------------------+
| CAST("1" as unsigned integer) |
+-------------------------------+
| 1 |
+-------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT CAST("-1" as unsigned integer);
+--------------------------------+
| CAST("-1" as unsigned integer) |
+--------------------------------+
| 18446744073709551615 |
+--------------------------------+
1 row in set, 1 warning (0.00 sec)
El uso de CAST() para ordenar un campo ENUM como CHAR en lugar del valor numérico interno:
MariaDB [Prueba1]> CREATE TABLE enum_list (enum_field enum('c','a','b'));
Query OK, 0 rows affected (0.92 sec)
MariaDB [Prueba1]> INSERT INTO enum_list (enum_field) VALUES('c'),('a'),('c'),('b');
Query OK, 4 rows affected (0.11 sec)
Records: 4 Duplicates: 0 Warnings: 0
MariaDB [Prueba1]> SELECT * FROM enum_list ORDER BY enum_field;
+------------+
| enum_field |
+------------+
| c |
| c |
| a |
| b |
+------------+
4 rows in set (0.03 sec)
MariaDB [Prueba1]> SELECT * FROM enum_list ORDER BY CAST(enum_field AS CHAR);
+------------+
| enum_field |
+------------+
| a |
| b |
| c |
| c |
+------------+
4 rows in set (0.00 sec)
CHAR
Sintaxis CHAR( N, ... [USING charset_name] ) Dexcripción CHAR() interpreta cada argumento como enteros y devuelve una cadena formada por los caracteres dados por los códigos de tales enteros. Los valores NULL se omiten. De forma predeterminada, CHAR() devuelve una cadena binaria. Para producir una cadena en un conjunto de caracteres dada, utilice la cláusula USING opcional: SELECT CHARSET( CHAR( 0x65 ) ), CHARSET( CHAR( 0x65 USING utf8 ) ); +-------------------------+------------------------------------+ | CHARSET( CHAR( 0x65 ) ) | CHARSET( CHAR( 0x65 USING utf8 ) ) | +-------------------------+------------------------------------+ | binary | utf8 | +-------------------------+------------------------------------+ Si se administra usando y la cadena resultante es ilegal que el conjunto de caracteres dado, se emite una advertencia. Además, si está activado el strict SQL mode, el resultado de CHAR() se convierte en NULL. Ejemplos MariaDB [Prueba1]> SELECT CHAR( 77, 97, 114, '105', 97, '68', 66 ); +------------------------------------------+ | CHAR( 77, 97, 114, '105', 97, '68', 66 ) | +------------------------------------------+ | MariaDB | +------------------------------------------+ 1 row in set (0.00 sec) MariaDB [Prueba1]> SELECT CHAR( 77, 77.3, '77.3' ); +--------------------------+ | CHAR( 77, 77.3, '77.3' ) | +--------------------------+ | MMM | +--------------------------+ 1 row in set, 1 warning (0.00 sec) MariaDB [Prueba1]> show warnings; +---------+------+-------------------------------------------+ | Level | Code | Message | +---------+------+-------------------------------------------+ | Warning | 1292 | Truncated incorrect INTEGER value: '77.3' | +---------+------+-------------------------------------------+ 1 row in set (0.00 sec)
CHARACTER_LENGTH
Sintaxis CHARACTER_LENGTH( str ) Descripción CHARACTER_LENGTH() es sinónimo de CHAR_LENGTH().
CHAR_LENGTH
Sintaxis
CHAR_LENGTH( str )
Dexcripción
Devuelve la longitud de la cadena str, medida 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() retorna 10,
mientras que CHAR_LENGTH() devuelve 5. Si el argumento es NULL, devuelve NULL.
Si str no es un valor de cadena, se convierte en una cadena.
CHARACTER_LENGTH() es un sinónimo.
Ejemplos
MariaDB [Prueba1]> SELECT CHAR_LENGTH('MariaDB');
+------------------------+
| CHAR_LENGTH('MariaDB') |
+------------------------+
| 7 |
+------------------------+
1 row in set (0.00 sec)
MariaDB [Prueba1]> SELECT CHAR_LENGTH('Cómo');
+----------------------+
| CHAR_LENGTH('Cómo') |
+----------------------+
| 4 |
+----------------------+
1 row in set (0.01 sec)
CONCAT
Sintaxis
CONCAT(str1,str2,...)
Dexcripción
Devuelve la cadena resultado 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 todas
las cadenas binarias, el resultado es una cadena binaria. Un argumento
numérico se convierte en su forma de cadena binaria equivalente; si se
quiere evitar eso, se puede utilizar un tipo de conversión explícita.
Ejemplos
MariaDB [(none)]> SELECT CONCAT( 'Ma', 'ria', 'DB' );
+---------------------------+
| CONCAT('Ma', 'ria', 'DB') |
+---------------------------+
| MariaDB |
+---------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT CONCAT( 'Ma', 'ria', NULL, 'DB' );
+---------------------------------+
| CONCAT('Ma', 'ria', NULL, 'DB') |
+---------------------------------+
| NULL |
+---------------------------------+
1 row in set (0.01 sec)
MariaDB [(none)]> SELECT CONCAT( 42, 5 );
+---------------+
| CONCAT(42, 5) |
+---------------+
| 425 |
+---------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT CONCAT( 42, .5 );
+----------------+
| CONCAT(42, .5) |
+----------------+
| 420.5 |
+----------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT CONCAT( 'The value of @v is: ', IFNULL( @v, ) );
+------------------------------------------------+
| CONCAT('The value of @v is: ', IFNULL(@v, )) |
+------------------------------------------------+
| The value of @v is: |
+------------------------------------------------+
1 row in set (0.00 sec)
CONCAT_WS
Sintaxis
CONCAT_WS( separator, str1, str2, ... )
Descripción
CONCAT_WS() significa Concatenate con separador y es una forma especial
de CONCAT(). El primer argumento es el separador para el resto de los argumentos.
Se añade el separador entre las cuerdas para ser concatenados. El separador puede
ser una cadena, al igual que el resto de los argumentos.
Si el separador es NULL, el resultado es NULL; todos los demás valores NULL
se omiten. Esto hace CONCAT_WS() adecuado cuando se desea concatenar algunos
valores y evitar la pérdida de toda la información si uno de ellos es NULL.
Ejemplos
MariaDB [Prueba1]> SELECT CONCAT_WS(', ', 'Nombre', 'Apellodo Paterno', 'Apellido Materno' );
+--------------------------------------------------------------------+
| CONCAT_WS(', ', 'Nombre', 'Apellodo Paterno', 'Apellido Materno' ) |
+--------------------------------------------------------------------+
| Nombre, Apellodo Paterno, Apellido Materno |
+--------------------------------------------------------------------+
1 row in set (0.00 sec)
MariaDB [Prueba1]> SELECT CONCAT_WS( '-', 'Piso', NULL, 'Quarto' );
+------------------------------------------+
| CONCAT_WS( '-', 'Piso', NULL, 'Quarto' ) |
+------------------------------------------+
| Piso-Quarto |
+------------------------------------------+
1 row in set (0.00 sec)
MariaDB [Prueba1]> SET @a = 'a', @b = NULL, @c = 'c';
Query OK, 0 rows affected (0.00 sec)
MariaDB [Prueba1]> SELECT CONCAT_WS( , @a, @b, @c );
+-----------------------------+
| CONCAT_WS( , @a, @b, @c ) |
+-----------------------------+
| ac |
+-----------------------------+
1 row in set (0.00 sec)
MariaDB [Prueba1]> SELECT CONCAT(@a, @b, @c );
+---------------------+
| CONCAT(@a, @b, @c ) |
+---------------------+
| NULL |
+---------------------+
1 row in set (0.00 sec)
CONVERT
Sintaxis
CONVERT( expr,type ), CONVERT( expr USING transcoding_name )
<Descripción
The type puede ser uno de los siguiente valores:
BINARY[(N)]
CHAR[(N)]
DATE
DATETIME[(D)] — Decimal (D) specifier new in 5.3
DECIMAL[(M[,D])]
DOUBLE[(M[,D])] — New in 5.3
INTEGER — New in 5.3
Short for SIGNED INTEGER
SIGNED [INTEGER]
TIME[(D)] — Decimal (D) specifier new in 5.3
UNSIGNED [INTEGER]
Tenga en cuenta que en MariaDB, INT y INTEGER son la misma cosa.
BINARIO produce una cadena con el tipo de datos binarios. Ver binario
para una descripción de cómo esto afecta a las comparaciones. Si se da
la longitud opcional N, BINARY (N) hace que el molde a utilizar no más
de N bytes del argumento. Los valores más cortos que N bytes se rellenan
con 0x00 bytes a una longitud de N.
CHAR (N) hace que el reparto de utilizar no más de N caracteres del argumento.
La principal diferencia entre el CAST() y CONVERT() es que CONVERT(expr, tipo)
es la sintaxis ODBC mientras CAST(expr como tipo) y CONVERT(... USING ...) están
SQL92 sintaxis.
CONVERT() con USING se utiliza para convertir datos entre diferentes conjuntos
de caracteres. En MariaDB, nombres de transcodificación son los mismos que
establece el carácter correspondiente nombres. Por ejemplo, este comando convierte
la cadena 'abc' en el juego de caracteres predeterminado a la cadena correspondiente
en el conjunto de caracteres UTF-8:
Ejemplo
MariaDB [Prueba1]> SELECT LOWER( @x ), LOWER( CONVERT( @x USING latin1 ) );
+-------------+-------------------------------------+
| LOWER( @x ) | LOWER( CONVERT( @x USING latin1 ) ) |
+-------------+-------------------------------------+
| AardVark | aardvark |
+-------------+-------------------------------------+
1 row in set (0.00 sec)
ELT
Sintaxis ELT( N, str1, str2, str3, ... ) Descripción se deben pasar al menos dos parámetros. Devuelve str1 si N = 1, str2 si N = 2, y así sucesivamente. Si N es un número flotante, se redondea al entero más cercano. Retorna NULL si N es menor que 1 o mayor que el número de argumentos o no un número. ELT() es el complemento de FIELD(). Ejemplos MariaDB [Prueba1]> SELECT ELT( 1, 'ej', 'Heja', 'hej', 'foo' ); +--------------------------------------+ | ELT( 1, 'ej', 'Heja', 'hej', 'foo' ) | +--------------------------------------+ | ej | +--------------------------------------+ 1 row in set (0.00 sec) MariaDB [Prueba1]> SELECT ELT( 4, 'ej', 'Heja', 'hej', 'foo' ); +--------------------------------------+ | ELT( 4, 'ej', 'Heja', 'hej', 'foo' ) | +--------------------------------------+ | foo | +--------------------------------------+ 1 row in set (0.00 sec) MariaDB [Prueba1]> SELECT ELT( 3.4, 'ej', 'Heja', 'hej', 'foo' ); +----------------------------------------+ | ELT( 3.4, 'ej', 'Heja', 'hej', 'foo' ) | +----------------------------------------+ | hej | +----------------------------------------+ 1 row in set (0.00 sec) MariaDB [Prueba1]> SELECT ELT( 3.5, 'ej', 'Heja', 'hej', 'foo' ); +----------------------------------------+ | ELT( 3.5, 'ej', 'Heja', 'hej', 'foo' ) | +----------------------------------------+ | foo | +----------------------------------------+ 1 row in set (0.00 sec) MariaDB [Prueba1]> SELECT ELT( .5, 'ej', 'Heja', 'hej', 'foo' ); +---------------------------------------+ | ELT( .5, 'ej', 'Heja', 'hej', 'foo' ) | +---------------------------------------+ | ej | +---------------------------------------+ 1 row in set (0.00 sec) MariaDB [Prueba1]> SELECT ELT( .3, 'ej', 'Heja', 'hej', 'foo' ); +---------------------------------------+ | ELT( .3, 'ej', 'Heja', 'hej', 'foo' ) | +---------------------------------------+ | NULL | +---------------------------------------+ 1 row in set (0.00 sec) MariaDB [Prueba1]> SELECT ELT( 9, 'ej', 'Heja', 'hej', 'foo' ); +--------------------------------------+ | ELT( 9, 'ej', 'Heja', 'hej', 'foo' ) | +--------------------------------------+ | NULL | +--------------------------------------+ 1 row in set (0.00 sec)
FIELD
Sintaxis
FIELD( str, str1, str2, str3, ... )
<Descripción
se deben pasar al menos dos parámetros. Devuelve el índice (posición) de str en
el str1, str2, str3, ... la lista. Devuelve 0 si str no se encuentra.
Si todos los argumentos a FIELD() son cadenas, todos los argumentos se comparan
como cadenas de mayúsculas y minúsculas. Si todos los argumentos son números, se
comparan como números. De lo contrario, los argumentos se comparan como doble.
Si no se encuentra str en la lista, el valor de retorno es 0. Si str es NULL,
el valor de retorno es NULL. Si la lista contiene str más de una vez, se
considera sólo la primera aparición. FIELD() es el complemento de ELT().
Ejemplos
MariaDB [Prueba1]> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
+------------------------------------------------+
| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') |
+------------------------------------------------+
| 2 |
+------------------------------------------------+
1 row in set (0.00 sec)
MariaDB [Prueba1]> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
+------------------------------------------------+
| FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo') |
+------------------------------------------------+
| 0 |
+------------------------------------------------+
1 row in set (0.00 sec)
FIND_IN_SET
Sintaxis
FIND_IN_SET( str, strlist )
Descripción
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. Una lista de cadenas es una cadena
compuesta de subcadenas separadas por "," caracteres. Si el primer argumento es una
cadena constante y la segunda es una columna de tipo SET, la función FIND_IN_SET()
está optimizado para usar la bit aritmétic. Devuelve 0 si str no está en strlist o
si strlist es la cadena vacía. Retorna NULL
si cualquier argumento es NULL. Esta función no funciona correctamente si el primer
argumento contiene una (",") carácter de coma.
Ejemplos
MariaDB [(none)]> SELECT FIND_IN_SET('b','a,b,c,d');
+----------------------------+
| FIND_IN_SET('b','a,b,c,d') |
+----------------------------+
| 2 |
+----------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT FIND_IN_SET('l','a,b,c,d');
+----------------------------+
| FIND_IN_SET('l','a,b,c,d') |
+----------------------------+
| 0 |
+----------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT FIND_IN_SET('l','a,NULL,c,d');
+-------------------------------+
| FIND_IN_SET('l','a,NULL,c,d') |
+-------------------------------+
| 0 |
+-------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT FIND_IN_SET('c','a,NULL,c,d');
+-------------------------------+
| FIND_IN_SET('c','a,NULL,c,d') |
+-------------------------------+
| 3 |
+-------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT FIND_IN_SET('c','a,"",c,d');
+-----------------------------+
| FIND_IN_SET('c','a,"",c,d') |
+-----------------------------+
| 3 |
+-----------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT FIND_IN_SET('c','a,",",c,d');
+------------------------------+
| FIND_IN_SET('c','a,",",c,d') |
+------------------------------+
| 4 |
+------------------------------+
1 row in set (0.00 sec)
FORMAT
Sintaxis FORMAT( X, D ) Descripción Formatos del número X de un formato como '###, ###, ###. ###', Redondeado a D decimales, y devuelve el resultado como una cadena. Si D es 0, el resultado no tiene punto decimal o parte fraccionaria. Ejemplos MariaDB [(none)]> SELECT FORMAT(1234567890.09876543210, 4); +-----------------------------------+ | FORMAT(1234567890.09876543210, 4) | +-----------------------------------+ | 1,234,567,890.0988 | +-----------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT FORMAT( 1234567890.09876543210, 4 ); +-------------------------------------+ | FORMAT( 1234567890.09876543210, 4 ) | +-------------------------------------+ | 1,234,567,890.0988 | +-------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT FORMAT(1234567.89, 4); +-----------------------+ | FORMAT(1234567.89, 4) | +-----------------------+ | 1,234,567.8900 | +-----------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT FORMAT( 1234567.89, 0 ); +-------------------------+ | FORMAT( 1234567.89, 0 ) | +-------------------------+ | 1,234,568 | +-------------------------+ 1 row in set (0.00 sec)
HEX
Sintaxis
HEX( N_or_S )
Descripción
Si N_OR_S es un número, devuelve una cadena que representa el valor hexadecimal
de N, donde N es un número longlong (BIGINT). Esto es equivalente a CONV( N, 10, 16 ).
Si N_OR_S es una cadena, devuelve una cadena hexadecimal de N_OR_S donde cada byte
de cada caracter en N_OR_S se convierte a dos dígitos hexadecimales. Si N_OR_S es
NULL, devuelve NULL. La inversa de esta operación se realiza por la función UNHEX().
Ejemplos
MariaDB [(none)]> SELECT HEX( 255 );
+------------+
| HEX( 255 ) |
+------------+
| FF |
+------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT 0x4D617269614442;
+------------------+
| 0x4D617269614442 |
+------------------+
| MariaDB |
+------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT HEX('MariaDB');
+----------------+
| HEX('MariaDB') |
+----------------+
| 4D617269614442 |
+----------------+
1 row in set (0.00 sec)
INSERT
Sintaxis INSERT( str, pos, len, newstr ) Descripción Retorna la cadena str, con la subcadena que comienza en la posición pos y len caracteres de largo 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 de la posición pos si len no está dentro de la longitud del resto de la cadena. Retorna NULL si cualquier argumento es NULL. Ejemplos MariaDB [(none)]> SELECT INSERT( 'Quadratico', 3, 4, 'Cual' ); +--------------------------------------+ | INSERT( 'Quadratico', 3, 4, 'Cual' ) | +--------------------------------------+ | QuCualtico | +--------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT INSERT( 'Quadratico', -1, 4, 'Cual' ); +---------------------------------------+ | INSERT( 'Quadratico', -1, 4, 'Cual' ) | +---------------------------------------+ | Quadratico | +---------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT INSERT( 'Quadratico', 1, 14, 'Cual' ); +---------------------------------------+ | INSERT( 'Quadratico', 1, 14, 'Cual' ) | +---------------------------------------+ | Cual | +---------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT INSERT( 'Quadratico', 2, 14, 'Cual' ); +---------------------------------------+ | INSERT( 'Quadratico', 2, 14, 'Cual' ) | +---------------------------------------+ | QCual | +---------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT INSERT( 'Quadratico', 0, 14, 'Cual' ); +---------------------------------------+ | INSERT( 'Quadratico', 0, 14, 'Cual' ) | +---------------------------------------+ | Quadratico | +---------------------------------------+ 1 row in set (0.00 sec)
INSTR
Sintaxis INSTR( str, substr ) Descripción Devuelve la posición de la primera ocurrencia de la subcadena substr en la cadena str. Esta es la misma como la forma de dos argumentos de LOCATE(), excepto que el orden de los argumentos se invierte. Instr() realiza una búsqueda entre mayúsculas y minúsculas. Si algún argumento es NULL, devuelve NULL. Ejemplos MariaDB [(none)]> SELECT INSTR( 'foobarbar', 'bar' ); +-----------------------------+ | INSTR( 'foobarbar', 'bar' ) | +-----------------------------+ | 4 | +-----------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT INSTR( 'My', 'Maria' ); +------------------------+ | INSTR( 'My', 'Maria' ) | +------------------------+ | 0 | +------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT INSTR( 'ma', 'Maria' ); +------------------------+ | INSTR( 'ma', 'Maria' ) | +------------------------+ | 0 | +------------------------+ 1 row in set (0.00 sec)
LCASE
Sintaxis LCASE( str ) Descripción UCASE() es sinónimo de LOWER()
LOWER
Sintaxis LOWER( str ) Descripción Retorna la cadena str con todos los caracteres cambiados a minúsculas según el mapeo del conjunto de caracteres actual. El valor predeterminado es latin1 (CP1252 Europa occidental). LOWER() ( y UPPER() ) son ineficaces cuando se aplican a las cadenas binarias (BINARIO, VARBINARY, BLOB). Para realizar la conversión de mayúsculas y minúsculas, convertir la cadena en una cadena no binaria. Ejemplos MariaDB [(none)]> SELECT LOWER( "Viernes, 21 de Agosto AÑO 2016" ); +--------------------------------------------+ | LOWER( "Viernes, 21 de Agosto AÑO 2016" ) | +--------------------------------------------+ | viernes, 21 de agosto año 2016 | +--------------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LOWER( "Viernes, 21 de Agosto AÑO 2016" ); +--------------------------------------------+ | LOWER( "Viernes, 21 de Agosto AÑO 2016" ) | +--------------------------------------------+ | viernes, 21 de agosto año 2016 | +--------------------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LOWER( @str ), LOWER( CONVERT( @str USING utf8 ) ); +-------------------------+------------------------------------+ | LOWER( @str ) | LOWER(CONVERT( @str USING utf8 ) ) | +-------------------------+------------------------------------+ | Guadalajara, Jalisco MX | guadalajara, jalisco mx | +-------------------------+------------------------------------+ 1 row in set (0.00 sec)
LEFT
Sintaxis LEFT( str, len ) Descripción Devuelve len caracteres más a la izquierda de la cadena str, o NULL si cualquier argumento es NULL. Ejemplos MariaDB [(none)]> SELECT LEFT( 'MariaDB' ); ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near ')' at line 1 MariaDB [(none)]> SELECT LEFT( 'MariaDB', 0 ); +----------------------+ | LEFT( 'MariaDB', 0 ) | +----------------------+ | | +----------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LEFT( 'MariaDB', 1 ); +----------------------+ | LEFT( 'MariaDB', 1 ) | +----------------------+ | M | +----------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LEFT( 'MariaDB', 5 ); +----------------------+ | LEFT( 'MariaDB', 5 ) | +----------------------+ | Maria | +----------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LEFT( 'MariaDB', 33 ); +-----------------------+ | LEFT( 'MariaDB', 33 ) | +-----------------------+ | MariaDB | +-----------------------+ 1 row in set (0.00 sec)
LENGTH
Sintaxis LENGTH( str ) Descripción 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() retorna 10, mientras que CHAR_LENGTH() devuelve 5. Si str no es un valor de cadena, se convierte en una cadena. Si str es NULL, la función devuelve NULL. Ejemplos MariaDB [(none)]> SELECT LENGTH( 'MariaDB' ); +---------------------+ | LENGTH( 'MariaDB' ) | +---------------------+ | 7 | +---------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LENGTH( 'Año' ); +------------------+ | LENGTH( 'Año' ) | +------------------+ | 4 | +------------------+ 1 row in set (0.00 sec)
LOCATE
Sintaxis LOCATE( substr, str ), LOCATE( substr, str, pos ) Descripción La primera sintaxis devuelve la posición de la primera ocurrencia de la subcadena substr en la cadena str. La segunda sintaxis devuelve la posición de la primera ocurrencia de la subcadena substr en la cadena str, empezando en la posición pos. Devuelve 0 si no es substr en str. LOCATE() realiza una búsqueda entre mayúsculas y minúsculas. Si algún argumento es NULL, devuelve NULL. Instr() es sinónimo de LOCATE() sin el tercer argumento. Ejemplos MariaDB [(none)]> SELECT LOCATE( 'bar', 'foobarbar' ); +------------------------------+ | LOCATE( 'bar', 'foobarbar' ) | +------------------------------+ | 4 | +------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LOCATE( 'bar', 'foobarbar', 5 ); +---------------------------------+ | LOCATE( 'bar', 'foobarbar', 5 ) | +---------------------------------+ | 7 | +---------------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LOCATE( 'my', 'MariaDB' ); +---------------------------+ | LOCATE( 'my', 'MariaDB' ) | +---------------------------+ | 0 | +---------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LOCATE( 'mar', 'MariaDB' ); +----------------------------+ | LOCATE( 'mar', 'MariaDB' ) | +----------------------------+ | 1 | +----------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LOCATE( 'db', 'MariaDB' ); +---------------------------+ | LOCATE( 'db', 'MariaDB' ) | +---------------------------+ | 6 | +---------------------------+ 1 row in set (0.00 sec)
POSITION
Sintaxis POSITION( substr IN str ) Descripción POSITION( substr in Str ) es un sinónimo de LOCATE( substr, str ). Es parte de ODBC 3.0.
LPAD
Sintaxis LPAD( str, len, padstr ) Descripción Retorna la cadena str, consigna para el rellenado con la cadena str almohadilla a una longitud de len caracteres. Si str es mayor que len, el valor de retorno se corta a len caracteres. Ejemplos MariaDB [(none)]> SELECT LPAD( 'hola', 5, '~' ); +------------------------+ | LPAD( 'hola', 5, '~' ) | +------------------------+ | ~hola | +------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LPAD( 'hola', 6, '~' ); +------------------------+ | LPAD( 'hola', 6, '~' ) | +------------------------+ | ~~hola | +------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LPAD( 'hola', 7, '~' ); +------------------------+ | LPAD( 'hola', 7, '~' ) | +------------------------+ | Rrc (discusión)hola | +------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LPAD( 'hola', 4, '~' ); +------------------------+ | LPAD( 'hola', 4, '~' ) | +------------------------+ | hola | +------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LPAD( 'hola', 3, '~' ); +------------------------+ | LPAD( 'hola', 3, '~' ) | +------------------------+ | hol | +------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT LPAD( 'hola', 2, '~' ); +------------------------+ | LPAD( 'hola', 2, '~' ) | +------------------------+ | ho | +------------------------+ 1 row in set (0.00 sec
QUOTE
Sintaxis
QUOTE( str )
Descripción
Cotizaciones una cadena para producir un resultado que puede ser utilizado
como un valor de datos correctamente escapado en una instrucción SQL.
La cadena se devuelve encerrado por comillas simples y con cada instancia de
comilla simple ("'"), la barra invertida ("\"), ASCII NUL, y
Control-Z precedido por una barra invertida. Si el argumento es NULL, el
valor de retorno es la palabra "NULL" sin encerrar entre comillas simples
Ejemplos
MariaDB [(none)]> SELECT QUOTE( "Don't do it!");
+------------------------+
| QUOTE( "Don't do it!") |
+------------------------+
| 'Don\'t do it!' |
+------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT QUOTE( "" );
+-------------+
| QUOTE( "" ) |
+-------------+
| '' |
+-------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT QUOTE( '' );
+-------------+
| QUOTE( '' ) |
+-------------+
| '' |
+-------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT QUOTE( NULL );
+---------------+
| QUOTE( NULL ) |
+---------------+
| NULL |
+---------------+
1 row in set (0.20 sec)
LTRIM
Sintaxis
LTRIM( str )
Descripción
Devuelve la cadena str con los caracteres en blanco iniciales eliminados.
Ejemplos
MariaDB [(none)]> SELECT QUOTE( LTRIM (' MariaDB ') );
+----------------------------------+
| QUOTE( LTRIM (' MariaDB ') ) |
+----------------------------------+
| 'MariaDB ' |
+----------------------------------+
1 row in set (0.00 sec)
SUBSTRING
<b<Sintax
SUBSTRING( str, pos ),
SUBSTRING( str FROM pos ),
SUBSTRING( str, pos,len ),
SUBSTRING( str FROM pos FOR len)
Descripción
Las formas sin un argumento len retornan una subcadena de la cadena str
empezando en la posición pos.
Las formas con un argumento len retornan una subcadena len caracteres de
longitud de cadena str, empezando en la posición pos.
Las formas 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 es caracteres de la final de la cadena, en
lugar de al principio. Un valor negativo puede ser utilizado para pos
en cualquiera de las formas de esta función.
Para todas las formas de SUBSTRING(), la posición del primer carácter
de la cadena de la que la subcadena se va a extraer es contada por 1.
Si algún argumento es NULL, devuelve NULL.
Ejemplos
MariaDB [(none)]> SELECT SUBSTRING( 'Más largo', 4 );
+------------------------------+
| SUBSTRING( 'Más largo', 4 ) |
+------------------------------+
| largo |
+------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT SUBSTRING( 'MariaDB' FROM 6 );
+-------------------------------+
| SUBSTRING( 'MariaDB' FROM 6 ) |
+-------------------------------+
| DB |
+-------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT SUBSTRING('Maravilla', 5, 5 );
+-------------------------------+
| SUBSTRING('Maravilla', 5, 5 ) |
+-------------------------------+
| villa |
+-------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT SUBSTRING( 'Buenos Días', -4 );
+---------------------------------+
| SUBSTRING( 'Buenos Días', -4 ) |
+---------------------------------+
| Días |
+---------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT SUBSTRING( 'Knowledgebase', -8, 4 );
+-------------------------------------+
| SUBSTRING( 'Knowledgebase', -8, 4 ) |
+-------------------------------------+
| edge |
+-------------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT SUBSTRING( 'Knowledgebase' FROM -8 FOR 4 );
+--------------------------------------------+
| SUBSTRING( 'Knowledgebase' FROM -8 FOR 4 ) |
+--------------------------------------------+
| edge |
+--------------------------------------------+
1 row in set (0.00 sec)
SUBSTR
Sintaxis SUBSTR es un sinónimo de SUBSTRING
MID
Sintaxis MID( str, pos, len ) Descripción MID( str, pos, len ) es un sinónimo de SUBSTRING( str, pos, len ) Ejemplos MariaDB [(none)]> SELECT MID( 'abcd', 4, 1 ); +---------------------+ | MID( 'abcd', 4, 1 ) | +---------------------+ | d | +---------------------+ 1 row in set (0.00 sec)
REPEAT
Sintaxis REPEAT( str, count ) Descripción Devuelve una cadena que consiste en los tiempos de conteo de repetición cadena str. Si el número es menor que 1, devuelve una cadena vacía. Devuelve NULL si str o recuento son nulos. Ejemplos MariaDB [(none)]> SELECT REPEAT( 'MariaDB ', 4); +----------------------------------+ | REPEAT( 'MariaDB ', 4) | +----------------------------------+ | MariaDB MariaDB MariaDB MariaDB | +----------------------------------+ 1 row in set (0.00 sec)
REPLACE
Sintaxis
REPLACE( str, from_str, to_str )
Descripción
Retorna la cadena str con todas las ocurrencias de la cadena from_str
reemplazados por el to_str. REPLACE() realiza una coincidencia
mayúscula en la búsqueda de from_str.
Ejemplos
MariaDB [(none)]> SELECT REPLACE('w.mariadb.org', 'w', 'WwW');
+--------------------------------------+
| REPLACE('w.mariadb.org', 'w', 'WwW') |
+--------------------------------------+
| WwW.mariadb.org |
+--------------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT REPLACE('w.mariadb.org', 'W', 'www');
+--------------------------------------+
| REPLACE('w.mariadb.org', 'W', 'www') |
+--------------------------------------+
| w.mariadb.org |
+--------------------------------------+
1 row in set (0.00 sec)
REVERSE
Sintaxis REVERSE( str ) Descripción Retorna la cadena str con el orden de los caracteres invertidos. Ejemplos MariaDB [(none)]> SELECT REVERSE( 'AbCéÑ' ); +----------------------+ | REVERSE( 'AbCéÑ' ) | +----------------------+ | ÑéCbA | +----------------------+ 1 row in set (0.00 sec)
RIGHT
Sintaxis RIGHT( str, len ) Descripción Devuelve los caracteres situados a la derecha n de la cadena str, o NULL si cualquier argumento es NULL. Ejemplos MariaDB [(none)]> SELECT RIGHT( 'MariaDB', 2 ); +-----------------------+ | RIGHT( 'MariaDB', 2 ) | +-----------------------+ | DB | +-----------------------+ 1 row in set (0.00 sec)
RPAD
Sintaxis RPAD( str, len, padstr ) Descripción Retorna la cadena str, haga acolchado con la almohadilla de cadena str con una longitud de len caracteres. Si str es mayor que len, el valor de retorno se corta a len caracteres. Ejemplos MariaDB [(none)]> SELECT RPAD( 'hola', 10, '.' ); +-------------------------+ | RPAD( 'hola', 10, '.' ) | +-------------------------+ | hola...... | +-------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT RPAD( 'hola', 2, '.' ); +------------------------+ | RPAD( 'hola', 2, '.' ) | +------------------------+ | ho | +------------------------+ 1 row in set (0.00 sec)
RTRIM
Sintaxis
RTRIM( str )
Descripción
Retorna la cadena str con caracteres de espacio retirados.
Ejemplos
MariaDB [(none)]> SELECT QUOTE(RTRIM('MariaDB '));
+-----------------------------+
| QUOTE(RTRIM('MariaDB ')) |
+-----------------------------+
| 'MariaDB' |
+-----------------------------+
1 row in set (0.00 sec)
STRCMP
Sintaxis STRCMP( expr1, expr2 ) Descripción STRCMP() devuelve 0 si las cadenas son iguales, -1 si el primer argumento es menor que el segundo acuerdo con el orden actual, y 1 en caso contrario. Ejemplos MariaDB [(none)]> SELECT STRCMP( 'texto', 'texto2' ); +-----------------------------+ | STRCMP( 'texto', 'texto2' ) | +-----------------------------+ | -1 | +-----------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT STRCMP( 'texto2', 'texto' ); +-----------------------------+ | STRCMP( 'texto2', 'texto' ) | +-----------------------------+ | 1 | +-----------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT STRCMP( 'texto', 'texto' ); +----------------------------+ | STRCMP( 'texto', 'texto' ) | +----------------------------+ | 0 | +----------------------------+ 1 row in set (0.00 sec)
TRIM
Sintaxis
TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM([remstr FROM] str )
Descripión
Retorna la cadena str con todos los prefijos o sufijos remstr retirados.
Si ningúno de los especificadores BOTH, LEADING, o TRAILINGl, BOTH
se supone. remstr es opcional y, si no se especifica, se eliminan los
espacios.
Ejemplos
MariaDB [(none)]> SELECT QUOTE( TRIM(' Maria DB ') );
+--------------------------------+
| QUOTE( TRIM(' Maria DB ') ) |
+--------------------------------+
| 'Maria DB' |
+--------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT TRIM( LEADING 'x' FROM 'xxxbarxxx' );
+------------------------------------------+
| TRIM( LEADING 'x' FROM 'xxxMariaDBxxx' ) |
+------------------------------------------+
| MariaDBxxx |
+------------------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT TRIM( TRAILING 'xyz' FROM 'xyzMariaDBxyz' );
+---------------------------------------------+
| TRIM( TRAILING 'xyz' FROM 'xyzMariaDBxyz' ) |
+---------------------------------------------+
| xyzMariaDB |
+---------------------------------------------+
1 row in set (0.00 sec)
MariaDB [(none)]> SELECT TRIM( BOTH 'x' FROM 'xxxMariaDBxxx' );
+---------------------------------------+
| TRIM( BOTH 'x' FROM 'xxxMariaDBxxx' ) |
+---------------------------------------+
| MariaDB |
+---------------------------------------+
1 row in set (0.00 sec)
UPPER
Sintaxis UPPER( str ) Descripción Retorna la cadena str con todos los caracteres cambiados a mayúsculas según el mapeo del conjunto de caracteres actual. El valor predeterminado es latin1 (CP1252 Europa occidental). Ejemplos MariaDB [(none)]> SELECT UPPER( 'buenos días' ); +-------------------------+ | UPPER( 'buenos días' ) | +-------------------------+ | BUENOS DÍAS | +-------------------------+ 1 row in set (0.00 sec) MariaDB [(none)]> SELECT UPPER( BINARY 'buenos días' ); +--------------------------------+ | UPPER( BINARY 'buenos días' ) | +--------------------------------+ | buenos días | +--------------------------------+ 1 row in set (0.02 sec)
UCASE
Sintaxis UCASE( str ) Descripción Sinónimo de UPPER
