Firedac als JSON ohne Feldbezeichner exportieren

[Kostas]

Hallo Zusammen,

gibt es eine Möglichkeit das Firedac ein JSON Exportiert allerdings ohne die Feldnamen?
Der Hintergrund, ich habe eine große Datenmenge 500.000 Datensätze die ich als JSON exportieren muss.
Wenn ich die Query exportieren lasse in JSON dann werden alle Feldbezeichner für jeden Record wiederholt.
Das ist eine sehr große Datenmenge die unnötig ist. Wenn ich die Query selbst durchlaufe und das Json selbst baue dann ist es perfekt. Das Durchlafen der Query dauert jedoch zu lange ca. 4.5min. Wenn es Firedag macht dann schafft es es in 30 Sekunden.

Gruß Kostas

[Uwe Raabe]

Das verstehe ich noch nicht ganz. Wenn du eine Tabelle in JSON-Objekte umwandelst, dann kommt da ein Array of JSON-Objekten heraus, bei dem doch jedes Objekt die Feldnamen enthält.

Wie soll das JSON denn aussehen? Hast du eine Beispiel?

[Kostas]

Hallo Uwe,

Firedac erzeugt so ein Json:

Code:

{"RecordSet" : [
   {
      "PERSONID" : 295,
      "NAMEN" : "Brandl",
      "TITEL" : null,
      "VORNAME" : "Carmen",
      "GEBURTSDATUM" : "29.08.1994",
      "PERSONALNR" : "10115854",
      "EINTRITTJAHR" : 0,
      "FACHNR" : 101006,
      "FACH" : "SV45HD",
   },
...

Wenn ich die Query selbst durchlaufe kann ich ein Jason erzeugen ohne Feldbezeichner PERSONID, NAMEN, TITEL...

Code:

[
       [1,  << die 1++ wird als Zähler automatisch beim hinzufügen eines Elements hinzugefügt.
        295,
        "Brandl",
        "",
        "Carmen",
        "29.08.1994",
        "10115854",
        0,
        101006,
        "SV45HD",
        ],
...

Delphi-Quellcode:

    LPersonen := TJSONArray.Create;

    while not qrPersonen.eof do
    begin
      LPersonenRec := TJSONArray.Create;
      LPersonenRec.add(qrPersonen.FieldByName('PERSONID').AsLargeInt);
      LPersonenRec.add(qrPersonen.FieldByName('NAMEN').AsString);
      LPersonenRec.add(qrPersonen.FieldByName('TITEL').AsString);
      LPersonenRec.add(qrPersonen.FieldByName('VORNAME').AsString);
      LPersonenRec.add(qrPersonen.FieldByName('GEBURTSDATUM').AsString);
      LPersonenRec.add(qrPersonen.FieldByName('PERSONALNR').AsString);
      LPersonenRec.add(qrPersonen.FieldByName('EINTRITTJAHR').AsInteger);
      LPersonenRec.add(qrPersonen.FieldByName('FACHNR').AsLargeInt);
      LPersonenRec.add(qrPersonen.FieldByName('FACH').AsString);

      LPersonen.Add(LPersonenRec);

      qrPersonen.next;
    end;

[Uwe Raabe]

Nun verstehe ich. Du willst also pro Datensatz nur ein Array der Feldwerte haben. Ich fürchte dafür gibt es nichts im Standard.

Ich kann aber auch nicht verstehen, woher die zeitliche Diskrepanz kommt. Kannst du den Scheinwerfer auf den Code mal etwas zurückziehen, damit man auch das Drumherum sehen kann?

Vielleicht hilft ja schon ein DisableControls/EnableControls.

[Kostas]

Hallo Uwe,

ich verwende die MARS Komponenten von Andre Magni und stelle damit einen REST-API Server bereit. Ich habe also keine Control die an der Query gebunden sind.

Um alle Personen abzurufen, nutze ich die Methode etwa so:

Delphi-Quellcode:

function TApiResource.GetPersonen: TFDQuery;
begin
  result :=FD.Query(' SELECT * FROM PERSONEN ');
end;

als Result bekommen ich:

Code:

{"RecordSet" : [
   {
      "PERSONID" : 295,
      "NAMEN" : "Brandl",
      "TITEL" : null,
      "VORNAME" : "Carmen",
      "GEBURTSDATUM" : "29.08.1994",
      "PERSONALNR" : "10115854",
      "EINTRITTJAHR" : 0,
      "FACHNR" : 101006,
      "FACH" : "SV45HD",
   },
...

Die Datenmenge ist relativ groß mit ca. 500.000 Records und es werden viel mehr Felder ausgegeben als hier im Beispiel.
Die Datenmenge kann ich übrigens nicht auf einmal exportieren da der Speicher nicht ausreicht. Die Feldbezeichner machen den größten Anteil aus und die wiederholen sich bei jedem Record.

Jetzt dache ich, ich durchlaufe die Query und exportiere die Daten ohne die Feldbezeichner einfach als Array von Werten.

Delphi-Quellcode:

function TApiResource.GetPersonen: TJSONArray;
var LPersonen, LPersonenRec: TJSONArray;
    qrPersonen: TFDQuery;
begin
  LPersonen := TJSONArray.Create;

  qrPersonen := FD.CreateQuery('');
  qrPersonen.open;


  while not qrPersonen.eof do
  begin
    LPersonenRec := TJSONArray.Create;
    LPersonenRec.add(qrPersonen.FieldByName('PERSONID').AsLargeInt);
    LPersonenRec.add(qrPersonen.FieldByName('NAMEN').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('TITEL').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('VORNAME').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('GEBURTSDATUM').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('PERSONALNR').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('EINTRITTJAHR').AsInteger);
    LPersonenRec.add(qrPersonen.FieldByName('FACHNR').AsLargeInt);
    LPersonenRec.add(qrPersonen.FieldByName('FACH').AsString);

    LPersonen.Add(LPersonenRec);

    qrPersonen.next;
  end;

  result := LPersonen;

end;

Dieser Vorgang dauert jedoch deutlich länger als wenn ich das TFDQuery direkt ausgebe.

Wenn ich die Methode umbaue auch

Code:

SELECT FIRST 10000 SKIP 10000 *...

dann dauert es insgesamt noch länger da das vorbereiten der Query erneut durchgeführt wird für alle 10000 Records. Die Query ist in dem Beispiel ohne Where und joins. Ich Wirklichkeit ist die Query also komplexer.

Dann dachte ich, ich erzeuge eben bei einer Anfrage eine JSON in einem anonymen Thread und schreibe es in ein File. Über eine zweite Methode rufe ich dann das File als Stream ab. Das funktioniert leider auch nicht da ich innerhalb des anonymen Threads auf das FD Object FD.CreateQuery(''); nicht zugreifen kann. Wenn das gehen würde, wäre das perfekt da das File im Hintergrund erzeug werden würde und ich nur periodisch nach dem File frage könnte.

[mytbo]

Zitat von Kostas:

Jetzt dache ich, ich durchlaufe die Query und exportiere die Daten ohne die Feldbezeichner einfach als Array von Werten.

Wenn ich dich richtig verstehe, hast du direkten Zugriff auf die FireDAC Query. Wenn es nur auf die Größe der JSON-Datei ankommt, dann packe sie. Ist dir die Struktur wichtig, kannst du es mit mORMot2 einfach erledigen. In mORMot gibt es verschiedene Wege. Weil ich einige Varianten schon in Artikeln oder Post im Forum vorgestellt habe, kommt heute mORMot TDynArray zum Einsatz. Es umhüllt alle Arten von dynamischen Arrays und stellt ca. 80 Eigenschaften und Funktionen für die Bearbeitung bereit. Egal ob es sich um ein array of Integer , array of String oder array of "record" handelt. TDynArray selbst hat keine Daten! Für die Lösung der Aufgabe wird ein array of array of Variant definiert. Dieser Typ reicht für die Aufgabe, weil jeder Datensatz, als auch die Anzahl der Datensätze handhabbar sind. Als Benchmark: Der Aufbau der Liste und die JSON Serialisierung für 1M Datensätze im gewünschten Format benötigt ca. 0,5 Sekunden. An der Gesamtlaufzeit ist dieser Teil vernachlässigbar klein. Entscheidend ist, wie schnell die Query die Daten liefert. In den Benchmarks schlägt sich FireDAC durchschnittlich. Wenn die Datenbank vor Ort ist, werden es geschätzt 50K Datensätze pro Sekunde bestimmt sein. Damit ist die Aufgabe in ca. 10 Sekunden erledigt. Den folgenden Quelltext habe ich aus den Kopf geschrieben, weil ich schon länger die mORMot Connection Klassen und nicht die Delphi Vorgehensweise nutze.

Delphi-Quellcode:

uses
  mormot.core.base,
  mormot.core.data,
  mormot.core.text,
  mormot.core.perf,
  mormot.core.os;

type
  TVariantDynArrayDynArray = array of array of Variant;

var
  idxPersonID, idxName, idxTitel, idxVorname, idxGeburtsdatum, idxPersonalNr, idxEintrittsjahr, idxFachNr, idxFach: Integer;
  dynArr: TDynArray;
  arrItem: TVariantDynArray;
  arrList: TVariantDynArrayDynArray;
  arrListCount: Integer;
  timer: TPrecisionTimer;
begin
  idxPersonID := qrPersonen.FindField('PERSONID').Index;
  idxName := qrPersonen.FindField('NAMEN').Index;
  idxTitel := qrPersonen.FindField('TITEL').Index;
  idxVorname := qrPersonen.FindField('VORNAME').Index;
  idxGeburtsdatum := qrPersonen.FindField('GEBURTSDATUM').Index;
  idxPersonalNr := qrPersonen.FindField('PERSONALNR').Index;
  idxEintrittsjahr := qrPersonen.FindField('EINTRITTJAHR').Index;
  idxFachNr := qrPersonen.FindField('FACHNR').Index;
  idxFach := qrPersonen.FindField('FACH').Index;

  dynArr.Init(TypeInfo(TVariantDynArrayDynArray), arrList, @arrListCount);
  dynArr.Capacity := 1 shl 18;
  SetLength(arrItem, 10);

  timer.Start;
  qrPersonen.First;
  var run: Integer := 1;
  while not qrPersonen.EoF do
  begin
    arrItem[0] := run;
    arrItem[1] := qrPersonen.Fields[idxPersonID].AsLargeInt;
    arrItem[2] := qrPersonen.Fields[idxName].AsString;
    arrItem[3] := qrPersonen.Fields[idxTitel].AsString;
    arrItem[4] := qrPersonen.Fields[idxVorname].AsString;
    arrItem[5] := qrPersonen.Fields[idxGeburtsdatum].AsString;
    arrItem[6] := qrPersonen.Fields[idxPersonalNr].AsString;
    arrItem[7] := qrPersonen.Fields[idxEintrittsjahr].AsInteger;
    arrItem[8] := qrPersonen.Fields[idxFachNr].AsLargeInt;
    arrItem[9] := qrPersonen.Fields[idxFach].AsString;
    dynArr.Add(arrItem);
    Inc(run);

    qrPersonen.Next;
  end;

  FileFromString(dynArr.SaveToJson, MakePath([Executable.ProgramFilePath, 'data.json']));
  ShowMessage(timer.Time);

Solltest du die mORMot Lösung umsetzen, würde ich mich über eine Rückmeldung mit Benchmark (DB, CPU, SSD Anbindung und Geschwindigkeit) Laufzeit freuen.

Bis bald...
Thomas

[himitsu]

Aber gerade bei SELECT * ist es grob fahrlässig, wenn man die Feldbezeichner weglässt.

OK, eine definierte Reihenfolge (im Select oder beim Auslesen) wäre eine andere Lösung.

[Uwe Raabe]

Zitat von Kostas:

da ich innerhalb des anonymen Threads auf das FD Object FD.CreateQuery(''); nicht zugreifen kann.

Um mit der Query im Thread zu arbeiten, brauchst du eine multi-thread fähige Umgebung mit mindestens einer pooled Connection-Definition (FDManager.AddConnectionDef). Dann könntest du folgende Methode im Thread ausführen:

Delphi-Quellcode:

procedure WritePersonen(const AFileName: string);
begin
  var conn := TFDConnection.Create(nil);
  try
    conn.ConnectionDefName := 'MyPooledConnectionDefName'; // oder wie die eben heißt
    var qry := TFDQuery.Create(nil);
    try
      qry.Connection := conn;
      qry.Open('SELECT * FROM PERSONEN');
      var writer := TJsonTextWriter.Create(TStreamWriter.Create(AFileName, True, TEncoding.UTF8), True);
      try
        writer.WriteStartArray;
        while not qry.Eof do begin
          writer.WriteStartArray;

          writer.WriteValue(qry.FieldByName('PERSONID').AsLargeInt);
          writer.WriteValue(qry.FieldByName('NAMEN').AsString);
          writer.WriteValue(qry.FieldByName('TITEL').AsString);
          writer.WriteValue(qry.FieldByName('VORNAME').AsString);
          writer.WriteValue(qry.FieldByName('GEBURTSDATUM').AsString);
          writer.WriteValue(qry.FieldByName('PERSONALNR').AsString);
          writer.WriteValue(qry.FieldByName('EINTRITTJAHR').AsInteger);
          writer.WriteValue(qry.FieldByName('FACHNR').AsLargeInt);
          writer.WriteValue(qry.FieldByName('FACH').AsString);

          writer.WriteEndArray;
          qry.Next;
        end;
        writer.WriteEndArray;
      finally
        writer.Free;
      end;
    finally
      qry.Free;
    end;
  finally
    conn.Free;
  end;
end;

[MyRealName]

Warum nennst Du die Felder im Query denn nicht um, damit die weniger Platz wegnehmen ?

Code:

Select Id AS "1", Vorname AS "2" FROM Personen

Sowas in der Richtung.

[TBx]

Zitat von Kostas:

Delphi-Quellcode:

{...}
  while not qrPersonen.eof do
  begin
    LPersonenRec := TJSONArray.Create;
    LPersonenRec.add(qrPersonen.FieldByName('PERSONID').AsLargeInt);
    LPersonenRec.add(qrPersonen.FieldByName('NAMEN').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('TITEL').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('VORNAME').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('GEBURTSDATUM').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('PERSONALNR').AsString);
    LPersonenRec.add(qrPersonen.FieldByName('EINTRITTJAHR').AsInteger);
    LPersonenRec.add(qrPersonen.FieldByName('FACHNR').AsLargeInt);
    LPersonenRec.add(qrPersonen.FieldByName('FACH').AsString);

    LPersonen.Add(LPersonenRec);

    qrPersonen.next;
  end;
{...}

Du kannst vermutlich eine Menge Zeit einsparen, wenn Du die Felder nicht für jeden Datensatz sondern einmal vor der Schleife ermittelst:

Delphi-Quellcode:

{...}
  var
    fldPERSONID,
    fldNAMEN,
    fldTITEL,
    fldVORNAME,
    fldGEBURTSDATUM,
    fldPERSONALNR,
    fldEINTRITTJAHR,
    fldFACHNR,
    fldFACH: TField;

{...}

  fldPERSONID := qrPersonen.FieldByName('PERSONID');
  fldNAMEN := qrPersonen.FieldByName('NAMEN');
  fldTITEL := qrPersonen.FieldByName('TITEL');
  fldVORNAME := qrPersonen.FieldByName('VORNAME');
  fldGEBURTSDATUM := qrPersonen.FieldByName('GEBURTSDATUM');
  fldPERSONALNR := qrPersonen.FieldByName('PERSONALNR');
  fldEINTRITTJAHR := qrPersonen.FieldByName('EINTRITTJAHR');
  fldFACHNR := qrPersonen.FieldByName('FACHNR');
  fldFACH :=qrPersonen.FieldByName('FACH');
  while not qrPersonen.eof do
  begin
    LPersonenRec := TJSONArray.Create;
    LPersonenRec.add(fldPERSONID.AsLargeInt);
    LPersonenRec.add(fldNAMEN.AsString);
    LPersonenRec.add(fldTITEL.AsString);
    LPersonenRec.add(fldVORNAME.AsString);
    LPersonenRec.add(fldGEBURTSDATUM.AsString);
    LPersonenRec.add(fldPERSONALNR.AsString);
    LPersonenRec.add(fldEINTRITTJAHR.AsInteger);
    LPersonenRec.add(fldFACHNR.AsLargeInt);
    LPersonenRec.add(fldFACH.AsString);

    LPersonen.Add(LPersonenRec);

    qrPersonen.next;
  end;
{...}