Scinde une chaîne en fonction de l'espace et le caractère délimiteur dans Oracle avec regexp_substr

SQL Violon

Oracle 11g R2 Schéma d'Installation:

CREATE TABLE TEST( str ) AS
          SELECT 'Hello world - test-test! - test' FROM DUAL
UNION ALL SELECT 'Hello world2 - test2 - test-test2' FROM DUAL;

Requête 1:

SELECT Str,
       COLUMN_VALUE AS Occurrence,
       REGEXP_SUBSTR( str ,'(.*?)([[:space:]]-[[:space:]]|$)', 1, COLUMN_VALUE, NULL, 1 ) AS split_value
FROM   TEST,
       TABLE(
         CAST(
           MULTISET(
             SELECT LEVEL
             FROM   DUAL
             CONNECT BY LEVEL < REGEXP_COUNT( str ,'(.*?)([[:space:]]-[[:space:]]|$)' )
           )
           AS SYS.ODCINUMBERLIST
         )
       )

Résultats:

|                               STR | OCCURRENCE |  SPLIT_VALUE |
|----------------------------------- | ------------ | --------------|
|   Hello world - test-test! - test |          1 |  Hello world |
|   Hello world - test-test! - test |          2 |   test-test! |
|   Hello world - test-test! - test |          3 |         test |
| Hello world2 - test2 - test-test2 |          1 | Hello world2 |
| Hello world2 - test2 - test-test2 |          2 |        test2 |
| Hello world2 - test2 - test-test2 |          3 |   test-test2 |

Essayer de nier le match de la chaîne '[[:space:]]-[[:space:]]' en le mettant dans une classe de caractère avec un accent circonflexe (^) pour annuler cela ne fonctionnera pas. Tout ce qui est entre une paire de crochets est traitée comme une liste d'option caractères sauf pour les nommé nommé classes de personnages qui se dilatent à une liste de caractères facultatifs, toutefois, en raison de la façon dont les classes de caractères nid, il est très probable que votre extérieur crochets sont interprétées comme suit:

• [^[[:space:]] Un seul espace non non gauche crochet caractère
• - suivi par un seul trait d'union
• [[:space:]] suivi d'un seul caractère espace
• ]+ suivie par 1 ou plusieurs de fermeture crochets.

Il peut être plus facile de convertir votre multi-caractère séparateur à un seul personnage avec regexp_replace, puis utilisez regex_substr pour vous trouver des pièces individuelles:

select regexp_substr(regexp_replace('Helloworld - test!'
                                   ,'[[:space:]]-[[:space:]]'
                                   ,chr(11))
                    ,'([^'||chr(11)||']*)('||chr(11)||'|$)'
                    ,1 -- Start here
                    ,2 -- return 1st, 2nd, 3rd, etc. match
                    ,null
                    ,1 -- return 1st sub exp
                    )
  from dual;

Dans ce code, je l'ai d'abord changé - à chr(11). C'est le code ASCII du caractère tabulation verticale (VT) caractère de ce qui est peu probable à apparaître dans la plupart des chaînes de texte. Le match de l'expression de la regexp_substr correspond à tous les non VT caractères suivis par un caractère VT ou la fin de la ligne. Seule la non VT personnages sont retournés (la première sous-expression).

CREATE OR REPLACE FUNCTION field(i_string            VARCHAR2
,i_delimiter         VARCHAR2
,i_occurance         NUMBER
,i_return_number     NUMBER DEFAULT 0
,i_replace_delimiter VARCHAR2) RETURN VARCHAR2     IS
-----------------------------------------------------------------------
-- Function Name.......: FIELD
-- Author..............: Dan Simson
-- Date................: 05/06/2016 
-- Description.........: This function is similar to the one I used from 
--                       long ago by Prime Computer.  You can easily
--                       parse a delimited string.
-- Example.............: 
--  String.............: This is a cool function
--  Delimiter..........: ' '
--  Occurance..........: 2
--  Return Number......: 3
--  Replace Delimiter..: '/'
--  Return Value.......: is/a/cool
--------------------------------------------------------------------------    ---                                    
v_return_string  VARCHAR2(32767);
n_start          NUMBER := i_occurance;
v_delimiter      VARCHAR2(1);
n_return_number  NUMBER := i_return_number;
n_max_delimiters NUMBER := regexp_count(i_string, i_delimiter);
BEGIN
IF i_return_number > n_max_delimiters THEN
n_return_number := n_max_delimiters + 1;
END IF;
FOR a IN 1 .. n_return_number LOOP
v_return_string := v_return_string || v_delimiter || regexp_substr    (i_string, '[^' || i_delimiter || ']+', 1, n_start);
n_start         := n_start + 1;
v_delimiter     := nvl(i_replace_delimiter, i_delimiter);
END LOOP;
RETURN(v_return_string);
END field;
SELECT field('This is a cool function',' ',2,3,'/') FROM dual;
SELECT regexp_substr('This is a cool function', '[^ ]+', 1, 1) Word1
,regexp_substr('This is a cool function', '[^ ]+', 1, 2) Word2
,regexp_substr('This is a cool function', '[^ ]+', 1, 3) Word3
,regexp_substr('This is a cool function', '[^ ]+', 1, 4) Word4
,regexp_substr('This is a cool function', '[^ ]+', 1, 5) Word5
FROM dual;