Array füllen mit Daten aus Datenbank (Join)

[Matze]

Hallo zusammen,

ich habe folgende Datenbanktabellen, bei denen die Datensätze der Prozessdaten über die Kopf-ID mit der Kopfdaten-ID verknüpft sind:

Kopfdaten:

Code:

ID    Datum  ...
1    12.11.16
2    13.11.16

Prozessdaten:

Code:

Kopf-ID    Name   Value
1         Kraft    10
1         Druck     2
1         Temp     22
2         Geschw.  110

Ich möchte diese Daten auslesen und eine Liste damit füllen:

Code:

class Data {
    public sting Name;
    public double Value;
}
Dictionary<int, List<Data>> result;

Gefüllt soll das so aussehen (Pseuso-Code):

Code:

[1] =>
    [
        Name = "Kraft"
        Value = 10
    ],
    [
        Name = "Druck"
        Value = 2
    ],
    [
        Name = "Temp"
        Value = 22
    ],
[2] =>
    [
        Name = "Geschw."
        Value = 110
    ],

Nun würde ich gerne wissen, wie man das am besten macht.
Folgende Möglichkeiten fallen mir ein (Pseudo-Code, achtet bitte nicht auf die Syntax o.ä. )

1. Mehrfache Datenbankabfragen, das sind jedoch u.U. sehr viele

Code:

headData = SELECT * FROM Kopfdaten;

foreach (sHeadData in headData) {
    id = sHeadData["ID"];
    values = SELECT * FROM Prozessdaten WHERE Kopf-ID = id;

    valuesParsed = new List<Data>();
    foreach (var sValue in values) {
        valuesParsed.Add(
            new Data() {
                Name = sData["Name"],
                Value = sData["Value"],
            }
        );
    }

    result.Add(id, valuesParsed);
}

2. Eine Abfrage mittels JOIN

Ich denke von der Abfrage her ist es deutlich schneller, aber die Logik für die Aufbereitung kommt mir eher umständlich vor.

Code:

data = SELECT * FROM Kopfdaten k
    INNER JOIN Prozessdaten p
        ON k.ID = p.Kopf-ID;

foreach (var sData in data) {
    id = sData["ID"];

    if (!result.ContainsKey(id)) {
        result.Add(id, new List<Data>());
    }

    result[id].Add(
        new Data() {
            Name = sData["Name"],
            Value = sData["Value"],
        }
    );
}

Ich hoffe, ihr könnt nachvollziehen worum es mir geht und mit idealerweise nennen, wie man das am besten umsetzt. 2 verknpüfte Tabellen hat man ja meist irgendwo und so außergewöhnlich ist die Aufgabenstellung daher nicht, denke ich.

Wie macht ihr sowas?

Grüße
Matze

[p80286]

Gestern Abend habe ich es nicht verstanden und heute Morgen immer noch nicht.
In einer Datenbank ist eine Information über mehrere Tabellen verteilt. Wenn Du also eine Information erhalten willst, kommst Du an einem JOIN nicht vorbei. Betrachtest Du zwei (oder mehr) TabellenInhalte getrennt, kann das auf die Rückgewinung der Information hinauslaufen, muß aber nicht.
U.U. kann das z.B. die Aufbereitung für die Ausgabe erleichtern, aber dadurch verlagerst Du Datenbankfunktionalität in Dein Anwendungsprogramm. Das halte ich für wenig empfehlenswert.

Gruß
K-H

[Lemmy]

Hallo Matze,

es kommt letztlich auf die Datenbankengine und die Datenmenge an.

Ich habe hier jahrelang versucht über einen Join eine akzeptable Ausführungsgeschwindigkeit hin zu bekommen - erst als ich dann zwei einzelne Abfragen verwendet habe, und die Liste auf dem Client dann sequentiell gefüllt habe, war das Teil so sau schnell, dass ich mich geärgert habe den Weg nicht schon früher gegangen zu sein.

Allerdings muss ich auch sagen, dass eine der Tabellen riesig war und ich die Datenmengen stark eingegrenzt hatte.

Daher bliebt nur der Rat: Versuch es und schau wie dein System reagiert - am sinnvollsten mit einer Kopie der Echtdaten, wenn das nicht geht mind. so viel Testdaten, dass eine vergleichbar große Datenbank entsteht. Vermutlich reicht es sogar aus, die beiden Abfragen (einmal mit Join, einmal 2 Abfragen ohne Join) gegeneinander antreten zu lassen.

[jfheins]

Was mich gerade noch etwas irritiert: Für dein Wunsch-Ergebnis sind gar keine Kopfdaten enthalten. Das kannst du ja rein über die Prozessdaten befüllen.

Wenn du das Zeug jetzt eigentlich irgendwie nach den Kopfdaten filtern willst (also alle Messungen im Zeitraum xy) dann würde ich folgendes Vorgehen empfehlen:

1. Kopfdaten selektieren, die du brauchst (SELECT * where Date > 2016-11-11)
2. Deren ids sammeln (Clientseitig z.B. in einem Hashset)
3. Messungen selektieren (SELECT * FROM `theTable` WHERE `id` IN (n, ... nk); )

Die Anzahl der SQL-Abfragen sollte möglichst nicht linear mit der Datenmenge skalieren. Daher würde ich Lösung 1 von dir ausschließen. Lösung 2 ist ok, wenn die Kopfdaten klein oder wenige Datenzeilen pro Messung vorliegen. Grund ist, dass du ja für jeden Datensatz die Kopfdaten nochmal im Ergebnis hast, was bei großen Kopfdaten irgendwann langsam wird.

[Phoenix]

Also, wenn ich dem Tag das C# korrekt entnehme, dann würde ich folgendes machen. Das ganze kannst Du 1:1 in LinqPad als C# Program reinwerfen und ausprobieren:

Code:

class Kopfdatum
{
   public int Id { get; set; }
   public DateTime Date { get; set; }
}

class Prozessdatum
{
   public int KopfId { get; set; }
   public string Name { get; set; }
   public double Value { get; set; }
}

class Data
{
   public string Name { get; set; }
   public double Value { get; set; }
}

void Main() {
   Kopfdatum[] Kopfdaten = {
      new Kopfdatum() { Id = 1, Date = new DateTime(2016, 11, 12) },
      new Kopfdatum() { Id = 2, Date = new DateTime(2016 ,11, 13) },
   };

   Prozessdatum[] Prozessdaten = {
      new Prozessdatum() { KopfId = 1, Name = "Kraft", Value = 10 },
      new Prozessdatum() { KopfId = 1, Name = "Druck", Value = 2 },
      new Prozessdatum() { KopfId = 1, Name = "Temp", Value = 22 },
      new Prozessdatum() { KopfId = 2, Name = "Geschwindigkeit", Value = 110 },
   };
      
   // Das hier ergibt das, was Du nach einem Join hast:
   var zwischenErgebnis = Prozessdaten
       .Join(Kopfdaten,
         p => p.KopfId,
         k => k.Id,
         (p, k) => new { KopfId = k.Id, KopfDatum = k.Date, ProzessName = p.Name, ProzessWert = p.Value }
      );

   // wenn in LinqPad ausgeführ macht das hier ne Zwischenausgabe :)
    zwischenErgebnis.Dump();
   
   var result = zwischenErgebnis
      .GroupBy(z => z.KopfId)
      .ToDictionary( // hier kommen die Gruppen rein
        group => group.Key,
        group => group.Select(
              i => new Data() { Name = i.ProzessName, Value = i.ProzessWert }
           ).ToList()
      );
      
      
   result.Dump();

   // oder, in einem Rutsch:
   result = Prozessdaten
     .Join(Kopfdaten,
         p => p.KopfId,
        k => k.Id,
        (p, k) => new { Id = k.Id, Val = new Data() { Name = p.Name, Value = p.Value } })
     .GroupBy(j => j.Id)
     .ToDictionary(
         g => g.Key,
        g => g.Select(v => v.Val).ToList()
      );
     
     result.Dump();
}