Sélection insensible à la casse MySQL

Quelqu'un peut-il me dire si une SELECTrequête MySQL est sensible à la casse ou à la casse par défaut? Et sinon, quelle requête devrais-je envoyer pour que je puisse faire quelque chose comme:

SELECT * FROM `table` WHERE `Value` = "iaresavage"

Alors qu'en réalité, la valeur réelle de Valueest IAreSavage.

Ils ne sont pas sensibles à la casse , sauf si vous effectuez une comparaison binaire .

Vous pouvez minuscule la valeur et le paramètre passé:

SELECT * FROM `table` WHERE LOWER(`Value`) = LOWER("IAreSavage")

Une autre (meilleure) façon serait d'utiliser l' COLLATEopérateur comme indiqué dans la documentation

UTILISER BINARY

Ceci est une simple sélection

SELECT * FROM myTable WHERE 'something' = 'Something'

= 1

Ceci est une sélection avec binaire

SELECT * FROM myTable WHERE BINARY 'something' = 'Something'

ou

SELECT * FROM myTable WHERE 'something' = BINARY 'Something'

= 0

Les comparaisons ne respectent pas la casse lorsque la colonne utilise un classement qui se termine par _ci(comme le classement par défaut latin1_general_ci ) et sont sensibles à la casse lorsque la colonne utilise un classement qui se termine par _csou _bin(comme les classements utf8_unicode_cset utf8_bin).

Vérifier le classement

Vous pouvez vérifier votre serveur , votre base de données et vos classements de connexion en utilisant:

mysql> show variables like '%collation%';
+----------------------+-------------------+
| Variable_name        | Value             |
+----------------------+-------------------+
| collation_connection | utf8_general_ci   |
| collation_database   | latin1_swedish_ci |
| collation_server     | latin1_swedish_ci |
+----------------------+-------------------+

et vous pouvez vérifier le classement de votre table en utilisant:

mysql> SELECT table_schema, table_name, table_collation 
       FROM information_schema.tables WHERE table_name = `mytable`;
+----------------------+------------+-------------------+
| table_schema         | table_name | table_collation   |
+----------------------+------------+-------------------+
| myschema             | mytable    | latin1_swedish_ci |

Modifier le classement

Vous pouvez modifier le classement de votre base de données, table ou colonne en quelque chose de sensible à la casse comme suit:

-- Change database collation
ALTER DATABASE `databasename` DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;

-- or change table collation
ALTER TABLE `table` CONVERT TO CHARACTER SET utf8 COLLATE utf8_bin;

-- or change column collation
ALTER TABLE `table` CHANGE `Value` 
    `Value` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_bin;

Vos comparaisons doivent désormais être sensibles à la casse.

La comparaison de chaînes dans la phrase WHERE n'est pas sensible à la casse. Vous pouvez essayer de comparer en utilisant

WHERE `colname` = 'keyword'

ou

WHERE `colname` = 'KeyWord'

et vous obtiendrez le même résultat . C'est le comportement par défaut de MySQL.

Si vous voulez que la comparaison soit sensible à la casse , vous pouvez ajouter COLLATEcomme ceci:

WHERE `colname` COLLATE latin1_general_cs = 'KeyWord'

Ce SQL donnerait un résultat différent avec celui-ci: WHERE colnameCOLLATE latin1_general_cs = 'keyword'

latin1_general_cs est un classement commun ou par défaut dans la plupart des bases de données.

Le classement que vous choisissez définit si vous êtes sensible à la casse ou non.

La valeur par défaut est insensible à la casse, mais la prochaine chose la plus importante que vous devriez examiner est la façon dont la table a été créée en premier lieu, car vous pouvez spécifier la sensibilité à la casse lorsque vous créez la table.

Le script ci-dessous crée une table. Remarquez en bas, il est écrit "COLLATE latin1_general_cs". Que cs à la fin signifie sensible à la casse. Si vous vouliez que votre table soit insensible à la casse, vous devez soit laisser cette partie ou utiliser "COLLATE latin1_general_ci".

   CREATE Table PEOPLE (

       USER_ID  INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,

       FIRST_NAME  VARCHAR(50) NOT NULL,
       LAST_NAME  VARCHAR(50) NOT NULL,

       PRIMARY KEY (USER_ID)

   )

   ENGINE=MyISAM DEFAULT CHARACTER SET latin1
    COLLATE latin1_general_cs AUTO_INCREMENT=0;

Si votre projet est tel que vous pouvez créer votre propre table, il est logique de spécifier votre préférence de respect de la casse lorsque vous créez la table.

SQL Select n'est pas sensible à la casse.

Ce lien peut vous montrer comment faire est sensible à la casse: http://web.archive.org/web/20080811231016/http://sqlserver2000.databases.aspfaq.com:80/how-can-i-make-my- sql-queries-case-sensitive.html

Essayez avec:

order by lower(column_name) asc;

Notez également que les noms de table sont sensibles à la casse sous Linux, sauf si vous définissez la lower_case_table_namedirective config sur 1 . En effet, les tables sont représentées par des fichiers sensibles à la casse sous Linux.

Méfiez-vous particulièrement du développement sur Windows qui n'est pas sensible à la casse et du déploiement en production où il se trouve. Par exemple:

"SELECT * from mytable" 

contre la table myTable réussira sous Windows mais échouera sous Linux, encore une fois, à moins que la directive susmentionnée ne soit définie.

Référence ici: http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html

La solution actuellement acceptée est généralement correcte.

Si vous utilisez une chaîne non binaire (CHAR, VARCHAR, TEXT), les comparaisons ne respectent pas la casse , selon le classement par défaut.

Si vous utilisez une chaîne binaire (BINARY, VARBINARY, BLOB), les comparaisons sont sensibles à la casse, vous devrez donc les utiliser LOWERcomme décrit dans d'autres réponses.

Si vous n'utilisez pas le classement par défaut et que vous utilisez une chaîne non binaire, la sensibilité à la casse est déterminée par le classement choisi.

Source: https://dev.mysql.com/doc/refman/8.0/en/case-sensitivity.html . Lisez attentivement. Certains se sont trompés en disant que les comparaisons sont nécessairement sensibles à la casse ou insensibles. Ce n'est pas le cas.

Tu peux l'essayer. j'espère que ce sera utile.

SELECT * FROM `table` WHERE `Value` COLLATE latin1_general_cs = "IAreSavage"

Les champs de chaîne avec l'indicateur binaire défini seront toujours sensibles à la casse. Si vous avez besoin d'une recherche sensible à la casse pour un champ de texte non binaire, utilisez ceci: SELECT 'test' REGEXP BINARY 'TEST' AS RESULT;