himXML (gesprochen himix ML)

[himitsu]

wollt eigentlich nur mal die ersten Fortschritte eines vor kurzem längerem begonnen Projektes vorstellen

es ist "nur" eine weitere kleine XML-Klasse.

der Grund war eigentlich, daß mir andere XML-Projekte zu rießig sind
und MSMXL (TXMLDocument) nicht grad schnell.

[info]
aktuell entwickle ich unter D2009 und direkt kompatibel düfte es bis Delphi 2006 / Turbo Delphi sein

und Aufgrund einiger Anfragen versuch ich, sobald es da "gut" läuft, eine Extraversion weiter abwärtskompatibel zu machen ... mal sehn, bis wie weit runter das geht
[/info]
[add 04.01.2001] aktuell sieht es so aus, als wenn es schonmal bis zu D7 läuft [add/]

aktueller Post: http://www.delphipraxis.net/internal...116416#1116416 #193

• aktuell ab Delphi 2006 bzw. Turbo Delphi und auch für Delphi2009
  ab Windows 2000 und öfters mal in Windows 7 getestet
• zu den möglichen unterstützten Delphi-Versionen gibt es, Aufgrund häufiger Nachfragen, in Beitrag #191 eine kleine Zusammenfassung.
• Lizenzen: MPL v1.1 , GPL v3.0 oder LGPL v3.0
  es sollte also hoffentlich mit vielen anderen Lizenzen kompatibel sein
• arbeitet weitetgehend nach XML-Standard 1.0 (Fifth Edition)
  und Extensible Markup Language (XML) 1.1 (Second Edition)
• ist nicht validierend
• ein einzulesendes Dokument sollte aber möglichst "Well-Formed" (wohlgeformt) sein
• es wird nur der "Standard" unterstützt ... andere DTDs oder ähnliche Informationen werden nicht unterstützt
• also <!xyz text> wird zwar ausgelesen, aber "text" wird nicht auswertet
• <![CDATA[text]]> wird dagen natürlich behandelt
• <?xyz text ?> wird unterstützt, allerdings wird "text" geparst und in Parameter zerlegt (also wird es Probleme geben falls sich "text" mal nicht in Parameter zerlegen läßt)
  (nach XML 1.0 wird "text" eigentlich nicht zuerlegt im XML-Baum abgelegt, sondern nur XML-Prozessor-intern verarbeitet oder ignoriert)
• unterstützte Kodierungen (teilweise auch via BOM):
  UTF-7, UTF-8, UTF-16, ISO-10646-UCS-2 (littel endian), Unicode (big endian)
  ISO-8859-1 bis ISO-8859-9, ISO-2022-JP, EUC-JP, SHIFT-JIS und WINDOWS-1250 bis WINDOWS-1258
• UCS-4 (4 Byte-Unicode) wird nicht unterstützt,
  denn leider kann man immernoch nicht mit UCS4Char und UCS4String richtig arbeiten, vorallem da sie vollkommen inkompatibel zu den anderen Strings sind (bauen intern nur auf LongWord auf, statt auf einen "Char")
• im Gegensatz zu MSXML (TXMLDocument) kann die Kodierung stärker umgeschaltet werden
  (auch von ANSI/UTF-8 nach Unicode ... MSXML kann z.B. nur umschalten, wenn sich die Zeichengröße in Byte nicht ändert)
• arbeitet nur mit Klassen
  (eine Variante für sehr große Dateien und mit Interfaces aufgebaut, welche die Dateninhalte vorwiegend direkt in der Datei liest, speichert und ändert, kommt vielleicht irgendwann mal)
• eine Thread-Absicherung wurde letztendlich doch nicht direkt integriert,
  aber die CriticalSection wurde dringelassen und kann direkt verwendet werden:
  
  Delphi-Quellcode:

  XML._Lock;
  Try
    ... mach was mit dem XML ...
  Finally
    XML._Unlock;
  End;

• es muß nur jeweils eine Datei eingebunden werden
  himXML, himXMLi, himXML_UseDLL oder himXML_UseDLLi,
  jenachdem mit welcher Schnittstelle man arbeitet
  > wichtige Typen und Konstanten werden in den Dateien weitergeleitet, falls sie nicht in der entsprechenden Unit definiert sind
• ein kleiner Benchmark ist aber schon lauffähig:
  
  Delphi-Quellcode:

  // inklusive Zeitmessung siehe FormCreate
  
  XML := TXMLDocument.Create(Self);
  XML.Active     := True;
  XML.Version    := '1.0';
  XML.StandAlone := 'yes';
  XML.Encoding   := 'UTF-8';
  XML.Options    := [doNodeAutoIndent];
  XML.AddChild('xml');
  For i := 0 to 100000 do XML.DocumentElement.AddChild('Node' + IntToStr(i));
  XML.SaveToFile('test2.xml');
  XML.Free;
  
  // versus
  
  XML := TXMLFile.Create(nil);
  For i := 0 to 100000 do XML.RootNode.Nodes.Add('Node' + IntToStr(i));
  XML.SaveToFile('test.xml');
  XML.Free;

  Delphi-Quellcode:

  //10.000 Nodes (ergibt ca. eine 150 KB-Datei)
  
  TXMLDocument = fill:6749  save:99
  TXMLFile     = fill:  10  save: 7
  
  // 100.000 Nodes (ergibt ca. eine 1,5 MB-Datei)
  
  TXMLDocument = fill:708145  save:348  load:331
  TXMLFile     = fill:   189  save:150  load:319

  Zeiten in Millisekunden
  
  weitere Tests und Vergleiche (auch mit anderen Libs), siehe demos\CheckLibs.dpr
  wer keine Lust hat, vorallem wegen MSXML 'ne halbe Stunde ein Programm laufen zu lassen ... auf den nächsten Seiten befinden sich sporatisch die Testergebnisse verteilt
• "wichtige" Grundfunktionen von .RootNode wurden direkt in die Basisklasse (TXMLFile) umgelegt, sowie von .Nodes in dessen Mutterklasse (TXMLNode)
  
  .Node (.Nodes.Node[], .RootNode.Nodes.Node[] bzw .Nodes[], .RootNode.Nodes[]), .NodeNF (.Nodes.NodeNF bzw. .RootNode.Nodes.NodeNF), .NodeList (.Nodes.NodeList bzw. .RootNode.Nodes.NodeList), .NodeListNF (.Nodes.NodeListNF bzw. .RootNode.Nodes.NodeListNF) und AddNode (.Nodes.Add bzw. .RootNode.Nodes.Add)
  (in Groß siehe Beitrag #65)
• Pfadangaben sind möglich
  in Kurz also XML['node1\node2'] statt XML.RootNode.Nodes['node1'].Nodes['node2']
  ebenso können Parameter und Indizes im Nodepfad angegeben werden (siehe Hilfesektion in himXMLi.pas)
• es kann direkt eine Inline-Verschlüsselung genutzt werden
  einfach für den gewünschten Knoden zusweisen und alles via .Text und .Text_S wird automatisch beim Zuweisen/Auslesen ver-/entschlüsselt
  
  Delphi-Quellcode:

  Node.Crypted := '*';         // Standardverschlüsselung nutzen (erstes in der Liste)
  Node.Crypted := 'RC4';       // RC4 verwenden
  Node.Text := X;              // zuweisen und automatisch verschlüsseln
  X := Node.Text;              // automatisch entschlüsseln und auslesen
  If Node.Crypted <> '' Then   // nur prüfen ob es verschlüsselt ist
  If Node.Crypted = 'RC4' Then // prüfen ob es RC4 verschlüsselt ist
  
  XML.CryptData['RC4'] := S; // anderen Key für RC4 festlegen

  da die Verschlüsselungsroutine Zugriff auf die Node-Attribute hat, könnte man auch eine eigene Verschlüsselung zuweisen, welche z.B. über ein weiteres Attribut jeden Node mit einem eigenem Key verschlüsselt.
  
  Delphi-Quellcode:

  XML.Cryptors       // listet alle registrierten Verschlüsselungen auf
  XML.SetCryptor     // setzt/lösche eine Verschlüsselung
  XML.CryptProc      // siehe SetCryptor
  XML.CryptData      // siehe SetCryptor
  XML.CryptAttrName  // der Name des Attributes, welcher die aktive Verschlüsselung enthält

• • himXML.pas
    - die ganzen Klassen
  • himXMLi.pas
    - die zugehörigen Interfaces (sie spiegeln auch die Funktionalität der Klassen wieder .. nur da halt über TXML... statt IXML...)
    - und enthält auch eine "kleine" Hilfe-Sektion
  • himXML_Tools.pas
    - kleine Zusatzmodule:
    TSimpleAssocVariantArray - sehr einfaches String-assoziatives Array of Variant
    TXMLSerializeRecord_Creator - erzeugt eine Record-Definition für .Serialize/.DeSerialize von Records
    TXMLIniFile - verwendet eine XML-Datei wie eine INI und läßt sich auch wie IniFiles.TIniFile nutzen
    TXMLRegistry - das Gleiche, nur halt mit Registry.TRegistry
    TXMLDatabase - noch unfertig, soll aber irgendwann mal eine XML-Datei wie eine kleine SQL-DB nutzbar machen
  • demos\CheckLibs.dpr
    - einige Tests/Benchmarks zum Projekt und anderen XML-Libs
  • demos\CheckLib_UseDLL.dpr und demos\CheckLib_UseDLLi.dpr
    - das Gleiche, nur über ein externes himXML via DLLs (siehe weiter unten)
  • demos\Demo_Serialize.dpr
    - zeigt einiges zu den (De)Serialisierungsfunktionsn
  • demos\Demo_Tree.dpr
    - 'ne kleine Demo, wo eine XML-Datei in eine TreeView geladen und angezeigt wird
  • demos\SAXParser.dpr
    - hier wird eine kleine XML-Testdatei sequentiel geladen
  • DLLs\himXML_UseDLL.pas und DLLs\himXML_UseDLLi.pas
    - dieses sind die Schnittstellen-Units für die DLLs
    einmal als Objekte und das Andere (mit dem i) als Interfaces
    bei der Objektversion sind die Exceptions noch nicht umgeleitet, also möglichst welche vermeiden
    in der Interfaceversion funktioniert das Freigeben nochn nicht
  • DLLs\himXML_DLL.dpr und DLLs\himXML_DLLi.dpr
    - die zugehörigen DLLs
  • other\*
    - einige andere XML-Libs (verwendet in demos\CheckLibs* )
  • test files\*
    - einige "XML"-Dateien zum Testen

ansonsten bin ich für Tipps und Vorschläge dankbar

[add 13.03.2009]
ach ja falls der Name jemandem nich gefällt ... Beschwerden bitte an Matze richten

[add]
im Beitrag #193 wird etwas über die im Download mit enthalenen anderen XML-Libs geschrieben.


[add]
Achtung, beim Forenupgrad der DP sind die Dateikommentare verschwunden und die Dateinamen sind unglücklich importiert wurden.

himxml_246.7z = v0.9 21.05.2009
himxml_164.7z = v0.99d 12.01.2010
other.7z = 30.12.2010 (only the "other" directory)

[himitsu]

@Muetze1: mal sehn wie ich das dann umsetze.

jetzt hab ich erstmal die Variants soweit fertigbekommen

Floats werd ich noch selber umwandeln müssen ... Delphi lokalisiert ja leider das Komma, wie ich grade mitbekommen hab (blöd bei Weitergabe der XML-Datei)

die Exceptionen hab ich nun fast alle mal ordentlich umgesetzt

und wie man am Beispielcode sieht, hab ich den Index ( Node['name[i]'] ) schon drin

dieses ...

Delphi-Quellcode:

Type TMyProc = Procedure(X: Integer) of Object;

Type TForm1 = Class(TForm)
    Label1: TLabel;
    Memo1: TMemo;
    Procedure FormCreate(Sender: TObject);
  Private
  Public
    _xyz: TMyProc;
    _abc: TXMLNodeTypes;
    _va:  Variant;
  Published
    Procedure MyProc(x: Integer);
    Property xyz: TMyProc read _xyz write _xyz Stored True;
    Property abc: TXMLNodeTypes read _abc write _abc Stored True Default [xtElement];
    Property va: Variant read _va write _va;
  End;

Var XML: TXMLFile;
  Node:  TXMLNode;
  z:     Array of Array of Array of Single;

XML := TXMLFile.Create;
Try
  Node := XML.RootNode.AddNode('node1');
  Node.Attributes['attr1'] := '123';
  Node.Attributes['attr2'] := '456';
  Node.AddNode('node1_2');
  Node := Node.AddNode('node1_3');
  Node.AddNode('node1_3_1');
  Node := XML.RootNode.AddNode('node2');
  Node := Node.AddNode('node2_1');
  Node.Attributes['attr3'] := 'abc';

  XML.Options := XML.Options + [xoNodeAutoCreate];
  XML.RootNode.AddNode('.\node1\..\node2\path\node3');
  XML.RootNode.AddNode('.\node1\..\node2\path>test=x\node4');
  XML.RootNode.AddNode('.\node1\..\node2\path\node5');
  XML.RootNode.AddNode('.\node1\..\node2\path>test=x\node6');

  Form1.abc := [xtElement];
  Form1.xyz := Form1.MyProc;
  SetLength(z, 2);
  SetLength(z[0], 3);
  SetLength(z[1], 3);
  SetLength(z[0, 0], 2);
  SetLength(z[0, 1], 2);
  SetLength(z[0, 2], 2);
  SetLength(z[1, 0], 2);
  SetLength(z[1, 1], 2);
  SetLength(z[1, 2], 2);
  z[0, 0, 0] := 000;
  z[0, 0, 1] := 001;
  z[0, 1, 0] := 010;
  z[0, 1, 1] := 011.110;
  z[0, 2, 0] := 020;
  z[0, 2, 1] := 021;
  z[1, 0, 0] := 100;
  z[1, 0, 1] := 101;
  z[1, 1, 0] := 110;
  z[1, 1, 1] := 111;
  z[1, 2, 0] := 120;
  z[1, 2, 1] := 121.121;
  Form1.va := z;
  Node := XML.RootNode.AddNode('object');
  Node.Serialize(Form1, [], SerializeProc);

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

... erstellt jetzt jenes

XML-Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<xml>
  <node1 attr1="123" attr2="456">
    <node1_2 />
    <node1_3>
      <node1_3_1 />
    </node1_3>
  </node1>
  <node2>
    <node2_1 attr3="abc" />
    <path>
      <node3 />
      <node5 />
    </path>
    <path test="x">
      <node4 />
      <node6 />
    </path>
  </node2>
  <object>
    <Tag>0</Tag>
    <AlignWithMargins>False</AlignWithMargins>
    <Left>132</Left>
    <Top>144</Top>
    <Cursor>0</Cursor>
    <HelpType>htContext</HelpType>
    <HelpContext>0</HelpContext>
    <Margins ClassType="TMargins">
      <Left>3</Left>
      <Top>3</Top>
      <Right>3</Right>
      <Bottom>3</Bottom>
    </Margins>
    <ParentCustomHint>True</ParentCustomHint>
    <HorzScrollBar ClassType="TControlScrollBar">
      <ButtonSize>0</ButtonSize>
      <Color>clBtnHighlight</Color>
      <Increment>8</Increment>
      <Margin>0</Margin>
      <ParentColor>True</ParentColor>
      <Position>0</Position>
      <Range>0</Range>
      <Smooth>False</Smooth>
      <Size>0</Size>
      <Style>ssRegular</Style>
      <ThumbSize>0</ThumbSize>
      <Tracking>False</Tracking>
      <Visible>True</Visible>
    </HorzScrollBar>
    <VertScrollBar ClassType="TControlScrollBar">
      <ButtonSize>0</ButtonSize>
      <Color>clBtnHighlight</Color>
      <Increment>8</Increment>
      <Margin>0</Margin>
      <ParentColor>True</ParentColor>
      <Position>0</Position>
      <Range>0</Range>
      <Smooth>False</Smooth>
      <Size>0</Size>
      <Style>ssRegular</Style>
      <ThumbSize>0</ThumbSize>
      <Tracking>False</Tracking>
      <Visible>True</Visible>
    </VertScrollBar>
    <Align>alNone</Align>
    <AlphaBlend>False</AlphaBlend>
    <AlphaBlendValue>255</AlphaBlendValue>
    <AutoSize>False</AutoSize>
    <BorderIcons>[biSystemMenu,biMinimize,biMaximize]</BorderIcons>
    <BorderStyle>bsSizeable</BorderStyle>
    <BorderWidth>0</BorderWidth>
    <Caption>Form1</Caption>
    <ClientHeight>201</ClientHeight>
    <ClientWidth>329</ClientWidth>
    <Color>clBtnFace</Color>
    <TransparentColor>False</TransparentColor>
    <TransparentColorValue>clBlack</TransparentColorValue>
    <Constraints ClassType="TSizeConstraints">
      <MaxHeight>0</MaxHeight>
      <MaxWidth>0</MaxWidth>
      <MinHeight>0</MinHeight>
      <MinWidth>0</MinWidth>
    </Constraints>
    <Ctl3D>True</Ctl3D>
    <UseDockManager>False</UseDockManager>
    <DefaultMonitor>dmActiveForm</DefaultMonitor>
    <DockSite>False</DockSite>
    <DoubleBuffered>False</DoubleBuffered>
    <DragKind>dkDrag</DragKind>
    <DragMode>dmManual</DragMode>
    <Enabled>True</Enabled>
    <ParentFont>False</ParentFont>
    <Font ClassType="TFont">
      <Charset>1</Charset>
      <Color>clWindowText</Color>
      <Height>-11</Height>
      <Name>Tahoma</Name>
      <Orientation>0</Orientation>
      <Pitch>fpDefault</Pitch>
      <Style>[]</Style>
    </Font>
    <FormStyle>fsNormal</FormStyle>
    <GlassFrame ClassType="TGlassFrame">
      <Enabled>False</Enabled>
      <Left>0</Left>
      <Top>0</Top>
      <Right>0</Right>
      <Bottom>0</Bottom>
      <SheetOfGlass>False</SheetOfGlass>
    </GlassFrame>
    <KeyPreview>False</KeyPreview>
    <Padding ClassType="TPadding">
      <Left>0</Left>
      <Top>0</Top>
      <Right>0</Right>
      <Bottom>0</Bottom>
    </Padding>[list=1]False</OldCreateOrder>
    <ParentBiDiMode>True</ParentBiDiMode>
    <PopupMode>pmNone</PopupMode>
    <Position>poDefaultPosOnly</Position>
    <PrintScale>poProportional</PrintScale>
    <Scaled>True</Scaled>
    <ScreenSnap>False</ScreenSnap>
    <SnapBuffer>10</SnapBuffer>
    <Visible>False</Visible>
    <WindowState>wsNormal</WindowState>
    <OnCreate>TForm1:Form1:FormCreate</OnCreate>
    <xyz>TForm1:Form1:MyProc</xyz>
    <abc>[xtElement]</abc>
    <va variant="Single-Array" dimensions="3">
      <dimDef0 count="2" low="0" />
      <dimDef1 count="3" low="0" />
      <dimDef2 count="2" low="0" />
      <dim0>
        <dim0>
          <dim0>0</dim0>
          <dim1>1</dim1>
        </dim0>
        <dim1>
          <dim0>10</dim0>
          <dim1>11,1099996566772</dim1>
        </dim1>
        <dim2>
          <dim0>20</dim0>
          <dim1>21</dim1>
        </dim2>
      </dim0>
      <dim1>
        <dim0>
          <dim0>100</dim0>
          <dim1>101</dim1>
        </dim0>
        <dim1>
          <dim0>110</dim0>
          <dim1>111</dim1>
        </dim1>
        <dim2>
          <dim0>120</dim0>
          <dim1>121,121002197266</dim1>
        </dim2>
      </dim1>
    </va>
    <Components>
      <Component ClassType="TLabel">
        <Tag>0</Tag>
        <AlignWithMargins>False</AlignWithMargins>
        <Left>32</Left>
        <Top>37</Top>
        <Width>31</Width>
        <Height>13</Height>
        <Cursor>0</Cursor>
        <HelpType>htContext</HelpType>
        <HelpContext>0</HelpContext>
        <Margins ClassType="TMargins">
          <Left>3</Left>
          <Top>3</Top>
          <Right>3</Right>
          <Bottom>3</Bottom>
        </Margins>
        <ParentCustomHint>True</ParentCustomHint>
        <Align>alNone</Align>
        <Alignment>taLeftJustify</Alignment>
        <AutoSize>True</AutoSize>
        <Caption>Label1</Caption>
        <Constraints ClassType="TSizeConstraints">
          <MaxHeight>0</MaxHeight>
          <MaxWidth>0</MaxWidth>
          <MinHeight>0</MinHeight>
          <MinWidth>0</MinWidth>
        </Constraints>
        <DragCursor>-12</DragCursor>
        <DragKind>dkDrag</DragKind>
        <DragMode>dmManual</DragMode>
        <EllipsisPosition>epNone</EllipsisPosition>
        <Enabled>True</Enabled>
        <GlowSize>0</GlowSize>
        <ParentBiDiMode>True</ParentBiDiMode>
        <ParentColor>True</ParentColor>
        <ParentFont>True</ParentFont>
        <ParentShowHint>True</ParentShowHint>
        <ShowAccelChar>True</ShowAccelChar>
        <Layout>tlTop</Layout>
        <Visible>True</Visible>
        <WordWrap>False</WordWrap>
      </Component>
      <Component ClassType="TMemo">
        <Tag>0</Tag>
        <AlignWithMargins>False</AlignWithMargins>
        <Left>32</Left>
        <Top>56</Top>
        <Width>257</Width>
        <Height>89</Height>
        <Cursor>0</Cursor>
        <HelpType>htContext</HelpType>
        <HelpContext>0</HelpContext>
        <Margins ClassType="TMargins">
          <Left>3</Left>
          <Top>3</Top>
          <Right>3</Right>
          <Bottom>3</Bottom>
        </Margins>
        <ParentCustomHint>True</ParentCustomHint>
        <TabStop>True</TabStop>
        <Align>alNone</Align>
        <Alignment>taLeftJustify</Alignment>
        <BevelEdges>[beLeft,beTop,beRight,beBottom]</BevelEdges>
        <BevelInner>bvRaised</BevelInner>
        <BevelKind>bkNone</BevelKind>
        <BevelOuter>bvLowered</BevelOuter>
        <BorderStyle>bsSingle</BorderStyle>
        <CharCase>ecNormal</CharCase>
        <Color>clWindow</Color>
        <Constraints ClassType="TSizeConstraints">
          <MaxHeight>0</MaxHeight>
          <MaxWidth>0</MaxWidth>
          <MinHeight>0</MinHeight>
          <MinWidth>0</MinWidth>
        </Constraints>
        <DragCursor>-12</DragCursor>
        <DragKind>dkDrag</DragKind>
        <DragMode>dmManual</DragMode>
        <Enabled>True</Enabled>
        <HideSelection>True</HideSelection>
        <ImeMode>imDontCare</ImeMode>
        <Lines ClassType="TMemoStrings">
          <Strings>
            <String>Memo1</String>
            <String />
            <String>abc</String>
          </Strings>
        </Lines>
        <MaxLength>0</MaxLength>
        <OEMConvert>False</OEMConvert>
        <ParentBiDiMode>True</ParentBiDiMode>
        <ParentColor>False</ParentColor>
        <ParentCtl3D>True</ParentCtl3D>
        <ParentDoubleBuffered>True</ParentDoubleBuffered>
        <ParentFont>True</ParentFont>
        <ParentShowHint>True</ParentShowHint>
        <ReadOnly>False</ReadOnly>
        <ScrollBars>ssNone</ScrollBars>
        <TabOrder>0</TabOrder>
        <Visible>True</Visible>
        <WantReturns>True</WantReturns>
        <WantTabs>False</WantTabs>
        <WordWrap>True</WordWrap>
      </Component>
    </Components>
  </object>
</xml>

[himitsu]

• @Muetze1: hab's doch erstmal als Array fertiggestellt (war einfacher so )
• dann hab ich die Excetpions fertig umgestellt .. müssen eventuell nur irgendwann mal die Texte verbessert werden.
• Node-Data und Attribut-Data wurde auf Variant umgestellt,
  wobei DateTime und Boolean nicht von vom Variant übersetzt werden, sondern laufen über ein eigenes Format
• die Serialisierung von Variants wurde von der Objekt-Serialisierung abgekapselt
  und die Deserialisierung dafür hab ich auch grad fertiggestellt
• einige interne Verwaltungsdinge wurden überarbeitet und aufgeräumt
• jetzt komt erstmal die Objekt-Deserialisierung dran,
  dann entweder endlich Mal das Parsen und die Konvertierung/Prüfung der Node-Daten.
• ...
• ja und im ersten Post gibt's diesmal auch endlich wieder ein Updade mit dem aktuellen Stand

[himitsu]

so, nun ist auch das En-/Decoding nehezu komplett überarbeitet worden
(unvollständige MultiByte-Zeichen erkennen)
und auch die Speicherprozedur würde etwas gendärt ... nur blöd, daß die Dekodierung garnicht sooooo langsam war ... aktuell nur etwa 60-70 ms für's Dekodieren und Speichern ... das Meißte an Plus wurde durch 'ne winzig kleine Änderung rausgeholt .... ich hatte ausversehn nach jedem Node ein Flush (Schreibpuffer leeren) drin ... also so etwa 35 Dekodier-/Speicheroperationen wurde dieses über 100.000 Mal in sehr kleinen Stücken gemacht
ja und Node.Next war sehr disoptimal (2-3 Sekunden für .Next und nochmal knapp 7-8 für's Flush)

hier nochmal die Testergebnisse für 100.000 Nodes (ergibt ca. eine 1,5 MB-Datei)

Code:

[b]alt[/b]
TXMLDocument = fill:672687  save:  391  free: 140
TXMLFile     = fill:   125  save:10922  free:3110


[b]TXMLDocument/IXMLDocument[/b]
Taskmanager:  11,5 Minuten mit bis zu 138 MB Speicherverbrauch
fill:692875  save:360  free:125

[b]himXML[/b]
Taskmanager:  3 Sekunden mir nur 22 MB
fill:110  save:125  free:2812

(Zeiten in Millisekunden)

aktueller Code kommt mit dem nächten Update und eventuell schon zusammen mit der Leseroutine (LoadFromFile und Co.)

[add]
so, noch 'ne kleine Änderung in NodeList.Clear
(einfach alles löschen und zusammen entfernen, statt einzeln entfernen und löschen)

Delphi-Quellcode:

// alt
Procedure TXMLNodeList.Clear;
  Begin
    While _Nodes <> nil do DeleteNF(_Nodes[0]);
  End;

// neu
Procedure TXMLNodeList.Clear;
  Var i: Integer;

  Begin
    If _Nodes <> nil Then
      Try
        For i := High(_Nodes) downto 0 do FreeAndNil(_Nodes[i]);
        _Nodes := nil;
      Except
        i := Length(_Nodes);
        While (i > 0) and (_Nodes[i - 1] = nil) do Dec(i);
        SetLength(_Nodes, i);
        Raise;
      End;
  End;

Ergebnis:

Code:

create:0  fill:109  save:125  free:31

also 0,26 Sekunden, statt über 11 Minuten bei MSXML (TXMLDocument), um 100.000 Nodes einzufügen und diese 1,5 MB-Datei zu speichern

[himitsu]

* einige Speicherroutinen überarbeitet (vorallem die Stringverarbeitung)
* es wurden endlich mal alle Datentests und -konverter fertiggestllt,
also die Prüfung auf gültige Daten, welche man an Nodes und Attributes übergibt
* die Variants sind auch wieder drin (waren mal kurz weg, da sich 'nen altes Backup einschlich )
* Code etwas aufgeräumt
* und ich scheine auch endlich mal "alle" fehlenden/leeren Prozeduren gefüllt zu haben
* aktueller Stand siehe Post #1

fehlt NUR noch:
* Deserialasierung für Objekte
* die Parserfunktion für LoadFromFile und Co.

und sonst scheint alles fertig zusein, falls sich keine Fehler eingeschlichen haben
(werd' aber die nächsten Tage alles nochmal ansehn und etwas testen)

[himitsu]

beim Aufräumen hab ich jetzt mal den SpeedTest ausgelagert
(er wird später noch durch 'nen Ladevergleich erweitert)

Code:

SetProcessAffinityMask: OK


fill TXMLFile with 10.000 nodes and save this into a file
QPC > create:0  fill:9  save:15  free:3

fill TXMLDocument with 10.000 nodes and save this into a file
QPC > create:13  fill:6805  save:92  free:0


fill TXMLFile with 10.000 nodes, delete 8.000 nodes and save this into a file
QPC > create:0  fill:10  delete:1545  save:5  free:0

fill TXMLDocument with 10.000 nodes, delete 8.000 nodes and save this into a file
QPC > create:0  fill:6799  delete:103127  save:46  free:0


fill TXMLFile with 10.000 nodes with attributes and save this into a file
QPC > create:0  fill:683  save:22  free:4

fill TXMLDocument with 10.000 nodes with attributes and save this into a file
QPC > create:0  fill:6536  save:126  free:0


fill TXMLFile with 100.000 nodes and save this into a file
QPC > create:0  fill:104  save:128  free:31

fill TXMLDocument with 100.000 nodes and save this into a file
QPC > create:0  fill:743807  save:194  free:0

press [enter]

Zeiten in Millisekunden

er läuft jetzt als Konsolenanwendung und die Ausführung läßt sich somit jederzeit beenden, ohne 'ne werteverfälschende Prüfung in den Schleifen.
(z.B. hab ich mitbekommen, daß ein Aufruf von ~200.000 mal QueryPerformenceCounter + Int64-Addition/-Subtraktion auch gut mal 'ne Sekunde fressen kann)


[add]
falls zufällig wer Wrapper für TIniFile bzw. TRegistry nach XML braucht ... siehe Anhang
(damit könnte man alte Anwendungen recht schnell auf XML umstellen oder mit der "bekannten" Benutzung dieser Komponenten dennoch eine XML-Datei verwenden)


[edit 21.05.]
Anhänge entfernt ... sind im Anhang des Post #1 inzwischen enthalten
- himXML_Tools.pas - Wrapper für TIniFile und TRegistry
- SpeedTest.dpr

[himitsu]

Schon schlimm, eigentlich wollte ich mein MatchText nur etwas hierfür anpassen und nun artet auch noch das mehr aus, als gedacht


Eigentlich wollt ich nur, vorallem wegen der Namespaces eine/zwei neue und auch andersweitig verwendbare Syntax zur Namensdefinition von Nodes einbinden, also "*:node" und "namespace:*" um den Namespace zu ignorieren, bzw. um alles nur von einem NameSpace aufzulisten,
wobei "*" und "?" denmächts auch für alle möglichen Maskendefinitionen zur Verfügung stehen.
(hierfür wurde gestern auch noch die Möglichkeit eingebaut, nun auch bei den Attributen eine Auswahlliste über solche "Masken" zu bekommen und nicht immer nur "einzelne" Attribute)

Und wollte (schonwieder dieses Wort ) damit gleich noch ein anderes Problem beseitigen:
Aktuell arbeitet meine Lib caseinsensitiv (damit es gewisse Probleme nicht gibt).

Wenn ich es dann abgeändert hab, wird die Lib per Standard zwar immernoch caseinsensitiv sein...
kann aber umgestellt werden, damit sie auch dort dann nach der XML-Spezifikation arbeitet.

[himitsu]

Also, das mit'm Einlesen geht langsam vorran (war in letzter Zeit vorwiegend damit beschäftigt alle Lese-/Schreibgrundroutinen diesbezüglich umzustellen )

Ansonsten hab ich mal was getestet, welches die ganze Zeit vernachlässigt wurde ...
und zwar das Suchen von Nodes.

z.B. alle 10.000 Nodes in zufälliger Reinfolge aus einer Reihe von 10.000 Subnodes rauszusuchen und das ersten und einzige Attribut auszulesen dauerte ~6,7 Sekunden (bei mir)

War mir etwas viel, drum hab ich da heut noch Einiges geändert
und einen Hashvergleich vor gewisse Stringvergleiche vorgeschaltet.

OK, so sehr viel Zeit konnte ich damit dann doch nicht rausholen, wie zuerst erhoft (mal sehn wo es noch hängt), aber fast doppelt so schnell ist auch schön

Dieses meinte dann das Testprogramm (siehe SpeedTest.dpr Post #1) dazu:

Code:

SetProcessAffinityMask: OK

use QueryPerformanceCounter

precreating used strings - do not create and convert this within the measuring
create:72


fill TXMLFile with 10.000 nodes with attributes and search nodes
create:0  fill:602  search:3268  free:8

fill TXMLDocument with 10.000 nodes with attributes and search nodes
create:3  fill:6394  search:146699  free:0

press [enter]

Obwohl, wenn ich mir das jetzt so betrachte ... gegenüber dem MS-XMLDOM ist/war es ja doch noch recht flott unterwegs.

Sind durchschnittlich 0,33 Millisekunden zum raussuchen eines Knotens aus 10.000 eigentlich schnell/langsam?
(hab jetzt noch keine Vergleichsmessungen an anderen Listen vorgenommen oder solche Zeiten irgendwo gelesen)

Und ich geb's zu ... zu dieser Optimierung hatten mich alzaimar's Hash-Tabellen verleitet, welche ich noch etwas im Kopf rumschwirren hatte.

Zitat von alzaimar:

Die CRC32-Hashfunktion wurde durch die wesentlich schnellere ELF-Hash Funktion ersetzt.

hab mich zwar nun auch für 'nen ELF-Hash entschieden, obwohl der in meinen Tests fast genausoschnell wie ein CRC32 war
(durchschnittlich bei über 20 Byte war CRC32 ein bissl flotter und darunter ELF)
nja, so brauchte ich zumindestens nicht noch 'ne Hashtabelle mit unterbringen
und der ELF ließ sich durch kleine Umbauten (incl. ein/zwei Extras für meine Bedürfnisse) direkt auf's Unicode (2 Byte pro Durchgang der Berechnungsschleife) loslassen und das fast nochmal doppelt so schnell (in diesem Sinne war es dann doch wesentlich schneller )


Angang siehe Post #1

[edit] Anhang (Post #1) durch 'ne Ansi-Version ersetzt ... wo kam denn das UTF8 schonwieder her?

[himitsu]

Hab jetzt noch eine Serialisierung von Records und (dyn.) Arrays implementiert
(aktuell noch nur die Serialisierung ... die Deserialisierung kommt, sobald ich diesen Code halbwegs getestet und "ganz" fertig hab).
Allerdings nicht via RTTI, sondern man muß selber den Aufbau der Daten deklarieren,
aber in der RTTI stehn eh nur die Gesamtgröße des Records und die initialisierbaren Typen.
Der Record wird dann praktisch Feld für Feld in einzelnen Nodes abgespeichert.

Delphi-Quellcode:

TXMLSerializeRDataType  = (rtByte, rtWord, rtLongWord, rtWord64, rtShortInt, rtSmallInt, rtLongInt, rtInt64,
    rtSingle, rtDouble, rtExtended, rtCurrency, rtDateTime, rtBoolean, rtBOOL,
    rtAnsiCharArray, rtWideCharArray, rtShortString, rtAnsiString, rtWideString, rtUnicodeString,
    rtBinar, rtVariant, rtObject, rt_Record, rt_Array, rt_DynArray);
  PXMLSerializeRecordInfo = ^TXMLSerializeRecordInfo;
  TXMLSerializeRecordInfo = Array of Record
    DType:    TXMLSerializeRDataType;
    Elements: Integer;  // for rtAnsiCharArray, rtWideCharArray, rtShortString, rtArrayOfByte and rt_Array
    SubInfo:  PXMLSerializeRecordInfo; // for rt_Record, rtArray and rtDynArray
  End;

TXMLNode = Class
  ...
  Procedure Serialize     (Const V: Variant); Overload;
  Procedure DeSerialize   (Var   V: Variant); Overload;
  Procedure Serialize     (C: TObject; SOptions: TXMLSerializeOptions = []; Proc: TXMLSerializeProc   = nil);
  Procedure DeSerialize   (C: TObject; SOptions: TXMLSerializeOptions = []; Proc: TXMLDeserializeProc = nil; CreateProc: TXMLClassCreateProc = nil);
  Function  Serialize     (Const Rec; Const RecInfo: TXMLSerializeRecordInfo; Align: Integer = 1 {packed <= 1}): Integer;
  Function  DeSerialize   (Var   Rec; Const RecInfo: TXMLSerializeRecordInfo; Align: Integer = 1 {packed <= 1}): Integer;
End;

Dann wurden für die Übersichtlichkeit der Units einige {$REGION}'s eingefügt

und die Tools-Unit überarbeitet.
Dort sind jetzt auch mal die Grundzüge einer DB-Schnittstelle drinnen (aber deren Fertigstellung wird noch dauern, auch wenn das auslesen des Results schon soweit fertig ist ... nur kann man die "DB" noch nicht verwalten und Anfragen senden ... es ist soweit im Stil von mySQL aus PHP gehalten ...

Delphi-Quellcode:

TXMLDatabase = Class
  Constructor Create          (Const FileName: TWideString = '');
  Destructor  Destroy;        Override;

  Property  CaseSensitive:    Boolean Read GetCaseSensitive Write SetCaseSensitive;

  Function  Connect           (Const FileName:  TWideString): Boolean;                                        // mysql_connect
  Function  ListTables:                                      TWideStringArray;                                // mysql_list_tables
  Function  ListFields        (Const TableName: TWideString): TWideStringArray;                               // mysql_list_fields
  Procedure Flush;                                                                                            // -
  Procedure Close             (Save: Boolean = True);                                                         // mysql_close

  Function  AffectedRows:     Integer;                                                                        // mysql_affected_rows
  Function  Stat:             TSimpleAssocVariantArray;                                                       // mysql_stat
  Function  Error:            TWideString;                                                                    // mysql_error

  Function  Query             (Const Query: TWideString): TXMLDBResult;                                       // mysql_query
  Function  NumFields         (Const DBResult: TXMLDBResult): Integer;                                        // mysql_num_fields
  Function  NumRows           (Const DBResult: TXMLDBResult): Integer;                                        // mysql_num_rows
  Procedure FreeResult        (Var   DBResult: TXMLDBResult);                                                 // mysql_free_result

  Function  DataSeek          (Var   DBResult: TXMLDBResult; Offset: Integer): Boolean;                       // mysql_data_seek
  Function  FetchRow          (Var   DBResult: TXMLDBResult; Var A: TSimpleAssocVariantArray): Boolean;       // mysql_fetch_row

  Function  FetchField        (Var   DBResult: TXMLDBResult; Offset: Integer = -1): TSimpleAssocVariantArray; // mysql_fetch_field
  Function  FieldTable        (Var   DBResult: TXMLDBResult; Offset: Integer = -1): TWideString;              // mysql_field_table
  Function  FieldName         (Var   DBResult: TXMLDBResult; Offset: Integer = -1): TWideString;              // mysql_field_name
  Function  FieldType         (Var   DBResult: TXMLDBResult; Offset: Integer = -1): TWideString;              // mysql_field_type
  Function  FieldLen          (Var   DBResult: TXMLDBResult; Offset: Integer = -1): Integer;                  // mysql_field_len
  Function  FieldSeek         (Var   DBResult: TXMLDBResult; Offset: Integer):      Integer;                  // mysql_field_seek

  Function  EscapeString      (Const UnescapedString: TWideString): TWideString;                              // mysql_real_escape_string
End;

... und ich versuch grad noch ein paar Grundfunktion in 'ner Art API-Funktionen da reinzubekommen)

Delphi-Quellcode:

TXMLDatabase = Class
  ...
  Function  CreateTable       (Const TableName: TWideString; Const Fields {[FieldName, Datatype], ...}:                            Array of TWideString): Boolean; Overload;
  Function  CreateTable       (Const TableName: TWideString; Const Fields {[FieldName, Datatype], ...}, PrimaryKey{FildName, ...}: Array of TWideString): Boolean; Overload;
  Function  AddField          (Const TableName, FildName, Datatype: TWideString; AtFirst: Boolean = False; Const AfterField: TWideString = ''): Boolean;
  Function  ChangeField       (Const TableName, OldFildName, NewFildName: TWideString; Const NewDatatype: TWideString = ''): Boolean;
  Function  ModifyField       (Const TableName, NewDatatype: TWideString): Boolean;
  Function  DropField         (Const TableName, FildName: TWideString): Boolean;
  Function  SetPrimaryKey     (Const TableName: TWideString; Const Fields: Array of TWideString): Boolean;
  Function  TruncateTable     (Const TableName: TWideString): Boolean;
  Function  DropTable         (Const TableName: TWideString): Boolean;
  Function  InsertRecord      (Const TableName: TWideString; Const Fields {[FieldName, Value], ...}: Array of TWideString): Boolean; Overload;
  Function  InsertRecordDirect(Const TableName: TWideString; Const Values {Value, ...}:              Array of TWideString): Boolean;
  Function  InsertRecord      (Const TableName: TWideString; Const Select, Condition):                                      Boolean; Overload;
  Function  UpdateRecord      (Const TableName: TWideString; Const Fields {[FieldName, Value], ...}: Array of TWideString; Const Condition): Boolean;
  Function  UpdateRecordDirect(Const TableName: TWideString; Const Values {Value, ...}:              Array of TWideString; Const Condition): Boolean;
  Function  SelectRecord      (Const Select; Var DBResult: TXMLDBResult): Boolean;
  Function  DeleteRecord      (Const TableName: TWideString; Const Condition): Boolean;
End;

und über die Query-Syntax bin ich mir auch noch nicht ganz einig ... die sieht aktuell so aus:

Code:

CREATE TABLE table (field datatyp [, field datatyp [, ...]]
  [PRIMARY KEY (field [, field [, ...]])]
  [FOREIGN KEY (field) REFERENCES extTable(extField)] )

ALTER TABLE table
  [ ADD field datatyp [{FIRST|AFTER posField}] [, field datatyp [{FIRST|AFTER posField}] [, ...]] [PRIMARY KEY (field [, field [, ...]])] ]
  [ DROP field [, field [, ...]] ]
  [ CHANGE field newField [newDatatyp] [, field newField [newDatatyp] [, ...]] ]
  [ MODIFY field newDatatyp [, field newDatatyp [, ...]] ]

TRUNCATE TABLE table

DROP TABLE table


INSERT INTO table (field [, field [, ...]])
  [ VALUES (value [, value [, ...]]) ]
  [ SELECT ...{see SELECT}... ]

UPDATE table SET field = value [, field = value [, ...]] WHERE condition [{AND|OR} condition [...]]

SELECT [DISTINCT] field [, field [, ...]] FROM table
  [WHERE condition [{AND|OR} condition [...]] [OUTER JOIN]]
  [GROUP BY field] [HAVING condition] [ORDER BY field [{ASC|DESC}]]
  [{UNION [ALL]|INTERSECT|MINUS} [ SELECT ...{see SELECT}... ]]

DELETE FROM table WHERE condition [{AND|OR} condition [...]]


table (SELECT): table as tableAlias

field (SELECT): {[DISTINCT] COUNT|SUM|MIN|MAX|AVR|CONCAT|TRIM|LTRIM|RTRIM}(field)
                field as fieldAlias

condition:      {field|value} {<|<=|=|>=|>|<>|LIKE} {field|value}
                {field|value} IN ({field|value}, {field|value} [, ...])
                {field|value} BETWEEN {field|value} AND {field|value}

Dateien siehe Post #1

[himitsu]

Soooooo,
endlich ist auch mal ein Parser drin, auch wenn der noch extrem langsam arbeitet (15 sekunden für schlappe ~200.000 Tags ist nicht wirklich flott, aber er arbeitet erstmal )

Demnach ist bis auf das Deserialisieren von Records und Objekten und die DB-Engine der Tools, erstmal alles soweit "funktionsfähig".

Anhang siehe Post #1



PS: wisst ihr wieviele Stunden man einen Fehler (auch noch erstmal an falscher Stelle) suchen kann?

Zitat:

MoveMemory(Buffer.GetDataP, Buffer.GetDataP + Length, (Buffer.Length - Length) * 2);

und am Ende fehlt nur eine kleine Klammer


[edit]
ich lad das jetzt nicht extra hoch

einfach diesen Wert für FileBufferSize eintragen
Const FileBufferSize = 1024; und das Lesen geht schneller

allerdings versteh ich grad noch nicht, warum es da plötzlich schneller wird, obwohl so eigentlich öfters umkopiert und nachgeladen werden muß
nja, so sind es statt 15-17 Sekunden nur noch 1,2

[himitsu]

• kleine Fehler der Lese-/Schreibbasisroutinen behoben
• das Problem des letzen Postes behoben
  - das Kopieren der Daten aus dem Temparray herraus mach ich jetzt selber
  (Delphi legte erstmal eine String-Kopie des gesamten Temp-Arrays (Array[..] of WideChar) an und wende dann erst dauf Copy an)
  - die Datei-Position für den Status wird nichtmehr nach jedem Tag neu berechnet

Code:

fill TXMLFile with 100.000 nodes and save into and load this from a file
create:0  fill:170  save:77  free:37
create:0  load:240  free:30

fill TXMLDocument with 100.000 nodes and save into and load this from a file
create:3  fill:735228  save:208  free:0
create:0  load:332  free:91

Anhang siehe Post #1


[todo]
fehlende Deserialisierungen fertigstellen (Object und Record)
DB-Engine der Tools weiterplanen

sonst läuft anscheinend erstmal alles Andere