himXML (gesprochen himix ML)

[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

[xZise]

Interessantes Projekt, besonders weil ich das XML Format eigentlich mag. Aber es lässt sich so schlecht verwenden. Ich werde dein Projekt mal testen Vll. taugt es was

MfG
xZise

[himitsu]

Zitat von xZise:

Aber es lässt sich so schlecht verwenden.

Einiges kommt mir zumindestens leichter vor ... hab auch "absichtlich" einiges anders definiert, als es z.B. beim (MS)XML-DOM der Fall ist.

Und wenn es dir dennoch zu schwer ist ... siehe Tools, da kannst du es (fast) wie TIniFile oder TRegistry verwenden, falls des dir leichter fällt.

Zitat von xZise:

Ich werde dein Projekt mal testen Vll. taugt es was

viel Spaß und ich hoff's


neues Update oben

• Indexfehler (Exception) in [Node].NodeList behoben
• Fehler in den Deserialisierungen behoben und Einiges überarbeitet
  (die Deserialisierung für Variants und Records scheint nun zu laufen ... für Objekte kommt hoffentlich auch bald)
• 2 Demos sind dazugekommen
  - Demo_Serialize.dpr - kleine Demonstration der (De)Serialisierungsfunktionen
  (besser im Debugger durchgehn, da man sonst noch nicht viel sieht)
  - Demo_Tree.dpr - eine XML-Datei einlesen und in einer TreeView anzeigen

[add]
soeben ist noch 'ne weitere Demo (SAXParser.dpr) entstanden ... es ist sowas wie ein SAX-Parser,
also die Daten werden schon wärend des Einlesens/Parsens ausgewertet und gleich wieder freigegeben
(dieses hab ich einfach in der schon vorhandenen Callback-Funktion gelöst)

man kann also auch mal Gigabyte-große Dateien parsen, ohne daß der geladene XML-Baum den RAM vollmacht
[/add]

SpeedTest.dpr liefert bei mir jetzt dieses Ergebnis

Code:

SetProcessAffinityMask: OK

use QueryPerformanceCounter

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


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

fill TXMLDocument with 10.000 nodes and save this into a file
create:12  fill:6458  save:108  free:0


fill TXMLFile with 10.000 nodes, delete 8.000 nodes and save this into a file
create:0  fill:15  delete:409  save:4  free:0

fill TXMLDocument with 10.000 nodes, delete 8.000 nodes and save this into a file
create:0  fill:6303  delete:106310  save:97  free:0


fill TXMLFile with 10.000 nodes with attributes and save this into a file
create:0  fill:691  save:386  free:5

fill TXMLDocument with 10.000 nodes with attributes and save this into a file
create:0  fill:6589  save:122  free:0


fill TXMLFile with 100.000 nodes, save into and load this from a file
create:0  fill:166  save:70  free:37
create:0  load:245  free:33

fill TXMLDocument with 100.000 nodes, save into and load this from a file
create:0  fill:708145  save:348  free:0
create:0  load:331  free:94


fill TXMLFile with 10.000 nodes with attributes and search nodes
create:0  fill:697  search:2746  free:4

fill TXMLDocument with 10.000 nodes with attributes and search nodes
create:0  fill:6503  search:164476  free:0

press [enter]

ich glaub damit kann ich erstmal leben

[xZise]

Zitat von himitsu:

Zitat von xZise:

Aber es lässt sich so schlecht verwenden.

Einiges kommt mir zumindestens leichter vor ... hab auch "absichtlich" einiges anders definiert, als es z.B. beim (MS)XML-DOM der Fall ist.

Ich glaube du hast mich nicht richtig verstanden Und zwar waren die bisherigen Lösungen (besonders das von MSXML) inner Unverhältnismäßig komplizierter. Wenn man also nicht zwingend XML benötigt, ist das via StringList immer einfacher gewesen... Deshalb setze ich so viel Hoffnung in das Projekt!

MfG
xZise