Spezielle SQL Anweisung



  • 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?



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



  • Das sind mehrere.

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



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



  • 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.



  • 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
    


  • ...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)
    

Log in to reply