Delphi-PRAXiS
Seite 3 von 35     123 4513     Letzte » 

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)
-   Software-Projekte der Mitglieder (https://www.delphipraxis.net/26-software-projekte-der-mitglieder/)
-   -   himXML (gesprochen himix ML) (https://www.delphipraxis.net/130751-himxml-gesprochen-himix-ml.html)

himitsu 24. Apr 2009 01:43

Re: himXML (gesprochen himixML)
 
@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 :mrgreen:

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 :-D
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 28. Apr 2009 11:52

Re: himXML (gesprochen himixML)
 
  • @Muetze1: hab's doch erstmal als Array fertiggestellt (war einfacher so :oops: )
  • 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 1. Mai 2009 02:34

Re: himXML (gesprochen himixML)
 
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 :wall:
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 :angel:

himitsu 5. Mai 2009 00:49

Re: himXML (gesprochen himixML)
 
* 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 :wall: )
* Code etwas aufgeräumt
* und ich scheine auch endlich mal "alle" fehlenden/leeren Prozeduren gefüllt zu haben :-D
* 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 5. Mai 2009 12:23

Re: himXML (gesprochen himixML)
 
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 7. Mai 2009 14:02

Re: himXML (gesprochen himixML)
 
Schon schlimm, eigentlich wollte ich mein MatchText nur etwas hierfür anpassen und nun artet auch noch das mehr aus, als gedacht :freak:


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 :shock: ) 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. :angel2:

himitsu 16. Mai 2009 22:18

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

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 :stupid:
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 :angel2:

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

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:

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 :gruebel:
(durchschnittlich bei über 20 Byte war CRC32 ein bissl flotter und darunter ELF)
nja, so brauchte ich zumindestens nicht noch 'ne Hashtabelle mit unterbringen :stupid:
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 :thumb: )


Angang siehe Post #1

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

himitsu 19. Mai 2009 17:00

Re: himXML (gesprochen himixML)
 
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 21. Mai 2009 01:00

Re: himXML (gesprochen himixML)
 
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 :stupid: )

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 :wall:


[edit]
ich lad das jetzt nicht extra hoch

einfach diesen Wert für FileBufferSize eintragen
Delphi-Quellcode:
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ß :gruebel:
nja, so sind es statt 15-17 Sekunden nur noch 1,2 :shock:

himitsu 21. Mai 2009 13:25

Re: himXML (gesprochen himixML)
 
  • 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 :-D


Alle Zeitangaben in WEZ +1. Es ist jetzt 16:48 Uhr.
Seite 3 von 35     123 4513     Letzte » 

Powered by vBulletin® Copyright ©2000 - 2022, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2021 by Daniel R. Wolf