Cómo funciona ORD() en MariaDB

En MariaDB, ORD() es una función de cadena incorporada que devuelve el código de carácter numérico del carácter más a la izquierda de su argumento de cadena.

El ORD() La función puede manejar caracteres de varios bytes. Esto contrasta con el ASCII() función, que solo maneja caracteres de un solo byte (8 bits).

Sintaxis

La sintaxis es así:

ORD(str)

Donde str es el argumento de cadena.

ORD() devolverá el código numérico de solo el más a la izquierda carácter de esta cadena.

Si el carácter más a la izquierda es un carácter de varios bytes, ORD() utiliza la siguiente fórmula para calcular su resultado:

  (1st byte code)
+ (2nd byte code x 256)
+ (3rd byte code x 256 x 256) ...

Ejemplo

Aquí hay un ejemplo simple para demostrarlo:

SELECT ORD('H');

Resultado:

+----------+
| ORD('H') |
+----------+
|       72 |
+----------+

Como se mencionó, ORD() solo devuelve el código del más a la izquierda personaje. Por lo tanto, lo siguiente produce el mismo resultado:

SELECT ORD('Homer');

Resultado:

+--------------+
| ORD('Homer') |
+--------------+
|           72 |
+--------------+

Para demostrar esto aún más, obtengamos el código de cada letra en la cadena anterior:

SELECT 
    ORD('H'),
    ORD('o'),
    ORD('m'),
    ORD('e'),
    ORD('r');

Resultado:

+----------+----------+----------+----------+----------+
| ORD('H') | ORD('o') | ORD('m') | ORD('e') | ORD('r') |
+----------+----------+----------+----------+----------+
|       72 |      111 |      109 |      101 |      114 |
+----------+----------+----------+----------+----------+

Caracteres de varios bytes

Aquí hay un ejemplo que usa un carácter de varios bytes:

SELECT ORD('©');

Resultado:

+-----------+
| ORD('©')  |
+-----------+
|     49833 |
+-----------+

Sensibilidad de mayúsculas y minúsculas

Las letras mayúsculas tienen un valor ASCII diferente al de sus equivalentes en minúsculas.

Ejemplo:

SELECT 
    ORD('H'),
    ORD('h');

Resultado:

+----------+----------+
| ORD('H') | ORD('h') |
+----------+----------+
|       72 |      104 |
+----------+----------+

Un ejemplo de base de datos

Aquí hay un ejemplo del uso de ORD() en una consulta de base de datos:

USE PetHouse;
SELECT 
  PetName, 
  ORD(PetName) AS 'ASCII value of leftmost character'
FROM Pets;

Resultado:

+---------+-----------------------------------+
| PetName | ASCII value of leftmost character |
+---------+-----------------------------------+
| Fluffy  |                                70 |
| Fetch   |                                70 |
| Scratch |                                83 |
| Wag     |                                87 |
| Tweet   |                                84 |
| Fluffy  |                                70 |
| Bark    |                                66 |
| Meow    |                                77 |
+---------+-----------------------------------+

Carácter más a la derecha

Aquí, uso el RIGHT() función para devolver el carácter más a la derecha de cada nombre de mascota, y luego usarlo de nuevo con ORD() para devolver el valor ASCII de ese carácter.

USE PetHouse;
SELECT 
  PetName,
  RIGHT(PetName, 1) 'Rightmost character',
  ORD(RIGHT(PetName, 1)) 'ASCII code'
FROM Pets;

Resultado:

+---------+---------------------+------------+
| PetName | Rightmost character | ASCII code |
+---------+---------------------+------------+
| Fluffy  | y                   |        121 |
| Fetch   | h                   |        104 |
| Scratch | h                   |        104 |
| Wag     | g                   |        103 |
| Tweet   | t                   |        116 |
| Fluffy  | y                   |        121 |
| Bark    | k                   |        107 |
| Meow    | w                   |        119 |
+---------+---------------------+------------+

Cadenas vacías

Proporcionar una cadena vacía da como resultado 0 siendo devuelto.

SELECT ORD('');

Resultado:

+---------+
| ORD('') |
+---------+
|       0 |
+---------+

Valores nulos

Proporcionar null da como resultado null siendo devuelto.

SELECT ORD(null);

Resultado:

+-----------+
| ORD(null) |
+-----------+
|      NULL |
+-----------+