Come impostare Sqlite3 senza distinzione tra maiuscole e minuscole durante il confronto tra stringhe?

Voglio selezionare i record dal database sqlite3 tramite la corrispondenza delle stringhe. Ma se uso ‘=’ nella clausola where, ho trovato che sqlite3 è case sensitive. Qualcuno può dirmi come usare la stringa comparando maiuscole e minuscole?

Puoi utilizzare COLLATE NOCASE nella tua query SELECT :

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

Addizionalmente, in SQLite, è ansible indicare che una colonna non deve collate nocase tra maiuscole e minuscole quando si crea la tabella, specificando collate nocase nella definizione della colonna (le altre opzioni sono binary (impostazione predefinita) e rtrim ; vedere qui ). È ansible specificare collate nocase quando si crea un indice. Per esempio:

 creare tabella Test
 (
   Text_Value text collate nocase
 );

 inserire in valori di test ('A');
 inserire in valori di test ('b');
 inserire in valori di test ('C');

 crea l'indice Test_Text_Value_Index
   su Test (Valore_testuale collasi nocase);

Le espressioni che coinvolgono Test.Text_Value ora non Test.Text_Value maiuscole e minuscole. Per esempio:

 sqlite> seleziona Text_Value da Test dove Text_Value = 'B';
 TEXT_VALUE      
 ----------------
 B               

 sqlite> seleziona Text_Value da Test order by Text_Value;
 TEXT_VALUE      
 ----------------
 UN               
 B               
 C    

 sqlite> seleziona Text_Value da Test order by Text_Value desc;
 TEXT_VALUE      
 ----------------
 C               
 B               
 UN               

L’ottimizzatore può anche potenzialmente utilizzare l’indice per la ricerca e la corrispondenza senza distinzione tra maiuscole e minuscole nella colonna. È ansible controllare questo utilizzando il comando SQL explain , ad esempio:

 sqlite> spiega select Text_Value da Test where Text_Value = 'b';
 addr opcode p1 p2 p3                               
 ---------------- -------------- ---------- ---------- ---------------------------------
 0 Vai a 0 16                                           
 1 intero 0 0                                            
 2 OpenRead 1 3 keyinfo (1, NOCASE)                
 3 SetNumColumns 1 2                                            
 4 Stringa8 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 Colonna 1 0                                            
 12 Richiamata 1 0                                            
 13 Avanti 1 9                                            
 14 Chiudi 1 0                                            
 15 Halt 0 0                                            
 16 Transazione 0 0                                            
 17 VerifyCookie 0 4                                            
 18 Vai a 0 1                                            
 19 Noop 0 0                                            
 SELECT * FROM ... WHERE name = 'someone' COLLATE NOCASE 

Puoi farlo in questo modo:

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

(Non è la soluzione, ma in alcuni casi è molto conveniente)

“L’operatore LIKE esegue un confronto di corrispondenza del modello L’operando a destra contiene il modello, l’operando di sinistra contiene la stringa da abbinare al modello Un simbolo di percentuale (“% “) nel modello corrisponde a qualsiasi sequenza di zero o più caratteri nella stringa Un carattere di sottolineatura (“_”) nel modello corrisponde a qualsiasi singolo carattere nella stringa.Qualsiasi altro carattere corrisponde a se stesso o al suo equivalente in lettere maiuscole / minuscole (cioè corrispondenza senza distinzione tra maiuscole e minuscole ) . maiuscole / minuscole per caratteri ASCII L’operatore LIKE rileva la distinzione tra maiuscole e minuscole per caratteri unicode che vanno oltre l’intervallo ASCII. Ad esempio, l’espressione ‘a’ LIKE ‘A’ è VERO ma ‘æ’ LIKE ‘Æ’ è FALSE.) “.

Questo non è specifico per sqlite, ma puoi farlo

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

Un’altra opzione è creare le tue regole di confronto personalizzate. È quindi ansible impostare le regole di confronto sulla colonna o aggiungerle alle clausole di selezione. Sarà usato per ordini e confronti.

Questo può essere usato per rendere ‘VOILA’ LIKE ‘voilà’.

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

La funzione di fascicolazione deve restituire un numero intero che è negativo, zero o positivo se la prima stringa è inferiore, uguale o superiore al secondo, rispettivamente.

Un’altra opzione che può o non ha senso nel tuo caso, è di avere effettivamente una colonna separata con valori pre-sottoeseguiti della colonna esistente. Questo può essere popolato usando la funzione SQLite LOWER() , e puoi quindi eseguire la corrispondenza su questa colonna.

Ovviamente, aggiunge ridondanza e potenziale incoerenza, ma se i tuoi dati sono statici potrebbe essere un’opzione adatta.

Se la colonna è di tipo char devi aggiungere il valore che stai interrogando con spazi, fai riferimento a questa domanda qui . Questo oltre a utilizzare COLLATE NOCASE o una delle altre soluzioni (superiore (), ecc.).

è ansible utilizzare la query simile per confrontare la rispettiva stringa con valori di tabella.

seleziona il nome della colonna da nome_tabella dove il nome della colonna è uguale a “valore di confronto corrispondente”;

Funziona perfettamente per me. SELECT NAME FROM TABLE_NAME WHERE NAME = 'test Name' COLLATE NOCASE