komplizierte SQl abfrage

Hi,

Ich habe ein tabelle mit läuter längen von Dokumenten.
Ich würde gerne die summe der Längen in X gleich große Stücke teilen, die die gleiche Summe haben.
Der Clou an der Sache ist, dass nur gleiche oder wenn nötig ähnliche Längen summiert werden.

Sowas in der Art:

SELECT len FROM table ORDER BY len

Das dann in x gleich große Stücke teilen.
Also Stücke, die alle die gleiche Summe der Längen haben.

Zeig bitte ein Beispiel.

Kleine Beispieltabelle:

id | len 
----+-----
  1 |   2
  2 |   1
  3 |   6
  4 |   5
  5 |   1
  6 |   5
  7 |   1
  8 |   3
  9 |   1
 10 |   3
 11 |   6
 12 |   5
 13 |   1
 14 |   4
 15 |   2
 16 |   1
 17 |   6
 18 |   3
 19 |   2
 20 |   3
 21 |   1
 22 |   3
 23 |   5
 24 |   4

Dann sortiert nach der Länge

 id | len 
----+-----
  9 |   1
  2 |   1
 21 |   1
 16 |   1
  5 |   1
 13 |   1
  7 |   1
  1 |   2
 15 |   2
 19 |   2
 10 |   3
 18 |   3
 20 |   3
 22 |   3
  8 |   3
 24 |   4
 14 |   4
  4 |   5
 12 |   5
  6 |   5
 23 |   5
  3 |   6
 11 |   6
 17 |   6

Und dann beispielsweise in 4 Stücke geteilt, die alle die gleiche Summer der Länge haben oder eine ähnlich, falls nicht ander möglich:

 id | len 
----+-----
  9 |   1
  2 |   1
 21 |   1
 16 |   1
  5 |   1
 13 |   1
  7 |   1
  1 |   2
 15 |   2
 19 |   2
sum(len) = 13



 id | len 
----+-----
 10 |   3
 18 |   3
 20 |   3
 22 |   3
  8 |   3
 24 |   4
 14 |   4
sum(len) = 23



 id | len 
----+-----
  4 |   5
 12 |   5
  6 |   5
 23 |   5
sum(len) = 20



 id | len 
----+-----
  3 |   6
 11 |   6
 17 |   6
sum(len) = 18

und das als Ausgabe

len | count
----+-----
1-2 | 13
3-4 | 23
5   | 20
6   | 18

Die Stücke haben hier eine recht unterschiedliche länge, weil ich es so wenig zeilen sind.

Ach ja wofür ich das brauche:
Für einen partiellen INdex der gleichmäßig aufgeteilt ist.
Die Rechenarbeit hängt nunmal grob von der Anzahl der Wörter ab.

Hrm.

Vielleicht könnte man da mit window-funktionen was intelligentes basteln. Aber zum Freitag nachmittag fällt mir da jetzt nix so wirklich ein…

Hab ich auch schon überlegt.
Naja ich kann das auch in ein paar Minuten mit ein paar sql Abfragen ermitteln.
Ich arbeite jetzt übrigens mit Sphinx, eine RDBMS war einfach nicht schnell genug.

Angenommen, du hast:

test=*# select * from jayni ;
 len
-----
   3
   2
   6
   5
   4
   3
   5
   4
   4
   3
   2
   3
   4
   4
   4
   5
   5
   2
   2
   2
   4
   3
   2
   5
   5
(25 rows)

Daraus kannst schon erst mal gewisse Informationen ziehen:

test=*# select len, max(r), s from(select len, row_number() over (partition by len order by len) as r, sum(len) over (partition by len) s from jayni) foo group by len, s order by s;
 len | max | s
-----+-----+----
   6 |   1 |  6
   2 |   6 | 12
   3 |   5 | 15
   4 |   7 | 28
   5 |   6 | 30
(5 rows)

max ist hier, wie oft len vorkommt, und s die Summe aller gleichen len - Werte. Du könntest den ersten und letzten, den zweiten und vorletzten und so weiter zu einer Gruppe nehmen, die sind dann etwa das, was Du suchst, oder?

Ja stimmt. Mir ist nur gerade noch eingefallen, dass die Indexe auch mit einer unterschiedliche Häufigkeit durchsucht werden. Das wird kniffelig.
Danke für deine Antwort.