schneller von der Datenbank abfragen

[Emrullah]

Hi würde gern mal wissen ob es ne Möglichkeit gibt das mein Programm die daten schneller abfragen kann weil momentan dauert es bei mir in etwas 5 min um in meiner Datenbank ca. 20000-30000 abfragen zu bearbeiten.

ich gebe von Ausgabe/Jahr ein und dann bis Ausgabe/Jahr.

Jetzt sagt mein Programm erstmal
1/1990 -> Datenbank abfrage was es da für Abonnementen gibt's->schließt die Datenbank->2/1990-> usw. und das geht bist 12/2021

ich dachte ich frag erstmal so bevor ich mein Code reinposte mit so viel Fehler und sich alle aufregen XD

 

[kneitzel]

Also ohne Details zu kennen machen viele Dinge Sinn, die man aber jetzt nur allgemein ansprechen kann:

a) Ständiges Öffnen / Schließen der Datenbank: Das ist etwas, das so keinen Sinn macht und extrem langsam ist. Dies im Code umzusetzen verkompliziert den Code aber! Das macht wenig Sinn, seinen Code so zu verkomplizieren! (Wenn man eine Connection hält, dann muss ggf. sicher gestellt sein, dass diese noch offen ist und valid u.s.w.)
==> Wie so oft, gibt es da natürlich eine fertige Lösung: Connection Pooling. Unterstützt ggf. schon der JDBC Treiber selbst und wenn nicht, dann gibt es dazu separate Lösungen, die man einbinden kann und über die es dann läuft. D.h. Du passt (mehr oder weniger) nur den Connection String an und hast dann die Zugriffe wie gewohnt mit try-with-resources Blöcken bei denen die Verbindung direkt geschlossen wird.

b) Fasse SQL Abfragen zusammen. Also statt viele einzelne Abfragen zu erstellen, erstellst Du weniger Abfragen. Statt also 1/1990, 2/1990, ... abzufragen, machst Du eine Abfrage auf alle Elemente, die eben 1/1990 oder 2/1990 oder 3/1990 oder .... haben.

ich dachte ich frag erstmal so bevor ich mein Code reinposte mit so viel Fehler und sich alle aufregen XD

Also aufregen tut sich eigentlich niemand, aber Du wirst ggf viele Anregungen bekommen. Und nie vergessen: Es wird ja nur über den Code "geschimpft" und nicht über Dich. Es ist bisher noch kein Meister vom Himmel gefallen.

 

[Emrullah]

@kneitzel

danke für deine schnelle Antwort 😀

das mit den schimpfen nicht aber viele hätten glaub ich dann durch Kopfschütteln ein Schleuder Trauma erlitten 🙂

also wie ich es verstanden habe meinst das ich den Zeitraum als Array setzte z.b.

Zeitraum[1] = 1/1990
Zeitraum[2] = 2/1990
usw.

dann den Array direkt in der Datenbank durchlaufen lasse ohne die Verbindung zu schließen.

Würde es dadurch effizienter arbeiten??

 

[Oneixee5]

Was ist Zeitraum für ein Datentyp? Man könnte z.B.: ein Datum mit between abfragen: zeitraum between datum1 and datum2

 

[Emrullah]

@Oneixee5

das würde int. sein bzw. mit doppelten Array.

int Zeitraum [Ausgabe][Jahr]

weil ich ja bei der Datenbank beide abfragen müsste.

dann würde ich es mit eine zwei for schleife einbinden

for (int i = 0 ; i <= Jahr.length ;i++){
for (int j=0;j<=Ausgabe.length;j++){
Zeitraum [0][0] // Ausgabe solle dann sein 1 1990
Zeitraum [1][0] // Ausgabe solle dann sein 2 1990
usw
}
}


das würde ich dann in die Datenbank abfrage schicken wodurch ich es nicht immer neu öffnen und schliessen müsste und ich einfach den Array durchlaufen lassen kann.


war dann eher mein Gedanke(ist nur ein Beispiel).

 

[kneitzel]

Das wäre eine Optimierung aber nicht das, was ich geschrieben habe 🙂

Der Punkt a dreht sich um ein Connection Pooling.

Der Punkt b dreht sich darum, dass man die Anzahl der Abfragen verringert. Also etwas wie:
SELECT .... FROM ... WHERE YEAR = 1990 and Month in (1, 2, 3, 4, 5, 6, 7);
Wenn das ganze Jahr 1990 abgefragt würde, dann wäre es einfach:
SELECT .... FROM ... WHERE YEAR = 1990;

Wenn mehrere Jahre abgefragt werden als ganzes, dann wäre es etwas wie:
SELECT .... FROM ... WHERE YEAR in (1990, 1993, 1997);

oder bei zusammenhängenden Intervallen:
SELECT .... FROM ... WHERE YEAR >= 1990 AND YEAR <= 1993;

Bei einem Zusammenhängenden Intervall wären das dann 3 Abfragen:
1. Monate des ersten Jahres also Monat 7-12 des ersten Jahres
2. die Jahre dazwischen also Jahr >= x und jahr <= y
3. Monate des letzten Jahres also z.B. Monat 1-4 des letzten Jahres.

Prinzipiell wäre auch denkbar, dass man einfach alle Jahre abfragt und den "Mehrfang" am Anfang und am Ende einfach nicht übernimmt. Das würde ich aber nicht so machen aber es ist eine Option.

 

[Emrullah]

@kneitzel

die Problem sind das

1. jedes Heft oder Magazin hat unterschiedliche ausgaben pro Jahr.
2. wenn ich den Zeitraum von 2000/bis 2005 angezeigt haben möchte brauch ich natürlich wie viele Abonnementen im Jahr 1990
bis 1999 dazu oder abgegangen sind, das ich ein wert habe für den Anfang von 2000.

deswegen ist immer eine komplette abfrage notwendig.

 

[kneitzel]

deswegen ist immer eine komplette abfrage notwendig.

Nein, die Schlussfolgerung stimmt nicht. Nur ohne Details zu den Daten, der Datenstruktur und der genauen Abfrage ist das leider nicht konkret zu sagen.

Es mag sein, dass Du alle "vorherigen" Datensätze auch betrachten musst um da halt Dinge aufzusummieren oder so, aber das ändert nichts daran, dass dies die Datenbank machen kann. SQL bietet viele Möglichkeiten - so wäre z.B. eine CTE denkbar, die etwas aufbereitet so dass Du dann da gezielte Abfragen machen kannst. Also z.B. baut die CTE erst eine Tabelle, die alle Rows einer Tabelle sortiert (nach jahr und Monat) um da dann ein neues Feld hinzu zu bauen, das dann halt irgendwas zusätzliches beinhaltet.... (Wobei da ggf. das Datenbankschema überdacht werden könnte. Aber ohne Details keine Aussage möglich.)

 

[Emrullah]

@kneitzel


zu Datenbank kann ich eigentlich nur sagen (das es extrem unübersichtlich ist )

hab die privaten stellen abgeschwätzt.

es ist eine pervasive Datenbank

und leider kann man die Datenbank nach spalte nicht sortieren ( hab es schon öfters probiert)


relevant sind die spalten
ABO_AB_AUSG
ABO_AB_JAHR

ABO_BIS_AUSG
ABO_BIS_JAHR

ABO_Z_ANZ
ABO_FREI

 

[mihe7]

viele hätten glaub ich dann durch Kopfschütteln ein Schleuder Trauma erlitten

LOL.

relevant sind die spalten

Damit ein Abo in einem gegebenen Zeitraum A-B gültig ist, muss das Ende E des Abos offensichtlich nach dem Beginn A des Zeitraums liegen (E >= A) und der Start S des Abos offensichtlich vor dem Ende B des Zeitraums liegen (S <= B).

Gibt mir alle "Abonnements", die im Jahr 2000 gültig sind:

SELECT * FROM ABO WHERE ABO_BIS_JAHR >= 2000 AND ABO_VON_JAHR <= 2000;

Jetzt willst Du z. B. die Anzahl der Abos, die in den Jahren 2000 bis 2003 gültig sind, das könnte z. B. in etwa so aussehen.

WITH RECURSIVE jahre AS (
    SELECT 2000 AS jahr
    UNION ALL
    SELECT jahr+1 FROM jahre WHERE jahr < 2003
)
SELECT jahre.jahr, count(ABO.ABO_NR) AS Anzahl
 FROM jahre LEFT JOIN ABO_BIS_JAHR >= jahre.jahr AND ABO_VON_JAHR <= jahre.jahr
GROUP BY jahre.jahr
ORDER BY jahre.jahr;

 

[mihe7]

FROM jahre LEFT JOIN ABO_BIS_JAHR >= jahre.jahr AND ABO_VON_JAHR <= jahre.jahr

Das ist natürlich syntaktisch falsch:

FROM jahre LET JOIN ABO ON ABO_BIS_JAHR >= jahre.jahr AND ABO_VON_JAHR <= jahre.jahr

 

[Emrullah]

@mihe7

danke für deine Hilfe statt jetzt 5 min zu warten brauch ich nur noch dadurch 45 sec 😀

 

[mihe7]

Das kommt mir immer noch viel zu lange vor. Bei den paar Sätzen würde ich eine Antwort in "Nullzeit" erwarten.

 

[Mart]

wie siehts mit deinerü physikalischen dtaenbank verbindung aus?

 

[Neumi5694]

Versuch mal, mit einer Unterabfrage zu arbeiten. Lass zuerst die Anzahl der Abos pro Jahr auslesen und führe deine Von-Bis Abfrage dann auf diese Unterabfrage aus.
So, wie es aktuell ist, wird für jedes Von-Bis Paar jedesmal alles neu gezählt.

Falls das zu komplex ist, mach die die Von-Bis Summe auf Java-Seite, nachdem du die einfache Anzahl pro Jahr in eine Liste oder eine Map (pro Jahr eine Anzahl) eingelesen hast.

 

[mihe7]

Eventuell fehlt auch einfach ein Index auf den Jahresspalten.