Comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3

1. Implementar la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3
2. Utilice COLLATE NOCASE en la consulta CREATE para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3
3. Utilice COLLATE NOCASE en la consulta SELECT para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3
4. Uso del operador LIKE para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3
5. Use las funciones LOWER() o UPPER() para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3

El motor de base de datos SQLite está desarrollado en lenguaje C. No es una aplicación que pueda funcionar sola; más bien, es una biblioteca que los desarrolladores de aplicaciones pueden usar para implementar sus aplicaciones.

Al igual que MySQL, SQLite también es un sistema de administración de bases de datos relacionales (RDBMS) y se implementa en SQL (lenguaje de consulta estructurado). En la versión 3 de SQLite, la base de datos distingue entre mayúsculas y minúsculas cuando se comparan cadenas, por lo que cuando un usuario selecciona un registro de una base de datos utilizando el operador = (igual único) en la cláusula where, la base de datos de SQLite muestra que es distingue mayúsculas y minúsculas.

Implementar la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3

Tenemos diferentes formas de trabajar con la base de datos SQLite para abordar esta situación:

1. A menudo usamos la cláusula collate nocase en las instrucciones de consulta CREATE o SELECT.
2. Otra opción es utilizar el operador LIKE, que no distingue entre mayúsculas y minúsculas al comparar los operandos de cadena.
3. Por último, usamos las funciones UPPER() y LOWER() en ambos lados de los operandos al comparar una cadena con el operador =.

Utilice COLLATE NOCASE en la consulta CREATE para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3

Supongamos que tenemos una base de datos con diferentes registros agregados con el texto (cadena) como tipo de datos. Ahora, queremos seleccionar algunos registros de la tabla usando el operador =, y luego la base de datos muestra que los registros distinguen entre mayúsculas y minúsculas.

Por lo tanto, en general, en SQLite, puede mencionar que una columna no debe distinguir entre mayúsculas y minúsculas cuando crea una tabla con una consulta intercalar sin mayúsculas y minúsculas. También podemos especificar collate nocase con un id o valor de índice en la tabla.

En el siguiente ejemplo, el example.New_text no distingue entre mayúsculas y minúsculas.

create table example
(
  New_text text collate nocase
);

insert into example values ('ABC');
insert into example values ('def');
insert into example values ('GHI');

create index example_New_text_Index
  on example (New_text collate nocase);

Una vez que creamos e insertamos algunos registros en la tabla ejemplo, podemos probar su distinción entre mayúsculas y minúsculas recuperando los registros en una consulta seleccionar. Los resultados a continuación nos muestran que la “intercalación sin mayúsculas y minúsculas” funciona bien siempre que necesitamos la insensibilidad a mayúsculas y minúsculas para comparar los tipos de datos de cadena en la cláusula “dónde”.

Ejemplo 1:

SELECT New_Text FROM example WHERE New_Text = 'DEF';

Producción :

def

El ejemplo 1 da como resultado un valor def cuando usamos el operador = en la cláusula where sin tener en cuenta los valores que distinguen entre mayúsculas y minúsculas dentro de la tabla. La razón es que el uso de collate nocase en el momento de la creación de la tabla hace que los valores de la columna New_text no distingan entre mayúsculas y minúsculas.

Ejemplo 2:

SELECT New_Text FROM example ORDER BY New_Text;

Producción :

ABC
def
GHI

Ejemplo 3:

SELECT New_Text FROM example ORDER BY New_Text DESC;

Producción :

GHI
def
ABC

Use el comando EXPLAIN en la base de datos SQLite

También podemos verificar la búsqueda y la coincidencia entre mayúsculas y minúsculas usando un índice en la columna. Usamos el comando EXPLAIN para este propósito.

EXPLAIN SELECT New_Text FROM example WHERE New_Text = 'def';

Producción :

addr              opcode          p1          p2
1                 Integer         0           0
2                 OpenRead        1           3
3                 SetNumColumns   1           2
4                 String8         0           0
5                 IsNull          -1          14
6                 MakeRecord      1           0
7                 MemStore        0           0
8                 MoveGe          1           14
9                 MemLoad         0           0
10                IdxGE           1           14
11                Column          1           0
12                Callback        1           0
13                Next            1           9
14                Close           1           0
15                Halt            0           0
16                Transaction     0           0
17                VerifyCookie    0           4
18                Goto            0           1
19                Noop            0           0

Utilice COLLATE NOCASE en la consulta SELECT para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3

Supongamos que creamos una tabla sin considerar el problema de la distinción entre mayúsculas y minúsculas y sin usar la cláusula collate nocase. Entonces, aún podemos usar la cláusula collate nocase mientras recuperamos los registros con la consulta SELECT.

En este ejemplo, podemos ver que la cláusula collate nocase se puede usar con la declaración SELECT en SQLite.

SELECT * FROM NameOfTheTable WHERE value = 'MatchingValue' COLLATE NOCASE

Uso del operador LIKE para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3

Similar a la cláusula collate nocase, podemos usar el operador LIKE para la comparación sin distinción entre mayúsculas y minúsculas del tipo de cadena en la base de datos SQLite.

El operador LIKE es un operador de coincidencia de patrones. Como operador habitual, hay operandos del lado izquierdo y derecho para comparar.

Los operandos del lado izquierdo contienen la cadena coincidente, mientras que el operando del lado derecho contiene el patrón para que coincida con la cadena coincidente. Este operador también contiene el símbolo de porcentaje % para cualquier número de secuencias de un carácter determinado.

El operador LIKE tampoco distingue entre mayúsculas y minúsculas, por lo que no importa si se utilizan letras mayúsculas o minúsculas para la coincidencia; solo distingue entre mayúsculas y minúsculas con los caracteres Unicode, no para los caracteres de código ASCII.

Por ejemplo, en el operador LIKE, los caracteres ASCII A y a son iguales, pero los caracteres Unicode Æ y æ son diferentes. Usamos el operador LIKE para comparar los registros que no distinguen entre mayúsculas y minúsculas en la base de datos SQLite.

SELECT * FROM NameOFTheTable WHERE Value LIKE 'something'

Use las funciones LOWER() o UPPER() para la comparación de cadenas que no distingue entre mayúsculas y minúsculas en Sqlite3

Supongamos que tenemos registros en una columna particular con valores en mayúsculas y minúsculas. Sin embargo, cuando comparamos los valores usando el operador = en la declaración SELECT, tenemos un problema de mayúsculas y minúsculas en el resultado.

Para solucionar este problema, podemos implementar las funciones de SQLite LOWER() y UPPER(), donde la función LOWER() está en minúsculas para todos los caracteres y la función UPPER() está en mayúsculas para todos los caracteres. de la cadena proporcionada. Usamos estas funciones en la sentencia SELECT para hacerlas efectivas.

El siguiente ejemplo demuestra que la cadena coincidente primero se convierte en caracteres en minúsculas usando la función LOWER() y el carácter en mayúsculas si usamos la función UPPER().

Usando la función UPPER() en SQLite:

SELECT * FROM NameOFTheTable WHERE UPPER(value) = UPPER('something')

Usando la función LOWER() en SQLite:

SELECT * FROM NameOFTheTable WHERE LOWER(value) = LOWER('something')