himXML (gesprochen himix ML)

[himitsu]

Bis auf ein paar interne Sachen wurden vorallem ein paar neue Property eingefügt.

FindNode, FindNodes, FindNodeNF und FindNodesNF sind nun in den NodeListen zu finden, sowie als Weiterleitung im RootDokument und den Nodes.

Diese sind fast das Selbe wie die Property Node und NodeList, nur daß sie die gewünscheten Nodes nicht NUR direkt im gewählten Node/Dokument suchen, sondern auch in allen SubNodes.

Als NodeName/Pfad kann hier die selbe Syntax verwendet werden, wie bei den normalen Nodes, wodurch man z.B. auch ganze Pfade suchen kann.

XML.FindNode['MeinNode'] würde also den ersten Node mit dem Namen "MeinNode" zurückliefern, welcher irgendwo innerhalb des RootNode oder seinen SubNodes rumliegt.

Für Einzelnodes (ohne Pfadangabe) wird dieses Verhalten demnächst auch in den "normalen" Node und Node-Listen verfügbar sein ... ich glaub ich werde dieses über das Präfix @ dort integrieren.

[himitsu]

Passend zu FindNode versuch ich auch mal XPath zu implementieren,
allerdings extern über 'nen Class-Helper einzubinden.
(so gibt es dann auch 'ne Vorlage, falls jemand noch etwas Anderes nachrüsten will ... meine intere Pfade-Analyse abzukapseln und über eine Schnittstelle wieder einzubinden, so daß man direkt in die Klassen z.B. XPath einbinden könnte, hab ich doch gelassen ... das Ganze entsprechend umzubauen war mir dann doch zu aufwändig, wobei ich Einiges dann auch hätte ganz anders lösen müssen, falls das überhaupt ginge)


als Vorlage nutze ich derzeit erstmal
http://de.wikipedia.org/wiki/XPath

falls wer 'ne "nettere" Seite kennt, so melde er/sie sich bitte mal.

[himitsu]

So, hab nun genügend Infos/Links und auch die zugehörigen XPath-Specs ... ich würde mal sagen, ich überspringe die 1.0 und gehe gleich zu 2.0 .

Wer hat das eigentlich erfunden?
Der gehört geteert und gefedert!
Wenn man das nach Spec parsen will, dann muß man ja 'ne völlig massochistische Ader haben.

Will heißen, daß ich mich erstmal vorwiegend um andere Dinge kümmer und dieses nur nebenher mal versuche hinzubekommen,
womit es also noch etwas dauern kann, aber die Verschachtelungen, Befehle und sonstige Möglichkeiten sind soooooo zahlreich und etwas verwirrend ........

Dabei dachte ich, daß ich schon 'ne Grundversion fast fertig hätte, aber nachdem ich merkte, daß da doch was etwas anderes laufen kann ... nja, nun muß ich es doch irgendwie anders lösen.

[himitsu]

Wie gesagt, XPath wird noch etwas dauern, da dieses Aufgrund der Komplexität nich so einfach umzusetzen ist.

In der Zwischenzeit hab ich aber schonmal die Serialisierungen überarbeitet.
- Variant-(De)Serialisierung ist fertig
- Record-Serialisierung scheint wieder zu laufen
- Record-Deserialisierung ist grad in arbeit (muß komlett geändert werden, da sich die Serialisierung änderte)
- die Objektserialisierung kommt danach dran, hat aber schon einige Änderungen erhalten
und Aufgrund neuer Erkenntnisse wird die Deserialisierung auch bald laufen

ein Update der Dateien wird es die nächsten Tage geben (wollte nur schonmal was sagen, bevor ich's vergeß)

mein D2010 sollte auch bald ankommen und dann werd' ich mal sehn was die neue RTTI hierfür (Record-Analyse und Co.) zu bieten hat.

Record/Array-Serialisierung:

Delphi-Quellcode:

Var Test:  TSearchRec;
  XML:     TXMLFile;
  RI, RIx: TXMLSerializeRecordInfo;
  SL:      TStrings;

// einfach nur den Record mit irgendetwas befüllen
FindFirst(Application.ExeName, faAnyFile, Test);
FindClose(Test);

XML := TXMLFile.Create;
Try

  RI := TXMLSerializeRecordInfo.Create;
  Try
    RI.SaveTypeInfos := True;

    RI.Add('Time',    rtInteger);
    RI.Add('Size',    rtInt64);
    RI.Add('Attr',    rtInteger);
    RI.Add('Name',    rtString);
    RI.Add('Exclude', rtInteger);
    RI.Add('Handle',  rtLongWord);
    RIx := RI.Add('Data', rtRecord);
    RIx.Add('Attributes', rtLongWord);
    RIx.Add('Creation',   rtWord64BE);
    RIx.Add('LastAccess', rtWord64BE);
    RIx.Add('LastWrite',  rtWord64BE);
    RIx.Add('FileSize',   rtWord64LE);
    RIx.Add('Reserved0',  rtLongWord);
    RIx.Add('Reserved1',  rtLongWord);
    RIx.Add('FileName',   rtCharArray, 260);
    RIx.Add('Alternate',  rtCharArray, 14);

    // RI.Parse('I"Time" I8"Size" I"Attr" S"Name" I"Exclude" W4"Handle" R"Data" ('
    //   + 'W4"Attributes" WE"Creation" WE"LastAccess" WE"LastWrite" IX"FileSize"'
    //   + 'W4"Reserved0" W4"Reserved1" C260"FileName" C14"Alternate" )');

    // RI.Parse('I I8 I S I W4 R ( W4 WE WE WE WX W4 W4 C260 C14 )');

    // RI.Parse('ii8isiw4r(w4wewewewxw4w4c260c14)');

    XML.AddNode('TestRec').Serialize(Test, RI);
  Finally
    RI.Free;
  End;

  XML.SaveToFile('Test.xml');
Finally
  XML.Free;
End;

//type
//  TFileName = type String;
//  THandle = LongWord;
//  TWin32FindData = record
//    dwFileAttributes:   DWORD;
//    ftCreationTime:     TFileTime;
//    ftLastAccessTime:   TFileTime;
//    ftLastWriteTime:    TFileTime;
//    nFileSizeHigh:      DWORD;
//    nFileSizeLow:       DWORD;
//    dwReserved0:        DWORD;
//    dwReserved1:        DWORD;
//    cFileName:          array[0..259] of Char;
//    cAlternateFileName: array[0..13] of Char;
//  end;
//
//  TSearchRec = record
//    Time:        Integer;
//    Size:        Int64;
//    Attr:        Integer;
//    Name:        TFileName;
//    ExcludeAttr: Integer;
//    FindHandle:  THandle;
//    FindData:    TWin32FindData;
//  end;

je nach Einstellung würde z.B. eines der folgenden Ergebnisse entstehen:

XML-Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<xml>
  <TestRec>
    <Time himxml:type="LongInt">998079892</Time>
    <Size himxml:type="Int64">978432</Size>
    <Attr himxml:type="LongInt">8224</Attr>
    <Name himxml:type="WideString">Test.exe</Name>
    <Exclude himxml:type="LongInt">0</Exclude>
    <Handle himxml:type="LongWord">4294967295</Handle>
    <Data himxml:type="Record">
      <Attributes himxml:type="LongWord">8224</Attributes>
      <Creation himxml:type="Word64">129031275541718750</Creation>
      <LastAccess himxml:type="Word64">129039794795625000</LastAccess>
      <LastWrite himxml:type="Word64">129039794795625000</LastWrite>
      <FileSize himxml:type="Word64LE">978432</FileSize>
      <Reserved0 himxml:type="LongWord">0</Reserved0>
      <Reserved1 himxml:type="LongWord">0</Reserved1>
      <FileName himxml:type="WideCharArray">Test.exe</FileName>
      <Alternate himxml:type="WideCharArray"/>
    </Data>
  </TestRec>
</xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<xml>
  <TestRec>
    <Time>998079912</Time>
    <Size>978432</Size>
    <Attr>8224</Attr>
    <Name>Test.exe</Name>
    <Exclude>0</Exclude>
    <Handle>4294967295</Handle>
    <Data>
      <Attributes>8224</Attributes>
      <Creation>129031275541718750</Creation>
      <LastAccess>129039795155312500</LastAccess>
      <LastWrite>129039795155312500</LastWrite>
      <FileSize>978432</FileSize>
      <Reserved0>0</Reserved0>
      <Reserved1>0</Reserved1>
      <FileName>Test.exe</FileName>
      <Alternate/>
    </Data>
  </TestRec>
</xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<xml>
  <TestRec>
    <rec:0>998080983</rec:0>
    <rec:1>978432</rec:1>
    <rec:2>8224</rec:2>
    <rec:3>Test.exe</rec:3>
    <rec:4>0</rec:4>
    <rec:5>4294967295</rec:5>
    <rec:6>
      <rec:0>8224</rec:0>
      <rec:1>129031275541718750</rec:1>
      <rec:2>129039812850781250</rec:2>
      <rec:3>129039812850781250</rec:3>
      <rec:4>978432</rec:4>
      <rec:5>0</rec:5>
      <rec:6>0</rec:6>
      <rec:7>Test.exe</rec:7>
      <rec:8/>
    </rec:6>
  </TestRec>
</xml>

[samso]

Hallo Himitsu,
ich habe himXml (v0.983) gegen SimpleXML bzw. NativXML getestet. Ich habe viele sehr kleine XML-Dateien (1168 Dateien, UTF-8, 3kB..10kB). Bei diesem Test ist mir aufgefallen, dass sowohl SimpleXML als auch NativXML die Dateien merklich schneller parsen, als himXml. Bei SimpleXML habe ich mir mal die Mühe gemacht das Ganze nach Delphi 2009 zu portieren. SimpleXML und himXml laufen nun also beide mit Unicode-Strings. Trotzdem ist SimpleXML um Faktor 5 schneller (der Hash wird bei meiner Implementation bei jeder Datei neu aufgebaut - Bei der ursprünglich Implementation war dies nicht der Fall - macht SimpleXML aber nur 10% langsamer). Wenn ich die Units unter Delphi 2007 teste (SimpleXML dann mit Widestrings) komme ich zu ähnlichen Ergebnissen. Hast Du einen Tipp in welcher Richtung ich nach dem Performance-Fresser suchen könnte?

[himitsu]

Daß diese schneller sind, stimmt.
Ist auch in meinem Testprogramm (himXML\demos\CheckLibs.dpr) erkennbar,
allerdings solltest du mal sehn, wie diese beiden Libs seit D2009 reagieren
(da sind/waren dann erstmal Unmassen an Compilerwarungen).

Es ist schön, daß SimpleXML auf D2009 portiert hast.
Hast du dieses komplett auf Unicode umgestellt oder nur die Schnittstellen?
1. dann kommt es jetzt wohl nur noch mit Unicode-XML-Dateien klar
2. dann kommt es nur mit Ansi-XML-Dateien klar

Das normale SimpleXML kann im Unicode-Modus eigentlich nur Unicode-Dateien verarbeiten
und ansonsten nur Ansi-Dateien, wobei man da Extern für die (De)Codierung (in den AnsiStrings) sorgen muß.
Also praktisch was es ursprünglich schon unicodetauglich, aber es funktionierte nicht so richtig.

Du kannst aber gern mal die Unicode-Versionmit hochladen. Es gibt bestimmt welche, die sich darüber freuen würden.

Der Overhead bei mir kommt vorallem von der entsprechenden Dekodierung, da die Dateien auch unterschiedlich kodiert sein können, was diese Libs garnicht oder nur teilweise beachten.
Abgesehn davon laden diese die Dateien komplett in den RAM, bevor sie parsen.
himXML ließt die Dateien "nur" stückchenweise ein, welches natürlich auch noch ein bissl bremst, aber dafür Speicher spart und der Parser selber kommt auch mit größeren Dateien von mehrere Terabyte locker klar.
Versuch es also auch mal mit größeren Dateien.

Zitat:

um Faktor 5 schneller

Nja, himXML war auch schonmal etwas schneller, aber ein größerer Funktionsumfang ist da schon etwas hinderlich.
Aber im Vergleich mit MSXML sind diese Libs so oder so alle extrem flott.

Ein grundsätzliches Problem, welches es mit vielen dieser kleinen Libs gibt, daß sie seit vielen Jahren nicht mehr weiterentwickelt/gewartet werden.
So darf/muß man sich dann selber damit rumschlagen und es erstmal zum Laufen bekommen.
Ich hab jetzt schon versucht es halbwegs zukunftssicher zu gestalten.
So mußte nur ein kleiner Denkfehler (2 Codestellen) behoben werden und es lief unter D2010 und in den nächsten Delphi-Versionen rechne ich (hoffentlich) mit noch weniger Problemen.

PS: laut der NativeXML-Webseite schaft dieses ~1Mb/sec ... ich hab grad 'ne kleine 230 MB XML-Datei in etwa 25 Sekunden in mein himXML eingelesen, das macht dann 9 MB/s (mit D7 kompilert geht's noch schneller).
(gut, mein Rechner ist gut doppelt so schnell, wie deren 1.5GHz P3-Testrechner, also sagen wir mal ~2 MB/s)

[samso]

Zitat:

Hast du dieses komplett auf Unicode umgestellt oder nur die Schnittstellen?
1. dann kommt es jetzt wohl nur noch mit Unicode-XML-Dateien klar
2. dann kommt es nur mit Ansi-XML-Dateien klar

Ich habe nur die Schnittstelle umgestellt => SimpleXML kommt nur mit Ansi/UTF8-XML-Dateien klar. Da das erstmal nur eine Quick-and-Dirty-Lösung für Testzwecke ist, habe ich die Version nicht hochgeladen. Ich bin zur Zeit noch unschlüssig, ob ich die Variante weiter verfolge.
Danke erstmal für die Hinweise.

[himitsu]

Was ich witzig finde:
in D4 bis D2007 kann man SimpleXML entweder im Ansi-Modus (inklusive UTF-8, aber ohne Dekodierung) laufen lassen,
oder im Unicode-Modus ( einfach diesen Befehl aktivieren > { $DEFINE XML_WIDE_CHARS} ).
Wobei hier dann nur noch Unicode-Dateien lesbar sind und andere XML-Parser durchdrehen da dieser die Datei zwar im Unicode (UTF-16) speichert, aber standardmäßig "windows-1251" als Standardencoding im "Header" speichert.

Und seit D2009 ist SimpleXML nativ nur noch Unicode (wobei viele Stellen nicht korrekt arbeiten)
und wenn man jetzt aber zusätzlich noch { $DEFINE XML_WIDE_CHARS} aktiviert, denn arbeitet es überhaupt nicht mehr, da es das Unicode dann als Ansi ansieht und versucht es nochmals in Unicode umzuwandeln

z.B.:

Delphi-Quellcode:

{$IFDEF XML_WIDE_CHARS}
CurChar := AnsiToUnicode(FBufPtr^);
{$ELSE}
CurChar := FBufPtr^;
{$ENDIF}

FBufPtr ist schon PChar, wird als AnsiChar genommen und nochmals in WideChar umgewandlet.

also bis D2007 noch nutzbar und danach muß man ganz schön aufpassen.


PS: in den JEDIs gibt/gab (?) es auch ein "SimpleXML"
hab hier zwei "ältere" Dateien JvSimpleXml.pas (2002) JclSimpleXml.pas (01. 2009), aber da ich die JEDIs grad nicht installiert hab, kann ich nichts weiteres dazu sagen.

[samso]

Das Teil im Jedi-Projekt ist allerdings schon nicht mehr besonders "Simple", weil es diverse Jedi-Units benutzt. Daraus folgt dann, dass man im Grunde am besten das gesamte Projekt installiert. Nicht gerade das, was man sich so vorstellt, wenn man "nur mal schnell" eine kleine XML-Datei auslesen will.

[himitsu]

Dann solltest du dir nicht, KDS XML, OmniXML und Co. ansehn.
(bei mir reicht im Grunde eine Datei ... die himXMLCheck.inc könnte man weglassen und die Strings der himXML_Lang.pas integrieren)

Wobei das Simple doch wohl eigentlich mehr auf "einfache" Benutzung hinweisen soll, aber so einfach ist einiges davon nicht gerade.