Come effettuare una ricerca con distinzione tra maiuscole e minuscole nella clausola WHERE?

Voglio una ricerca con distinzione tra maiuscole e minuscole nella query SQL. Ma per impostazione predefinita, MySQL non considera il caso delle stringhe.

Qualche idea su come eseguire una ricerca con distinzione tra maiuscole e minuscole nella query SQL?

per impostazione predefinita, MySQL non considera il caso delle stringhe

Questo non è del tutto vero. Ogni volta che ti trovi create databasein MySQL, il database / schema ha un set di caratteri e un confronto. Ogni set di caratteri ha un confronto predefinito; vedi qui per maggiori informazioni.

Le regole di confronto predefinite per il set di caratteri latin1, ovvero latin1_swedish_ci, non fanno distinzione tra maiuscole e minuscole.

Puoi scegliere un confronto con distinzione tra maiuscole e minuscole, ad esempio latin1_general_cs( grammatica MySQL ):

CREATE SCHEMA IF NOT EXISTS `myschema` 
DEFAULT CHARACTER SET latin1 
COLLATE latin1_general_cs ;

Questo ha un effetto su cose come il raggruppamento e l'uguaglianza. Per esempio,

create table casetable (
  id int primary key, 
  thing varchar(50)
);

select * from casetable;
+----+-------+
| id | thing |
+----+-------+
|  3 | abc   |
|  4 | ABC   |
|  5 | aBc   |
|  6 | abC   |
+----+-------+

In un database con distinzione tra maiuscole e minuscole, otteniamo:

select thing, count(*) from casetable group by thing;
+-------+----------+
| thing | count(*) |
+-------+----------+
| ABC   |        1 |
| aBc   |        1 |
| abC   |        1 |
| abc   |        1 |
+-------+----------+

select * from casetable where thing = "abc";
+----+-------+
| id | thing |
+----+-------+
|  3 | abc   |
+----+-------+

In un database senza distinzione tra maiuscole e minuscole, otteniamo:

select thing, count(*) from casetable group by thing;
+-------+----------+
| thing | count(*) |
+-------+----------+
| abc   |        4 |
+-------+----------+

select * from casetable where thing = "abc";
+----+-------+
| id | thing |
+----+-------+
|  3 | abc   |
|  4 | ABC   |
|  5 | aBc   |
|  6 | abC   |
+----+-------+

Si noti che è anche possibile modificare le regole di confronto all'interno di una query . Ad esempio, nel database con distinzione tra maiuscole e minuscole , posso fare

select * from casetable where thing collate latin1_swedish_ci = "abc";
+----+-------+
| id | thing |
+----+-------+
|  3 | abc   |
|  4 | ABC   |
|  5 | aBc   |
|  6 | abC   |
+----+-------+

Dovresti sempre indicare con la tua domanda quale versione di MySQL stai usando, perché MySQL è in costante sviluppo.

Ok, torniamo alla tua domanda:

Le funzioni di stringa in MySQL sono sempre maiuscole e minuscole, quindi è possibile utilizzare una delle funzioni LOCATE, POSITIONo INSTR.

Per esempio:

SELECT phone FROM user WHERE POSITION('term' IN user_name)>0;

La corrispondenza del modello con l'espressione regolare ( RLIKEo REGEXP) fa sempre distinzione tra maiuscole e minuscole per tutte le versioni di MySQL, tranne la più recente 3.23.4.

Per esempio:

SELECT phone FROM user WHERE user_name REGEXP 'term';

Sia per il confronto normale (=) che per la corrispondenza del modello SQL ( LIKE) il comportamento dipende dai campi coinvolti:

un. CHAR, VARCHARe tutte le varianti dei campi TEXT confrontano la distinzione tra maiuscole e minuscole.

b. CHAR BINARY, VARCHAR BINARY E tutte le varianti di campi BLOB si confrontano tra maiuscole e minuscole.

Se si confronta un campo da (a) con un campo da (b), il confronto farà distinzione tra maiuscole e minuscole (vince la distinzione tra maiuscole e minuscole). Vedere il capitolo "7.2.7 Tipi di stringhe" del Manuale di riferimento di MySQL e cercare le istruzioni su ordinamento e confronti.

A partire da V3.23.0 è anche possibile forzare un confronto nella distinzione tra maiuscole e minuscole con l'operatore di cast BINARY, indipendentemente dai tipi di campi coinvolti. Vedere il capitolo "7.3.7 Operatori di trasmissione" del Manuale di riferimento di MySQL.

Quindi potresti anche cambiare il tipo di user_name o con V3.23.x provare qualcosa del tipo:

SELECT phone FROM user WHERE BINARY username LIKE '%term%';

Nella mia situazione, sto usando Access 2010, ma ho avuto lo stesso problema ma la soluzione è diversa: utilizzare la StrComp()funzione e testare il suo ritorno su zero.

StrComp( thing, 'abc', 0) = 0

Perché StrComp()restituisce -1se il primo argomento è "più piccolo", 1se è "più grande" e 0se è "uguale", quando StrComp()=0si ha una corrispondenza sensibile al maiuscolo / minuscolo.

Vedi qui , qui o qui .

Funzionerà in MySQL indipendentemente dal set di caratteri. SELEZIONA 'test' REGEXP BINARY 'TEST' COME RISULTATO; Mettere 'BINARY' forza un confronto binario.

Prova questo per una ricerca insensibile, funziona benissimo con grandi prestazioni:

"SELECT phone FROM user WHERE lower(user_name) like ".srtlower($username);