sql - transponer - División de cadena en múltiples filas en Oracle

pivot oracle columns to rows

Question

Sé que esto ha sido respondido hasta cierto punto con PHP y MYSQL, pero me preguntaba si alguien podría enseñarme el enfoque más simple para dividir una cadena (delimitada por comas) en múltiples filas en Oracle 10g (preferiblemente) y 11g.

La tabla es la siguiente:

Name | Project | Error 
108    test      Err1, Err2, Err3
109    test2     Err1

Quiero crear lo siguiente:

Name | Project | Error
108    Test      Err1
108    Test      Err2 
108    Test      Err3 
109    Test2     Err1

He visto algunas soluciones potenciales alrededor de la pila, sin embargo, solo representaban una sola columna (siendo la cadena delimitada por comas). Cualquier ayuda sería muy apreciada.

Answer 1

A partir de Oracle 12c, puede usar JSON_TABLE y JSON_ARRAY :

CREATE TABLE tab(Name, Project, Error) AS
SELECT 108,''test'' ,''Err1, Err2, Err3'' FROM dual UNION 
SELECT 109,''test2'',''Err1''             FROM dual;

Y consulta:

SELECT *
FROM tab t
OUTER APPLY (SELECT TRIM(p) AS p
            FROM JSON_TABLE(REPLACE(JSON_ARRAY(t.Error), '','', ''","''),
           ''$[*]'' COLUMNS (p VARCHAR2(4000) PATH ''$''))) s;

Salida:

┌──────┬─────────┬──────────────────┬──────┐
│ Name │ Project │      Error       │  P   │
├──────┼─────────┼──────────────────┼──────┤
│  108 │ test    │ Err1, Err2, Err3 │ Err1 │
│  108 │ test    │ Err1, Err2, Err3 │ Err2 │
│  108 │ test    │ Err1, Err2, Err3 │ Err3 │
│  109 │ test2   │ Err1             │ Err1 │
└──────┴─────────┴──────────────────┴──────┘

Answer 2

Aquí hay una implementación alternativa que utiliza XMLTABLE que permite enviar datos a diferentes tipos de datos:

select 
  xmltab.txt
from xmltable(
  ''for $text in tokenize("a,b,c", ",") return $text''
  columns 
    txt varchar2(4000) path ''.''
) xmltab
;

... o si tus cadenas delimitadas están almacenadas en una o más filas de una tabla:

select 
  xmltab.txt
from (
  select ''a;b;c'' inpt from dual union all
  select ''d;e;f'' from dual
) base
inner join xmltable(
  ''for $text in tokenize($input, ";") return $text''
  passing base.inpt as "input"
  columns 
    txt varchar2(4000) path ''.''
) xmltab
  on 1=1
;

Answer 3

Creo que la mejor manera de conectarme y la función de expresión regular

   with temp as  (
       select 108 Name, ''test'' Project, ''Err1, Err2, Err3'' Error  from dual
       union all
       select 109, ''test2'', ''Err1'' from dual
     )

SELECT distinct Name, Project, trim(regexp_substr(str, ''[^,]+'', 1, level)) str
  FROM (SELECT Name, Project, Error str FROM temp) t
CONNECT BY instr(str, '','', 1, level - 1) > 0
order by Name

SOURCE

Answer 4

Hay una gran diferencia entre los dos siguientes:

• dividiendo una sola cadena delimitada
• dividir cadenas delimitadas para múltiples filas en una tabla.

Si no restringe las filas, entonces la cláusula CONNECT BY produciría múltiples filas y no dará el resultado deseado.

• Para una cadena delimitada individual, mire la cadena delimitada por comas simples en filas
• Para dividir cadenas delimitadas en una tabla, observe las cadenas delimitadas por comas en una tabla

Además de las expresiones regulares , algunas otras alternativas están utilizando:

• XMLTable
• Cláusula MODELO

Preparar

SQL> CREATE TABLE t (
  2    ID          NUMBER GENERATED ALWAYS AS IDENTITY,
  3    text        VARCHAR2(100)
  4  );

Table created.

SQL>
SQL> INSERT INTO t (text) VALUES (''word1, word2, word3'');

1 row created.

SQL> INSERT INTO t (text) VALUES (''word4, word5, word6'');

1 row created.

SQL> INSERT INTO t (text) VALUES (''word7, word8, word9'');

1 row created.

SQL> COMMIT;

Commit complete.

SQL>
SQL> SELECT * FROM t;

        ID TEXT
---------- ----------------------------------------------
         1 word1, word2, word3
         2 word4, word5, word6
         3 word7, word8, word9

SQL>

Usando XMLTABLE :

SQL> SELECT id,
  2         trim(COLUMN_VALUE) text
  3  FROM t,
  4    xmltable((''"''
  5    || REPLACE(text, '','', ''","'')
  6    || ''"''))
  7  /

        ID TEXT
---------- ------------------------
         1 word1
         1 word2
         1 word3
         2 word4
         2 word5
         2 word6
         3 word7
         3 word8
         3 word9

9 rows selected.

SQL>

Usando la cláusula MODELO :

SQL> WITH
  2  model_param AS
  3     (
  4            SELECT id,
  5                      text AS orig_str ,
  6                   '',''
  7                          || text
  8                          || '',''                                 AS mod_str ,
  9                   1                                             AS start_pos ,
 10                   Length(text)                                   AS end_pos ,
 11                   (Length(text) - Length(Replace(text, '',''))) + 1 AS element_count ,
 12                   0                                             AS element_no ,
 13                   ROWNUM                                        AS rn
 14            FROM   t )
 15     SELECT   id,
 16              trim(Substr(mod_str, start_pos, end_pos-start_pos)) text
 17     FROM     (
 18                     SELECT *
 19                     FROM   model_param MODEL PARTITION BY (id, rn, orig_str, mod_str)
 20                     DIMENSION BY (element_no)
 21                     MEASURES (start_pos, end_pos, element_count)
 22                     RULES ITERATE (2000)
 23                     UNTIL (ITERATION_NUMBER+1 = element_count[0])
 24                     ( start_pos[ITERATION_NUMBER+1] = instr(cv(mod_str), '','', 1, cv(element_no)) + 1,
 25                     end_pos[iteration_number+1] = instr(cv(mod_str), '','', 1, cv(element_no) + 1) )
 26                 )
 27     WHERE    element_no != 0
 28     ORDER BY mod_str ,
 29           element_no
 30  /

        ID TEXT
---------- --------------------------------------------------
         1 word1
         1 word2
         1 word3
         2 word4
         2 word5
         2 word6
         3 word7
         3 word8
         3 word9

9 rows selected.

SQL>

Answer 5

La respuesta aceptada tiene un rendimiento deficiente cuando se usan grandes conjuntos de datos.

Esta puede ser una forma mejorada (también con regexp y connect by):

with temp as
(
    select 108 Name, ''test'' Project, ''Err1, Err2, Err3'' Error  from dual
    union all
    select 109, ''test2'', ''Err1'' from dual
)
select distinct
  t.name, t.project,
  trim(regexp_substr(t.error, ''[^,]+'', 1, levels.column_value))  as error
from 
  temp t,
  table(cast(multiset(select level from dual connect by  level <= length (regexp_replace(t.error, ''[^,]+''))  + 1) as sys.OdciNumberList)) levels
order by name

EDITAR : Aquí hay una explicación simple (como en, "no en profundidad") de la consulta.

1. length (regexp_replace(t.error, ''[^,]+'')) + 1 usa regexp_replace para borrar cualquier cosa que no sea el delimitador (coma en este caso) y la length +1 para obtener cuántos elementos (errores) hay.

2. El select level from dual connect by level <= (...) usa una consulta jerárquica para crear una columna con un número creciente de coincidencias encontradas, desde 1 hasta el número total de errores.

   Avance:

   select level, length (regexp_replace(''Err1, Err2, Err3'', ''[^,]+''))  + 1 as max 
   from dual connect by level <= length (regexp_replace(''Err1, Err2, Err3'', ''[^,]+''))  + 1

3. table(cast(multiset(.....) as sys.OdciNumberList)) hace algo de fundición de tipos de oráculo.
   • El cast(multiset(.....)) as sys.OdciNumberList transforma múltiples colecciones (una colección para cada fila en el conjunto de datos original) en una única colección de números, OdciNumberList.
   • La función table() transforma una colección en un conjunto de resultados.

4. FROM sin una unión crea una combinación cruzada entre su conjunto de datos y el conjunto múltiple. Como resultado, una fila en el conjunto de datos con 4 coincidencias se repetirá 4 veces (con un número creciente en la columna denominada "column_value").

   Avance:

   select * from 
   temp t,
   table(cast(multiset(select level from dual connect by  level <= length (regexp_replace(t.error, ''[^,]+''))  + 1) as sys.OdciNumberList)) levels

5. trim(regexp_substr(t.error, ''[^,]+'', 1, levels.column_value)) utiliza el column_value como el parámetro nth_appearance / ocurrence para regexp_substr .
6. Puede agregar algunas otras columnas de su conjunto de datos ( t.name, t.project como ejemplo) para una fácil visualización.

Algunas referencias a documentos de Oracle:

• REGEXP_REPLACE
• REGEXP_SUBSTR
• Constantes de extensibilidad, tipos y asignaciones (OdciNumberList)
• CAST (multiset)
• Consultas jerárquicas

Answer 6

Me gustaría agregar otro método. Este usa consultas recursivas, algo que no he visto en las otras respuestas. Es compatible con Oracle desde 11gR2.

with cte0 as (
    select phone_number x
    from hr.employees
), cte1(xstr,xrest,xremoved) as (
        select x, x, null
        from cte0
    union all        
        select xstr,
            case when instr(xrest,''.'') = 0 then null else substr(xrest,instr(xrest,''.'')+1) end,
            case when instr(xrest,''.'') = 0 then xrest else substr(xrest,1,instr(xrest,''.'') - 1) end
        from cte1
        where xrest is not null
)
select xstr, xremoved from cte1  
where xremoved is not null
order by xstr

Es bastante flexible con el carácter de división. Simplemente INSTR en las llamadas INSTR .

Answer 7

Me gustaría proponer un enfoque diferente utilizando una función de tabla PIPELINED. Es algo similar a la técnica de XMLTABLE, excepto que está proporcionando su propia función personalizada para dividir la cadena de caracteres:

-- Create a collection type to hold the results
CREATE OR REPLACE TYPE typ_str2tbl_nst AS TABLE OF VARCHAR2(30);
/

-- Split the string according to the specified delimiter
CREATE OR REPLACE FUNCTION str2tbl (
  p_string    VARCHAR2,
  p_delimiter CHAR DEFAULT '','' 
)
RETURN typ_str2tbl_nst PIPELINED
AS
  l_tmp VARCHAR2(32000) := p_string || p_delimiter;
  l_pos NUMBER;
BEGIN
  LOOP
    l_pos := INSTR( l_tmp, p_delimiter );
    EXIT WHEN NVL( l_pos, 0 ) = 0;
    PIPE ROW ( RTRIM( LTRIM( SUBSTR( l_tmp, 1, l_pos-1) ) ) );
    l_tmp := SUBSTR( l_tmp, l_pos+1 );
  END LOOP;
END str2tbl;
/

-- The problem solution
SELECT name, 
       project, 
       TRIM(COLUMN_VALUE) error
  FROM t, TABLE(str2tbl(error));

Resultados:

      NAME PROJECT    ERROR
---------- ---------- --------------------
       108 test       Err1
       108 test       Err2
       108 test       Err3
       109 test2      Err1

El problema con este tipo de enfoque es que a menudo el optimizador no conocerá la cardinalidad de la función de tabla y tendrá que adivinar. Esto podría ser potencialmente dañino para sus planes de ejecución, por lo que esta solución se puede ampliar para proporcionar estadísticas de ejecución para el optimizador.

Puede ver esta estimación del optimizador ejecutando un PLAN EXPLICACIÓN en la consulta anterior:

Execution Plan
----------------------------------------------------------
Plan hash value: 2402555806

----------------------------------------------------------------------------------------------
| Id  | Operation                          | Name    | Rows  | Bytes | Cost (%CPU)| Time     |
----------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                   |         | 16336 |   366K|    59   (0)| 00:00:01 |
|   1 |  NESTED LOOPS                      |         | 16336 |   366K|    59   (0)| 00:00:01 |
|   2 |   TABLE ACCESS FULL                | T       |     2 |    42 |     3   (0)| 00:00:01 |
|   3 |   COLLECTION ITERATOR PICKLER FETCH| STR2TBL |  8168 | 16336 |    28   (0)| 00:00:01 |
----------------------------------------------------------------------------------------------

Aunque la colección solo tiene 3 valores, el optimizador estimó 8168 filas para ella (valor predeterminado). Esto puede parecer irrelevante al principio, pero puede ser suficiente para que el optimizador decida por un plan subóptimo.

La solución es usar las extensiones del optimizador para proporcionar estadísticas para la colección:

-- Create the optimizer interface to the str2tbl function
CREATE OR REPLACE TYPE typ_str2tbl_stats AS OBJECT (
  dummy NUMBER,

  STATIC FUNCTION ODCIGetInterfaces ( p_interfaces OUT SYS.ODCIObjectList )
  RETURN NUMBER,

  STATIC FUNCTION ODCIStatsTableFunction ( p_function  IN  SYS.ODCIFuncInfo,
                                           p_stats     OUT SYS.ODCITabFuncStats,
                                           p_args      IN  SYS.ODCIArgDescList,
                                           p_string    IN  VARCHAR2,
                                           p_delimiter IN  CHAR DEFAULT '','' )
  RETURN NUMBER
);
/

-- Optimizer interface implementation
CREATE OR REPLACE TYPE BODY typ_str2tbl_stats
AS
  STATIC FUNCTION ODCIGetInterfaces ( p_interfaces OUT SYS.ODCIObjectList )
  RETURN NUMBER
  AS
  BEGIN
    p_interfaces := SYS.ODCIObjectList ( SYS.ODCIObject (''SYS'', ''ODCISTATS2'') );
    RETURN ODCIConst.SUCCESS;
  END ODCIGetInterfaces;

  -- This function is responsible for returning the cardinality estimate
  STATIC FUNCTION ODCIStatsTableFunction ( p_function  IN  SYS.ODCIFuncInfo,
                                           p_stats     OUT SYS.ODCITabFuncStats,
                                           p_args      IN  SYS.ODCIArgDescList,
                                           p_string    IN  VARCHAR2,
                                           p_delimiter IN  CHAR DEFAULT '','' )
  RETURN NUMBER
  AS
  BEGIN
    -- I''m using basically half the string lenght as an estimator for its cardinality
    p_stats := SYS.ODCITabFuncStats( CEIL( LENGTH( p_string ) / 2 ) );
    RETURN ODCIConst.SUCCESS;
  END ODCIStatsTableFunction;

END;
/

-- Associate our optimizer extension with the PIPELINED function   
ASSOCIATE STATISTICS WITH FUNCTIONS str2tbl USING typ_str2tbl_stats;

Probando el plan de ejecución resultante:

Execution Plan
----------------------------------------------------------
Plan hash value: 2402555806

----------------------------------------------------------------------------------------------
| Id  | Operation                          | Name    | Rows  | Bytes | Cost (%CPU)| Time     |
----------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT                   |         |     1 |    23 |    59   (0)| 00:00:01 |
|   1 |  NESTED LOOPS                      |         |     1 |    23 |    59   (0)| 00:00:01 |
|   2 |   TABLE ACCESS FULL                | T       |     2 |    42 |     3   (0)| 00:00:01 |
|   3 |   COLLECTION ITERATOR PICKLER FETCH| STR2TBL |     1 |     2 |    28   (0)| 00:00:01 |
----------------------------------------------------------------------------------------------

Como puede ver, la cardinalidad en el plan de arriba ya no es el valor calculado 8196. Todavía no es correcto porque estamos pasando una columna en lugar de un literal de cadena a la función.

Sería necesario hacer algunos ajustes al código de la función para dar una estimación más cercana en este caso particular, pero creo que el concepto general se explica bastante aquí.

La función str2tbl utilizada en esta respuesta fue desarrollada originalmente por Tom Kyte: https://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:110612348061

El concepto de asociar estadísticas con tipos de objetos se puede explorar más a fondo leyendo este artículo: http://www.oracle-developer.net/display.php?id=427

La técnica descrita aquí funciona en 10g +.

Answer 8

REGEXP_COUNT no se agregó hasta Oracle 11i. Aquí hay una solución de Oracle 10g, adoptada de la solución de Art.

SELECT trim(regexp_substr(''Err1, Err2, Err3'', ''[^,]+'', 1, LEVEL)) str_2_tab
  FROM dual
CONNECT BY LEVEL <=
  LENGTH(''Err1, Err2, Err3'')
    - LENGTH(REPLACE(''Err1, Err2, Err3'', '','', ''''))
    + 1;

Answer 9

Sin usar connect by o regexp :

    with mytable as (
      select 108 name, ''test'' project, ''Err1,Err2,Err3'' error from dual
      union all
      select 109, ''test2'', ''Err1'' from dual
    )
    ,x as (
      select name
      ,project
      ,'',''||error||'','' error
      from mytable
    )
    ,iter as (SELECT rownum AS pos
        FROM all_objects
    )
    select x.name,x.project
    ,SUBSTR(x.error
      ,INSTR(x.error, '','', 1, iter.pos) + 1
      ,INSTR(x.error, '','', 1, iter.pos + 1)-INSTR(x.error, '','', 1, iter.pos)-1
    ) error
    from x, iter
    where iter.pos < = (LENGTH(x.error) - LENGTH(REPLACE(x.error, '',''))) - 1;

Answer 10

Tuve el mismo problema, y xmltable me ayudó:

SELECT id, trim(COLUMN_VALUE) text 
FROM t, xmltable((''"''  || REPLACE(text, '','', ''","'') || ''"''))

Answer 11

Un par de más ejemplos de lo mismo:

SELECT trim(regexp_substr(''Err1, Err2, Err3'', ''[^,]+'', 1, LEVEL)) str_2_tab
  FROM dual
CONNECT BY LEVEL <= regexp_count(''Err1, Err2, Err3'', '','')+1
/

SELECT trim(regexp_substr(''Err1, Err2, Err3'', ''[^,]+'', 1, LEVEL)) str_2_tab
  FROM dual
CONNECT BY LEVEL <= length(''Err1, Err2, Err3'') - length(REPLACE(''Err1, Err2, Err3'', '','', ''''))+1
/

Además, puede usar DBMS_UTILITY.comma_to_table & table_to_comma: http://www.oracle-base.com/articles/9i/useful-procedures-and-functions-9i.php#DBMS_UTILITY.comma_to_table

Answer 12

Yo había usado la función DBMS_UTILITY.comma_to _table en realidad está trabajando el código de la siguiente manera

declare
l_tablen  BINARY_INTEGER;
l_tab     DBMS_UTILITY.uncl_array;
cursor cur is select * from qwer;
rec cur%rowtype;
begin
open cur;
loop
fetch cur into rec;
exit when cur%notfound;
DBMS_UTILITY.comma_to_table (
     list   => rec.val,
     tablen => l_tablen,
     tab    => l_tab);
FOR i IN 1 .. l_tablen LOOP
    DBMS_OUTPUT.put_line(i || '' : '' || l_tab(i));
END LOOP;
end loop;
close cur;
end; 

había usado mis propios nombres de tabla y columna

Answer 13

expresiones regulares es una cosa maravillosa :)

with temp as  (
       select 108 Name, ''test'' Project, ''Err1, Err2, Err3'' Error  from dual
       union all
       select 109, ''test2'', ''Err1'' from dual
     )

SELECT distinct Name, Project, trim(regexp_substr(str, ''[^,]+'', 1, level)) str
  FROM (SELECT Name, Project, Error str FROM temp) t
CONNECT BY instr(str, '','', 1, level - 1) > 0
order by Name

Answer 14

CREATE FUNCTION dbo.BreakStringIntoRows (@CommadelimitedString   varchar(1000))
RETURNS   @Result TABLE (Column1   VARCHAR(100))
AS
BEGIN
        DECLARE @IntLocation INT
        WHILE (CHARINDEX('','',    @CommadelimitedString, 0) > 0)
        BEGIN
              SET @IntLocation =   CHARINDEX('','',    @CommadelimitedString, 0)      
              INSERT INTO   @Result (Column1)
              --LTRIM and RTRIM to ensure blank spaces are   removed
              SELECT RTRIM(LTRIM(SUBSTRING(@CommadelimitedString,   0, @IntLocation)))   
              SET @CommadelimitedString = STUFF(@CommadelimitedString,   1, @IntLocation,   '''') 
        END
        INSERT INTO   @Result (Column1)
        SELECT RTRIM(LTRIM(@CommadelimitedString))--LTRIM and RTRIM to ensure blank spaces are removed
        RETURN 
END
GO

--Using the UDF to convert comma separated values into rows
SELECT * FROM dbo.BreakStringIntoRows(''Apple,Banana,Orange'')
SELECT * FROM dbo.BreakStringIntoRows(''Apple   ,    Banana,    Orange'')