Tabelle um Spalte erweitern und mit berechneten Werten füllen

[RWarnecke]

Hallo zusammen,

ich habe zwei Tabellen, die in Abhänigkeit sind in einer SQLite3 Datenbank.

Tabelle 1:

Spalte1	Spalte2	Spalte3
1	Wert1	310
2	Wert1	235
3	Wert1	310
4	Wert2	235
5	Wert2	310
6	Wert2	235
7	Wert3	310
8	Wert3	235

Tabelle 2:

Spalte1	Spalte2
Wert1	1500
Wert2	1250
Wert3	1000

In Tabelle 1 soll jetzt eine Spalte 4 hinzugefügt werden und dann möchte ich mit einem oder mehreren SQL-Befehl(en) einen Wert für die Spalte 4 errechnen. Beispiel für Wert 1 aus Tabelle 1 :

Zeile 1 --> 1500 - 310 = 1190
Zeile 2 --> 1190 - 235 = 955
Zeile 3 --> 955 - 310 = 645

Die ausgerechneten Werte sollen dann jeweils in Spalte 4 der Tabelle 1 eingetragen werden. Das soll natürlich auch für Wert 2 und 3 gemacht werden. Ist dieses mit SQL-Befehlen möglich oder muß ich das ganze im Quelltext der Anwendung programmieren ?

[himitsu]

Du kannst Spalten aus anderen Tabellen via JOIN oder als Sub-SELECT aufnehmen,
oder du benutzt ein CalcField und baust es in das DataSet ein.

SQL-Code:

SELECT A1, A2, (B1 - A1) AS Bx
FROM A
JOIN B ON ...

SELECT A1, A2, (SELECT B1 - A1 FROM B WHERE ...) AS Bx
FROM A

[RWarnecke]

Das sind doch nur ganz normale Select-Anweisungen. Mein Ergebnis nach dem/den SQL-Befehl(en) soll so aussehen :

Spalte1	Spalte2	Spalte3	Spalte4
1	Wert1	310	1190
2	Wert1	235	955
3	Wert1	310	645
4	Wert2	235	1015
5	Wert2	310	705
6	Wert2	235	470
7	Wert3	310	690
8	Wert3	235	455

Stelle ich die Frage anders. Kann ich einen INSERT INTO Befehl so aufbauen, dass er mir die Spalte 4 so aufbaut, wie in der Tabelle ? Wenn ja, wie muss das gemacht werden ?

[mkinzler]

Sollte durch Update gehen

SQL-Code:

update tabelle1 t1
  set spalte4 = (select spalte2 from tabelle2 t2 where t2.spalte1 = t1.spalte) - t1.spalte3;

[RWarnecke]

Hallo Markus,

ich habe Dein Update-Befehl ausprobiert. Leider bringt er nicht das gewünschte Ergebnis. Der Wert aus Tabelle 2 (Beispiel: 1500) soll nur bei der ersten Subtrahierung genommen werden. Beim zweiten Mal soll der Wert genommen werden, der durch das Update in Spalte 4 der ersten Tabelle eingefügt wurde.

[Olli73]

Zitat:

Zitat von RWarnecke (Beitrag 1306118)

ich habe Dein Update-Befehl ausprobiert. Leider bringt er nicht das gewünschte Ergebnis. Der Wert aus Tabelle 2 (Beispiel: 1500) soll nur bei der ersten Subtrahierung genommen werden. Beim zweiten Mal soll der Wert genommen werden, der durch das Update in Spalte 4 der ersten Tabelle eingefügt wurde.

Ungetestet (also "so ungefähr"):

Code:

update tabelle1 t1
   set t1.spalte4 = (select t2.spalte2 from tabelle2 t2 where t2.spalte1 = t1.spalte2) - (select sum(t3.spalte3) from tabelle1 t3 where t3.spalte2 = t1.spalte2 and t3.spalte1 <= t1.spalte1);

[jobo]

Also ich glaube nicht, dass das so ohne weiteres geht (mit sqLite)
1. Die Anforderung benötigt im Prinzip Window Functions, was sqLite nicht besitzt (gibt glaub ich ein Mod, das etwas davon umsetzt)
2. Man bräuchte zum Verzicht auf die Window Fuctions noch genauere Angaben zu den Werten (Sortierung, Anzahl) Also ist das was man sieht, aufsteigend, lückenlos usw. garantiert oder "Zufall"
3. Ich frage mich nach dem Sinn. Du baust im Grunde gezielt eine funktionale Beziehung zwischen Daten ein. Das ist Denormalisierung, das will man nicht. Außer aus Performancegründen vielleicht, dann muss man es aber absichern oder regulieren, dass die Werte beliebig neu berechnet werden können oder oder

[frankyboy1974]

Hallo,

ich mag mich täuschen, aber ich würde sagen, dies ist mit einem einzigen deskriptiven SQL-Statement nicht möglich. Dass man das Ergebnis der einen Zeile, als Zwischenergebnis speichert und mit diesem Ergebnis dann in der nächsten Ergebniszeile weiterrechnet, ist meines Wissens nicht SQL-konform. Meine letzte SQL-Schulung ist zwar schon ein paar Jahre (Jahrzehnte) her, aber ich würde sagen nein. Mit Datenbankprogrammierung bzw. Delphiprogrammierung sollte das Problem aber einfach zu lösen sein. Falls ich mich geirrt habe, würde ich mich freuen, wenn mich jemand korrigiert (Man lernt nie aus).

mfg

Frank

[ibp]

kann SQLLite StoredProcedure? Dann mach das damit.

oder ein Denkanstoß...

Zitat:

Zeile 1 --> 1500 - 310 = 1190
Zeile 2 --> 1190 - 235 = 955
Zeile 3 --> 955 - 310 = 645

ist das gleiche wie...., damit brauchst du keinen Zwischenspeicher für das Ergebnis der vorausgegangenen Zeile...

Code:

Zeile 1 --> 1500              -  310 = 1190
Zeile 2 --> 1500 - 310        -  235 = 955
Zeile 3 --> 1500 - 310 - 235  -  310 = 645

[user0815]

Oder eine View erstellen & damit weiter arbeiten ?

SQL-Code:

SELECT t1.Spalte1, t1.Spalte2, t1.Spalte3, t2.Spalte2 AS Wert, (t2.Spalte2 - t1.Spalte3) AS Rest
FROM Tabelle1 t1
LEFT JOIN Tabelle2 t2 ON t1.Spalte2 = t2.Spalte1

[ibp]

Ansatz, baut auf meinem vorigen Beitrag auf...

SQL-Code:

select
t2.spalte2
,(select sum(ts.spalte3)
from tabelle1 ts
where ts.spalte1 < (t1.spalte1)
) as Summe
,t1.spalte3
from tabelle1 t1
left join tabelle2 t2 on (t2.spalte1 = t1.spalte2)
where t1.spalte2 = 'Wert1'
order by t1.spalte1

Ergebnis:

Code:

Spalte2  Summe    Spalte3
1500     <null>   310
1500     310      235
1500     545      310

nur das Ergebnis...

SQL-Code:

select
t2.spalte2 -
   (select sum(ts.spalte3) from tabelle1 ts where ts.spalte1 <= t1.spalte1)
from tabelle1 t1
left join tabelle2 t2 on (t2.spalte1 = t1.spalte2)
where t1.spalte2 = 'Wert1'
order by t1.spalte1

Das Prinzip sollte klar sein, den Rest bekommst du schon hin...

[ibp]

für die ganze Tabelle... geht es auch mit einem Statement...

SQL-Code:

select
t1.spalte1,
t1.spalte2,
t1.spalte3,
t2.spalte2 -
   (select sum(ts.spalte3) from tabelle1 ts where (ts.spalte1 <= t1.spalte1) and (ts.spalte2=t1.spalte2))
as spalte4
from tabelle1 t1
left join tabelle2 t2 on (t2.spalte1 = t1.spalte2)
order by t1.spalte1

immer in Mengen denken :wink:

[frankyboy1974]

hallo,

@idb
ich sehe in deiner Abfrage noch nicht einmal, wo irgendwelche Datensätze aktualisiert werden. Der TE wollte wissen, ob er mit einem SQL Statement, die Daten aktualisieren kann. Ohne es ausprobiert zu haben, würde ich sagen, das dein SQL-Statement auch noch nicht einmal die richtigen Werte liefert. Selbst wenn du dass anschliessend in der DB speichers (insert into select from).

Um deine Worte zu benutzen

immer erst überhaupt denken :lol:

mfg

frank

[jobo]

Zitat:

Zitat von frankyboy1974 (Beitrag 1306265)

immer erst überhaupt denken :lol:

Dieser Tipp ist natürlich unschlagbar!
:)

[ibp]

@frankyboy1974

ich gehe davon aus das Rolf Warnecke durchaus in der Lage ist die Transferleistung zu erbringen aus einer Select-Anweisung ein Update-Statement zu erstellen.

SQL-Code:

update tabelle1 ut1
set ut1.spalte4 =
(
select t2.spalte2 - (select sum(ts.spalte3) from tabelle1 ts where (ts.spalte1 <= t1.spalte1) and (ts.spalte2=t1.spalte2))
from tabelle1 t1
left join tabelle2 t2 on (t2.spalte1 = t1.spalte2)
where t1.spalte1 = ut1.spalte1
)

Des weiteren ist es anmaßend aus einem Verdacht heraus generell etwas als falsch darzustellen und dann auch noch beleidigende Aussagen zu treffen.

MfG IbP

[BUG]

Zitat:

Zitat von user0815 (Beitrag 1306240)

Oder eine View erstellen & damit weiter arbeiten ?

Aus Datenbankler-Sicht ist das der richtige Weg, da es Inkonsistenzen vermiedet.

Siehe auch:

Zitat:

Zitat von jobo (Beitrag 1306198)

Du baust im Grunde gezielt eine funktionale Beziehung zwischen Daten ein. Das ist Denormalisierung, das will man nicht. Außer aus Performancegründen vielleicht, dann muss man es aber absichern oder regulieren, dass die Werte beliebig neu berechnet werden können oder oder

Aber du wirst schon nen Grund haben :mrgreen:

[jobo]

Es haben sich wohl genug Hinweise bzw. Ansätze und Lösungen gesammelt, denke der TE kann das schon sinnvoll umsetzen.
Was das beste ist, kann man anhand seiner bisherigen Angaben hier nicht sagen. Ich vote dennoch blindlings für einen View.

[Dejan Vu]

Bei einer derartig gestalteten View ist der Aufwand doch O(n^2), oder genau O(n*m), wobei n die Anzahl der Zeilen und m die mittlere/maximale Länge der zu summierenden Abschnitte ist, also doch letztendlich O(n^2)

Wenn ich die Tabelle einlesen und das per Hand mache, wäre der Aufwand dagegen O(n). Wenn ich die Daten also im Speicher benötige, sollte das dann -zumindest theoretisch- schneller gehen.