Tengo una tabla con ~ 500k filas; La columna varchar (255) UTF8 filenamecontiene un nombre de archivo;

Estoy tratando de eliminar varios caracteres extraños del nombre de archivo, pensé que usaría una clase de caracteres: [^a-zA-Z0-9()_ .\-]

Ahora, ¿hay una función en MySQL que le permita reemplazar a través de una expresión regular ? Estoy buscando una funcionalidad similar a la función REPLACE (): a continuación se muestra un ejemplo simplificado:

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

Output: "stackoverflow"

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

Output: "-tackover-low"

Sé acerca de REGEXP / RLIKE , pero esos solo comprueban si hay una coincidencia, no cuál es la coincidencia.

( Podría hacer un " SELECT pkey_id,filename FROM foo WHERE filename RLIKE '[^a-zA-Z0-9()_ .\-]'" desde un script PHP, hacer un preg_replacey luego " UPDATE foo ... WHERE pkey_id=...", pero parece un truco lento y feo de último recurso)

Con MySQL 8.0+ puede usar la REGEXP_REPLACEfunción nativa .

12.5.2 Expresiones regulares :

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

Reemplaza las ocurrencias en la cadena expr que coinciden con la expresión regular especificada por el patrón pat con la respuesta de la cadena de reemplazo , y devuelve la cadena resultante. Si expr , pat o repl es NULL, el valor de retorno es NULL.

y soporte de expresiones regulares :

Anteriormente, MySQL usaba la biblioteca de expresiones regulares de Henry Spencer para admitir operadores de expresiones regulares ( REGEXP, RLIKE).

El soporte de expresiones regulares se ha reimplementado utilizando International Components for Unicode (ICU), que proporciona soporte completo de Unicode y es seguro para múltiples bytes. La REGEXP_LIKE()función realiza una coincidencia de expresiones regulares a la manera deREGEXPRLIKE operadores y , que ahora son sinónimos de esa función. Además, el REGEXP_INSTR(), REGEXP_REPLACE()y REGEXP_SUBSTR() las funciones están disponibles para encontrar las posiciones de los partidos y llevar a cabo la sustitución de subcadenas y extracción, respectivamente.

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

DBFiddle Demo

MySQL 8.0+ :

Puedes usar la REGEXP_REPLACEfunción nativa .

Versiones anteriores:

Puede usar una función definida por el usuario ( UDF ) como mysql-udf-regexp .

Utilice MariaDB en su lugar. Tiene una funcion

REGEXP_REPLACE(col, regexp, replace)

Ver MariaDB docs y PCRE Mejoras de expresión regular

Tenga en cuenta que también puede usar la agrupación regexp (lo encontré muy útil):

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

devoluciones

over - stack - flow

Mi método de fuerza bruta para hacer que esto funcione fue simplemente:

1. Volcar la mesa mysqldump -u user -p database table > dump.sql
2. Encuentre y reemplace un par de patrones find /path/to/dump.sql -type f -exec sed -i 's/old_string/new_string/g' {} \;, obviamente, también hay otras expresiones regeulares perl que podría realizar en el archivo.
3. Importar la tabla - mysqlimport -u user -p database table < dump.sql

Si desea asegurarse de que la cadena no esté en otra parte de su conjunto de datos, ejecute algunas expresiones regulares para asegurarse de que todas ocurran en un entorno similar. Tampoco es tan difícil crear una copia de seguridad antes de ejecutar un reemplazo, en caso de que destruya accidentalmente algo que pierde profundidad de información.

resolvemos este problema sin usar regex, esta consulta reemplaza solo la cadena de coincidencia exacta.

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

Ejemplo:

emp_id employee_firstname

1 jay

2 jay ajay

3 jay

Después de ejecutar el resultado de la consulta:

emp_id employee_firstname

1 abc

2 abc ajay

3 abc

Recientemente escribí una función MySQL para reemplazar cadenas usando expresiones regulares. Puedes encontrar mi publicación en la siguiente ubicación:

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

Aquí está el código de función:

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 ;

Ejecución de ejemplo:

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

Me complace informar que, dado que se hizo esta pregunta, ¡ahora hay una respuesta satisfactoria! Eche un vistazo a este excelente paquete:

https://github.com/mysqludf/lib_mysqludf_preg

SQL de muestra:

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

Encontré el paquete de esta publicación de blog como vinculado a esta pregunta .

ACTUALIZACIÓN 2: Un conjunto útil de funciones regex que incluye REGEXP_REPLACE ahora se ha proporcionado en MySQL 8.0. Esto hace que la lectura sea innecesaria a menos que esté limitado a usar una versión anterior.

ACTUALIZACIÓN 1: Ahora he convertido esto en una publicación de blog: http://stevettt.blogspot.co.uk/2018/02/a-mysql-regular-expression-replace.html

Lo siguiente se expande sobre la función proporcionada por Rasika Godawatte, pero rastrea todas las subcadenas necesarias en lugar de solo probar caracteres individuales:

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

Manifestación

Demo de Rextester

Limitaciones

1. Por supuesto, este método llevará un tiempo cuando la cadena de asunto es grande. Actualización: ahora se han agregado parámetros de longitud de coincidencia mínima y máxima para mejorar la eficiencia cuando se conocen (cero = desconocido / ilimitado).
2. Es no permitir sustitución de referencias hacia atrás (por ejemplo \1, \2 etc.) para sustituir a los grupos de captura. Si se necesita esta funcionalidad, consulte esta respuesta que intenta proporcionar una solución alternativa actualizando la función para permitir una búsqueda y reemplazo secundario dentro de cada coincidencia encontrada (a expensas de una mayor complejidad).
3. Si ^y / o $se usa en el patrón, deben estar al principio y al final respectivamente, por ejemplo, patrones como los que (^start|end$)no son compatibles.
4. Hay un indicador "codicioso" para especificar si la coincidencia general debe ser codiciosa o no codiciosa. a.*?b.*No se admite la combinación de coincidencia codiciosa y perezosa dentro de una sola expresión regular (p . Ej. ).

Ejemplos de uso

La función se ha utilizado para responder las siguientes preguntas de StackOverflow:

• ¿Cómo contar palabras en MySQL / sustituto de expresión regular?
• ¿Cómo extraer la enésima palabra y contar las apariciones de palabras en una cadena MySQL?
• ¿Cómo extraer dos dígitos consecutivos de un campo de texto en MySQL?
• ¿Cómo eliminar todos los caracteres no alfanuméricos de una cadena en MySQL?
• ¿Cómo reemplazar cualquier otra instancia de un personaje en particular en una cadena MySQL?
• ¿Cómo obtener todas las palabras distintas de una longitud mínima especificada de varias columnas en una tabla MySQL?

Puede 'hacerlo' ... pero no es muy sabio ... esto es tan atrevido como lo intentaré ... en la medida en que RegEx completo lo respalde mucho mejor usando perl o similares.

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

Podemos usar la condición IF en la consulta SELECT de la siguiente manera:

Supongamos que para cualquier cosa con "ABC", "ABC1", "ABC2", "ABC3", ..., queremos reemplazar con "ABC" y luego usar la condición REGEXP e IF () en la consulta SELECT, podemos lograr esto .

Sintaxis:

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

Ejemplo:

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

Básicamente, el siguiente encuentra la primera coincidencia desde la izquierda y luego reemplaza todas las ocurrencias (probada en mysql-5.6)

Uso:

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

Implementación:

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 ;

Creo que hay una manera fácil de lograr esto y está funcionando bien para mí.

Para SELECCIONAR filas usando REGEX

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

Para ACTUALIZAR filas usando 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'

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