Denkblockade: Wie speicher ich ein Array in einer Datenbank?

[Mithrandir]

Hi ihr,

irgendwie habe ich gerade eine Denkblockade und such mir schon n Wolf:

Ich möchte ein Array, dass bspw. so aufgebaut ist, in eine Firebird-Datenbank schreiben:

Delphi-Quellcode:

  TORPTag = packed record
     Key:   String;
     Value: String;
  end;

  TORPTags = Array of TORPTag;

Ich weiß, dass ich das mittels BLOBs erledigen kann. Dazu gibt es ja auch einige Beispiele, zumindest, wenn es sich um Bilder handelt. Die arbeiten meist alle mit TFileStream/TMemoryStream. Nur, wie bekomme ich ein Array in den Stream? Und wenn die Datenbankabfrage so aussieht:

Delphi-Quellcode:

procedure TORPDataBase.WriteWayToDB(Way: TORPWay);
var
  BlobStr: TStream;
begin
  //Create Query-Object for Way Insert
  fInsertWayQuery := TZQuery.Create(nil);
  fInsertWayQuery.SQL.Text := 'INSERT INTO WAYS (WAY_ID, SUB_NODES, TAGS) VALUES (:way_id, :sub_nodes, :tags) RETURNING "ID"';
  try
    DecimalSeparator := '.';
    with fInsertWayQuery do
    begin
      Connection := fConnection;
      ParamCheck := true;
      ParamByName('way_id').AsInteger := StrToInt(Way.ID);
      ParamByName('tags').AsBlob := ?
      ParamByName('sub_nodes').AsString := EncodeSubNodes(Way.Subnodes);
      ExecSQL;
    end;
  finally
   fInsertWayQuery.Free;
  end;
end;

Wie bekomme ich das Array da drinne unter, ohne, dass mir Zeos das Query um die Ohren haut? Denn ein SQL-Statement ist ja ein Text-Statement, da kann man ja keine Binärdaten unterbringen, oder? :gruebel:

[mkinzler]

Du musst die einzelnen Komponenten des record mit Write() in den Stream schreiben und das dann in einer Schleife über alle Einträge des Arrays

[Dax]

Ich glaube, es wäre besser, das Array in einer separaten Tabelle zu speicher. "Tags" klingt, als solle man danach suchen können, und ein Blob ist nicht gerade durchsuchbar :)

[mkinzler]

Jenach dem wie man die Daten später benötigt. U.U. ist eine weitergehende Normalisierung der Datenbank dann sinnvoll

[Mithrandir]

@mkinzler, Dax:

:(

Also, ich drösel das Problem mal von Anfang an auf:

Momentan werden die Tags in einer Schleife in die Datenbank geschrieben, und die ID anschließend einem String angehängt. Dieser String wird dann in der Datenbank gespeichert.

Im Quelltext sieht das so aus:

Delphi-Quellcode:

constructor TORPDatabase.Create(DBFileName: string);
begin
{...}
  //Create Query-Object for Tag Insert
  fInsertTagQuery := TZQuery.Create(nil);
  fInsertTagQuery.SQL.Text := 'INSERT INTO TAGS ("KEY", "VALUE") VALUES (:key, :val) RETURNING "ID"';

  //Create Query-Object for Way Insert
  fInsertWayQuery := TZQuery.Create(nil);
  fInsertWayQuery.SQL.Text := 'INSERT INTO WAYS (WAY_ID, SUB_NODES, TAGS) VALUES (:way_id, :sub_nodes, :tags) RETURNING "ID"';
{...}
end;

function TORPDataBase.WriteTagsToDB(Tags: TORPTags): string;
var
  i: integer;
begin
  Result := '';
  DecimalSeparator := '.';
  for i := 0 to Length(Tags) - 1 do
  begin
    with fInsertTagQuery do
    begin
      Connection := fConnection;
      begin
        ParamCheck := true;
        ParamByName('key').AsString := Tags[i].Key;
        ParamByName('val').AsString := Tags[i].Value;
        Open;
        Result := Result + FieldByName('ID').AsString + '|';
      end;
    end;
  end;
end;

procedure TORPDataBase.WriteWayToDB(Way: TORPWay);
var
  BlobStr: TStream;
begin
  try
    DecimalSeparator := '.';
    with fInsertWayQuery do
    begin
      Connection := fConnection;
      ParamCheck := true;
      ParamByName('way_id').AsInteger := StrToInt(Way.ID);
      ParamByName('tags').AsString := WriteTagsToDB(Way.Tags);
      ParamByName('sub_nodes').AsString := EncodeSubNodes(Way.Subnodes);
      ExecSQL;
    end;
  finally

  end;
end;

Ich sehe jetzt 2 Performanceprobleme: Zum einen musste ich gewährleisten, dass mindestens x Unterknoten gespeichert werden können, resp. deren IDs. Dadurch wird das VarChar-Feld ja riesig. Außerdem braucht es für jeden Tag ein "Insert Into" - Statement. Klar, dadurch, dass ich mit Parametern arbeite, geht das schon schneller. Aber durch die Nutzung von Blobs hätte ich mir jetzt einen stärkeren Geschwindigkeitsvorteil und einen geringeren Speicherbedarf auf Kosten der Suchfunktion erhofft. Würde ich mit diesen Mutmaßungen richtige liegen?

[mkinzler]

Ja. sollte schneller sein als die einzelnen Teile des Arrays getrennt in extra Tabelle zu schreiben

[Mithrandir]

Zitat:

Zitat von mkinzler

Ja. sollte schneller sein als die einzelnen Teile des Arrays getrennt in extra Tabelle zu schreiben

Ok, danke. Also, oft kann ich mit deinen berühmten "One Linern" ja was anfangen, aber hier:

Zitat:

Zitat von mkinzler

Du musst die einzelnen Komponenten des record mit Write() in den Stream schreiben und das dann in einer Schleife über alle Einträge des Arrays

bin ich etwas überfordert... :mrgreen:


Ein einfaches

Delphi-Quellcode:

fStream.Write(Way.Tags[0], SizeOf(Way.Tags));

Würde als nicht funktionieren?

Aber wie bekomme ich die Daten dann wieder raus? Fragen über Fragen... :gruebel:

[Dax]

Code:

WriteString (string, stream): stream.Write(string.Length), stream.Write(string[0], string.Length);
WriteRec (rec, stream): WriteStrimg(rec.Key, stream), WriteString(rec.Value, stream);

Und auslesen entsprechend andersrum: Länge lesen, SetLength, Lesen am Stück, Länge... ;)

[mkinzler]

So hatte ich es gemeint

Delphi-Quellcode:

Writeln( BlobStr, Length( TORPTags)); //Anzahl
for i := Low( TORPTags) to High( TORPTags) do
begin
    WriteLn( BlobStr, TORPTags[i].Key);
    WriteLn( BlobStr, TORPTags[i].Value);
end;

[Mithrandir]

Hi ihr beiden,

So langsam bröckelt die Mauer vor meinem geistigen Auge. Die herangehensweise über WriteLN find ich dabei interessant. Darauf wäre ich von selbst wohl nicht gekommen... :gruebel:

Danke ihr zwei. ;)