Curso de MariaDB Desde la Consola/StringFunciones

De WikiCabal
Saltar a: navegación, buscar

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</b>

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</b>

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<b>
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.

<b>Ejemplos<b>

MariaDB [(none)]> SELECT REPEAT( 'MariaDB ', 4);
+----------------------------------+
| REPEAT( 'MariaDB ', 4)           |
+----------------------------------+
| MariaDB MariaDB MariaDB MariaDB  |
+----------------------------------+
1 row in set (0.00 sec)

REPLACE

<b>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<b>

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

<b>Sintaxis

RTRIM( str )

Descripción

Retorna la cadena str con caracteres de espacio retirados.

Ejemplos<b>

MariaDB [(none)]> SELECT QUOTE(RTRIM('MariaDB    '));
+-----------------------------+
| QUOTE(RTRIM('MariaDB    ')) |
+-----------------------------+
| 'MariaDB'                   |
+-----------------------------+
1 row in set (0.00 sec)

STRCMP

<b>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