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

Delphi-Quellcode:

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:

Zitat von Kostas (Beitrag 1521436)

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

Delphi-Quellcode:

array of Integer

,

Delphi-Quellcode:

array of String

oder

Delphi-Quellcode:

array of "record"

handelt. TDynArray selbst hat keine Daten! Für die Lösung der Aufgabe wird ein

Delphi-Quellcode:

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

SQL-Code:

SELECT *

ist es grob fahrlässig, wenn man die Feldbezeichner weglässt. :freak:

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

[Uwe Raabe]

Zitat:

Zitat von Kostas (Beitrag 1521436)

da ich innerhalb des anonymen Threads auf das FD Object

Delphi-Quellcode:

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:

Zitat von Kostas (Beitrag 1521436)

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;
{...}

[Uwe Raabe]

Zitat:

Zitat von TBx (Beitrag 1521454)

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

Das ist schon eine Weile nicht mehr wirklich relevant, da das DataSet die Felder in einem Dictionary vorhält. Man spart sicher schon noch etwas, aber es ist nicht mehr so gravierend wie früher.

[Kostas]

Zitat:

Zitat von mytbo (Beitrag 1521437)

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

Hallo Thomas,
Das MARS Projekt nutzt ebenfalls Elemente von mormot. Um meine Installation nicht zu beschädigen werde ich die Tage ein SnapShot machen, mormot installieren und den Test durchführen. Es dauert noch etwas bis ich dazu kommen aber du bekommst den Benchmark.

Gruß Kostas

[Kostas]

Zitat:

Zitat von himitsu (Beitrag 1521438)

Aber gerade bei

SQL-Code:

SELECT *

ist es grob fahrlässig, wenn man die Feldbezeichner weglässt. :freak:

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

Meine Query ist deutlich komplexer und hat einige Joins und auch kein select *. Für den Fall ist das SQL jedoch nicht wichtig. Deshalb habe ich eine abgespeckte Version angeboten.

Gruß Kostas

[Kostas]

Zitat:

Zitat von Uwe Raabe (Beitrag 1521439)

Zitat:

Zitat von Kostas (Beitrag 1521436)

da ich innerhalb des anonymen Threads auf das FD Object

Delphi-Quellcode:

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;

Das habe ich jetzt umgesetzt und funktioniert einwandfrei. Der Gesamte Ablauf dauert 1.5min in einem Anonymous Thread das ist perfekt.
Den TJsonTextWriter kannte ich bisher auch nicht, ist viel eleganter wie mein Weg.

Vielen herzlichen Dank Uwe, ich weis das sehr zu schätzen. Du hast mir persönlich so oft geholfen, du bist wirklich eine große Bereicherung für das Forum. Von deinem Kaliber gibt es noch weitere die ich sehr Schätze wie z.B. himitsu um nur einen von vielen weiteren zu nennen.

Gruß Kostas

[Kostas]

Zitat:

Zitat von MyRealName (Beitrag 1521452)

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.

Auf die einfachste Möglichkeit hätte ich kommen können. Vielen Dank dafür. Mittlerweile habe ich die perfekte Lösung aber an Field Alias denke ich viel zu selten.

Gruß Kostas

[himitsu]

Geht es nur um einen einzelnen Record, oder um das ganze Dataset?

Natürlich wäre es da intelligenter, wenn der Exporter die Namen nur einmal in einem Header-Array erwähnt und dann die Fields/Records nur noch als JsonArray, anstatt als JsonObject.


FireDAC nutzt für das SavaToFile/Stream mit sfJSON ja den TFDStanStorageJSONLink.
Dieser hat keine Parameter, aber bestimmt könnte man ihn ableiten oder nachbauen und dann ein besseres Format bereitstellen.

[Kostas]

Hallo himitsu,

das result verarbeitet eine PWA Webanwendung die ebenfalls von uns ist. Somit ist das Format egal.
Die Daten werden für einen offline Betrieb der App benötigt. Es sind zwei Tabellen. Eine davon mit ca. 500.000 Records und eine zweite als Details Tabelle mit etwa 270.000 Records. Dier App läuft als PWA auf jedes Device also auch am smarth phones, tablets usw. Das Abrufen der Daten von dem REST-API Server direkt als GET Endpoint hat zu lange gedauert. Ich bin immer auf ein timeout gekommen. Durch den jetzigen Umbau nur die Feldwerte zu übertragen ist es deutlich schneller und viel weniger Daten die übertragen werden müssen. Jetzt übertrage ich also zwei JSON Files eines 50mb und das zwei 11MB. Als File geht das sehr schnell. Der Json Inhalt wird in einer Indexed DB geschrieben als ein Record. Ich spare mir also auch die inserts in der DB. Das Frontend ist umgesetzt in React.js und ant.design. Der Anwender muss die Datenquelle nicht komplett sehen. Er such nach einen Begriff und die Records werden angezeigt. Das funktioniert alles Pfeilschnell und kann durch PWA auch offline genutzt werden.

[mytbo]

Zitat:

Zitat von Kostas (Beitrag 1521465)

Das MARS Projekt nutzt ebenfalls Elemente von mormot. Um meine Installation nicht zu beschädigen werde ich die Tage ein SnapShot machen, mormot installieren und den Test durchführen. Es dauert noch etwas bis ich dazu kommen aber du bekommst den Benchmark.

Danke für den Test. Meine Lösung von gestern Abend war etwas verspielt. Ich dachte, es ist eine selten genutzte Funktion und damit eine gute Gelegenheit etwas Ausgefallenes aus der mORMot Bibliothek vorzustellen. Die schnellen TextWriter Klassen von mORMot hatte ich im Forum schon vorgestellt, sind hier aber die richtige Wahl. Die Klasse TJsonWriter aus der Unit mormot.core.json ist in meinen Tests größer Faktor 400 schneller als die Delphi Klasse TJsonTextWriter. Für 500K Datensätze ist die Laufzeit kleiner 100 Millisekunden und damit ca. Faktor 4 schneller als mein erster Vorschlag Variant-Array. Das wird deinem Vorhaben einen zusätzlichen Push geben. Schreibe es so:

Delphi-Quellcode:

qrPersonen.First;
var run: Integer := 1;
var w: TJsonWriter := TJsonWriter.CreateOwnedFileStream(MakePath([Executable.ProgramFilePath, 'data.json']));
try
  w.Add('[');
  while not qrPersonen.EoF do
  begin
    w.Add('[');
    w.AddCsvConst([run,
      qrPersonen.Fields[idxPersonID].AsLargeInt;
      qrPersonen.Fields[idxName].AsString;
      qrPersonen.Fields[idxTitel].AsString;
      qrPersonen.Fields[idxVorname].AsString;
      qrPersonen.Fields[idxGeburtsdatum].AsString;
      qrPersonen.Fields[idxPersonalNr].AsString;
      qrPersonen.Fields[idxEintrittsjahr].AsInteger;
      qrPersonen.Fields[idxFachNr].AsLargeInt;
      qrPersonen.Fields[idxFach].AsString
    ]);
    w.Add(']');
    w.AddComma;
  end;
  w.CancelLastComma;
  w.Add(']');
finally
  w.FlushFinal;
  w.Free;
end;

Bis bald...
Thomas

[Union]

Ein Webservice, der potentiell eine so große Datenmenge zurückgibt, sollte mit Paging arbeiten und dies in der API parametrisierbar machen. Die Parameter können dann entsprechend für die Queries verwendet werden; die meisten DB-Server behalten die inner Query im Cache (jedenfalls nach meinen bisherigen Erfahrungen und Messungen):

Delphi-Quellcode:

select 
{LIMIT(0, 100)}
* from
(select * from &Tablename) innerquery

[Kostas]

Zitat:

Zitat von mytbo (Beitrag 1521488)

Zitat:

Zitat von Kostas (Beitrag 1521465)

Das MARS Projekt nutzt ebenfalls Elemente von mormot. Um meine Installation nicht zu beschädigen werde ich die Tage ein SnapShot machen, mormot installieren und den Test durchführen. Es dauert noch etwas bis ich dazu kommen aber du bekommst den Benchmark.

Danke für den Test. Meine Lösung von gestern Abend war etwas verspielt. Ich dachte, es ist eine selten genutzte Funktion und damit eine gute Gelegenheit etwas Ausgefallenes aus der mORMot Bibliothek vorzustellen. Die schnellen TextWriter Klassen von mORMot hatte ich im Forum schon vorgestellt, sind hier aber die richtige Wahl. Die Klasse TJsonWriter aus der Unit mormot.core.json ist in meinen Tests größer Faktor 400 schneller als die Delphi Klasse TJsonTextWriter. Für 500K Datensätze ist die Laufzeit kleiner 100 Millisekunden und damit ca. Faktor 4 schneller als mein erster Vorschlag Variant-Array. Das wird deinem Vorhaben einen zusätzlichen Push geben. Schreibe es so:

Delphi-Quellcode:

qrPersonen.First;
var run: Integer := 1;
var w: TJsonWriter := TJsonWriter.CreateOwnedFileStream(MakePath([Executable.ProgramFilePath, 'data.json']));
try
  w.Add('[');
  while not qrPersonen.EoF do
  begin
    w.Add('[');
    w.AddCsvConst([run,
      qrPersonen.Fields[idxPersonID].AsLargeInt;
      qrPersonen.Fields[idxName].AsString;
      qrPersonen.Fields[idxTitel].AsString;
      qrPersonen.Fields[idxVorname].AsString;
      qrPersonen.Fields[idxGeburtsdatum].AsString;
      qrPersonen.Fields[idxPersonalNr].AsString;
      qrPersonen.Fields[idxEintrittsjahr].AsInteger;
      qrPersonen.Fields[idxFachNr].AsLargeInt;
      qrPersonen.Fields[idxFach].AsString
    ]);
    w.Add(']');
    w.AddComma;
  end;
  w.CancelLastComma;
  w.Add(']');
finally
  w.FlushFinal;
  w.Free;
end;

Bis bald...
Thomas

Hi Thomas,

ich installiere Mormot V2 oder? https://github.com/synopse/mORMot2

[mytbo]

Zitat:

Zitat von Kostas (Beitrag 1521493)

ich installiere Mormot V2 oder? https://github.com/synopse/mORMot2

Ich verwende im Beispiel mORMot2. MARS verwendet mORMot1. Du kannst es auch damit versuchen. Die Klasse, die du verwenden musst, heißt TTextWriter aus der Unit SynCommons. Diese Unit ist in MARS mit dabei. Da ich schon fast 3 Jahre mORMot 2 verwende, alles ohne Gewähr.

Bis bald...
Thomas

[Kostas]

Hallo Thomas,

anbei meine Result:
Rechner: HPE DEL380 Gen10 2x S4208 Xeon CPU
RAM: 256GB ECC Ram DDR4-2933
HDDS: 5x 2TB SSD RAID 5
OS: ESXi 7
VM der Entwickler Maschine Windows Data Center 2019, RAM 16GB, 4 cores zugewiesen.

Die Query liefert 445718 Records.
-Die Query leer durchlaufen also nur next: 4.249 sec.
-Json exportier mit Delphi JsonWriter und FileByName: 52.564 sec.
-Json exportier mit Delphi JsonWriter und Filds[idx]: 52.130 sec.
-Json exportier mit mormot TextWriter und Filds[idx]: 5.754 sec.

ich habe nur die Unit SynCommons aus der mormot installation von MARS eingebunden und System.JSON.Writers deaktiviert.
Der mormot TextWriter ist deutlich schneller.

Vielen Dank Thomas für den Hinweis, kann man gerne einsetzen.

[mytbo]

Zitat:

Zitat von Kostas (Beitrag 1521518)

anbei meine Result:
Rechner: HPE DEL380 Gen10 2x S4208 Xeon CPU
RAM: 256GB ECC Ram DDR4-2933
HDDS: 5x 2TB SSD RAID 5
OS: ESXi 7
VM der Entwickler Maschine Windows Data Center 2019, RAM 16GB, 4 cores zugewiesen.

Die Query liefert 445718 Records.
-Die Query leer durchlaufen also nur next: 4.249 sec.
-Json exportier mit Delphi JsonWriter und FileByName: 52.564 sec.
-Json exportier mit Delphi JsonWriter und Filds[idx]: 52.130 sec.
-Json exportier mit mormot TextWriter und Filds[idx]: 5.754 sec.

ich habe nur die Unit SynCommons aus der mormot installation von MARS eingebunden und System.JSON.Writers deaktiviert.
Der mormot TextWriter ist deutlich schneller.

Vielen Dank für die ausführliche Rückmeldung. Solche Werte sind wichtig, um bei anfallenden Aufgaben in der Planung die voraussichtliche Landezone schnell abschätzen zu können. Mein Schätzwert aus Post #6 mit 10 Sekunden war etwas zu vorsichtig. Beim Vergleich mit dem Anfangswert hat sich das Experimentieren für dich aber gelohnt.

Bis bald...
Thomas