¿Cómo configurar Sqlite3 para que no distinga entre mayúsculas y minúsculas al comparar cadenas?

Quiero seleccionar registros de la base de datos sqlite3 por coincidencia de cadenas. Pero si uso '=' en la cláusula where, descubrí que sqlite3 distingue entre mayúsculas y minúsculas. ¿Alguien puede decirme cómo usar cadenas comparando mayúsculas y minúsculas?

Puede usar COLLATE NOCASEen su SELECTconsulta:

SELECT * FROM ... WHERE name = 'someone' COLLATE NOCASE

Además, en SQLite, puede indicar que una columna no distingue entre mayúsculas y minúsculas cuando crea la tabla especificando collate nocaseen la definición de columna (las otras opciones son binary(el valor predeterminado) y rtrim; consulte aquí ). También puede especificar collate nocasecuándo crea un índice. Por ejemplo:

crear tabla de prueba
(
  Text_Value text cotejar nocase
);

insertar en los valores de prueba ('A');
insertar en los valores de prueba ('b');
insertar en los valores de prueba ('C');

crear índice Test_Text_Value_Index
  en prueba (Text_Value cotejar nocase);

Las expresiones involucradas Test.Text_Valueahora deben ser insensibles a mayúsculas y minúsculas. Por ejemplo:

sqlite> seleccione Text_Value de Test donde Text_Value = 'B';
Text_Value      
----------------
si               

sqlite> seleccione Text_Value del orden de prueba por Text_Value;
Text_Value      
----------------
UNA               
si               
C    

sqlite> seleccione Text_Value del orden de prueba por Text_Value desc;
Text_Value      
----------------
C               
si               
UNA               

El optimizador también puede hacer uso del índice para buscar y hacer coincidir mayúsculas y minúsculas en la columna. Puede verificar esto usando el explaincomando SQL, por ejemplo:

sqlite> explique select Text_Value de Test donde Text_Value = 'b';
addr código de operación p1 p2 p3                               
---------------- -------------- ---------- ---------- ---------------------------------
0 Ir a 0 16                                           
1 Entero 0 0                                            
2 OpenRead 1 3 keyinfo (1, NOCASE)                
3 SetNumColumns 1 2                                            
4 cuerdas 8 0 0 b                                
5 IsNull -1 14                                           
6 MakeRecord 1 0 a                                
7 MemStore 0 0                                            
8 MoveGe 1 14                                           
9 MemLoad 0 0                                            
10 IdxGE 1 14 +                                
11 Columna 1 0                                            
12 Devolución de llamada 1 0                                            
13 Siguiente 1 9                                            
14 Cerrar 1 0                                            
15 Detener 0 0                                            
16 Transacción 0 0                                            
17 VerifyCookie 0 4                                            
18 Ir a 0 1                                            
19 Noop 0 0                                            

SELECT * FROM ... WHERE name = 'someone' COLLATE NOCASE

Puedes hacerlo así:

SELECT * FROM ... WHERE name LIKE 'someone'

(No es la solución, pero en algunos casos es muy conveniente)

"El operador LIKE hace una comparación de coincidencia de patrones. El operando a la derecha contiene el patrón, el operando de la izquierda contiene la cadena para que coincida con el patrón. Un símbolo de porcentaje ("% ") en el patrón coincide con cualquier secuencia de cero o más caracteres en la cadena. Un guión bajo ("_") en el patrón coincide con cualquier carácter individual en la cadena. Cualquier otro carácter coincide con sí mismo o con su equivalente en minúscula / mayúscula (es decir, coincidencia entre mayúsculas y minúsculas ) . (Un error: SQLite solo entiende mayúscula / minúscula para caracteres ASCII. El operador LIKE distingue entre mayúsculas y minúsculas para caracteres unicode que están más allá del rango ASCII. Por ejemplo, la expresión 'a' LIKE 'A' es VERDADERA pero 'æ' LIKE 'Æ'Es falso.)."

Esto no es específico de sqlite pero solo puedes hacer

SELECT * FROM ... WHERE UPPER(name) = UPPER('someone')

Otra opción es crear su propia colación personalizada. Luego puede establecer esa clasificación en la columna o agregarla a sus cláusulas de selección. Se utilizará para ordenar y hacer comparaciones.

Esto se puede usar para hacer 'VOILA' COMO 'voilà'.

http://www.sqlite.org/capi3ref.html#sqlite3_create_collation

La función de clasificación debe devolver un número entero que sea negativo, cero o positivo si la primera cadena es menor, igual o mayor que la segunda, respectivamente.

Otra opción que puede o no tener sentido en su caso, es tener una columna separada con valores precalificados de su columna existente. Esto se puede completar utilizando la función SQLiteLOWER() , y luego puede realizar coincidencias en esta columna.

Obviamente, agrega redundancia y un potencial de inconsistencia, pero si sus datos son estáticos, podría ser una opción adecuada.

Simplemente, puede usar COLLATE NOCASE en su consulta SELECT:

SELECT * FROM ... WHERE name = 'someone' COLLATE NOCASE

Si la columna es de tipo, charentonces debe agregar el valor que está consultando con espacios, consulte esta pregunta aquí . Esto además de usar COLLATE NOCASEo una de las otras soluciones (upper (), etc.).

puede usar la consulta similar para comparar la cadena respectiva con los valores de tabla.

seleccione el nombre de la columna de table_name donde el nombre de la columna como 'valor de comparación respectivo';

Me está funcionando perfectamente. SELECT NAME FROM TABLE_NAME WHERE NAME = 'test Name' COLLATE NOCASE