Delphi-PRAXiS - Einzelnen Beitrag anzeigen

**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.

zusammenfalten · markieren

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

zusammenfalten · markieren

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)

zusammenfalten · markieren

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:

markieren

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

Einzelnen Beitrag anzeigen

Re: himXML (gesprochen himixML)