Mam tabelę z ~ 500 tys. Rzędów; varchar (255) kolumna UTF8 filenamezawiera nazwę pliku;

Próbuję usunąć różne dziwne znaki z nazwy pliku - pomyślałem, że użyję klasy znaków: [^a-zA-Z0-9()_ .\-]

Czy w MySQL jest funkcja, która pozwala zastąpić wyrażenie regularne ? Szukam funkcji podobnej do funkcji REPLACE () - uproszczony przykład poniżej:

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

Output: "stackoverflow"

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

Output: "-tackover-low"

Wiem o REGEXP / RLIKE , ale sprawdzają one tylko, czy istnieje dopasowanie, a nie to , co to jest dopasowanie.

( Mógłbym zrobić „ SELECT pkey_id,filename FROM foo WHERE filename RLIKE '[^a-zA-Z0-9()_ .\-]'” ze skryptu PHP, zrobić preg_replacea potem „ UPDATE foo ... WHERE pkey_id=...”, ale to wygląda na ostateczny powolny i brzydki hack)

Z MySQL 8.0+ możesz używać REGEXP_REPLACEfunkcji natywnej .

12.5.2 Wyrażenia regularne :

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

Zamienia wystąpienia w wyrażeniu ciągu pasujące do wyrażenia regularnego określonego przez pat wzoru na zastępujący ciąg repl i zwraca łańcuch wynikowy. Jeśli expr , pat lub repl jest NULL, zwracana jest wartość NULL.

i obsługa wyrażeń regularnych :

Wcześniej MySQL korzystał z biblioteki wyrażeń regularnych Henry Spencer do obsługi operatorów wyrażeń regularnych ( REGEXP, RLIKE).

Obsługa wyrażeń regularnych została ponownie zaimplementowana przy użyciu International Components for Unicode (ICU), który zapewnia pełną obsługę Unicode i jest bezpieczny dla wielu bajtów. REGEXP_LIKE()Funkcja wykonuje regularne dostosowywanie wyraz w sposobie porozumiewania się REGEXPi RLIKEpodmiotów, które obecnie są synonimami dla tej funkcji. Ponadto REGEXP_INSTR(), REGEXP_REPLACE()i REGEXP_SUBSTR() działa w celu znalezienia dopasowania położenia i wykonywać podciąg podstawienia i ekstrakcji, odpowiednio.

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

DBFiddle Demo

MySQL 8.0+ :

Możesz użyć natywnego REGEXP_REPLACE funkcji .

Starsza wersja:

Możesz użyć funkcji zdefiniowanej przez użytkownika ( UDF ), takiej jak mysql-udf-regexp .

Zamiast tego użyj MariaDB. Ma funkcję

REGEXP_REPLACE(col, regexp, replace)

Zobacz dokumenty MariaDB i rozszerzenia wyrażeń regularnych PCRE

Pamiętaj, że możesz także użyć grupowania wyrażeń regularnych (uważam, że to bardzo przydatne):

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

zwroty

over - stack - flow

Moja metoda brutalnej siły, aby to zadziałało, to:

1. Zrzuć stół - mysqldump -u user -p database table > dump.sql
2. Znajdź i zamień kilka wzorców - find /path/to/dump.sql -type f -exec sed -i 's/old_string/new_string/g' {} \;Istnieją oczywiście inne wyrażenia regularne perla, które możesz wykonać na pliku.
3. Zaimportuj tabelę - mysqlimport -u user -p database table < dump.sql

Jeśli chcesz się upewnić, że ciąg nie znajduje się w innym miejscu w zestawie danych, uruchom kilka wyrażeń regularnych, aby upewnić się, że wszystkie występują w podobnym środowisku. Tworzenie kopii zapasowej nie jest również trudne przed uruchomieniem zastępowania, na wypadek, gdyby przypadkowo zniszczyłeś coś, co traci głębię informacji.

rozwiązujemy ten problem bez użycia wyrażenia regularnego to zapytanie zastępuje tylko ciąg dokładnie dopasowany.

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

Przykład:

emp_id nazwa_pierwszego pracownika

1 jay

2 sójka ajay

3 jay

Po wykonaniu wyniku zapytania:

emp_id nazwa_pierwszego pracownika

1 abc

2 abc ajay

3 abc

Niedawno napisałem funkcję MySQL do zamiany ciągów za pomocą wyrażeń regularnych. Możesz znaleźć mój post w następującej lokalizacji:

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

Oto kod funkcji:

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 ;

Przykładowe wykonanie:

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

Z przyjemnością informuję, że skoro zadano to pytanie, teraz jest zadowalająca odpowiedź! Spójrz na ten wspaniały pakiet:

https://github.com/mysqludf/lib_mysqludf_preg

Przykładowy SQL:

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

Znalazłem paczkę z tego postu na blogu jako link do tego pytania .

AKTUALIZACJA 2: Użyteczny zestaw funkcji wyrażeń regularnych, w tym REGEXP_REPLACE , został teraz udostępniony w MySQL 8.0. Czyni to czytanie niepotrzebnym, chyba że jesteś ograniczony do używania wcześniejszej wersji.

AKTUALIZACJA 1: Zrobiłem to z postu na blogu: http://stevettt.blogspot.co.uk/2018/02/a-mysql-regular-expression-replace.html

Poniższe rozwinięcie funkcji Rasika Godawatte, ale przeszukuje wszystkie niezbędne podłańcuchy, a nie tylko testuje pojedyncze znaki:

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

Próbny

Demo Rextester

Ograniczenia

1. Ta metoda oczywiście potrwa chwilę, gdy ciąg znaków jest duży. Aktualizacja: Dodano teraz parametry minimalnej i maksymalnej długości dopasowania w celu poprawy wydajności, gdy są one znane (zero = nieznany / nieograniczony).
2. To nie pozwala podstawienie wstecznych (na przykład \1, \2 etc.) w celu zastąpienia grup przechwytywanie. Jeśli ta funkcja jest potrzebna, zapoznaj się z tą odpowiedzią która próbuje zapewnić obejście, aktualizując funkcję, aby umożliwić wtórne wyszukiwanie i zamianę w każdym znalezionym dopasowaniu (kosztem zwiększonej złożoności).
3. Jeśli ^i / lub $jest używany we wzorcu, muszą znajdować się odpowiednio na samym początku i na samym końcu - np. Wzorce, (^start|end$)które nie są obsługiwane.
4. Istnieje flaga „chciwa”, która określa, czy ogólne dopasowanie powinno być zachłanne, czy nie. Łączenie zachłannego i leniwego dopasowywania w jednym wyrażeniu regularnym (np. a.*?b.*) Nie jest obsługiwane.

Przykłady użycia

Funkcja została użyta do odpowiedzi na następujące pytania StackOverflow:

• Jak liczyć słowa w MySQL / zamienniku wyrażeń regularnych?
• Jak wyodrębnić n-te słowo i policzyć wystąpienia słów w ciągu MySQL?
• Jak wyodrębnić dwie kolejne cyfry z pola tekstowego w MySQL?
• Jak usunąć wszystkie znaki alfanumeryczne z ciągu znaków w MySQL?
• Jak zamienić każdą inną instancję określonego znaku w łańcuchu MySQL?
• Jak uzyskać wszystkie wyraźne słowa o określonej minimalnej długości z wielu kolumn w tabeli MySQL?

Możesz to zrobić ... ale nie jest to zbyt mądre ... jest to tak odważne, jak spróbuję ... o ile pełne wsparcie RegEx będzie znacznie lepsze przy użyciu Perla lub podobnego.

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

Możemy użyć warunku IF w zapytaniu SELECT, jak poniżej:

Załóżmy, że dla czegokolwiek z „ABC”, „ABC1”, „ABC2”, „ABC3”, ... chcemy zastąpić „ABC”, a następnie używając warunku REGEXP i IF () w zapytaniu SELECT, możemy to osiągnąć .

Składnia:

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

Przykład:

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

Poniższy w zasadzie znajduje pierwsze dopasowanie od lewej, a następnie zastępuje wszystkie jego wystąpienia (testowane w mysql-5.6).

Stosowanie:

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

Realizacja:

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 ;

Myślę, że istnieje prosty sposób na osiągnięcie tego i działa dobrze dla mnie.

Aby WYBRAĆ wiersze za pomocą REGEX

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

Aby zaktualizować wiersze za pomocą REGEX

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'

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