4. Spezielle SQL Anweisung

Spezielle SQL Anweisung

  • B

    Hallo,
    ich benötige ein spzielle SQL-Anweisung, falls dies ünerhaupt funktioniert. Hier mal ein paar Beispiel Daten meiner Tabelle PRUEFUNG

    PREUFUNGSTART|PREUFUNGENDE|PRUEFPROGRAMM
    20.11.2008 06:00:00|20.11.2008 06:00:30|Programm1
    20.11.2008 06:02:00|20.11.2008 06:02:30|Programm1
    20.11.2008 06:08:00|20.11.2008 06:08:30|Programm1
    20.11.2008 12:00:00|20.11.2008 12:00:30|Programm2
    20.11.2008 12:02:00|20.11.2008 12:02:30|Programm2
    20.11.2008 12:08:00|20.11.2008 12:08:30|Programm2
    20.11.2008 16:00:00|20.11.2008 16:00:30|Programm1
    20.11.2008 16:02:00|20.11.2008 16:02:30|Programm1
    20.11.2008 16:08:00|20.11.2008 16:08:30|Programm1
    20.11.2008 16:20:00|20.11.2008 16:20:30|Programm1

    Also Ergebnis der SQL hätte ich gerne folgende
    START|ENDE|PRUEFPROGRAMM|ANZAHLPRUEFUNGEN
    20.11.2008 06:00:00|20.11.2008 06:08:30|Programm1|3
    20.11.2008 12:00:00|20.11.2008 06:08:30|Programm2|3
    20.11.2008 16:00:00|20.11.2008 16:20:30|Programm1|4

    Geht sowas?
    Wenn nicht wie würdet ihr das lösen?

    0

  • Direkten Befehl kenne ich nicht.
    Vielleicht solltest du aber erstmal dazuschreiben welchen SQL Dialekt du verwendest.

    0
  • B

    Das sind mehrere.

    Vorerst ist es Access. Bei weiteren Projekten kommt dann noch eine DB2 und eine ORACLE Datenbank dazu!

    0
  • U

    Das Problem ist nicht die Anzahl Prüfungen sondern Datum.
    Wie soll der Server wissen welches Datum er aus den Rows auswählen soll.

    0
  • D

    Das Problem ist eine geeeignete Gruppierung. Die Gruppierung nach PRUEFPROGRAMM reicht nicht aus, weil die Sortierung nach Datum berücksichtigt werden muss. Möglicherweise helfen 'window functions', aber vermutlich wird es einfacher sein, diese Ansicht mit Hilfe einer Programmier-/Skriptsprache zu erstellen.

    /* EDIT: */ Wie aussieht sind die 'window functions' nur ein Oracle-Feature.

    0
  • W

    Hi,

    Ich habe mir den Spaß mal mit postgres erlaubt. Ich würde das aber auch eher in einer prozeduralen Sprache lösen, da blickt kein Schwein mehr durch. 🙄

    select *, (select count(*) from dd where dd.von >= f.von and dd.bis <= f.bis) as anz
from (
select g.von,
COALESCE((select bis from dd where g.prog = prog and bis >= g.von and bis < (select von from dd where prog != g.prog and von > g.von order by von limit 1) 
order by bis desc limit 1),(select max(bis) from dd)) as bis
,g.prog
from
(
(select von,prog
from dd
order by von
limit 1)

union all

select von,prog
from dd z1
where prog != (select prog from dd where von < z1.von order by von desc limit 1)
)g
order by g.von
)f
    0
  • W

    ...und es ist sau teuer: 😮

    Subquery Scan f  (cost=32465.63..57506.17 rows=1095 width=40)
  ->  Sort  (cost=32465.63..32468.36 rows=1095 width=32)
        Sort Key: g.von
        InitPlan
          ->  Aggregate  (cost=23.75..23.76 rows=1 width=8)
                ->  Seq Scan on dd  (cost=0.00..21.00 rows=1100 width=8)
        ->  Result  (cost=0.00..32386.58 rows=1095 width=32)
              ->  Append  (cost=0.00..186.64 rows=1095 width=32)
                    ->  Limit  (cost=0.00..0.06 rows=1 width=32)
                          ->  Index Scan using dd_pkey on dd  (cost=0.00..64.75 rows=1100 width=32)
                    ->  Seq Scan on dd z1  (cost=0.00..175.63 rows=1094 width=32)
                          Filter: ((prog)::text <> ((subplan))::text)
                          SubPlan
                            ->  Limit  (cost=0.00..0.14 rows=1 width=32)
                                  ->  Index Scan Backward using dd_pkey on dd  (cost=0.00..50.67 rows=367 width=32)
                                        Index Cond: (von < $6)
              SubPlan
                ->  Limit  (cost=29.40..29.41 rows=1 width=8)
                      InitPlan
                        ->  Limit  (cost=0.00..0.14 rows=1 width=8)
                              ->  Index Scan using dd_pkey on dd  (cost=0.00..51.59 rows=365 width=8)
                                    Index Cond: (von > $3)
                                    Filter: ((prog)::text <> ($2)::text)
                      ->  Sort  (cost=29.26..29.27 rows=1 width=8)
                            Sort Key: bis
                            ->  Seq Scan on dd  (cost=0.00..29.25 rows=1 width=8)
                                  Filter: ((($2)::text = (prog)::text) AND (bis >= $3) AND (bis < $4))
  SubPlan
    ->  Aggregate  (cost=22.85..22.86 rows=1 width=0)
          ->  Bitmap Heap Scan on dd  (cost=7.03..22.54 rows=122 width=0)
                Recheck Cond: (von >= $0)
                Filter: (bis <= $1)
                ->  Bitmap Index Scan on dd_pkey  (cost=0.00..7.00 rows=367 width=0)
                      Index Cond: (von >= $0)
    0
Anmelden zum Antworten