Tabelle modellieren

Hallo zusammen,
Ich bin eine Tabelle mit drei Spalten am modellieren. Die Spalten heissen: name, wert_real, wert_theo.
Der wert_theo ist prinzipiell der gerundete wert von wert_real. Jetzt habe ich aber mehrere Elemente mit demselben namen aber der wert_real variiert. Was ich nun machen möchte ist, dass der wert_theo für alle Elemente mit gleichem namen gleich bleibt. Versteht jemand was ich gerne machen möchte und kann mir mit dem sql-Statment helfen?
Hier noch ein Beispiel von dem was ich habe:

name wert_real wert_theo
A 5.23 5
B 6.34 6
C 6.31 6
A 7.21 5
B 3.21
F 3.19
G 4.58


der Eintrag in Zeile vier beim wert_theo solle nun wieder 5 und nicht 7

Kann mir da jemand helfen?
Danke und liebe Grüsse
Sams

Nein, versteh ich nicht. Du rundest einmal z.B. 6.31 auf 6 runter und willst dann 7.21 auf 5 abrunden?

Vielleicht suchst Du eine Aggregation : select name, min(wert_real) from table group by name, wobei die min(wert_real) noch gemäß mir unbekannter Regeln zu runden wäre.

Hallo, danke.
Das Runden ist nicht das Problem. ich möchte nur für jedes Tupel mit dem Namen A den Wert fünf und für jeden Namen B den Wert 6 etc.
Grüsse
Sams

Für C dann 7, D 8 und E 9?

Nein, das läuft nicht so weiter.
Prinzipiell sind dies verschiedene Zeitzustände. Der reale Wert der variiert über die Zeit, aber der theoretische Wert soll derselbe bleiben.
D habe ich in meinem Beispiel gar nicht aufgeführt. Aber F hätte dann nach meinem Beispiel den Wert 3 und G den Wert 5.

Was heissen soll: ich habe zwei attribute unterschlagen, was für das Verständinis meiner Frage etwas doof war :confused:
Es gibt noch die Attribute t_start und t_ende
z.B
t_start t_ende name wert_real wert_theo
2000-01-01 2000-02-02 A 5.23 5
2000-02-02 2000-03-03 A 7.21 5

Da soll der theoretische Wert dann nicht der reale Wert gerundet sein, sondern der theoretische Wert vom vorgängigen A übernommen werden.

Ja, sehr doof. Lange spiele ich nicht mehr mit Dir.

test=*# select * from sams;
 id | name | wert
----+------+------
  1 | a    |   10
  2 | b    |   20
  3 | c    |   30
  4 | a    |   15
  5 | b    |   22
  6 | c    |   45
  7 | a    |    8
  8 | b    |   12
  9 | c    |    2
(9 rows)
test=*# select id, name, wert as real_wert, coalesce(lag(wert) over (partition by name order by id rows between unbounded preceding and current row),wert) as theo_wert fromsams order by id;
 id | name | real_wert | theo_wert
----+------+-----------+-----------
  1 | a    |        10 |        10
  2 | b    |        20 |        20
  3 | c    |        30 |        30
  4 | a    |        15 |        10
  5 | b    |        22 |        20
  6 | c    |        45 |        30
  7 | a    |         8 |        15
  8 | b    |        12 |        22
  9 | c    |         2 |        45
(9 rows)

Das sieht schon mal gut aus, danke!!!
Es gibt nur noch ein kleines Problem:
a hat beim ersten und zweiten mal den theo_wert 10. Beim dritten mal aber 15, weils den real_wert vom zweitenmal übernimmt. Sollte aber beim wert 10 bleiben.

Mal als grobe Idee:

test=*# select id, name, real_wert from (select id, name, wert as real_wert, coalesce(lag(wert) over (partition by name order by id rows between unbounded preceding and current row),wert) as theo_wert, case when lag(wert) over (partition by name order by id rows between unbounded preceding and current row) is null then 1 else 0 end as flag from sams order by id) foo where flag = 1;
 id | name | real_wert
----+------+-----------
  1 | a    |        10
  2 | b    |        20
  3 | c    |        30
(3 rows)

Und dazu via UNION die Rows wo flag = 0 und da die real_wert von eben (je name) einsetzen. Geht aber sicher noch einfacher.

Zum Beispiel so:
Aus

test=*# select * from (select id, name, wert as real_wert, coalesce(lag(wert) over (partition by name order by id rows between unbounded preceding and 1 following),wert) as theo_wert, case when lag(wert) over (partition by name order by id rows between unbounded preceding and current row) is null then 1 else 0 end as flag from sams order by id) foo where flag=1;
 id | name | real_wert | theo_wert | flag
----+------+-----------+-----------+------
  1 | a    |        10 |        10 |    1
  2 | b    |        20 |        20 |    1
  3 | c    |        30 |        30 |    1
(3 rows)

bateln wir uns einen VIEW

test=*# create view startwerte as select * from (select id, name, wert as real_wert, coalesce(lag(wert) over (partition by name order by id rows between unbounded precedingand 1 following),wert) as theo_wert, case when lag(wert) over (partition by name order by id rows between unbounded preceding and current row) is null then 1 else 0 end as flag from sams order by id) foo where flag=1;
CREATE VIEW

und vergewaltigen ihn in

test=*# select sams.id, sams.name, wert, theo_wert from sams left join startwerte on (sams.name=startwerte.name);
 id | name | wert | theo_wert
----+------+------+-----------
  1 | a    |   10 |        10
  2 | b    |   20 |        20
  3 | c    |   30 |        30
  4 | a    |   15 |        10
  5 | b    |   22 |        20
  6 | c    |   45 |        30
  7 | a    |    8 |        10
  8 | b    |   12 |        20
  9 | c    |    2 |        30
(9 rows)

Danke viel mal, das funktioniert!!! :smiley: :smiley: :smiley: