Insensibles à la casse REMPLACER dans MySQL?

MySQL fonctionne assez bien toutes les comparaisons de chaînes sous le classement par défaut... sauf la REPLACE de commande. J'ai un classement de casse et de la nécessité d'exécuter un casse REPLACE. Est-il un moyen de forcer REPLACE à utiliser le classement actuel plutôt que de toujours faire de la casse des comparaisons? Je suis prêt à mettre à jour mon MySQL (actuellement en cours d'exécution 5.1) pour obtenir des fonctionnalités supplémentaires...

mysql> charset utf8 collation utf8_unicode_ci;
Charset changed

mysql> select 'abc' like '%B%';
+------------------+
| 'abc' like '%B%' |
+------------------+
|                1 |
+------------------+

mysql> select replace('aAbBcC', 'a', 'f');
+-----------------------------+
| replace('aAbBcC', 'a', 'f') |
+-----------------------------+
| fAbBcC                      |   <--- *NOT* 'ffbBcC'
+-----------------------------+

InformationsquelleAutor dkarp | 2011-04-13

mysql replace

19

Si replace(lower()) ne fonctionne pas, vous aurez besoin de créer une autre fonction.
- J'ai besoin de préserver les cas de non-remplacés reste de la chaîne d'origine, donc pas de.
- Mise à JOUR repSchedule SET Email=REPLACE ( INFÉRIEUR(e-mail), '@xyz.com','@xxyyzz.co."au royaume-uni)
InformationsquelleAutor fvox
7

Mes 2 cents.

Puisque beaucoup de gens ont mis à niveau à partir de MySQL à MariaDB ces personnes auront à disposition une nouvelle fonction appelée REGEXP_REPLACE. L'utiliser comme vous le feriez pour un remplacer, mais le motif est une expression régulière.

C'est un exemple de travail:
```
UPDATE `myTable`
SET `myField` = REGEXP_REPLACE(`myField`, '(?i)my insensitive string', 'new string') 
WHERE `myField` REGEXP '(?i)my insensitive string'
```
L'option (?i) rend tous les autres matches de la casse (si placé au début de la répétition, comme je l'ai ensuite tout est insensible à la casse).

Voir ici pour plus d'informations: https://mariadb.com/kb/en/mariadb/pcre/

Edit: comme MySQL 8.0, vous pouvez maintenant utiliser le regexp_replace fonction, voir la documentation: https://dev.mysql.com/doc/refman/8.0/en/regexp.html
- dans ce cas particulier, le "où ..." une partie n'est pas strictement nécessaire, puisque la fonction remplacera uniquement lorsqu'une correspondance est trouvée, mais j'ai pensé qu'il serait bon de noter que regexp peut être utilisé dans où conditions trop. Btw, les regexp dans où conditions est pris en charge dans la plaine de mysql, mais pas regexp_replace.
InformationsquelleAutor santiago arizti

Autre fonction pour celle qui est parlée par fvox.

DELIMITER |
CREATE FUNCTION case_insensitive_replace ( REPLACE_WHERE text, REPLACE_THIS text, REPLACE_WITH text )
RETURNS text
DETERMINISTIC 
BEGIN
    DECLARE last_occurency int DEFAULT '1';

    IF LCASE(REPLACE_THIS) = LCASE(REPLACE_WITH) OR LENGTH(REPLACE_THIS) < 1 THEN
         RETURN REPLACE_WHERE;
    END IF;

    WHILE Locate( LCASE(REPLACE_THIS), LCASE(REPLACE_WHERE), last_occurency ) > 0  DO
      BEGIN
        SET last_occurency = Locate(LCASE(REPLACE_THIS), LCASE(REPLACE_WHERE));
         SET REPLACE_WHERE = Insert( REPLACE_WHERE, last_occurency, LENGTH(REPLACE_THIS), REPLACE_WITH);
         SET last_occurency = last_occurency + LENGTH(REPLACE_WITH);
      END;
    END WHILE;
    RETURN REPLACE_WHERE;
END;
|
DELIMITER ;

Petit test:

SET @str = BINARY 'New York';
SELECT case_insensitive_replace(@str, 'y', 'K');

Réponses: New Kork

InformationsquelleAutor Aivar

0

Je suis allé avec http://pento.net/2009/02/15/case-insensitive-replace-for-mysql/ (en fvox de réponse) qui effectue la recherche insensible à la casse avec la casse de remplacement et sans changer le cas de ce qui devrait être affectée caractères ailleurs dans la chaîne recherchée.

N. B. le commentaire plus bas sur cette même page indiquant que CHAR(255) doit être modifiée pour être de type VARCHAR(255) - cela semblait être tenus pour moi aussi.

InformationsquelleAutor Wandering Zombie

Cette modification de Luist de réponse permet de remplacer l'aiguille avec un différemment tubé version de l'aiguille (deux lignes de changement).

DELIMITER |
CREATE FUNCTION case_insensitive_replace ( REPLACE_WHERE text, REPLACE_THIS text, REPLACE_WITH text )
RETURNS text
DETERMINISTIC 
BEGIN
  DECLARE last_occurency int DEFAULT '1';

  IF LENGTH(REPLACE_THIS) < 1 THEN
    RETURN REPLACE_WHERE;
  END IF;

  WHILE Locate( LCASE(REPLACE_THIS), LCASE(REPLACE_WHERE), last_occurency ) > 0  DO
    BEGIN
      SET last_occurency = Locate(LCASE(REPLACE_THIS), LCASE(REPLACE_WHERE), last_occurency);
      SET REPLACE_WHERE = Insert( REPLACE_WHERE, last_occurency, LENGTH(REPLACE_THIS), REPLACE_WITH);
       SET last_occurency = last_occurency + LENGTH(REPLACE_WITH);
    END;
  END WHILE;
  RETURN REPLACE_WHERE;
END;
|
DELIMITER ;

InformationsquelleAutor notalbert

0

Dans les réponses précédentes, et l'pento.net lien, les arguments pour LOCATE() sont écrit en minuscule.

C'est un gaspillage de ressources, que RECHERCHEZ est insensible à la casse par défaut:
```
mysql> select locate('el', 'HELLo');
+-----------------------+
| locate('el', 'HELLo') |
+-----------------------+
|                     2 |
+-----------------------+
```
Vous pouvez remplacer

WHILE Locate( LCASE(REPLACE_THIS), LCASE(REPLACE_WHERE), last_occurency ) > 0 DO

avec

WHILE Locate(REPLACE_THIS, REPLACE_WHERE, last_occurency ) > 0 DO

etc.

InformationsquelleAutor fisharebest
0

Dans le cas de caractères 'spéciaux' il y a des comportements inattendus:
```
SELECT case_insensitive_replace('A', 'Ã', 'a')
```
Donne
```
a
```
Qui est inattendu... puisque nous voulons remplacer l'Ã pas Un

Ce qui est encore plus bizarre:
```
SELECT LOCATE('Ã', 'A');
```
donne
```
0
```
Qui est le résultat correct... semble avoir à faire avec le codage des paramètres de la procédure stockée...

InformationsquelleAutor iwritecode

Vous devez vous connecter pour publier un commentaire.