Zusammenbruch Mehrerer Datensätze Zu einem Einzigen Datensatz Mit Mehreren Spalten

In einem Programm Pflege ich, wir bekamen eine riesige (~500 Zeilen) SQL-Anweisung durch den Kunden. Es wird verwendet für die Erzeugung von flat files mit fester Länge Datensätze für die übermittlung von Daten zu einem anderen großen Geschäft. Da es ein massives flat-file sein, nicht relationale und die standard-normal-Formen der Daten sind zusammengebrochen. Also, wenn Sie einen Datensatz mit mehreren codes zugeordnet, in diesem Fall bis zu 19 haben Sie alle geschrieben werden, in Zeile, aber seperate Felder in der flachen Datei.

Hinweis: dieses Beispiel ist vereinfacht.

Den Daten könnte wie folgt Aussehen, mit drei Tabellen:

RECORDS
record_id   firstname   lastname    
--------------------------------    
123         Bob         Schmidt
324         George      Washington
325         Ronald      Reagan
290         George      Clooney


CODE_TABLE
code_id     code_cd     code_txt
--------------------------------
5           3           President
2           4           Actor    
3           7           Plumber


CODES_FOR_RECORDS
record_id   code_cd
-------------------
123         7    
325         3
290         4
324         3
325         4
123         4

Diese Bedürfnisse zu produzieren Datensätze wie:

firstname   lastname    code1       code2       code3
Bob         Schmidt     Actor       Plumber     NULL
George      Washington  President   NULL        NULL
Ronald      Reagon      Actor       President   NULL
George      Clooney     Actor       NULL        NULL

Den Teil der aktuellen Abfrage an, wir bekamen die aussieht wie diese, aber mit 19 code-Spalten anstelle der 5:

select 
    x.record_id,
    max(case when  x.rankk = 1  then code_txt end) as CodeColumn1,
    max(case when  x.rankk = 2  then code_txt end) as CodeColumn2,
    max(case when  x.rankk = 3  then code_txt end) as CodeColumn3,
    max(case when  x.rankk = 4  then code_txt end) as CodeColumn4,
    max(case when  x.rankk = 5  then code_txt end) as CodeColumn5,
from 
    (
        select 
            r.record_id,
            ct.code_txt as ctag ,
            dense_rank() over (partition by r.record_id order by cfr.code_id) as rankk
        from            
            records as r
            codes_for_records as cfr,
            code_table as ct
        where
            r.record_id = cfr.record_id
            and ct.code_cd = cfr.code_cd
            and cfr.code_cd is not null
            and ct.code_txt not like '%V%'
    ) as x
where
    x.record_id is not null
group by
    x.record_id

Ich nach unten getrimmt, die Dinge für simplicties Willen, sondern die eigentliche Aussage beinhaltet eine innere Abfrage und eine Verknüpfung und mehr, wo die Bedingungen, aber das sollte auf die Idee kommen über. Mein Gehirn sagt mir, es muss einen besseren Weg, aber ich bin kein SQL-Experte. Wir sind mit der DB2 v8, wenn das hilft. Und die codes werden in separaten Spalten, so dass keine Koaleszenz Dinge in einem einzigen string. Gibt es eine sauberere Lösung als diese?

Update:

Landete ich nur refacorting das original query, es sill verwendet die häßlich MAX () - Geschäft, aber insgesamt, die Abfrage ist sehr viel besser lesbar durch Nachbesserung anderen teilen.

  • Wenn ich code schreiben, um Daten zu transformieren und manuell, das Verfahren ist selten unter 1000 Zeilen lang. Der code sieht ziemlich einfach und unkompliziert auf mich.
  • Vielleicht, dass ich bin nicht wirklich vertraut mit SQL, da mir scheint, dass Art verwickelt. Und ein Teil davon ist ein 1.000-Zeilen, wenn getrennt in logischen Blöcken ist nicht schlecht. 500 Zeilen SQL, das ist so miteinander verbunden, wie es scheint, spaghetti, ist eine andere Sache, IMHO.
InformationsquelleAutor troutinator | 2011-02-07
  1. 0

    Es klingt wie das, was Sie suchen, ist schwenkbare.

    WITH joined_table(firstname, lastname, code_txt, rankk) AS
(
SELECT
  r.firstname,
  r.lastname,
  ct.code_txt,
  dense_rank() over (partition by r.record_id order by cfr.code_id) as rankk
FROM
  records r
INNER JOIN
  codes_for_records cfr
  ON r.record_id = cfr.record_id
INNER JOIN
  codes_table ct
  ON ct.code_cd = cfr.code_cd
),

decoded_table(firstname, lastname,
  CodeColumn1, CodeColumn2, CodeColumn3, CodeColumn4, CodeColumn5) AS
(
  SELECT
    firstname,
    lastname,
    DECODE(rankk, 1, code_txt),
    DECODE(rankk, 2, code_txt),
    DECODE(rankk, 3, code_txt),
    DECODE(rankk, 4, code_txt),
    DECODE(rankk, 5, code_txt)
  FROM
    joined_table jt
)

SELECT
  firstname,
  lastname,
  MAX(CodeColumn1),
  MAX(CodeColumn2),
  MAX(CodeColumn3),
  MAX(CodeColumn4),
  MAX(CodeColumn5)
FROM
  decoded_table dt
GROUP BY
  firstname,
  lastname;

    Beachten Sie, dass ich nie wirklich getan diese selbst vor. Ich verlasse mich auf die verlinkten Dokument als Referenz.

    Müssen Sie möglicherweise gehören die record_id zu berücksichtigen, für doppelte Namen.

    Edit: Hinzugefügt wurde die GRUPPE DURCH.

    • Interessant. Ich werde ihm eine Chance geben.
    • Ich immer noch denke, dass alle diese MAX() business ist hässlich.
    InformationsquelleAutor Leons
  2. 0

    Eine der möglichen Lösungen ist die Verwendung von rekursiven Abfrage:

    with recursive_view (record_id, rankk, final) as
(
  select
    record_id, 
    rankk,
    cast (ctag as varchar (100))
  from inner_query t1

  union all 

  select
    t1.record_id,
    t1.rankk,
    /* all formatting here */
    cast (t2.final || ',' || t1.ctag as varchar (100))
  from 
    inner_query t1,
    recursive_view t2
  where 
    t2.rankk < t1.rankk
    and t1.record_id = t2.record_id
    and locate(t1.ctag, t2.final) = 0
)
select record_id, final from recursive_view;

    Kann nicht garantieren, dass es funktioniert, aber hoffe, es wird hilfreich sein. Ein anderer Weg ist die Verwendung der benutzerdefinierten Aggregatfunktion.

    • Vielen Dank für die Anregungen. Jedoch ist jeder code muss verlassen werden, wie Ihr auf collumn. Es kann nicht sein, trat in einen riesigen string.
    • Formatiert werden können durch die Polsterung sieht aus wie Haufen von Spalten. Ansonsten ohne pivot und dynamische sql-Sie sind gezwungen, doppelte max(groß -) Konstruktionen.
    InformationsquelleAutor Lev Khomich
Schreibe einen Kommentar