Regex motif à l'intérieur de SQL fonction Remplacer?

Vous pouvez utiliser PATINDEX
pour trouver le premier indice de la forme (chaîne) de l'événement. Ensuite, utilisez TRUCS à des choses d'une autre chaîne dans le modèle(chaîne) appariés.

En boucle sur chaque ligne. Remplacer chaque caractère illégal de ce que vous voulez. Dans votre cas, remplacez non numérique avec vide. La boucle intérieure est si vous avez plus d'un caractère illégal dans une cellule de la boucle.

DECLARE @counter int

SET @counter = 0

WHILE(@counter < (SELECT MAX(ID_COLUMN) FROM Table))
BEGIN  

    WHILE 1 = 1
    BEGIN
        DECLARE @RetVal varchar(50)

        SET @RetVal =  (SELECT Column = STUFF(Column, PATINDEX('%[^0-9.]%', Column),1, '')
        FROM Table
        WHERE ID_COLUMN = @counter)

        IF(@RetVal IS NOT NULL)       
          UPDATE Table SET
          Column = @RetVal
          WHERE ID_COLUMN = @counter
        ELSE
            break
    END

    SET @counter = @counter + 1
END

Attention: C'est lent quand même!! Avoir une colonne de type varchar peut avoir un impact. Donc, en utilisant LTRIM RTRIM peut aider un peu. Peu importe, il est lent.

De crédit va à cette StackOverFlow réponse.

MODIFIER
Le mérite en revient aussi à @srutzky

Modifier (par @Tmdean)
Au lieu de faire une ligne à la fois, cette réponse peut être adapté à une série de plus à base de solution. - Il encore itère le max du nombre de caractères non numériques dans une seule ligne, donc il n'est pas l'idéal, mais je pense qu'il devrait être acceptable dans la plupart des situations.

WHILE 1 = 1 BEGIN
    WITH q AS
        (SELECT ID_Column, PATINDEX('%[^0-9.]%', Column) AS n
        FROM Table)
    UPDATE Table
    SET Column = STUFF(Column, q.n, 1, '')
    FROM q
    WHERE Table.ID_Column = q.ID_Column AND q.n != 0;

    IF @@ROWCOUNT = 0 BREAK;
END;

Vous pouvez également améliorer l'efficacité de beaucoup si vous conservez un peu de colonne dans le tableau qui indique si la zone a été nettoyée encore. (NULL représente "Inconnu" dans mon exemple et doit être la colonne par défaut.)

DECLARE @done bit = 0;
WHILE @done = 0 BEGIN
    WITH q AS
        (SELECT ID_Column, PATINDEX('%[^0-9.]%', Column) AS n
        FROM Table
        WHERE COALESCE(Scrubbed_Column, 0) = 0)
    UPDATE Table
    SET Column = STUFF(Column, q.n, 1, ''),
        Scrubbed_Column = 0
    FROM q
    WHERE Table.ID_Column = q.ID_Column AND q.n != 0;

    IF @@ROWCOUNT = 0 SET @done = 1;

    -- if Scrubbed_Column is still NULL, then the PATINDEX
    -- must have given 0
    UPDATE table
    SET Scrubbed_Column = CASE
        WHEN Scrubbed_Column IS NULL THEN 1
        ELSE NULLIF(Scrubbed_Column, 0)
    END;
END;

Si vous ne voulez pas changer votre schéma, c'est facile de s'adapter à stocker des résultats intermédiaires dans une table d'une valeur de la variable qui est appliqué à la table à la fin.

Au lieu d'éliminer la trouvé de caractères par sa seule position, à l'aide de Replace(Column, BadFoundCharacter, '') pourrait être sensiblement plus rapide. En outre, au lieu de simplement remplacer l'un de mauvais caractère suivant dans chaque colonne, il remplace tous ceux trouvés.

WHILE 1 = 1 BEGIN
    UPDATE dbo.YourTable
    SET Column = Replace(Column, Substring(Column, PatIndex('%[^0-9.-]%', Column), 1), '')
    WHERE Column LIKE '%[^0-9.-]%'
    If @@RowCount = 0 BREAK;
END;

Je suis convaincu que cela fonctionne mieux que l'accepté de répondre, si seulement parce qu'il fait moins d'opérations. Il y a d'autres moyens qui pourraient également être plus rapide, mais je n'ai pas le temps d'explorer ceux-ci maintenant.

Voici une fonction que j'ai écrit pour accomplir cette basés sur les réponses précédentes.

CREATE FUNCTION dbo.RepetitiveReplace
(
    @P_String VARCHAR(MAX),
    @P_Pattern VARCHAR(MAX),
    @P_ReplaceString VARCHAR(MAX),
    @P_ReplaceLength INT = 1
)
RETURNS VARCHAR(MAX)
BEGIN
    DECLARE @Index INT;

    -- Get starting point of pattern
    SET @Index = PATINDEX(@P_Pattern, @P_String);

    while @Index > 0
    begin
        --replace matching charactger at index
        SET @P_String = STUFF(@P_String, PATINDEX(@P_Pattern, @P_String), @P_ReplaceLength, @P_ReplaceString);
        SET @Index = PATINDEX(@P_Pattern, @P_String);
    end

    RETURN @P_String;
END;

Gist

Edit:

À l'origine, j'avais une fonction récursive, ici, qui n'a pas bien jouer avec sql server en tant qu'il a un 32 limite de niveau d'imbrication qui aboutirait à une erreur semblable à celui ci-dessous toutes les fois que vous essayez de faire 32+ remplacements avec la fonction. Au lieu d'essayer de faire un serveur de changement de niveau pour permettre à plus de nidification (qui pourrait être dangereux, comme permettent de ne jamais se terminant boucles) de commutation à une boucle while fait beaucoup plus de sens.

Maximale de la procédure stockée, une fonction, un déclencheur ou une vue de niveau d'imbrication dépassé (limite de 32).

Si vous faites cela juste pour un paramètre dans une Procédure Stockée, vous pouvez utiliser les éléments suivants:

while PatIndex('%[^0-9]%', @Param) > 0
    select  @Param = Replace(@Param, Substring(@Param, PatIndex('%[^0-9]%', @Param), 1), '')

J'ai créé cette fonction pour nettoyer une chaîne de caractères contenue non caractères numériques dans un champ de temps. Le temps contenait des points d'interrogation quand ils n'ont pas ajouté les minutes, quelque chose comme 20:??. Fonction boucle de chaque personnage et remplace l' ? avec un 0 :

 CREATE FUNCTION [dbo].[CleanTime]
(
    -- Add the parameters for the function here
    @intime nvarchar(10) 
)
RETURNS nvarchar(5)
AS
BEGIN
    -- Declare the return variable here
    DECLARE @ResultVar nvarchar(5)
    DECLARE @char char(1)
    -- Add the T-SQL statements to compute the return value here
    DECLARE @i int = 1
    WHILE @i <= LEN(@intime)
    BEGIN
    SELECT @char =  CASE WHEN substring(@intime,@i,1) like '%[0-9:]%' THEN substring(@intime,@i,1) ELSE '0' END
    SELECT @ResultVar = concat(@ResultVar,@char)   
    set @i  = @i + 1       
    END;
    -- Return the result of the function
    RETURN @ResultVar

END