Eindeutiger Wert in einem Associative Array

Allex

Benutzer
Beiträge
9
Hallo,
Ich habe eine Frage und schreibe erst das Szenario und dann stelle ich meine Frage:
wir gehen davon aus, dass u.g Tabelle durch einen Cursor in einem Associative Array gespeichert ist.
-------------------------------------------------------------------------
CREATE TABLE test_eindeutigkeit
(
f1 VARCHAR2(20 CHAR)
,f2 VARCHAR2(20 CHAR)
,f3 VARCHAR2(20 CHAR)
)
;

COMMIT;

INSERT INTO test_eindeutigkeit VALUES ('A',NULL,1);
INSERT INTO test_eindeutigkeit VALUES ('A',1,2);
INSERT INTO test_eindeutigkeit VALUES ('A',1,1);
--
INSERT INTO test_eindeutigkeit VALUES ('B',NULL,NULL);
INSERT INTO test_eindeutigkeit VALUES ('B',4,NULL);
INSERT INTO test_eindeutigkeit VALUES ('B',5,NULL);
--
COMMIT;
-------------------------

Associative Array :

F1F2F3
ANULL1
A12
A11
BNULLNULL
B4NULL
B5NULL


jetzt die Frage :

Ich würde gerne Aufgrund des Feldes "F1" einen eindeutigen Wert für Die Felder F2 und F3 unter folgenden Bedingungen haben :
1- Die Werte "Null" sollen übersehen werden.
2- Außer Null wenn die restlichen Werte eindeutig sind, übernehmen wir den Wert und wenn nicht soll mit NULL befüllt werden.

Bspw.
F1= A => F2=1 (Eindeutig, weil alle werte außer NUll 1 sind) , F3=NULL (Nicht eindeutig, weil wir außer Null sowohl 1 als auch 2 haben)

Das heißt, es soll am Ende solcher Array sein :
F1F2F3
A1NULL
BNULLNULL


kann jemand mir helfen, wie ich erster Array umwandeln und in zweiten Array speichern?
Ich danke euch im Voraus
 
Zuletzt bearbeitet:
Werbung:
Deine Wunsch-Ergebnistabelle und Deine Frage passen m.E. nicht richtig zusammen.
Was bedeuet "eindeutig" für Dich?
Nehmen wir die orginalen Begriffe: "unique" und "groub by"
und bedenken wir, dass es spalten und zeilen gibt und eine Zeile aus mehreren Spalten bestehen kann. Und das die Begriffe "unique" und "group by" für mehrere Zeilen und Spalten gelten (können).
Wie sollen Deine Daten hiermit verarbeitet ?
 
Ich glaube, dass ich klar erzählt habe aber gerne erkläre ich wieder über die Verarbeitung der Daten:

Es geht nicht um group by, weil ich über einen Array gefragt habe, nicht Tabelle.
wir haben einen Array mit verschiedene Spalten und jeweilige spalte auch kann unterschiedlichen Werte haben. Das Feld F1 ist nicht eindeutig. Das heißt, es kann mehrmals vorkommen. genauso wie o.g. Beispiel (3 Mal A und 3 Mal B usw.)

jetzt wurden wir einen neuen Array haben, dessen F1 eindeutig ist (Nur einmal A und einmal B usw.) und für die restlichen spalten nehmen wir nur die Werte, die nicht unterschiedlich sind (Null Werte sollen Übersehen werden). Also wenn F1=A , hat F2 die Werte (NULL,1,1) und wenn wir Null übersehen, bleiben die Werte (1,1) und da die beiden nicht unterschied sind, können wir den Wert 1 schreiben.

genauso für das Feld F3. Wenn F1=A, hat F3 die Werte (1,2,1) und da wir zwei unterschiedliche Werte (1,2) haben, sollen wir den Wert mit NULL belegen.

mit oben genannte Erklärung wird der Datensatz eindeutig. D.h. pro jede F1 haben wir nur einen Wert für F2, F3 usw.

Ich hoffe , dass ich meine Frage besser bilden konnte.
 
Es geht nicht um group by, weil ich über einen Array gefragt habe, nicht Tabelle.
Was Du zeigst, ist ein create table. Ich sehe nirgendwo ein array.
"Unique" und "Group by" habe ich vorgeschlagen, weil es klare Begriffe sind, die unabhängig von einer (automatischen) Übersetzung im Bereich Tabellen, Datenbanken und SQL gelten.
Wenn Du von Eindeutigkeit sprichst und dabei sowohl von einem eindeutigen Datensatz, als auch von einzelnen Spalten, dann ist eben nicht klar, was eindeutig sein soll.
Dein Regelwerk beschreibt außerdem nicht, wie sich die Eindeutigkeit in Bezug auf die dargestellten Mengen verhält.
Kann es immer nur genau 3 Datensätze von A, B, .. geben? Auch C, D, E? Können es auch weniger sein oder mehr?
 
Ich habe schon mal fett geschrieben Associative Array und ich habe Create Table gezeigt, damit jemand, der mir antworten möchte, schneller einen Cursor einbauen und diesen Cursor in Array schreiben kann.

Feld F1 soll nicht immer 3 Datensätze haben. Also kann 1 oder irgendwelche Zahl sein. D.h. kann F1, 100 mal A, 1 mal B, 1000 mal C usw. sein.
 
Ich habe schon mal fett geschrieben Associative Array
Ja, ich kann lesen. Ob Du es fett schreibst oder nicht, für mich liefert die Information Assoziatives Array keinen Mehrwert in der Aufgabenstellung bzw. den Regeln, die Du zur Transformation angibst.
Ich weiß immer noch nicht, ob ich Dich nun also richtig verstanden habe.
Das Statement unten kann wahrscheinlich optimiert werden, es ist nicht mit Oracle getestet. Die Formulierung sollte aber unter Oracle die gleichen Ergebnisse bringen.
Es kann auch sein, dass bei großen, monotonen Mengen eine simple Schleifenprogrammierung schneller ist, wo für jedes f1 Werte für f2 und f3 persistiert werden, bis sie sich ändern und verworfen werden oder gespeichert, falls sie sich nie ändern.

Nebenbei, in Deinem Beispiel mit Create .. und Insert .. braucht man kein Commit, auch nicht 2x.
Wenn Du echten Code hast, der in dieser Art aufgebaut ist, ist er mglw. unsauber. Das kann aber anhand des Beispiels nur vermutet werden.

Code:
select f1.f1,
       f2.f2, --  f2.f1,
       f3.f3  --, f3.f1
  from (select distinct f1 from testuniq) f1             -- alle existierenden f1, garantiert, Basis für die beiden folgenden left join
  left join                                              -- dazu alle f2, die je f1 als einziges vorkommen
            (select x.f1, k.f2                           -- left outer führt so automatisch zur Ergänzung von NULL Werten für fehlende Einträge
               from (select f1
                       from (select distinct f1, f2
                               from testuniq
                              where f2 is not null) x1
                      group by f1
                     having count(*) = 1) x
               join (select distinct f1, f2
                      from testuniq
                     where f2 is not null) k
                 on x.f1 = k.f1) f2
    on f1.f1 = f2.f1
  left join                                              -- und noch mal dazu alle f3, die je f1 als einziges vorkommen
            (select x.f1, k.f3                           -- left outer führt so automatisch zur Ergänzung von NULL Werten für fehlende Einträge
               from (select f1
                       from (select distinct f1, f3
                               from testuniq
                              where f3 is not null) x1
                      group by f1
                     having count(*) = 1) x
               join (select distinct f1, f3
                      from testuniq
                     where f3 is not null) k
                 on x.f1 = k.f1) f3
    on f1.f1 = f3.f1
 order by f1.f1
 
Werbung:
Code:
postgres=# select * from allex ;
 f1 | f2 | f3 
----+----+----
 a  |    |  1
 a  |  1 |  2
 a  |  1 |  1
 b  |    |   
 b  |  4 |   
 b  |  5 |   
(6 rows)

postgres=# with tmp as (select f1, count(distinct f2) c2, array_agg(distinct(f2)) filter (where f2 is not null) v2, count(distinct f3) c3, array_agg(distinct(f3)) filter (where f3 is not null) v3 from allex group by f1) select f1, case when c2=1 then v2[1] else null end as f2, case when c3=1 then v3[1] else null end as f3 from tmp;
 f1 | f2 | f3 
----+----+----
 a  |  1 |   
 b  |    |   
(2 rows)

postgres=#

select Kaffee!
 
Zurück
Oben