große XML/GraphML Dateien schreiben

[bernhard_LA]

Ich versuche gerade eine sehr große XML/GraphML ( http://graphml.graphdrawing.org/prim...ml-primer.html ) zu erzeugen. Bei kleinen Projekten bis 50.000 Elementen funktioniert der aktuelle Code perfekt.
Wir kann ich die Erzeugung von großen XML Files mit MSXML beschleunigen ?
x- Millionen Nodes, 30 ++ Gbyte RAM für die Anwendung, Laufzeit x Tage , nicht akzeptabel

Delphi-Quellcode:

function WritegraphMLdatei  ( ......  ) : string ;

  LDocument: IXMLDocument;
  LNodeElement, LGRAPHelement,  NodeText,   NodeCData: IXMLNode;
begin

  ///
  ///
  ///

  CoInitialize(nil);

  ///
  /// the xml header
  ///
  LDocument := TXMLDocument.Create(nil);
  LDocument.Active := True;
  LDocument.DocumentElement := LDocument.CreateNode('graphml', ntElement, '');
  LDocument.DocumentElement.Attributes['xmlns'] :=
    'http://graphml.graphdrawing.org/xmlns';
  LDocument.DocumentElement.Attributes['xmlns:xsi'] :=
    'http://www.w3.org/2001/XMLSchema-instance';



  ///
  /// dieser Code wird x millionen fach ausgeführt .... 
  ///

  for graph.Edge  .... 

  LNodeElement := LDocument.DocumentElement.AddChild('key', -1);
  LNodeElement.Attributes['id'] := 'nkey' + IntToStr(1); 



  for graph.node ...... 

      LSubNodeElement := LGRAPHelement.AddChild('edge', -1);
      LSubNodeElement.Attributes['id'] :=  .... ;
      LSubNodeElement.Attributes['source'] := ... ;
      LSubNodeElement.Attributes['target'] :=...;
      .....


    end;

  finally

    result.Text := LDocument.XML.Text;

    CoUninitialize;

  end;

[generic]

MSXML ist dafür nicht geeignet, weil es den DOM-Document Ansatz implementiert.
D.h. alles muss im Speicher gehalten werden.

Der andere Ansatz ist was z.B. SAX macht.
Ereignis basiert bzw. im Stream.

Für Delphi habe ich da aber gerade nichts, was ich aus dem Hut zaubern könnte.

[peterbelow]

@bernhard_LA:

Take a look at http://www.berenddeboer.net/delphi/. This is pretty ancient code, so you may have to resolve some ANSI -> Unicode issues in modern Delphi versions.

[mytbo]

Zitat von bernhard_LA:

Ich versuche gerade eine sehr große XML/GraphML zu erzeugen.

Wie groß werden die XML Dateien? In mORMot gibt es die Funktion JsonToXML(). Die Limitierung ist der RawByteString.

Delphi-Quellcode:

var
  json, xml: RawByteString;
begin
  ...
  xml := JsonToXML(json);

mORMot verarbeitet fast alles zu Json. Die Konvertierung ist dann im ms Bereich erledigt.

Bis bald...
Thomas

[TiGü]

Zitat von generic:

MSXML ist dafür nicht geeignet, weil es den DOM-Document Ansatz implementiert.
D.h. alles muss im Speicher gehalten werden.

Der andere Ansatz ist was z.B. SAX macht.
Ereignis basiert bzw. im Stream.

Für Delphi habe ich da aber gerade nichts, was ich aus dem Hut zaubern könnte.

Da gab es vor Urzeiten mal ein kleine Demo von Marabu, die immer noch funktioniert, wenn man in der uses-Klausel einfach "MSXML2" mit "Winapi.msxml" ersetzt (hier Delphi 10.4).
Siehe in Beitrag 17 und folgende:
https://www.delphipraxis.net/67754-o...eichern-2.html

Da wird gezeigt, wie eine Instanz von TDemoClass sich selber in XML serialisiert.

Delphi-Quellcode:

unit DemoFrm;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Winapi.msxml;

type
  TDemoForm = class(TForm)
    Button: TButton;
    Memo: TMemo;
    procedure ButtonClick(Sender: TObject);
  end;

var
  DemoForm: TDemoForm;

implementation

{$R *.dfm}

type
  TDemoClass = class(Tobject)
    SomeInteger: Integer;
    SomeString: String;
    DemoClass: TDemoClass;
    procedure Serialize(cnth: ISAXContentHandler);
    procedure Deserialize(cnth: ISAXContentHandler);
    destructor Destroy; override;
  end;

var
  sEmpty: WideString;

function StartElement(cnth: ISAXContentHandler; name: String): Boolean;
var
  a: ISAXAttributes;
  sElement: WideString;
  iLength: Integer;
begin
  a := CoSaxAttributes.Create as ISAXAttributes;
  sElement := name;
  cnth.startElement(Word(sEmpty[1]), 0, Word(sEmpty[1]), 0, Word(sElement[1]), Length(sElement), a);
end;

function EndElement(cnth: ISAXContentHandler; name: String): Boolean;
var
  sElement: WideString;
begin
  sElement := name;
  cnth.endElement(Word(sEmpty[1]), 0, Word(sEmpty[1]), 0, Word(sElement[1]), Length(sElement));
end;

function WriteElement(cnth: ISAXContentHandler; name, content: String): Boolean;
var
  a: ISAXAttributes;
  sElement, sContent: WideString;
begin
  sElement := name;
  sContent := content;
  cnth.startElement(Word(sEmpty[1]), 0, Word(sEmpty[1]), 0, Word(sElement[1]), Length(sElement), a);
  cnth.characters(Word(sContent[1]), Length(sContent));
  cnth.endElement(Word(sEmpty[1]), 0, Word(sEmpty[1]), 0, Word(sElement[1]), Length(sElement));
end;

destructor TDemoClass.Destroy;
begin
  DemoClass.Free;
  inherited;
end;

procedure TDemoClass.Serialize(cnth: ISAXContentHandler);
var
  sElement, sContent: WideString;
begin
  StartElement(cnth, 'DemoClass');
  WriteElement(cnth, 'SomeInteger', IntToStr(SomeInteger));
  WriteElement(cnth, 'SomeString', SomeString);
  if Assigned(DemoClass) then
    DemoClass.Serialize(cnth);
  EndElement(cnth, 'DemoClass');
end;

procedure TDemoClass.Deserialize(cnth: ISAXContentHandler);
begin
  // to do
end;

procedure TDemoForm.ButtonClick(Sender: TObject);
var
  wrt: IMXWriter;
  cnth: ISAXContentHandler;
  dc: TDemoClass;
begin
  dc := TDemoClass.Create;
  dc.SomeInteger := 42;
  dc.SomeString := 'Good Omens';
  dc.DemoClass := TDemoClass.Create;
  dc.DemoClass.SomeInteger := 17;
  dc.DemoClass.SomeString := 'marabu';

  wrt := CoMXXMLWriter.Create;
  cnth := wrt as ISAXContentHandler;
  cnth.startDocument;
  dc.Serialize(cnth);
  cnth.endDocument;
  Memo.Text := VarToStr(wrt.output);
  dc.Free;
end;

initialization
  sEmpty := '';
end.

[bernhard_LA]

habe mich gegen sax entschieden, weil vermutlich nur unter Windows verfügbar.
Unter LINUX hatten wir teilweise code mit OmniXML im Einsatz, wenn ich hier auf ähnliche Probleme treffe -> ich versuche den XMLFilestream ansatz ....

[jobo]

Keine Hilfe, aber
ich habe ein Deja Vue, irgendwie gab es das Thema doch neulich schon?

Und mein blöder Einwand, der nicht hilft, aber vielleicht zu bedenken ist:
Wenn schon das Erzeugen solcher Dateien ein Problem darstellt, wie sieht es dann bei der Weiterverarbeitung aus? Mir schwebt der nächste Threadtitel vor: "Einlesen großer XML Dateien, welche Lib .."

Ich weiß, meistens gibt es Gründe, es so zu machen, wie gefordert, aber manchmal lohnt es vielleicht, einen anderen Ansatz zu erdenken oder die Wieso-Eigentlich Frage zu stellen. Natürlich auch für Leute, die das Thema später hier finden.

Und das muss nicht unbedingt ein anderes Format sein. Es reicht u.U. eine höhere Frequenz. Die kann sich aus Zeitrastern, Events, Kategorien ergeben und dann wird aus einer nächtlichen Monsteraktion etwas granulares, xyz MB statt GB. Wenn möglich (halbwegs robuste Online Verbindung) landet man z.B. bei mqtt oder sowas. Erzeugung und Weiterverarbeitung des Formats dürfte ja eh mehr oder weniger etabliert sein. Alles nur kleiner oder sehr klein portioniert. Das ergibt auch eine gleichmäßigere Systemauslastung.