himXML (gesprochen himix ML)

[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