Ich habe eine Tabelle mit ~ 500k Zeilen; Die Spalte varchar (255) UTF8 filenameenthält einen Dateinamen.

Ich versuche, verschiedene seltsame Zeichen aus dem Dateinamen zu entfernen - dachte, ich würde eine Zeichenklasse verwenden: [^a-zA-Z0-9()_ .\-]

Gibt es in MySQL eine Funktion, mit der Sie durch einen regulären Ausdruck ersetzen können ? Ich suche nach einer ähnlichen Funktionalität wie die Funktion REPLACE () - es folgt ein vereinfachtes Beispiel:

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

Output: "stackoverflow"

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

Output: "-tackover-low"

Ich weiß über REGEXP / RLIKE Bescheid , aber diese prüfen nur, ob es eine Übereinstimmung gibt, nicht, was die Übereinstimmung ist.

(Ich könnte ein " SELECT pkey_id,filename FROM foo WHERE filename RLIKE '[^a-zA-Z0-9()_ .\-]'" aus einem PHP-Skript machen, ein " preg_replaceund dann" UPDATE foo ... WHERE pkey_id=..."machen, aber das sieht aus wie ein langsamer und hässlicher Hack der letzten Instanz)

Mit MySQL 8.0+ können Sie die native REGEXP_REPLACEFunktion verwenden.

12.5.2 Reguläre Ausdrücke :

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

Ersetzt Vorkommen in der Zeichenkette expr , die den regulären Ausdruck durch das Muster angegebenen übereinstimmen pat mit dem Ersatz - String repl , und gibt den resultierenden String. Wenn expr , pat oder repl ist NULL, ist der Rückgabewert NULL.

und Unterstützung für reguläre Ausdrücke :

Zuvor verwendete MySQL die Henry Spencer-Bibliothek für reguläre Ausdrücke, um Operatoren für reguläre Ausdrücke ( REGEXP, RLIKE) zu unterstützen.

Die Unterstützung für reguläre Ausdrücke wurde mithilfe von International Components for Unicode (ICU) neu implementiert. Diese bietet vollständige Unicode-Unterstützung und ist multibyte-sicher. Die REGEXP_LIKE()Funktion führt einen regulären Ausdrucksabgleich in der Art der Operatoren REGEXPund durch RLIKE, die jetzt Synonyme für diese Funktion sind. Darüber hinaus ist die REGEXP_INSTR(), REGEXP_REPLACE(), und REGEXP_SUBSTR() sind Funktionen zur Verfügung Spiel Positionen zu finden , und die Substitution und Extraktion perform String, respectively.

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

DBFiddle Demo

MySQL 8.0+ :

Sie können die native REGEXP_REPLACEFunktion verwenden.

Ältere Versionen:

Sie können eine benutzerdefinierte Funktion ( UDF ) wie mysql-udf-regexp verwenden .

Verwenden Sie stattdessen MariaDB. Es hat eine Funktion

REGEXP_REPLACE(col, regexp, replace)

Siehe MariaDB-Dokumente und PCRE-Verbesserungen für reguläre Ausdrücke

Beachten Sie, dass Sie auch die Regexp-Gruppierung verwenden können (ich fand das sehr nützlich):

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

kehrt zurück

over - stack - flow

Meine Brute-Force-Methode, um dies zum Laufen zu bringen, war nur:

1. Den Tisch wegwerfen - mysqldump -u user -p database table > dump.sql
2. Suchen und Ersetzen find /path/to/dump.sql -type f -exec sed -i 's/old_string/new_string/g' {} \;einiger Muster - Es gibt offensichtlich andere reguläre Perl-Ausdrücke, die Sie auch für die Datei ausführen können.
3. Tabelle importieren - mysqlimport -u user -p database table < dump.sql

Wenn Sie sicherstellen möchten, dass sich die Zeichenfolge nicht an einer anderen Stelle in Ihrem Dataset befindet, führen Sie einige reguläre Ausdrücke aus, um sicherzustellen, dass sie alle in einer ähnlichen Umgebung vorkommen. Es ist auch nicht so schwierig, ein Backup zu erstellen, bevor Sie einen Ersatz ausführen, falls Sie versehentlich etwas zerstören, das an Informationstiefe verliert.

Wir lösen dieses Problem ohne Verwendung von Regex. Diese Abfrage ersetzt nur die exakte Übereinstimmungszeichenfolge.

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

Beispiel:

emp_id employee_firstname

1 jay

2 jay ajay

3 jay

Nach dem Ausführen des Abfrageergebnisses:

emp_id employee_firstname

1 abc

2 abc ajay

3 abc

Ich habe kürzlich eine MySQL-Funktion geschrieben, um Zeichenfolgen durch reguläre Ausdrücke zu ersetzen. Sie finden meinen Beitrag an folgender Stelle:

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

Hier ist der Funktionscode:

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 ;

Beispielausführung:

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

Ich freue mich, Ihnen mitteilen zu können, dass es seit der Beantwortung dieser Frage eine zufriedenstellende Antwort gibt! Schauen Sie sich dieses tolle Paket an:

https://github.com/mysqludf/lib_mysqludf_preg

Beispiel-SQL:

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

Ich habe das Paket aus diesem Blog-Beitrag gefunden, das auf diese Frage verlinkt ist .

UPDATE 2: In MySQL 8.0 wurde jetzt ein nützlicher Satz von Regex-Funktionen bereitgestellt, einschließlich REGEXP_REPLACE . Dies macht das Lesen unnötig, es sei denn, Sie müssen eine frühere Version verwenden.

UPDATE 1: Habe dies jetzt zu einem Blog-Beitrag gemacht: http://stevettt.blogspot.co.uk/2018/02/a-mysql-regular-expression-replace.html

Das Folgende erweitert die von Rasika Godawatte bereitgestellte Funktion, durchläuft jedoch alle erforderlichen Teilzeichenfolgen, anstatt nur einzelne Zeichen zu testen:

-- ------------------------------------------------------------------------------------
-- 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 ;

Demo

Rextester Demo

Einschränkungen

1. Diese Methode wird natürlich eine Weile dauern, wenn die Betreffzeichenfolge groß ist. Update: Jetzt wurden minimale und maximale Übereinstimmungslängenparameter hinzugefügt, um die Effizienz zu verbessern, wenn diese bekannt sind (Null = unbekannt / unbegrenzt).
2. Es wird nicht die Substitution von Rückreferenzierungen (zB erlauben \1, \2 etc.) erfassen Gruppen zu ersetzen. Wenn diese Funktionalität benötigt wird, lesen Sie bitte diese Antwort die versucht, eine Problemumgehung bereitzustellen, indem Sie die Funktion aktualisieren, um ein sekundäres Suchen und Ersetzen innerhalb jeder gefundenen Übereinstimmung zu ermöglichen (auf Kosten einer erhöhten Komplexität).
3. Wenn ^und / oder $im Muster verwendet wird, müssen sie ganz am Anfang bzw. am Ende stehen - z. B. Muster, (^start|end$)die nicht unterstützt werden.
4. Es gibt ein "gieriges" Flag, um anzugeben, ob die Gesamtübereinstimmung gierig oder nicht gierig sein soll. Das Kombinieren von gierigem und faulem Matching in einem einzelnen regulären Ausdruck (z. B. a.*?b.*) wird nicht unterstützt.

Anwendungsbeispiele

Die Funktion wurde verwendet, um die folgenden StackOverflow-Fragen zu beantworten:

• Wie zähle ich Wörter in MySQL / Ersetzer für reguläre Ausdrücke?
• Wie extrahiere ich das n-te Wort und zähle die Wortvorkommen in einer MySQL-Zeichenfolge?
• Wie extrahiere ich zwei aufeinanderfolgende Ziffern aus einem Textfeld in MySQL?
• Wie entferne ich alle nicht alphanumerischen Zeichen aus einer Zeichenfolge in MySQL?
• Wie ersetze ich jede andere Instanz eines bestimmten Zeichens in einer MySQL-Zeichenfolge?
• Wie erhalte ich alle eindeutigen Wörter einer bestimmten Mindestlänge aus mehreren Spalten in einer MySQL-Tabelle?

Sie können es tun ... aber es ist nicht sehr klug ... das ist ungefähr so ​​gewagt, wie ich es versuchen werde ... soweit die vollständige RegEx-Unterstützung Ihre viel bessere Verwendung von Perl oder dergleichen unterstützt.

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[[:>:]]'

Wir können die IF-Bedingung in der SELECT-Abfrage wie folgt verwenden:

Angenommen, für alles mit "ABC", "ABC1", "ABC2", "ABC3", ... möchten wir durch "ABC" ersetzen und dann die Bedingungen REGEXP und IF () in der SELECT-Abfrage verwenden, um dies zu erreichen .

Syntax:

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

Beispiel:

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

Die folgende findet im Grunde die erste Übereinstimmung von links und ersetzt dann alle Vorkommen davon (getestet in MySQL-5.6).

Verwendungszweck:

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

Implementierung:

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 ;

Ich denke, es gibt einen einfachen Weg, dies zu erreichen, und es funktioniert gut für mich.

Zeilen mit REGEX AUSWÄHLEN

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

Zeilen mit REGEX AKTUALISIEREN

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-Referenz: https://www.geeksforgeeks.org/mysql-regular-expressions-regexp/