~ 500k satır içeren bir tablo var; varchar (255) UTF8 sütunu filenamebir dosya adı içerir;

Ben dosya adı dışında çeşitli garip karakterler çıkarmaya çalışıyorum - bir karakter sınıfı kullanmak düşündüm: [^a-zA-Z0-9()_ .\-]

Şimdi, MySQL'de normal bir ifade ile değiştirmenize izin veren bir fonksiyon var mı? Basitleştirilmiş örnek aşağıdaki gibi REPLACE () işlevine benzer bir işlev arıyorum:

SELECT REPLACE('stackowerflow', 'ower', 'over');

Output: "stackoverflow"

/* does something like this exist? */
SELECT X_REG_REPLACE('Stackoverflow','/[A-Zf]/','-'); 

Output: "-tackover-low"

REGEXP / RLIKE hakkında biliyorum , ama bunlar sadece bir maç olup olmadığını kontrol ediyor , maçın ne olduğunu değil .

(I olabilir bir "do SELECT pkey_id,filename FROM foo WHERE filename RLIKE '[^a-zA-Z0-9()_ .\-]'" bir PHP komut dosyasından, bir do preg_replaceardından ve " UPDATE foo ... WHERE pkey_id=...", ancak böyle olduğu görünüyor yavaş ve çirkin kesmek son çare)

MySQL 8.0+ ile yerel REGEXP_REPLACEişlevi kullanabilirsiniz .

12.5.2 Normal İfadeler :

REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])

Yerini dize içinde oluşumları expre deseni ile belirtilen düzenli ifadeyi eşleştirmek pat yedek dize ile repl ve döner çıkan dize. Eğer expr , pat veya repl olduğu NULL, dönüş değeridir NULL.

ve Düzenli ifade desteği :

Daha önce, MySQL düzenli ifade operatörlerini ( REGEXP, RLIKE) desteklemek için Henry Spencer düzenli ifade kütüphanesini kullanıyordu .

Tam Unicode desteği sağlayan ve çok baytlı güvenli Uluslararası Unicode Bileşenleri (ICU) kullanılarak düzenli ifade desteği yeniden uygulanmıştır. REGEXP_LIKE()Fonksiyonu şekilde normal ifade eşleştirmesini gerçekleştirir REGEXPve RLIKEşimdi bu işlev için eş olan operatörler. Buna ek olarak, REGEXP_INSTR(), REGEXP_REPLACE()ve REGEXP_SUBSTR() işlevleri eşleme konumlarını bulmak için mevcuttur ve sırasıyla, ikame ve çıkarma substring gerçekleştirmek.

SELECT REGEXP_REPLACE('Stackoverflow','[A-Zf]','-',1,0,'c'); 
-- Output:
-tackover-low

DBFiddle Demosu

MySQL 8.0+ :

Yerel REGEXP_REPLACEişlevi kullanabilirsiniz .

Eski versiyonlar:

Mysql-udf-regexp gibi kullanıcı tanımlı bir işlev ( UDF ) kullanabilirsiniz .

Bunun yerine MariaDB kullanın. Bir işlevi var

REGEXP_REPLACE(col, regexp, replace)

Bkz mariadb dokümanlar ve PCRE Düzenli ifade geliştirmeleri

Not regexp gruplama da kullanabilirsiniz (çok yararlı buldum):

SELECT REGEXP_REPLACE("stackoverflow", "(stack)(over)(flow)", '\\2 - \\1 - \\3')

İadeler

over - stack - flow

Bu işe almak için kaba kuvvet yöntemi sadece:

1. Masayı boşaltın - mysqldump -u user -p database table > dump.sql
2. Birkaç desen bulun ve değiştirin - find /path/to/dump.sql -type f -exec sed -i 's/old_string/new_string/g' {} \;, Açıkçası dosyada da yapabileceğiniz diğer perl regeular ifadeleri var.
3. Tabloyu içe aktarın - mysqlimport -u user -p database table < dump.sql

Dizenin veri kümenizin başka bir yerinde olmadığından emin olmak istiyorsanız, hepsinin benzer bir ortamda gerçekleştiğinden emin olmak için birkaç normal ifade çalıştırın. Ayrıca, bilgi derinliğini kaybeden bir şeyi yanlışlıkla yok etmeniz durumunda, bir yedek çalıştırmadan önce yedek oluşturmak da zor değildir.

regex kullanmadan bu sorunu yalnızca tam eşleme dizesinin yerini alıyoruz.

update employee set
employee_firstname = 
trim(REPLACE(concat(" ",employee_firstname," "),' jay ',' abc '))

Misal:

emp_id çalışan_firmaadı

1 alakarga

2 jay ajay

3 alakarga

Sorgu sonucunu yürüttükten sonra:

emp_id çalışan_firmaadı

1 abc

2 abc ajay

3 abc

Son zamanlarda düzenli ifadeler kullanarak dizeleri değiştirmek için bir MySQL işlevi yazdım. Yazımı şu konumda bulabilirsiniz:

http://techras.wordpress.com/2011/06/02/regex-replace-for-mysql/

İşlev kodu şöyledir:

DELIMITER $$

CREATE FUNCTION  `regex_replace`(pattern VARCHAR(1000),replacement VARCHAR(1000),original VARCHAR(1000))
RETURNS VARCHAR(1000)
DETERMINISTIC
BEGIN 
 DECLARE temp VARCHAR(1000); 
 DECLARE ch VARCHAR(1); 
 DECLARE i INT;
 SET i = 1;
 SET temp = '';
 IF original REGEXP pattern THEN 
  loop_label: LOOP 
   IF i>CHAR_LENGTH(original) THEN
    LEAVE loop_label;  
   END IF;
   SET ch = SUBSTRING(original,i,1);
   IF NOT ch REGEXP pattern THEN
    SET temp = CONCAT(temp,ch);
   ELSE
    SET temp = CONCAT(temp,replacement);
   END IF;
   SET i=i+1;
  END LOOP;
 ELSE
  SET temp = original;
 END IF;
 RETURN temp;
END$$

DELIMITER ;

Örnek yürütme:

mysql> select regex_replace('[^a-zA-Z0-9\-]','','2my test3_text-to. check \\ my- sql (regular) ,expressions ._,');

Bu soru sorulduğundan beri artık tatmin edici bir cevap olduğunu bildirmekten mutluluk duyuyorum! Bu müthiş pakete bir göz atın:

https://github.com/mysqludf/lib_mysqludf_preg

Örnek SQL:

SELECT PREG_REPLACE('/(.*?)(fox)/' , 'dog' , 'the quick brown fox' ) AS demo;

Bu blog gönderisindeki paketi bu soruya bağlı olarak buldum .

GÜNCELLEME 2: MySQL 8.0'da REGEXP_REPLACE dahil olmak üzere yararlı normal ifade işlevleri seti sağlanmıştır. Bu, daha önceki bir sürümü kullanmakla sınırlı olmadığınız sürece okumayı gereksiz kılar.

GÜNCELLEME 1: Şimdi bunu bir blog yayınına dönüştürdüm: http://stevettt.blogspot.co.uk/2018/02/a-mysql-regular-expression-replace.html

Aşağıdakiler Rasika Godawatte tarafından sağlanan işlevi genişletir, ancak yalnızca tek karakterleri test etmek yerine gerekli tüm alt dizelerde dolaşır :

-- ------------------------------------------------------------------------------------
-- USAGE
-- ------------------------------------------------------------------------------------
-- SELECT reg_replace(<subject>,
--                    <pattern>,
--                    <replacement>,
--                    <greedy>,
--                    <minMatchLen>,
--                    <maxMatchLen>);
-- where:
-- <subject> is the string to look in for doing the replacements
-- <pattern> is the regular expression to match against
-- <replacement> is the replacement string
-- <greedy> is TRUE for greedy matching or FALSE for non-greedy matching
-- <minMatchLen> specifies the minimum match length
-- <maxMatchLen> specifies the maximum match length
-- (minMatchLen and maxMatchLen are used to improve efficiency but are
--  optional and can be set to 0 or NULL if not known/required)
-- Example:
-- SELECT reg_replace(txt, '^[Tt][^ ]* ', 'a', TRUE, 2, 0) FROM tbl;
DROP FUNCTION IF EXISTS reg_replace;
DELIMITER //
CREATE FUNCTION reg_replace(subject VARCHAR(21845), pattern VARCHAR(21845),
  replacement VARCHAR(21845), greedy BOOLEAN, minMatchLen INT, maxMatchLen INT)
RETURNS VARCHAR(21845) DETERMINISTIC BEGIN 
  DECLARE result, subStr, usePattern VARCHAR(21845); 
  DECLARE startPos, prevStartPos, startInc, len, lenInc INT;
  IF subject REGEXP pattern THEN
    SET result = '';
    -- Sanitize input parameter values
    SET minMatchLen = IF(minMatchLen < 1, 1, minMatchLen);
    SET maxMatchLen = IF(maxMatchLen < 1 OR maxMatchLen > CHAR_LENGTH(subject),
                         CHAR_LENGTH(subject), maxMatchLen);
    -- Set the pattern to use to match an entire string rather than part of a string
    SET usePattern = IF (LEFT(pattern, 1) = '^', pattern, CONCAT('^', pattern));
    SET usePattern = IF (RIGHT(pattern, 1) = '$', usePattern, CONCAT(usePattern, '$'));
    -- Set start position to 1 if pattern starts with ^ or doesn't end with $.
    IF LEFT(pattern, 1) = '^' OR RIGHT(pattern, 1) <> '$' THEN
      SET startPos = 1, startInc = 1;
    -- Otherwise (i.e. pattern ends with $ but doesn't start with ^): Set start pos
    -- to the min or max match length from the end (depending on "greedy" flag).
    ELSEIF greedy THEN
      SET startPos = CHAR_LENGTH(subject) - maxMatchLen + 1, startInc = 1;
    ELSE
      SET startPos = CHAR_LENGTH(subject) - minMatchLen + 1, startInc = -1;
    END IF;
    WHILE startPos >= 1 AND startPos <= CHAR_LENGTH(subject)
      AND startPos + minMatchLen - 1 <= CHAR_LENGTH(subject)
      AND !(LEFT(pattern, 1) = '^' AND startPos <> 1)
      AND !(RIGHT(pattern, 1) = '$'
            AND startPos + maxMatchLen - 1 < CHAR_LENGTH(subject)) DO
      -- Set start length to maximum if matching greedily or pattern ends with $.
      -- Otherwise set starting length to the minimum match length.
      IF greedy OR RIGHT(pattern, 1) = '$' THEN
        SET len = LEAST(CHAR_LENGTH(subject) - startPos + 1, maxMatchLen), lenInc = -1;
      ELSE
        SET len = minMatchLen, lenInc = 1;
      END IF;
      SET prevStartPos = startPos;
      lenLoop: WHILE len >= 1 AND len <= maxMatchLen
                 AND startPos + len - 1 <= CHAR_LENGTH(subject)
                 AND !(RIGHT(pattern, 1) = '$' 
                       AND startPos + len - 1 <> CHAR_LENGTH(subject)) DO
        SET subStr = SUBSTRING(subject, startPos, len);
        IF subStr REGEXP usePattern THEN
          SET result = IF(startInc = 1,
                          CONCAT(result, replacement), CONCAT(replacement, result));
          SET startPos = startPos + startInc * len;
          LEAVE lenLoop;
        END IF;
        SET len = len + lenInc;
      END WHILE;
      IF (startPos = prevStartPos) THEN
        SET result = IF(startInc = 1, CONCAT(result, SUBSTRING(subject, startPos, 1)),
                        CONCAT(SUBSTRING(subject, startPos, 1), result));
        SET startPos = startPos + startInc;
      END IF;
    END WHILE;
    IF startInc = 1 AND startPos <= CHAR_LENGTH(subject) THEN
      SET result = CONCAT(result, RIGHT(subject, CHAR_LENGTH(subject) + 1 - startPos));
    ELSEIF startInc = -1 AND startPos >= 1 THEN
      SET result = CONCAT(LEFT(subject, startPos), result);
    END IF;
  ELSE
    SET result = subject;
  END IF;
  RETURN result;
END//
DELIMITER ;

gösteri

Rextester Demosu

Sınırlamalar

1. Bu yöntem elbette konu dizesi büyük olduğunda biraz zaman alacaktır. Güncelleme: Artık bilindiği zaman verimliliği artırmak için minimum ve maksimum eşleşme uzunluğu parametreleri ekledik (sıfır = bilinmeyen / sınırsız).
2. Bu olmaz geribaşvuruların (örn ikamesine imkan verir \1, \2 yakalama gruplarını değiştirmek için vs.). Bu işlevsellik gerekiyorsa, bulunan her bir eşleşme içinde (artan karmaşıklık pahasına) ikincil bir bulma ve değiştirme işlevini güncelleyerek bir geçici çözüm sağlamaya çalışan bu yanıta bakın .
3. Eğer ^ve / veya $gibi mesela desenleri - desende kullanılan, çok başlatmak ve çok sırasıyla sona olmalıdır (^start|end$)desteklenmez.
4. Genel eşleşmenin açgözlü veya açgözlü olmamasını belirten "açgözlü" bir bayrak vardır. Açgözlü ve tembel eşleşmeyi tek bir düzenli ifade (örneğin a.*?b.*) içinde birleştirmek desteklenmez.

Kullanım örnekleri

İşlev, aşağıdaki StackOverflow sorularını cevaplamak için kullanılmıştır:

• MySQL / normal ifade değiştiricideki kelimeleri nasıl sayabilirim?
• MySQL dizesinde n'inci sözcüğü ayıklama ve sözcük oluşumlarını sayma
• MySQL'deki bir metin alanından iki ardışık hane nasıl çıkarılır?
• MySQL'de bir dizeden alfa olmayan tüm sayısal karakterler nasıl kaldırılır?
• MySQL dizesindeki belirli bir karakterin diğer tüm örneklerini nasıl değiştirebilirim?
• Bir MySQL tablosundaki birden çok sütundan belirli bir minimum uzunluktaki tüm farklı kelimeleri nasıl alabilirim?

Yapabilirsin ... ama çok akıllıca değil ... bu deneyeceğim kadar cüretkar ... tam RegEx kadar perl veya benzeri kullanarak çok daha iyi destek.

UPDATE db.tbl
SET column = 
CASE 
WHEN column REGEXP '[[:<:]]WORD_TO_REPLACE[[:>:]]' 
THEN REPLACE(column,'WORD_TO_REPLACE','REPLACEMENT')
END 
WHERE column REGEXP '[[:<:]]WORD_TO_REPLACE[[:>:]]'

SELECT sorgusunda IF koşulunu aşağıdaki gibi kullanabiliriz:

"ABC", "ABC1", "ABC2", "ABC3", ... ile ilgili herhangi bir şey için, "ABC" ile değiştirmek ve ardından SELECT sorgusunda REGEXP ve IF () koşulunu kullanmak istediğimizi varsayalım. .

Sözdizimi:

SELECT IF(column_name REGEXP 'ABC[0-9]$','ABC',column_name)
FROM table1 
WHERE column_name LIKE 'ABC%';

Misal:

SELECT IF('ABC1' REGEXP 'ABC[0-9]$','ABC','ABC1');

Aşağıdaki maç temel olarak soldan ilk eşleşmeyi bulur ve ardından tüm tekrarlarını değiştirir ( mysql-5.6).

Kullanımı:

SELECT REGEX_REPLACE('dis ambiguity', 'dis[[:space:]]*ambiguity', 'disambiguity');

Uygulama:

DELIMITER $$
CREATE FUNCTION REGEX_REPLACE(
  var_original VARCHAR(1000),
  var_pattern VARCHAR(1000),
  var_replacement VARCHAR(1000)
  ) RETURNS
    VARCHAR(1000)
  COMMENT 'Based on https://techras.wordpress.com/2011/06/02/regex-replace-for-mysql/'
BEGIN
  DECLARE var_replaced VARCHAR(1000) DEFAULT var_original;
  DECLARE var_leftmost_match VARCHAR(1000) DEFAULT
    REGEX_CAPTURE_LEFTMOST(var_original, var_pattern);
    WHILE var_leftmost_match IS NOT NULL DO
      IF var_replacement <> var_leftmost_match THEN
        SET var_replaced = REPLACE(var_replaced, var_leftmost_match, var_replacement);
        SET var_leftmost_match = REGEX_CAPTURE_LEFTMOST(var_replaced, var_pattern);
        ELSE
          SET var_leftmost_match = NULL;
        END IF;
      END WHILE;
  RETURN var_replaced;
END $$
DELIMITER ;

DELIMITER $$
CREATE FUNCTION REGEX_CAPTURE_LEFTMOST(
  var_original VARCHAR(1000),
  var_pattern VARCHAR(1000)
  ) RETURNS
    VARCHAR(1000)
  COMMENT '
  Captures the leftmost substring that matches the [var_pattern]
  IN [var_original], OR NULL if no match.
  '
BEGIN
  DECLARE var_temp_l VARCHAR(1000);
  DECLARE var_temp_r VARCHAR(1000);
  DECLARE var_left_trim_index INT;
  DECLARE var_right_trim_index INT;
  SET var_left_trim_index = 1;
  SET var_right_trim_index = 1;
  SET var_temp_l = '';
  SET var_temp_r = '';
  WHILE (CHAR_LENGTH(var_original) >= var_left_trim_index) DO
    SET var_temp_l = LEFT(var_original, var_left_trim_index);
    IF var_temp_l REGEXP var_pattern THEN
      WHILE (CHAR_LENGTH(var_temp_l) >= var_right_trim_index) DO
        SET var_temp_r = RIGHT(var_temp_l, var_right_trim_index);
        IF var_temp_r REGEXP var_pattern THEN
          RETURN var_temp_r;
          END IF;
        SET var_right_trim_index = var_right_trim_index + 1;
        END WHILE;
      END IF;
    SET var_left_trim_index = var_left_trim_index + 1;
    END WHILE;
  RETURN NULL;
END $$
DELIMITER ;

Bunu başarmanın kolay bir yolu olduğunu düşünüyorum ve benim için iyi çalışıyor.

REGEX kullanarak satırları SEÇME

SELECT * FROM `table_name` WHERE `column_name_to_find` REGEXP 'string-to-find'

REGEX kullanarak satırları GÜNCELLEME

UPDATE `table_name` SET column_name_to_find=REGEXP_REPLACE(column_name_to_find, 'string-to-find', 'string-to-replace') WHERE column_name_to_find REGEXP 'string-to-find'

REGEXP Referansı: https://www.geeksforgeeks.org/mysql-regular-expressions-regexp/