unit uDAInterfaces;

{----------------------------------------------------------------------------}
{ Data Abstract Library - Core Library                                       }
{                                                                            }
{ compiler: Delphi 6 and up, Kylix 3 and up                                  }
{ platform: Win32, Linux                                                     }
{                                                                            }
{ (c)opyright RemObjects Software. all rights reserved.                      }
{                                                                            }
{ Using this code requires a valid license of the Data Abstract              }
{ which can be obtained at http://www.remobjects.com.                        }
{----------------------------------------------------------------------------}

{$I DataAbstract.inc}

interface

uses
  Classes, DB, uROClasses, SysUtils, uDASupportClasses,
  DataAbstract3_Intf, DataAbstract4_Intf, uROXmlIntf, FMTBcd;

const
  func_GetDriverObject = 'GetDriverObject';
  ClientFieldPrefix = '##';

type
  TDAObjecttype = (dotTable,dotProcedure, dotView);
  TDAChangeType = (ctInsert, ctUpdate, ctDelete);
  TDAChangeTypes = set of TDAChangeType;
  TDAChangeStatus = (csPending, csResolved, csFailed);

  TDASQLCondition = (cEqual,
    cDifferent,
    cMajor,
    cLess,
    cMajorOrEqual,
    cLessOrEqual,
    cLike,
    cIn,
    cContaining,
    cIsNull,
    cIsNotNull);

  TDASQLOperator = (opAND,
    opOR,
    opNOT);

  TDADefaultOperator = (doNone, doAnd, doOr);

  TDABlobType = (dabtUnknown, dabtBlob, dabtMemo, dabtOraBlob, dabtOraClob, dabtGraphic, dabtTypedBinary);

  TDAJoinType = (jtInner, jtLeftOuter, jtRightOuter, jtFullOuter, jtCross);

  TDARelationshipType = (rtForeignKey, rtMasterDetail);

const
  StrSQLCondition: array[TDASQLCondition] of string = (
    '=', '<>', '>', '<', '>=', '<=', 'LIKE', 'IN', 'CONTAINING', 'IS NULL', 'IS NOT NULL');

  StrSQLOperator: array[TDASQLOperator] of string = (
    'AND', 'OR', 'NOT');

  BlobTypeMappings : array[TDABlobType] of TFieldType =
    (ftBlob, ftBlob, ftMemo, ftOraBlob, ftOraClob, ftGraphic,ftTypedBinary);

type
  { Forwards }
  IDADriver = interface;
  IDAStoredProcedure = interface;
  IDADataset = interface;
  IDAConnection = interface;
  IDASQLCommand = interface;
  IDADataDictionary = interface;
  IDATestableObject = interface;
  IDAConnectionPool = interface;
  IDAConnectionManager = interface;

  TDACustomField = class;
  TDADataset = class;

  { Driver access }
  TDAGetDriverObject = function: IDADriver; stdcall;

  //TDriverErrorEvent = procedure(anErrorCode : integer; const anErrorMessage : string) of object;

  EDADriverLoadException = class(Exception)
  private
    fErrorCode: integer;

  public
    constructor Create(anErrorCode: integer; const anErrorMessage: string);

    property ErrorCode: integer read fErrorCode;
  end;
  EDADriverLoadExceptionClass = class of EDADriverLoadException;
  TDADataAbstractException = EDADriverLoadException;
  TDADataAbstractExceptionClass = class of TDADataAbstractException;

  { Misc. types }
  TDASQLStatementType = (stSQL, stStoredProcedure, stAutoSQL);

  TDACommandType = (cmdInsert, cmdDelete, cmdUpdate);
  TDACommandTypes = set of TDACommandType;

  TDAPersistFormat = (pfBinary, pfXML);

  TDAParamType = (daptUnknown, daptInput, daptOutput, daptInputOutput, daptResult);

  TDADataType = (datUnknown,
    datString,
    datDateTime,
    datFloat,
    datCurrency,
    datAutoInc,
    datInteger,
    datLargeInt,
    datBoolean,
    datMemo,
    datBlob,
    datWideString,
    datWideMemo,
    datLargeAutoInc,
    datByte,
    datShortInt,
    datWord,
    datSmallInt,
    datCardinal,
    datLargeUInt,
    datGuid,
    datXml,
    datDecimal,
    datSingleFloat);

  { Forwards }
  TDASQLCommand = class;
  TDAStatementCollection = class;
  TDASQLCommandCollection = class;
  TDAParamCollection = class;
  TDAJoinConditionCollection = class;
  TDAUnionSourceTableCollection = class;

  { TDAColumnMapping }
  TDAColumnMapping = class(TInterfacedCollectionItem)
  private
    fDatasetField: string;
    fTableField: string;
    fSQLOrigin: string;
    function GetSQLOrigin: string;
    function StoreSQLOrigin: Boolean;
    procedure SetDatasetField(const Value: string);
    procedure SetSQLOrigin(const Value: string);
    procedure SetTableField(const Value: string);

  public
    procedure Assign(aSource: TPersistent); override;
    procedure AssignFieldMapping(aSource: TPersistent);

  published
    property DatasetField: string read fDatasetField write SetDatasetField;
    property TableField: string read fTableField write SetTableField;
    property SQLOrigin: string read GetSQLOrigin write SetSQLOrigin stored StoreSQLOrigin;
  end;

  { TDAColumnMappingCollection }
  TDAColumnMappingCollection = class(TSearcheableCollection)
  private
    function GetColumnMappings(Index: integer): TDAColumnMapping;
    procedure SetColumnMappings(Index: integer;
      const Value: TDAColumnMapping);

  protected
    function SetItemName(anItem: TCollectionItem; const aName: string): string; override;
    function GetItemName(anItem: TCollectionItem): string; override;

  public
    constructor Create(aOwner: TPersistent);

    procedure AssignColumnMapping(aSource: TPersistent);

    function Add: TDAColumnMapping; reintroduce;
    function FindMappingByDatasetField(const aDatasetField: string): TDAColumnMapping;
    function MappingByDatasetField(const aDatasetField: string): TDAColumnMapping;
    function MappingByTableField(const aTableField: string): TDAColumnMapping;

    property ColumnMappings[Index: integer]: TDAColumnMapping read GetColumnMappings write SetColumnMappings; default;
  end;

  { TDAStatement }
  TDAStatement = class(TCollectionItem)
  private
    fSQL: string;
    fStatementType: TDASQLStatementType;
    fConnection: string;
    fColumnMappings: TDAColumnMappingCollection;
    fTargetTable: string;
    fName: string;
    fConnectionType: string;
    fDefault: boolean;

    procedure SetColumnMappings(const Value: TDAColumnMappingCollection);
    function GetStatementCollection: TDAStatementCollection;
    procedure SetSQL(const Value: string);
    function GetNeedsParams: boolean;
    function StoreSQL: Boolean;

  protected

  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;

    procedure Assign(aSource: TPersistent); override;

    property StatementCollection: TDAStatementCollection read GetStatementCollection;
    property NeedsParams: boolean read GetNeedsParams;
  published
    property Connection: string read fConnection write fConnection;
    property ConnectionType: string read fConnectionType write fConnectionType;
    property Default: boolean read fDefault write fDefault default false;
    property TargetTable: string read fTargetTable write fTargetTable;
    property Name: string read fName write fName;
    property SQL: string read fSQL write SetSQL stored StoreSQL;
    property StatementType: TDASQLStatementType read fStatementType write fStatementType;
    property ColumnMappings: TDAColumnMappingCollection read fColumnMappings write SetColumnMappings;
  end;

  { TDAStatementCollection }
  TDAStatementCollection = class(TSearcheableCollection)
  private
    fSQLCommand: TDASQLCommand;

    function GetStatements(Index: integer): TDAStatement;
    procedure SetStatements(Index: integer; const Value: TDAStatement);

  protected
    function SetItemName(anItem: TCollectionItem; const aName: string): string; override;
    function GetItemName(anItem: TCollectionItem): string; override;

  public
    constructor Create(aOwner: TPersistent; aSQLCommand: TDASQLCommand);

    function Add: TDAStatement; reintroduce;
    function FindItem(const aName: string; const aStatementName: string=''; const aConnectionType: string = ''; aReturnDefault: Boolean = false): TDAStatement; reintroduce;

    function StatementByName(const aName: string): TDAStatement;

    property SQLCommand: TDASQLCommand read fSQLCommand;
    property Statements[Index: integer]: TDAStatement read GetStatements write SetStatements; default;
  end;

  { TDAUpdateRule }
  TDAUpdateFailureBehavior = (fbRaiseException, fbLogAndContinue, fbIgnoreAndContinue);

  TDAUpdateRule = class(TCollectionItem)
  private
    fDatasetName: string;
    fName: string;
    fFailureBehavior: TDAUpdateFailureBehavior;
    fDoInsert: boolean;
    fDoUpdate: boolean;
    fDoDelete: boolean;
    function GetChangeTypes: TDAChangeTypes;

  protected
    function GetDisplayName : string; override;

  public
    constructor Create(aCollection : TCollection); override;

    procedure Assign(aSource: TPersistent); override;

    property ChangeTypes: TDAChangeTypes read GetChangeTypes;

  published
    property Name : string read fName write fName;
    property DoUpdate : boolean read fDoUpdate write fDoUpdate default True;
    property DoInsert : boolean read fDoInsert write fDoInsert default True;
    property DoDelete : boolean read fDoDelete write fDoDelete default True;
    property DatasetName : string read fDatasetName write fDatasetName;

    property FailureBehavior : TDAUpdateFailureBehavior read fFailureBehavior write fFailureBehavior;
  end;

  { TDAUpdateRuleCollection }
  TDAUpdateRuleCollection = class(TSearcheableCollection)
  private
    function GetUpdateRules(Index: integer): TDAUpdateRule;
  protected
  public
    constructor Create(aOwner : TComponent);

    function Add: TDAUpdateRule; reintroduce;
    function UpdateRuleByName(const aName : string) : TDAUpdateRule;

    property UpdateRules[Index : integer] : TDAUpdateRule read GetUpdateRules; default;
  end;

  { TDABaseField }
  TDABaseField = class(TInterfacedCollectionItem)
  private
    fDictionaryEntry: string;
    fSize: integer;
    fDescription,
    fName: string;
    fDataType: TDADataType;
    fValue: Variant;
    fBlobType: TDABlobType;
    fGeneratorName : string;
    FDecimalPrecision: Integer;
    FDecimalScale: Integer;
    //procedure FixSize;

  protected
    function MergeDatadictionaries: Boolean;
    function GetBlobSize: Integer; virtual;
    function GetName: string; virtual;
    procedure SetName(const Value: string); virtual;
    function GetDataType: TDADataType;
    procedure SetDataType(Value: TDADataType);
    function GetSize: integer;
    procedure SetSize(Value: integer);
    function GetValue: Variant; virtual;
    procedure SetValue(const aValue: Variant); virtual;
    function GetDescription: string;
    procedure SetDescription(const Value: string);
    function StoreBlobType : boolean;
    function GetBlobType: TDABlobType;
    procedure SetBlobType(const Value: TDABlobType); virtual;
    function GetGeneratorName: string;
    procedure SetGeneratorName(const aValue: string);

    function GetAsBoolean: boolean; virtual;
    function GetAsCurrency: currency; virtual;
    function GetAsDateTime: TDateTime; virtual;
    function GetAsFloat: double; virtual;
    function GetAsInteger: integer; virtual;
    function GetAsString: string; virtual;
    function GetAsVariant: variant; virtual;
    function GetAsLargeInt: int64; virtual;
    function GetAsWideString: Widestring; virtual;
    function GetAsByte: Byte; virtual;
    function GetAsCardinal: Cardinal; virtual;
    function GetAsDecimal: TBcd; virtual;
    function GetAsGuid: TGUID; virtual;
    function GetAsLargeUInt: Int64; virtual;
    function GetAsShortInt: ShortInt; virtual;
    function GetAsSingle: Single; virtual;
    function GetAsSmallInt: SmallInt; virtual;
    function GetAsWord: Word; virtual;
    function GetAsXml: IXMLNode; virtual;
    procedure SetAsByte(const Value: Byte); virtual;
    procedure SetAsCardinal(const Value: Cardinal); virtual;
    procedure SetAsDecimal(const Value: TBcd); virtual;
    procedure SetAsGuid(const Value: TGUID); virtual;
    procedure SetAsLargeUInt(const Value: Int64); virtual;
    procedure SetAsShortInt(const Value: ShortInt); virtual;
    procedure SetAsSingle(const Value: Single); virtual;
    procedure SetAsSmallInt(const Value: SmallInt); virtual;
    procedure SetAsWord(const Value: Word); virtual;
    procedure SetAsXml(const Value: IXMLNode); virtual;
    procedure SetAsBoolean(const aValue: boolean); virtual;
    procedure SetAsCurrency(const aValue: currency); virtual;
    procedure SetAsDateTime(const aValue: TDateTime); virtual;
    procedure SetAsString(const aValue: string); virtual;
    procedure SetAsVariant(const aValue: variant); virtual;
    procedure SetAsFloat(const aValue: double); virtual;
    procedure SetAsInteger(const aValue: integer); virtual;
    procedure SetAsLargeInt(const aValue: Int64); virtual;
    procedure SetAsWideString(const aValue: Widestring); virtual;
    function GetIsNull: boolean; virtual;

    function StoreDataType: Boolean;
    function StoreDescription: Boolean;
    function StoreGeneratorName: Boolean;
    function StoreSize: Boolean;
    function StoreDecimalPrecision: Boolean;
    function StoreDecimalScale: Boolean;

    function GetDictionaryEntry: string;
    procedure SetDictionaryEntry(const Value: string);
    function FindDictionaryField: TDACustomField;
    function GetDictionaryField: TDACustomField;

    // Internal
    function GetDisplayName: string; override;
    procedure SetDisplayName(const Value: string); override;
    function GetDecimalPrecision: Integer; virtual;
    procedure SetDecimalPrecision(const Value: Integer);virtual;
    function GetDecimalScale: Integer;virtual;
    procedure SetDecimalScale(const Value: Integer);virtual;
    function IsCompatibleV4: boolean; virtual;
  public
    property Value: Variant read GetValue write SetValue;

    procedure Assign(Source: TPersistent); override;
    procedure AssignField(Source: TDABaseField); virtual;

    function HasValidDictionaryField: Boolean;

    procedure Clear;

    function GetNamePath: string; override;

    property AsBoolean: boolean read GetAsBoolean write SetAsBoolean;
    property AsCurrency: currency read GetAsCurrency write SetAsCurrency;
    property AsDateTime: TDateTime read GetAsDateTime write SetAsDateTime; //null->0
    property AsFloat: double read GetAsFloat write SetAsFloat; //null->0
    property AsInteger: integer read GetAsInteger write SetAsInteger; //null->0
    property AsString: string read GetAsString write SetAsString; //null->''
    property AsVariant: variant read GetAsVariant write SetAsVariant;
    property AsLargeInt: Int64 read GetAsLargeInt write SetAsLargeInt;
    property AsWideString: WideString read GetAsWideString write SetAsWideString;
    property BlobSize: Integer read GetBlobSize;
    property IsNull: boolean read GetIsNull;
    property AsByte: Byte read GetAsByte write SetAsByte;
    property AsShortInt: ShortInt read GetAsShortInt write SetAsShortInt;
    property AsWord: Word read GetAsWord write SetAsWord;
    property AsSmallInt: SmallInt read GetAsSmallInt write SetAsSmallInt;
    property AsCardinal: Cardinal read GetAsCardinal write SetAsCardinal;
    property AsLargeUInt: Int64 read GetAsLargeUInt write SetAsLargeUInt;
    property AsGuid: TGUID read GetAsGuid write SetAsGuid;
    property AsDecimal: TBcd read GetAsDecimal write SetAsDecimal;
    property AsXml: IXMLNode read GetAsXml write SetAsXml;
    property AsSingle: Single read GetAsSingle write SetAsSingle;

    property DictionaryEntry: string read GetDictionaryEntry write SetDictionaryEntry;
  published
    property Name: string read GetName write SetName;
    property DataType: TDADataType read GetDataType write SetDataType default datUnknown;
    property Size: integer read GetSize write SetSize default 0;
    property Description: string read GetDescription write SetDescription;
    property BlobType: TDABlobType read GetBlobType write SetBlobType default dabtUnknown;
    property GeneratorName : string read GetGeneratorName write SetGeneratorName;
    property DecimalPrecision: Integer read GetDecimalPrecision write SetDecimalPrecision stored StoreDecimalPrecision;
    property DecimalScale: Integer read GetDecimalScale write SetDecimalScale stored StoreDecimalScale;
  end;

  { TDACustomField }
  TDAFieldNotifyEvent = procedure(Sender: TDACustomField) of object;
  TDAFieldGetTextEvent = procedure(Sender: TDACustomField; var Text: string; DisplayText: boolean) of object;
  TDAFieldSetTextEvent = procedure(Sender: TDACustomField; const Text: string) of object;

  TDACustomFieldCollection = class;

  TDACustomField = class(TDABaseField)
  private
    fField: TField;
    fTableField: string;
    fCustomAttributes: TStringList;

    fRequired: boolean;
    fInPrimaryKey: boolean;
    fRegExpression: string;
    fDefaultValue: string;
    fDisplayWidth: integer;
    fDisplayLabel: string;
    fReadOnly: boolean;
    fVisible: boolean;
    fEditMask: string;
    fLogChanges: boolean;
    fCalculated: boolean;
    fOnChange: TDAFieldNotifyEvent;
    fOnValidate: TDAFieldNotifyEvent;
    fDisplayFormat: string;
    fBusinessClassID: string;
    fAlignment : TAlignment;
    fEditFormat : string;
    fLookupCache: boolean;
    fLookupKeyFields: string;
    fLookupResultField: string;
    fKeyFields: string;
    fLookupSource: TDataSource;
    fLookup: boolean;
    fServerAutoRefresh: boolean;
    fSQLOrigin: string;
    fServerCalculated: Boolean;
    fExpression: string;

    function GetDisplayLabel: string;
    
    function StoreDisplayLabel: Boolean;
    
    function StoreProperties : boolean;

    function GetDefaultValue: string;
    function GetDisplayWidth: integer;
    function GetEditMask: string;
    function GetReadOnly: boolean;
    function GetVisible: boolean;
    //procedure SetBusinessRulesID(const Value: string);
    //function GetBusinessRulesID: string;
    function GetDisplayFormat: string;
    function GetAlignment: TAlignment;
    function GetEditFormat: string;
    procedure SetAlignment(const Value: TAlignment);
    procedure SetEditFormat(const Value: string);

    procedure SetKeyFields(const Value: string);
    procedure SetLookupCache(const Value: boolean);
    procedure SetLookupKeyFields(const Value: string);
    procedure SetLookupResultField(const Value: string);
    procedure SetLookupSource(const Value: TDataSource);
    procedure SetCalculated(const Value: boolean);
    procedure SetLookup(const Value: boolean);
    function GetFieldCollection: TDACustomFieldCollection;
    {function GetNotNull: boolean;
    procedure SetNotNull(const Value: boolean);}
    function GetServerAutoRefresh: boolean;
    procedure SetServerAutoRefresh(const Value: boolean);
    function GetLogChanges: boolean;
    function GetOldValue: Variant;
    function GetSQLOrigin: string;
    function GetBusinessClassID: string;
    procedure SetBusinessClassID(const Value: string);
    procedure SetServerCalculated(const Value: Boolean);
    procedure SetExpression(const Value: string);
    function StoredServerCalculated: Boolean;
    function StoredExpression: Boolean;

  protected
    function GetOwner: TPersistent; override;

    procedure SetName(const Value: string); override;

    function GetInPrimaryKey: boolean;
    function GetRegExpression: string;
    function GetRequired: boolean;
    procedure SetInPrimaryKey(const Value: boolean);
    procedure SetRegExpression(const Value: string);
    function GetBlobSize: Integer; override;
    function GetValue: Variant; override;
    procedure SetValue(const Value: Variant); override;
    function GetTableField: string;
    procedure SetTableField(const Value: string);
    function GetCustomAttributes: TStrings;
    procedure SetCustomAttributes(const Value: TStrings);
    procedure SetDisplayFormat(const Value: string);
    procedure SetBlobType(const Value: TDABlobType); override;

    procedure SetRequired(const aValue: boolean);
    procedure SetDisplayLabel(const aValue: string);
    procedure SetVisible(const aValue: boolean);
    procedure SetDisplayWidth(const aValue: integer);
    procedure SetEditMask(const aValue: string);
    procedure SetReadOnly(const aValue: boolean);

    // Event hooks
    procedure InternalOnChange(Sender: TField);
    procedure InternalOnValidate(Sender: TField);

    function GetAsBoolean: boolean; override;
    function GetAsCurrency: currency; override;
    function GetAsDateTime: TDateTime; override;
    function GetAsFloat: double; override;
    function GetAsInteger: integer; override;
    function GetAsString: string; override;
    function GetAsVariant: variant; override;
    function GetAsLargeInt: int64; override;
    function GetAsWideString: Widestring; override;
    function GetAsByte: Byte; override;
    function GetAsCardinal: Cardinal; override;
    function GetAsDecimal: TBcd; override;
    function GetAsGuid: TGUID; override;
    function GetAsLargeUInt: Int64; override;
    function GetAsShortInt: ShortInt; override;
    function GetAsSingle: Single; override;
    function GetAsSmallInt: SmallInt; override;
    function GetAsWord: Word; override;
    function GetAsXml: IXMLNode; override;
    procedure SetAsByte(const Value: Byte); override;
    procedure SetAsCardinal(const Value: Cardinal); override;
    procedure SetAsDecimal(const Value: TBcd); override;
    procedure SetAsGuid(const Value: TGUID); override;
    procedure SetAsLargeUInt(const Value: Int64); override;
    procedure SetAsShortInt(const Value: ShortInt); override;
    procedure SetAsSingle(const Value: Single); override;
    procedure SetAsSmallInt(const Value: SmallInt); override;
    procedure SetAsWord(const Value: Word); override;
    procedure SetAsXml(const Value: IXMLNode); override;
    procedure SetAsBoolean(const aValue: boolean); override;
    procedure SetAsCurrency(const aValue: currency); override;
    procedure SetAsDateTime(const aValue: TDateTime); override;
    procedure SetAsString(const aValue: string); override;
    procedure SetAsVariant(const aValue: variant); override;
    procedure SetAsFloat(const aValue: double); override;
    procedure SetAsInteger(const aValue: integer); override;
    procedure SetAsLargeInt(const aValue: Int64); override;
    procedure SetAsWideString(const aValue: Widestring); override;
    function GetIsNull: boolean; override;
    function GetDecimalPrecision: Integer; override;
    procedure SetDecimalPrecision(const Value: Integer);override;
    function GetDecimalScale: Integer;override;
    procedure SetDecimalScale(const Value: Integer);override;
    function IsCompatibleV4: boolean; override;
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;

    function GetNamePath: string; override;

    procedure Bind(aField: TField);
    procedure Unbind;

    procedure SaveToStream(const aStream: IROStream); overload;
    procedure LoadFromStream(const aStream: IROStream); overload;
    procedure SaveToStream(const aStream: TStream); overload;
    procedure LoadFromStream(const aStream: TStream); overload;
    procedure SaveToFile(const aFileName: string);
    procedure LoadFromFile(const aFileName: string);

    property FieldCollection : TDACustomFieldCollection read GetFieldCollection;

    procedure FocusControl;

    property TableField: string read GetTableField write SetTableField;
    property SQLOrigin: string read GetSQLOrigin write fSQLOrigin;

    procedure Assign(Source: TPersistent); override;
    procedure AssignField(Source: TDABaseField); override;

    property OldValue : Variant read GetOldValue;
    property BindedField: TField read FField;
  public
    property OnChange: TDAFieldNotifyEvent read fOnChange write fOnChange;
    property OnValidate: TDAFieldNotifyEvent read fOnValidate write fOnValidate;

    property InPrimaryKey: boolean read GetInPrimaryKey write SetInPrimaryKey default False;

    property Calculated: boolean read fCalculated write SetCalculated default False;
    property Expression: string read fExpression write SetExpression stored StoredExpression;
    property ServerCalculated: Boolean read fServerCalculated write SetServerCalculated stored StoredServerCalculated default False;
    property Lookup : boolean read fLookup write SetLookup default False;

    property LookupSource : TDataSource read fLookupSource write SetLookupSource;
    property LookupKeyFields : string read fLookupKeyFields write SetLookupKeyFields;
    property LookupResultField : string read fLookupResultField write SetLookupResultField;
    property KeyFields : string read fKeyFields write SetKeyFields;
    property LookupCache : boolean read fLookupCache write SetLookupCache default False;

  published

    property LogChanges: boolean read GetLogChanges write fLogChanges stored StoreProperties default true;

    property RegExpression: string read GetRegExpression write SetRegExpression               stored StoreProperties;
    property DefaultValue: string read GetDefaultValue write fDefaultValue                    stored StoreProperties;
    property Required: boolean read GetRequired write SetRequired                             stored StoreProperties default FALSE;
    property DisplayWidth: integer read GetDisplayWidth write SetDisplayWidth                 stored StoreProperties default 0;
    property DisplayLabel: string read GetDisplayLabel write SetDisplayLabel                  stored StoreDisplayLabel;
    property EditMask: string read GetEditMask write SetEditMask                              stored StoreProperties;
    property Visible: boolean read GetVisible write SetVisible                                stored StoreProperties default TRUE;
    property ReadOnly: boolean read GetReadOnly write SetReadOnly                             stored StoreProperties default FALSE;
    property CustomAttributes: TStrings read GetCustomAttributes write SetCustomAttributes    stored StoreProperties;
    property DisplayFormat: string read GetDisplayFormat write SetDisplayFormat               stored StoreProperties;
    //property BusinessRulesID : string read GetBusinessRulesID write SetBusinessRulesID        stored StoreProperties;
    property BusinessClassID : string read GetBusinessClassID write SetBusinessClassID        stored StoreProperties;
    property EditFormat : string read GetEditFormat write SetEditFormat                       stored StoreProperties;
    property Alignment :  TAlignment read GetAlignment write SetAlignment                     stored StoreProperties default taLeftJustify;
    property ServerAutoRefresh : boolean read GetServerAutoRefresh write SetServerAutoRefresh default FALSE;
  end;

  TDAField = class(TDACustomField)
  protected
    function GetDisplayName: string; override;
  published
    property DictionaryEntry;

    property InPrimaryKey;
    property Calculated;
    property Expression;
    property ServerCalculated;

    property OnChange;
    property OnValidate;

    property Lookup;

    property LookupSource;
    property LookupKeyFields;
    property LookupResultField;
    property KeyFields;
    property LookupCache;
  end;

  TDADataDictionaryField = class(TDACustomField)
  end;

  TDAFieldClass = class of TDACustomField;

  { TDACustomFieldCollection }
  TDACustomFieldCollection = class(TSearcheableInterfacedCollection)
  private
    fDataDictionary: IDADataDictionary;
    fFieldEventsDisabled: boolean;
    fFieldBeforeUpdate,
    fFieldAfterUpdate: TDAFieldNotifyEvent;
    fIsCompatibleV4: boolean;
    function GetFields(Index: integer): TDACustomField;
    procedure SetFields(Index: integer; const Value: TDACustomField);
  public
    constructor Create(aOwner: TPersistent; aFieldClass: TDAFieldClass);

    procedure Bind(aDataset: TDataset);
    procedure Unbind;

    property FieldEventsDisabled:boolean read fFieldEventsDisabled write fFieldEventsDisabled default false;

    function Add: TDAField; reintroduce; overload;
    function Add(const aName: string; aType: TDADataType; aSize: integer = 0): TDACustomField; overload;

    procedure Assign(Source: TPersistent); override;
    procedure AssignFieldCollection(Source: TDACustomFieldCollection);

    function FieldByName(const aName: string): TDACustomField;
    function FindField(const aName: string): TDACustomField;

    property DataDictionary: IDADataDictionary read fDataDictionary write fDataDictionary;

    property Fields[Index: integer]: TDACustomField read GetFields write SetFields; default;

    property OnFieldBeforeUpdate: TDAFieldNotifyEvent read fFieldBeforeUpdate write fFieldBeforeUpdate;
    property OnFieldAfterUpdate: TDAFieldNotifyEvent read fFieldAfterUpdate write fFieldAfterUpdate;
    property IsCompatibleV4: boolean read fIsCompatibleV4 write fIsCompatibleV4;
  end;

  TDAFieldCollection = class(TDACustomFieldCollection)
  private
    function GetFields(Index: integer): TDAField;
    procedure SetFields(Index: integer; const Value: TDAField);
  public
    constructor Create(aOwner: TPersistent);

    function FieldByName(const aName: string): TDAField; reintroduce;
    function FindField(const aName: string): TDAField;
    property Fields[Index: integer]: TDAField read GetFields write SetFields; default;
  end;

  TDADriverForeignKey = class(TInterfacedCollectionItem)
  private
    fValues:array[0..3] of string;
    fName: string;
    function GetValue(const Index: Integer): string;
    procedure SetValue(const Index: Integer; const Value: string);
  published
    property Name: string read fName write fName;
    property FKTable: string index 0 read GetValue write SetValue;
    property PKTable: string index 1 read GetValue write SetValue;
    property FKField: string index 2 read GetValue write SetValue;
    property PKField: string index 3 read GetValue write SetValue;
  end;

  TDADriverForeignKeyCollection = class(TInterfacedCollection)
  private
    function GetForeignKeys(Index: integer): TDADriverForeignKey;
    procedure SetForeignKeys(Index: integer; const Value: TDADriverForeignKey);
  public
    constructor Create(aOwner: TPersistent);
    function Add: TDADriverForeignKey; reintroduce; overload;

    //procedure Assign(Source: TPersistent); override;
    //procedure AssignFieldCollection(Source: TDACustomFieldCollection);

    property ForeignKeys[Index: integer]: TDADriverForeignKey read GetForeignKeys write SetForeignKeys; default;
  end;

  TDADataDictionaryFieldCollection = class(TDACustomFieldCollection)
  end;

  { TDAParam }
  TDAParam = class(TDABaseField)
  private
    fParamType: TDAParamType;

    function GetParamType: TDAParamType;
    procedure SetParamType(Value: TDAParamType);

  public
    procedure SaveToStream(const aStream: IROStream);
    procedure LoadFromStream(const aStream: IROStream);
    procedure SaveToFile(const aFileName: string);
    procedure LoadFromFile(const aFileName: string);
    procedure AssignField(Source: TDABaseField); override;

  published
    property Value stored true;
    property AsString stored false;
    property ParamType: TDAParamType read GetParamType write SetParamType default daptUnknown;
  end;

  { TDAParamCollection }
  TDAParamCollection = class(TSearcheableInterfacedCollection) // They are used also by the driver commands/datasets
  private
    function GetParams(Index: integer): TDAParam;
    procedure SetParams(Index: integer; const Value: TDAParam);
    function GetHasInputParams: boolean;

  protected
  public
    constructor Create(aOwner: TPersistent);

    procedure WriteValues(OutputParams: TParams);
    procedure ReadValues(InputParams: TParams);

    function Add: TDAParam; reintroduce;

    function ParamByName(const aName: string): TDAParam;
    function FindParam(const aParamName: string): TDAParam;

    procedure Assign(Source: TPersistent); override;
    procedure AssignParamCollection(Source: TDAParamCollection);

    property Params[Index: integer]: TDAParam read GetParams write SetParams; default;
    property HasInputParams:boolean read GetHasInputParams;
  end;

  { TDASQLCommand }
  TDASQLCommand = class(TCollectionItem)
  private
    fName: string;
    fDescription: string;
    fStatements: TDAStatementCollection;
    fParams: TDAParamCollection;
    fCustomAttributes: TStrings;
    fIsPublic: Boolean;

    procedure SetName(const Value: string);
    procedure SetCustomAttributes(const Value: TStrings);

  protected
    function GetDisplayName: string; override;
    procedure SetDisplayName(const Value: string); override;
    function GetParams: TDAParamCollection; virtual;
    procedure SetParams(const Value: TDAParamCollection); virtual;
    function GetStatements(): TDAStatementCollection; virtual;
    procedure SetStatements(const Value: TDAStatementCollection); virtual;
    function GetSQLCommandCollection: TDASQLCommandCollection; virtual;

  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;

    function ParamByName(const aName: string): TDAParam;

    procedure Assign(aSource: TPersistent); override;

    property SQLCommandCollection: TDASQLCommandCollection read GetSQLCommandCollection;

  published
    property IsPublic: Boolean read fIsPublic write fIsPublic default True;
    property Params: TDAParamCollection read GetParams write SetParams;
    property Statements: TDAStatementCollection read GetStatements write SetStatements;
    property Name: string read fName write SetName;
    property Description: string read fDescription write fDescription;
    property CustomAttributes: TStrings read fCustomAttributes write SetCustomAttributes;
  end;

  TDASQLCommandClass = class of TDASQLCommand;

  { TDASQLCommandCollection }
  TDASQLCommandCollection = class(TSearcheableCollection)
  private
    function GetSQLCommands(Index: integer): TDASQLCommand;
    procedure SetSQLCommands(Index: integer; const Value: TDASQLCommand);

  protected
    function GetItemClass: TDASQLCommandClass; virtual;

  public
    constructor Create(aOwner: TComponent);

    function Add: TDASQLCommand; reintroduce;

    function SQLCommandByName(const aName: string): TDASQLCommand;

    property SQLCommands[Index: integer]: TDASQLCommand read GetSQLCommands write SetSQLCommands; default;
  end;

  TROSEScriptLanguage = (rslPascalScript);

  TDABusinessRuleScript = class(TPersistent)
  private
    fScriptLanguage: TROSEScriptLanguage;
    fScript: string;
    fDescription: string;
  published
    property Script: string read fScript write fScript;
    property ScriptLanguage: TROSEScriptLanguage read fScriptLanguage write fScriptLanguage default rslPascalScript;
    property Description: string read fDescription write fDescription;
  end;

  TDAClientBusinessRuleScript = class(TDABusinessRuleScript)
  private
    fRunOnClientAndServer: boolean;
    fCompileOnServer: boolean;
  published
    constructor Create();
    property CompileOnServer: boolean read fCompileOnServer write fCompileOnServer default true;
    property RunOnClientAndServer: boolean read fRunOnClientAndServer write fRunOnClientAndServer default true;
  end;

  { TDADatasetRelationship }
  TDADatasetRelationship = class(TCollectionItem)
  private
    fDetailFields: string;
    fMasterFields: string;
    fDetailDatasetName: string;
    fMasterDatasetName: string;
    fName: string;
    fDescription: string;
    fRelationshipType: TDARelationshipType;
  protected
    function GetDisplayName : string; override;
  public
    constructor Create(Collection: TCollection); override;
  published
    procedure Assign(Source : TPersistent); override;

    property Name : string read fName write fName;
    property MasterDatasetName : string read fMasterDatasetName write fMasterDatasetName;
    property MasterFields : string read fMasterFields write fMasterFields;
    property DetailDatasetName : string read fDetailDatasetName write fDetailDatasetName;
    property DetailFields : string read fDetailFields write fDetailFields;
    property Description: string read fDescription write fDescription;
    property RelationshipType: TDARelationshipType read fRelationshipType write fRelationshipType;
  end;

  { TDADatasetRelationshipList }
  TDADatasetRelationshipList = class(TList)
  private
    function GetItems(Index: integer): TDADatasetRelationship;
  protected
  public
    function Add(aRelationship : TDADatasetRelationship) : integer; reintroduce;

    property Items[Index : integer] : TDADatasetRelationship read GetItems; default;
  end;

  { TDADatasetRelationshipCollection }
  TDADatasetRelationshipCollection = class(TSearcheableCollection)
  private
    function GetRelationShips(Index: integer): TDADatasetRelationship;
  protected
  public
    constructor Create(aOwner : TComponent);
    procedure GetDetails(const aMasterDatasetName: string; aList: TDADatasetRelationshipList);

    function Add: TDADatasetRelationship; overload;
    function RelationShipByName(const aName : string) : TDADatasetRelationship;

    property RelationShips[Index : integer] : TDADatasetRelationship read GetRelationShips; default;
  end;

  { TDADataset }
  TDADataset = class(TDASQLCommand)
  private
    fFields: TDAFieldCollection;
    fBusinessClassID: string;
    fBusinessRulesServer: TDABusinessRuleScript;
    fBusinessRulesClient: TDAClientBusinessRuleScript;
    fReadOnly: Boolean;

    procedure SetFields(const Value: TDAFieldCollection);
    procedure SetBusinessRulesClient(const Value: TDAClientBusinessRuleScript);
    procedure SetBusinessRulesServer(const Value: TDABusinessRuleScript);

  protected
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;

    procedure Assign(aSource: TPersistent); override;

    function FieldByName(const aName: string): TDAField;
    function FindField(const aName: string): TDAField;
  published
    property Fields: TDAFieldCollection read fFields write SetFields;
    property BusinessClassID : string read fBusinessClassID write fBusinessClassID;
    property ReadOnly: Boolean read fReadOnly write fReadOnly default False;

    property BusinessRulesClient: TDAClientBusinessRuleScript read fBusinessRulesClient write SetBusinessRulesClient;
    property BusinessRulesServer: TDABusinessRuleScript read fBusinessRulesServer write SetBusinessRulesServer;
  end;

  { TDADatasetCollection }
  TDADatasetCollection = class(TDASQLCommandCollection)
  private
    function GetDatasets(Index: integer): TDADataset;
    procedure SetDatasets(Index: integer; const Value: TDADataset);
  protected
    function GetItemClass: TDASQLCommandClass; override;

  public
    function Add: TDADataset; reintroduce;

    function DatasetByName(const aName: string): TDADataset;
    function FindDatasetByName(const aName: string): TDADataset;

    property Datasets[Index: integer]: TDADataset read GetDatasets write SetDatasets; default;
  end;

  { TDAJoinSourceTable }
  TDAJoinSourceTable = class(TCollectionItem)
  private
    fName: String;
    fJoinType: TDAJoinType;
    fJoinConditions: TDAJoinConditionCollection;    
  protected
    function GetDisplayName : string; override;
    procedure SetName(const Value: string);
  public
    constructor Create(Collection: TCollection); override;
	  procedure Assign(aSource: TPersistent); override;
  published
    property Name: string read fName write SetName;
    property JoinType: TDAJoinType read fJoinType write fJoinType;
    property JoinConditions: TDAJoinConditionCollection read fJoinConditions;
  end;

  { TDAJoinSourceTableCollection }
  TDAJoinSourceTableCollection = class(TSearcheableCollection)
  private
    function GetJoinSourceTables(Index: integer): TDAJoinSourceTable;
    procedure SetJoinSourceTables(Index: integer; const Value: TDAJoinSourceTable);
  public
    constructor Create(aOwner: TPersistent);
    function Add: TDAJoinSourceTable; reintroduce;
    function JoinSourceTableByName(const aName: string): TDAJoinSourceTable;
    property JoinSourceTables[Index:Integer]: TDAJoinSourceTable read GetJoinSourceTables write SetJoinSourceTables;
  end;

  { TDAJoinCondition }
  TDAJoinCondition = class(TCollectionItem)
  private
    fFromTableName: String;
    fFromFieldName: String;
    fToTableName: String;
    fToFieldName: String;
  published
    property FromTableName: String read fFromTableName write fFromTableName;
    property FromFieldName: String read fFromFieldName write fFromFieldName;
    property ToTableName: String read fToTableName write fToTableName;
    property ToFieldName: String read fToFieldName write fToFieldName;
  end;

  { TDAJoinConditionCollection }
  TDAJoinConditionCollection = class(TOwnedCollection)
  private
  public
    constructor Create(aOwner: TPersistent);
    function Add: TDAJoinCondition; reintroduce;
  end;


  { TDAJoinDataTable }
  TDAJoinDataTable = class(TDADataset)
  private
    fMasterTable: String;
    fJoinSourceTables: TDAJoinSourceTableCollection;
    procedure SetJoinSourceTables(const Value: TDAJoinSourceTableCollection);
  protected
    function GetParams: TDAParamCollection; override;
    procedure SetParams(const Value: TDAParamCollection); override;
    function GetStatements(): TDAStatementCollection; override;
    procedure SetStatements(const Value: TDAStatementCollection); override;
    function GetSQLCommandCollection: TDASQLCommandCollection; override;
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
    procedure Assign(aSource: TPersistent); override;
    property Params;
    property Statements;
  published
    property JoinSourceTables: TDAJoinSourceTableCollection read fJoinSourceTables write SetJoinSourceTables;
    property MasterTable: String read fMasterTable write fMasterTable;
  end;

  TDAJoinDataTableClass = class of TDAJoinDataTable;

  { TDAJoinedTableCollection }
  TDAJoinDataTableCollection = class(TSearcheableCollection)
  private
    function GetJoinDataTables(Index: integer): TDAJoinDataTable;
    procedure SetJoinDataTables(Index: integer; const Value: TDAJoinDataTable);
  protected
    //function GetItemClass: TDAJoinedTableClass; override;
  public
    constructor Create(aOwner : TComponent);
    function Add: TDAJoinDataTable; reintroduce;
    function JoinTableByName(const aName: string): TDAJoinDataTable;
    function FindJoinTableByName(const aName: string): TDAJoinDataTable;
    property JoinTables[Index: integer]: TDAJoinDataTable read GetJoinDataTables write SetJoinDataTables; default;
  end;

  {TDAUnionSourceTable}
  TDAUnionSourceTable = class(TCollectionItem)
  private
    fName: string;
    fColumnMappings: TDAColumnMappingCollection;
    fReadOnly: Boolean;
    procedure SetColumnMappings(const Value: TDAColumnMappingCollection);
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
  published
    property Name: string read fName write fName;
    property ColumnMappings: TDAColumnMappingCollection read fColumnMappings write SetColumnMappings;
    property IsReadOnly: Boolean read fReadOnly write fReadOnly;
  end;

  {TDAUnionSourceTableCollection}
  TDAUnionSourceTableCollection = class(TSearcheableCollection)
  private
    function GetUnionSourceTables(Index: integer): TDAUnionSourceTable;
  protected
  public
    constructor Create(aOwner : TPersistent);

    function Add: TDAUnionSourceTable; reintroduce;
    function UnionSourceTableByName(const aName : string) : TDAUnionSourceTable;

    property UnionSourceTables[Index : integer] : TDAUnionSourceTable read GetUnionSourceTables; default;
  end;

  {TDAUnionDataTable}
  TDAUnionDataTable = class(TDADataset)
  private
    fDefaultSourceTable: string;
    fSourceTables: TDAUnionSourceTableCollection;
    procedure SetSourceTables(Value: TDAUnionSourceTableCollection);
  protected
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
    property Params;
    property Statements;
  published
    property SourceTables: TDAUnionSourceTableCollection read fSourceTables write SetSourceTables;
    property DefaultSourceTable: String read fDefaultSourceTable write fDefaultSourceTable;
  end;

  { TDAUnionDataTableCollection }
  TDAUnionDataTableCollection = class(TSearcheableCollection)
  private
    function GetUnionDataTables(Index: integer): TDAUnionDataTable;
    procedure SetUnionDataTables(Index: integer; const Value: TDAUnionDataTable);
  protected
    //function GetItemClass: TDAJoinedTableClass; override;
  public
    constructor Create(aOwner : TComponent);
    function Add: TDAUnionDataTable; reintroduce;
    function UnionDataTableByName(const aName: string): TDAUnionDataTable;
    function FindUnionDataTableByName(const aName: string): TDAUnionDataTable;
    property UnionDataTables[Index: integer]: TDAUnionDataTable read GetUnionDataTables write SetUnionDataTables; default;
  end;

  { TDAConnection }
  TDAConnection = class(TCollectionItem)
  private
    fDescription: string;
    fConnectionString: string;
    fConnectionType: string;
    fName: string;
    fDefault: boolean;
    fTag: integer;
    procedure SetDefault(const Value: boolean);
    procedure SetName(const Value: string);

  protected
    function GetDisplayName: string; override;
    procedure SetDisplayName(const Value: string); override;

    function GetConnectionString: string; virtual;
    procedure SetConnectionString(const aValue: string); virtual;

  public
    procedure Assign(aSource: TPersistent); override;

  published
    property Name: string read fName write SetName;
    property ConnectionString: string read GetConnectionString write SetConnectionString;
    property Description: string read fDescription write fDescription;
    property ConnectionType: string read fConnectionType write fConnectionType;
    property Default: boolean read fDefault write SetDefault default False;
    property Tag: integer read fTag write fTag default 0;
  end;

  { TDAConnectionCollection }
  TDAConnectionCollection = class(TSearcheableCollection)
  private
    function GetConnections(Index: integer): TDAConnection;
    procedure SetConnections(Index: integer; const Value: TDAConnection);
    procedure ClearDefaults(iExceptFor: TDAConnection);
  protected
    function ItemName: string; override;

  public
    constructor Create(aOwner: TPersistent);

    function Add: TDAConnection; reintroduce;
    function ConnectionByName(const aName: string): TDAConnection;
    function FindConnection(const aName: string; const aType: string): TDAConnection;

    function GetDefaultConnection : TDAConnection;

    property Connections[Index: integer]: TDAConnection read GetConnections write SetConnections; default;
    property OnItemRenamed;
    property OnItemRemoved;
  end;

  EDADriverAlreadyLoaded = class(EDADriverLoadException);
  EDASchemaModelerOnly = class(EDADriverLoadException);

  IDADataDictionary = interface
  ['{34078D79-6310-494C-BA92-0FC187B275BE}']
    procedure SetFields(const Value: TDADataDictionaryFieldCollection);
    function GetFields: TDADataDictionaryFieldCollection;
    property Fields: TDADataDictionaryFieldCollection read GetFields write SetFields;
  end;

  IDAHasDataDictionary = interface
  ['{A25ADACE-BBD7-4A04-84A9-B9B699389E3D}']
    function GetDataDictionary: IDADataDictionary;
    property DataDictionary: IDADataDictionary read GetDataDictionary;
  end;
  { IDADriverManager
      Provides access to all the functionality needed to load, unload and verify drivers.
      Access to this interface is obtained using a TDADriverManager component.
      There can only be one driver manager loaded at any give time in one application. }
  IDADriverManager = interface
    ['{5B6B8C91-F91A-4A25-8B6F-CF7959275682}']
    // Properties readers/writers
    function GetDrivers(Index: integer): IDADriver;
    function GetDriverCount: integer;

    // Methods
    procedure LoadDriver(const aFileName: string);
    procedure UnloadDriver(anIndex: integer);

    procedure LoadDrivers;overload;
    procedure LoadDrivers(const aDriverList: IROStrings; aIgnoreDuplicates: boolean = false; aIgnoreErrors: boolean = false);overload;
    procedure UnloadAllDrivers;

    function ListDrivers(const aDirectory: string; out FileNames: IROStrings): integer;

    function FindDriver(const aDriverID: string; out Driver: IDADriver): boolean;
    function DriverByDriverID(const aDriverID: string): IDADriver;

    // Properties
    property Drivers[Index: integer]: IDADriver read GetDrivers; default;
    property DriverCount: integer read GetDriverCount;
  end;

  TDAAvailableDriverOption = (doAuxDriver, doServerName, doDatabaseName, doLogin, doCustom);
  TDAAvailableDriverOptions = set of TDAAvailableDriverOption;

  TDADriverHelpType = (dhConnectionWizard);

  { IDADriver
      An object implementing this interface is returned by the Data Abstract drivers. You get a reference to
      it by calling the DLL's exported function GetDriverObject. If the DLL doesn't support this method, it is
      not a Data Abstract driver. Once you retrieve a reference to this object you can query it for additional
      interfaces such as IDAConnectionPool and obtain access to additional functionality. Not all drivers implement
      the same number of interfaces. }

  TDATraceSource = (tsUnknown, tsConnection, tsDataset, tsCommand);
  TDATraceOption = (toPrepare,
    toExecute,
    toFetch,
    toError,
    toStmt,
    toConnect,
    toTransact,
    toBlob,
    toService,
    toMisc,
    toParams);
  TDATraceOptions = set of TDATraceOption;

  TDALogTraceEvent = procedure(Sender: TObject; const Text: string; Tag: integer) of object;

  IDADriver = interface
    ['{1829ABED-299B-4698-9803-DBABCF5443FA}']
    // Properties readers/writers
    function GetDriverID: string; safecall;
    function GetDescription: string; safecall;
    function GetMajVersion: byte; safecall;
    function GetMinVersion: byte; safecall;

    // Methods
    procedure Initialize; safecall;
    procedure Finalize; safecall;

    function NewConnection(const aName: string = '';const aConnectionType: string = ''): IDAConnection; safecall; overload; {deprecated;}
    function NewConnection(const aConnectionManager: IDAConnectionManager; aConnectionDefinition: TDAConnection): IDAConnection; safecall; overload;

    procedure SetTraceOptions(TraceActive: boolean; TraceOptions: TDATraceOptions; Callback: TDALogTraceEvent); safecall;

    function GetAvailableDriverOptions: TDAAvailableDriverOptions; safecall;
    function GetDefaultCustomParameters: string; safecall;

    // Properties
    property DriverID: string read GetDriverID;
    property Description: string read GetDescription;
    property MajVersion: byte read GetMajVersion;
    property MinVersion: byte read GetMinVersion;

    procedure GetAuxDrivers(out List: IROStrings); safecall;
    procedure GetAuxParams(const AuxDriver: string; out List: IROStrings); safecall;
    function GetDefaultConnectionType(const AuxDriver: string): string; safecall;
  end;

  IDADriver30 = interface(IDADriver)
    ['{F14A6526-CE1F-4A6B-BC4D-3892BA712FE2}']
    function GetDriverHelp(aType: TDADriverHelpType): string;
  end;

  IDADriver40 = interface(IDADriver30)
    ['{82903957-974A-4E1F-B91C-C07F608A96A9}']
    function GetProviderDefaultCustomParameters(Provider: string): string; safecall;
  end;

  IDACanQueryDatabaseNames = interface
  ['{67870220-37E2-4510-BD6A-627EADED75ED}']
    function GetDatabaseNames: IROStrings;
  end;

  IDAFileBasedDatabase = interface
  ['{C37EA8EE-9AC7-44F3-863C-EFB1581D4D57}']
    function GetFileExtensions: IROStrings;
  end;

  IDADirectoryBasedDatabase = interface
  ['{40C102F0-B86E-4CD6-AB3D-4B0903723A5D}']
  end;

  { IDAConnectionObjectAccess
      Provides access to the internal connection component and facilitates access to its
      properties in form of a collection of properties. This interface is useful when you want
      to complete control of the internal object. In order to use this interface you need
      to use ShareMem or FastShareMem. }
  IDAConnectionObjectAccess = interface
    ['{FF8F2319-4EAE-4A2B-8713-A6E6B3F5E48A}']
    // Properties readers/writers
    function GetConnectionObject: TObject; safecall;
    function GetConnectionProperties(const aPropertyName: string): Variant; safecall;
    procedure SetConnectionProperties(const aPropertyName: string; const aValue: Variant); safecall;

    // Properties
    property ConnectionObject: TObject read GetConnectionObject;
    property ConnectionProperties[const aPropertyName: string]: Variant read GetConnectionProperties write SetConnectionProperties;
  end;

  TDAQuoteCharArray = array[0..1] of char;

  TDABeforeOpenDatasetEvent = procedure(const Sender: IDADataset) of object;
  TDAAfterOpenDatasetEvent = procedure(const Sender: IDADataset; ActualSQL: string; ElapsedMilliseconds: Cardinal) of object;
  TDAOpenDatasetErrorEvent = procedure(const Sender: IDADataset; ActualSQL: string; Error: Exception) of object;

  TDABeforeExecuteCommandEvent = procedure(const Sender: IDASQLCommand) of object;
  TDAAfterExecuteCommandEvent = procedure(const Sender: IDASQLCommand; ActualSQL: string; ElapsedMilliseconds: Cardinal) of object;
  TDAExecuteCommandErrorEvent = procedure(const Sender: IDASQLCommand; ActualSQL: string; Error: Exception) of object;

  { TDAWhereBuilder }

  TDAWhereBuilder = class;
  TDAWhereExpression = class(TObject)
  private
    fOwner: TDAWhereBuilder;
  public
    constructor Create(anOwner: TDAWhereBuilder);

    property Owner: TDAWhereBuilder read fOwner;

    class function ParseExpression(aOwner: TDAWhereBuilder; xr: IXmlNode): TDAWhereExpression;

    procedure ReadFromXml(xr: IXmlNode); virtual; abstract;
    procedure WriteToXml(sw: IXmlNode); virtual; abstract;
  end;

  TDABinaryOperator = (dboAnd, dboOr, dboXor, dboLess, dboLessOrEqual, dboGreater,
    dboGreaterOrEqual, dboNotEqual, dboEqual, dboLike, dboIn, dboAddition, dboSubtraction,
    dboMultiply, dboDivide);
  TDAUnaryOperator = (duoNot, duoMinus);

  TDAWhereBuilder = class
  private
    fExpression: TDAWhereExpression;
    FColumnMapping: TDAColumnMappingCollection;// for TDAESQLCommand
    fParams: TDAParamCollection;
    function getXml: WideString;
    procedure setXml(const aValue: WideString);
    procedure SetColumnMapping(const Value: TDAColumnMappingCollection);
    procedure SetParams(const Value: TDAParamCollection);
  protected
    function ReadFromXml(xr: IXmlNode): TDAWhereExpression; virtual;
    procedure WriteToXml(sw: IXmlNode; const aExpression: TDAWhereExpression); virtual;
  public
    constructor Create;

    destructor Destroy; override;

    property Expression: TDAWhereExpression read fExpression write FExpression;

    property Xml: WideString read GetXml write SetXml;
    function NewBinaryExpression(aLeft, aRight: TDAWhereExpression; anOp: TDABinaryOperator): TDAWhereExpression;
    function NewUnaryExpression(anExpression: TDAWhereExpression; anOp: TDAUnaryOperator): TDAWhereExpression;
    function NewConstant(const aValue: Variant; aType: TDADataType): TDAWhereExpression;
    function NewList(const aValues: array of TDAWhereExpression): TDAWhereExpression;
    function NewParameter(const aParameterName: string): TDAWhereExpression;
    function NewField(const aTableName,aFieldName: string): TDAWhereExpression;
    function NewNull: TDAWhereExpression;
    function NewMacro(const aName: string): TDAWhereExpression; overload;
    function NewMacro(const aName: string; const aValues: array of TDAWhereExpression): TDAWhereExpression; overload;
    procedure Clear;
    function IsEmpty:Boolean;
    property ColumnMapping: TDAColumnMappingCollection read FColumnMapping write SetColumnMapping;
    property Params: TDAParamCollection read fParams write SetParams;
    function ExpressionToXmlNode(const aExpression: TDAWhereExpression): IXMLNode;
    function XMLToExpression(const aXML: widestring):TDAWhereExpression;
  end;

  TDAQueryBuilder = class;
  TDASQLWhereBuilder = class(TDAWhereBuilder)
  private
    FId: Integer;
    FConnection: IDAConnection;
    FQueryBuilder: TDAQueryBuilder;
    function GenerateParamName: String;
    function GenerateParameter(const aParameterName: string):string;
    function GetMappingTableField(const aDataSetField: string): string;
  protected
    function GenerateFieldName(aTablename, aFieldName: string):string; virtual;
    function ProcessExpression(AExpression: TDAWhereExpression): string;
    function ProcessBinaryExpression(AExpression: TDAWhereExpression): string; virtual; abstract;
    function ProcessUnaryExpression(AExpression: TDAWhereExpression): string; virtual; abstract;
    function ProcessConstantExpression(AExpression: TDAWhereExpression): string; virtual;
    function ProcessListExpression(AExpression: TDAWhereExpression): string; virtual;
    function ProcessParameterExpression(AExpression: TDAWhereExpression): string; virtual;
    function ProcessFieldExpression(AExpression: TDAWhereExpression): string; virtual;
    function ProcessNullExpression(AExpression: TDAWhereExpression): string; virtual; abstract;
    function ProcessMacroExpression(AExpression: TDAWhereExpression): string; virtual;
  public
    constructor Create(AConnection: IDAConnection); overload;
    constructor Create(AQueryBuilder: TDAQueryBuilder); overload;
    function CreateWhereClause: string;
    property Connection: IDAConnection read FConnection;
    property QueryBuilder: TDAQueryBuilder read FQueryBuilder;
  end;
  { TDAQueryBuilder }

  TDATableFieldCollectionItem = class(TCollectionItem)
  private
    FFieldName: string;
    FTableName: string;
  public
    procedure Assign(Source: TPersistent); override;
    property TableName: string read FTableName write FTableName;
    property FieldName: string read FFieldName write FFieldName;
  end;

  TDASelectItem = TDATableFieldCollectionItem;
  TDASelectCollection = TCollection;

  TDAGroupByItem = TDATableFieldCollectionItem;
  TDAGroupByCollection = TCollection;

  TDAOrderByItem = TDATableFieldCollectionItem;
  TDAOrderByCollection = TCollection;

  TDAQueryBuilderOption = (qboSelectDistinct, qboGenerateSimpleSelect, qboGenerateDynamicWhereStatement);
  TDAQueryBuilderOptions = set of TDAQueryBuilderOption;

  TDAQueryBuilder = class(TPersistent)
  private
    // IDAConnection
    FMainTable: TDAJoinDataTable;
    FSelectCollection: TDASelectCollection;
    FGroupByCollection: TDAGroupByCollection;
    FOrderByCollection: TDAOrderByCollection;
    FWhere: TDASQLWhereBuilder;
    FOptions: TDAQueryBuilderOptions;
    FConnection: IDAConnection;
    FColumnMapping: TDAColumnMappingCollection;
    procedure SetColumnMapping(const Value: TDAColumnMappingCollection);
    function GetWhereBuilder: TDASQLWhereBuilder;
  protected
    function GetMappingTableField(const aDataSetField: string): string;
    procedure Validate; virtual;
    function CreateWhereBuilder: TDASQLWhereBuilder; virtual; abstract;
    function CreateSelectClause: string; virtual;
    function CreateTableClause: string; virtual;abstract;
    function CreateGroupByClause: string; virtual;
    function CreateOrderByClause: string; virtual;
    function GenerateFieldName(aTablename, aFieldName: string; aProcessMapping: Boolean = True):string; virtual;
    function QuoteFieldNameIfNeeded(const aTableName, aFieldName: string): string; virtual;
    function QuoteIdentifierIfNeeded(const iIdentifier: string): string; virtual;
    function QuoteIdentifier(const iIdentifier: string): string; virtual;
    function IdentifierNeedsQuoting(const iIdentifier: string):boolean;virtual;
  public
    constructor Create;
    destructor Destroy; override;
    function GenerateSelectSQL: string; virtual;
    function CreateWhereClause: string; virtual;
    procedure Assign(Source: TPersistent); override;
    procedure Clear;
    procedure AddSelect(ATable, AField: string);
    procedure AddGroupBy(ATable, AField: string);
    procedure AddOrderBy(ATable, AField: string);
    procedure AddJoin(AJoinTable, AJoinFieldName, AJoinToTableName, AJoinToFieldName: string; AJoinType: TDAJoinType = jtInner); overload;
    procedure AddJoin(AJoinTable: string; AJoinFieldNames: array of string; AJoinToTableName: string; AJoinToFieldNames: array of string; AJoinType: TDAJoinType = jtInner); overload;
    procedure AddCrossJoin(ATable: string);
    property Select: TDASelectCollection read FSelectCollection;
    property MainTable: TDAJoinDataTable read FMainTable;
    property Where: TDASQLWhereBuilder read GetWhereBuilder;
    property GroupBy: TDAGroupByCollection read FGroupByCollection;
    property OrderBy: TDAOrderByCollection read FOrderByCollection;
    property Options: TDAQueryBuilderOptions read FOptions write FOptions;
    property Connection: IDAConnection read FConnection write FConnection;
    property ColumnMapping: TDAColumnMappingCollection read FColumnMapping write SetColumnMapping;
  end;

  IDABaseConnection = interface
    ['{B96CFC5B-CE8A-4B6F-994E-2A82509B0F18}']
  end;

  { IDAConnection
      Provides access to a connection object in a database and vendor independent manner.
      Objects implementing IDAConnection are returned by the driver.
      Each connection object might also implement additional interfaces that are specific to the
      underlying database or the data-access framework. These additional interfaces are defined in
      separate units. To find out what interfaces a connection implements you can check the source code
      of the relative uDAxxxDriver.pas unit. }
  IDAConnection = interface(IDABaseConnection)
    ['{6D9C806F-65A5-43B3-8F07-4ED782A13A0A}']
    // Properties readers/writers
    function GetConnectionPool: IDAConnectionPool; safecall;
    procedure SetConnectionPool(const Value: IDAConnectionPool); safecall;
    function GetConnectionString: string; safecall;
    procedure SetConnectionString(Value: string); safecall;
    function GetConnected: boolean; safecall;
    procedure SetConnected(Value: boolean); safecall;
    function GetName: string; safecall;
    function GetOnAfterExecuteCommand: TDAAfterExecuteCommandEvent; safecall;
    function GetOnAfterOpenDataset: TDAAfterOpenDatasetEvent; safecall;
    function GetOnBeforeExecuteCommand: TDABeforeExecuteCommandEvent; safecall;
    function GetOnBeforeOpenDataset: TDABeforeOpenDatasetEvent; safecall;
    function GetOnExecuteCommandError: TDAExecuteCommandErrorEvent; safecall;
    function GetOnOpenDatasetError: TDAOpenDatasetErrorEvent; safecall;
    procedure SetOnAfterExecuteCommand(const Value: TDAAfterExecuteCommandEvent); safecall;
    procedure SetOnAfterOpenDataset(const Value: TDAAfterOpenDatasetEvent); safecall;
    procedure SetOnBeforeExecuteCommand(const Value: TDABeforeExecuteCommandEvent); safecall;
    procedure SetOnBeforeOpenDataset(const Value: TDABeforeOpenDatasetEvent); safecall;
    procedure SetOnExecuteCommandError(const Value: TDAExecuteCommandErrorEvent); safecall;
    procedure SetOnOpenDatasetError(const Value: TDAOpenDatasetErrorEvent); safecall;
    function GetConnectionType: string; safecall;

    // Transaction support
    function BeginTransaction: integer; safecall;
    procedure CommitTransaction; safecall;
    procedure RollbackTransaction; safecall;
    function GetInTransaction: boolean; safecall;

    // UserID/Password
    function GetUserID: string; safecall;
    procedure SetUserID(const Value: string); safecall;
    function GetPassword: string; safecall;
    procedure SetPassword(const Value: string); safecall;

    // Connection
    procedure Open(const aUserID: string = ''; const aPassword: string = ''); safecall;
    procedure Close; safecall;

    // Metadata
    procedure GetTableNames(out List: IROStrings); safecall;
    procedure GetViewNames(out List: IROStrings); safecall;
    procedure GetStoredProcedureNames(out List: IROStrings); safecall;
    procedure GetTableFields(const aTableName: string; out Fields: TDAFieldCollection); safecall;
    procedure GetQueryFields(const aSQL: string; aParamsIfNeeded: TDAParamCollection; out Fields: TDAFieldCollection); safecall;
    procedure GetViewFields(const aViewName: string; out Fields: TDAFieldCollection); safecall;
    procedure GetStoredProcedureParams(const aStoredProcedureName: string; out Params: TDAParamCollection); safecall;
    procedure GetForeignKeys(out ForeignKeys: TDADriverForeignKeyCollection); safecall;

    function GetQuoteChars: TDAQuoteCharArray; safecall;
    function IdentifierNeedsQuoting(const iIdentifier: string): boolean; safecall;
    function QuoteIdentifierIfNeeded(const iIdentifier: string): string; safecall;
    function QuoteIdentifier(const iIdentifier: string): string; safecall;
    function QuoteFieldNameIfNeeded(const aTableName, aFieldName: string): string; safecall;
    function QuoteFieldName(const aTableName, aFieldName: string): string; safecall;
    function GetSPSelectSyntax(HasArguments: Boolean): string; safecall;

    // Commands and datasets
    function NewCommand(const Text: string; CommandType: TDASQLStatementType; const aCommandName: string = ''): IDASQLCommand; safecall;
    function NewDataset(const SQL: string; const aDatasetName: string = ''): IDADataset; safecall;
    function GetLastAutoInc(const GeneratorName: string = ''): integer; safecall;

    function isAlive: Boolean; safecall;
    // Properties
    property ConnectionString: string read GetConnectionString write SetConnectionString;
    property Connected: boolean read GetConnected write SetConnected;
    property Name: string read GetName;
    property InTransaction: boolean read GetInTransaction;
    property UserID: string read GetUserID write SetUserID;
    property Password: string read GetPassword write SetPassword;
    property ConnectionPool: IDAConnectionPool read GetConnectionPool write SetConnectionPool;
    property ConnectionType: string read GetConnectionType;

    property OnBeforeOpenDataset: TDABeforeOpenDatasetEvent read GetOnBeforeOpenDataset write SetOnBeforeOpenDataset;
    property OnAfterOpenDataset: TDAAfterOpenDatasetEvent read GetOnAfterOpenDataset write SetOnAfterOpenDataset;
    property OnOpenDatasetError: TDAOpenDatasetErrorEvent read GetOnOpenDatasetError write SetOnOpenDatasetError;
    property OnBeforeExecuteCommand: TDABeforeExecuteCommandEvent read GetOnBeforeExecuteCommand write SetOnBeforeExecuteCommand;
    property OnAfterExecuteCommand: TDAAfterExecuteCommandEvent read GetOnAfterExecuteCommand write SetOnAfterExecuteCommand;
    property OnExecuteCommandError: TDAExecuteCommandErrorEvent read GetOnExecuteCommandError write SetOnExecuteCommandError;
    // QueryBuilder
    function GetQueryBuilder: TDAQueryBuilder; safecall;
    function GetWhereBuilder: TDASQLWhereBuilder; safecall;
    function GetUseMacroProcessor: Boolean; safecall;
    procedure SetUseMacroProcessor(Value:Boolean); safecall;
    property UseMacroProcessor: Boolean read GetUseMacroProcessor write SetUseMacroProcessor;
  end;

  IDAHETConnection = interface(IDABaseConnection)
  ['{9471FB7A-F5C6-4420-A2E6-F2DD7C6535A7}']
    function GetConnectionForObject(const aObjectName: string; aOpenConnection: boolean = false): IDAConnection;
  end;

  { IDATestableObject }
  IDATestableObject = interface
  ['{DC2C3CD1-9031-4B0A-97B9-563580611C25}']
    procedure Test; safecall;
  end;

  { IDAUseGenerators }
  IDAUseGenerators = interface
  ['{7963D550-361E-486A-AAD6-EFD12896F719}']
    function GetNextAutoinc(const GeneratorName: string): integer; safecall;
  end;

  IDACanQueryGeneratorsNames = interface
  ['{E7C4A441-16B2-42BA-92DD-BD0F3EC39250}']
    function GetGeneratorNames: IROStrings;
  end;

  { IDAConnectionManager }
  IDAConnectionManager = interface
    ['{C2C2B1DB-7D0A-4772-8DDF-5E5150A84827}']
    function GetDefaultConnectionName: string;
    function NewConnection(const aConnectionName: string;
      OpenConnection: boolean = TRUE;
      const UserID: string = '';
      const Password: string = ''): IDAConnection;

    procedure Clear;
  end;
  IDAConnectionPool = interface
    ['{6E132C7B-A6AD-4ECB-B901-80000AC4B912}']
    procedure ReleaseConnection(const Conn: IDAConnection);
  end;

  { IDASchema }
  IDASchema = interface
    ['{19C63BF1-9CAA-43B7-B49C-E3FE82F5A02E}']
    function GetDatasetText(const aConnection: IDAConnection; const aName: string): string;
    function GetCommandText(const aConnection: IDAConnection; const aName: string): string;

    function NewDataset(const aConnection: IDAConnection; const aName: string;
      aStatementName: string='';
      OpenIt: boolean = false): IDADataset; overload;
    function NewDataset(const aConnection: IDAConnection; const aName: string;
      const ParamNames: array of string;
      const ParamValues: array of Variant;
      OpenIt: boolean = TRUE;
      aStatementName: string=''): IDADataset; overload;
    function NewDataset(const aConnection: IDAConnection; const aName: string;
      aDynSelectFields: array of string;
      aWhereClause: WideString;
      aStatementName: string='';
      OpenIt: boolean = false; AlwaysGenerateDynamicWhereStatement: Boolean=False): IDADataset; overload;
    function NewDataset(const aConnection: IDAConnection; const aName: string;
      const ParamNames: array of string;
      const ParamValues: array of Variant;
      aDynSelectFields: array of string;
      aWhereClause: WideString;
      OpenIt: boolean = TRUE;
      aStatementName: string=''): IDADataset; overload;

    function NewCommand(const aConnection: IDAConnection; const aName: string;
      aStatementName: string=''): IDASQLCommand; overload;
    function NewCommand(const aConnection: IDAConnection; const aName: string;
      const ParamNames: array of string;
      const ParamValues: array of Variant;
      ExecuteIt: boolean = TRUE;
      aStatementName: string=''): IDASQLCommand; overload;

    procedure Clear;
    function MergeDataDictionaries: Boolean;
  end;

  { TDAWhere
      Represents an abstraction of the WHERE condition of a SQL statement in an IDADataset. }
  TDAWhere = class
  private
    fFields: TDAFieldCollection;
    fClause: string;
    fOnChange: TNotifyEvent;
    fChanged,
    fClientFields: boolean;
    fLastWasCondition: Boolean;
    fDefaultOperator: TDADefaultOperator;

    function GetEmpty: boolean;
    function GetNotEmpty: boolean;
    function GetProperName(aField: TDACustomField) : string;

  protected
  public
    constructor Create(const aFields: TDAFieldCollection; aClientFields : boolean);

    procedure Clear;

    procedure AddOperator(aOperator: TDASQLOperator);
    function AddCondition(const FieldName: string;
      Condition: TDASQLCondition;
      const Value: Variant;
      SkipIfEmptyValue: boolean = TRUE): boolean;overload;
    function AddCondition(const FieldName: string;
      Condition: TDASQLCondition): boolean;overload;
    procedure AddValueGroup(const FieldName: string;
      const Values: array of Variant);
    procedure AddSpaces(Count: integer = 1);
    procedure AddText(const someText: string; MapClientFields : boolean = TRUE);

    procedure OpenBraket; deprecated;
    procedure CloseBraket; deprecated;
    procedure OpenBracket;
    procedure CloseBracket;

    function AddConditions(const FieldNames : array of string;
                           const Conditions : array of TDASQLCondition;
                           const Values: array of Variant;
                           const Operator: TDASQLOperator) : integer;

    property OnChange: TNotifyEvent read fOnChange write fOnChange;

    property Clause: string read fClause;
    property Fields: TDAFieldCollection read fFields write fFields;
    property Empty : boolean read GetEmpty;
    property NotEmpty : boolean read GetNotEmpty;

    property ClientFields : boolean read fClientFields;
    property DefaultOperator: TDADefaultOperator read fDefaultOperator write fDefaultOperator;
    property LastWasCondition: Boolean read fLastWasCondition write fLastWasCondition;
    property Changed: Boolean read fChanged write fChanged;
  end;

  { IDASQLCommand
      Base interface for SQL commands. It defines the common functionality shared by queries and stored procedures
      that is providing access to a parameter list and being able to execute a statement which affects a certain
      number of records. }
  IDASQLCommand = interface
    ['{F57D2647-2DDE-4F69-86C5-CFACD6AC601F}']
    // Properties readers/writers
    function GetParams: TDAParamCollection; safecall;
    function GetPrepared: boolean; safecall;
    procedure SetPrepared(Value: boolean); safecall;
    function GetWhere: TDAWhere; safecall; deprecated;
    function GetDynamicWhere: TDAWhereBuilder; safecall;
    procedure SetDynamicWhere(const Value: TDAWhereBuilder);safecall;
    function SQLContainsDynamicWhere:boolean; safecall;
    function GetSQL: string; safecall;
    procedure SetSQL(const Value: string); safecall;
    function GetDataset: TDataset; safecall;
    function GetName: string; safecall;
    function GetOnAfterExecute: TDAAfterExecuteCommandEvent; safecall;
    function GetOnBeforeExecute: TDABeforeExecuteCommandEvent; safecall;
    procedure SetOnAfterExecute(const Value: TDAAfterExecuteCommandEvent); safecall;
    procedure SetOnBeforeExecute(const Value: TDABeforeExecuteCommandEvent); safecall;
    function GetOnExecuteError: TDAExecuteCommandErrorEvent; safecall;
    procedure SetOnExecuteError(const Value: TDAExecuteCommandErrorEvent); safecall;

    // Methods
    procedure RefreshParams; safecall;
    function Execute: integer; safecall;

    function ParamByName(const aName: string): TDAParam; safecall;

    // Properties
    property Name: string read GetName;
    property Dataset: TDataSet read GetDataset;
    property SQL: string read GetSQL write SetSQL;
    property Params: TDAParamCollection read GetParams;
    property Prepared: boolean read GetPrepared write SetPrepared;
    {$WARN SYMBOL_DEPRECATED OFF}
    property Where: TDAWhere read GetWhere;
    {$WARN SYMBOL_DEPRECATED ON}
    property DynamicWhere: TDAWhereBuilder read GetDynamicWhere write SetDynamicWhere;

    property OnBeforeExecute: TDABeforeExecuteCommandEvent read GetOnBeforeExecute write SetOnBeforeExecute;
    property OnAfterExecute: TDAAfterExecuteCommandEvent read GetOnAfterExecute write SetOnAfterExecute;
    property OnExecuteError: TDAExecuteCommandErrorEvent read GetOnExecuteError write SetOnExecuteError;
  end;

  { IDAMustSetParams
      Implemented only by few SQL commands when we need to call PSSetParams after the parameter values
      are written. For internal use only. See TDAEDataset.DoSetActive }
  IDAMustSetParams = interface
    ['{575A8055-0200-44F1-AC5A-EF8604CBB489}']
    procedure SetParamValues(Params: TDAParamCollection); safecall;
    procedure GetParamValues(Params: TDAParamCollection); safecall;
  end;

  { IDADataset
      Provides access to a row set generated from a SQL select or a call to a stored procedure which
      returns rows. IDADataset objects are created using the method IDAConnection.NewDataset.
      Objects implementing this interface are equivalent to TDataset and in most cases simply wrap one. }
  IDADataset = interface(IDASQLCommand)
    ['{8A3E5056-A8B9-4455-B82C-67E48CC39EA5}']
    // Properties readers/writers
    function GetRecordCount: integer; safecall;
    function GetFieldCount: integer; safecall;
    function GetFields: TDAFieldCollection; safecall;
    function GetActive: boolean; safecall;
    procedure SetActive(Value: boolean); safecall;
    function GetEOF: boolean; safecall;
    function GetFieldValues(Index: integer): Variant; safecall;
    function GetNames(Index: integer): string; safecall;
    function GetIsEmpty : boolean; safecall;
    function GetLogicalName : string; safecall;
    procedure SetLogicalName(aName : string); safecall;

    function GetOnAfterOpen: TDAAfterOpenDatasetEvent; safecall;
    function GetOnBeforeOpen: TDABeforeOpenDatasetEvent; safecall;
    procedure SetOnAfterOpen(const Value: TDAAfterOpenDatasetEvent); safecall;
    procedure SetOnBeforeOpen(const Value: TDABeforeOpenDatasetEvent); safecall;
    function GetOnOpenError: TDAOpenDatasetErrorEvent; safecall;
    procedure SetOnOpenError(const Value: TDAOpenDatasetErrorEvent); safecall;

    // Methods
    procedure Open; safecall;
    procedure Close; safecall;

    procedure EnableControls; safecall;
    procedure DisableControls; safecall;


    procedure Next; safecall;

    function FieldByName(const aName: string): TDAField; safecall;
    function FindField(const aName: string): TDAField; safecall;

    function GetCurrentRecIdValue: integer;
    procedure SetCurrentRecIdValue(Value: integer);

    function GetRowRecIDValue: integer;

    procedure EnableConstraints; safecall;
    procedure DisableConstraints; safecall;

    function Locate(const KeyFields: string; const KeyValues: Variant; Options: TLocateOptions): Boolean; safecall;
    function Lookup(const KeyFields: string; const KeyValues: Variant; const ResultFields: string): Variant; safecall;

    property RowRecIdValue: integer read GetRowRecIdValue;
    property CurrentRecIdValue: integer read GetCurrentRecIdValue write SetCurrentRecIdValue;
    // Properties
    property IsEmpty : boolean read GetIsEmpty;
(*    property BOF: boolean read GetBOF;*)
    property EOF: boolean read GetEOF;
    property RecordCount: integer read GetRecordCount;
    property Fields: TDAFieldCollection read GetFields;
    property Active: boolean read GetActive write SetActive;
    property FieldCount: integer read GetFieldCount;
    property FieldValues[Index: integer]: Variant read GetFieldValues;
    property Names[Index: integer]: string read GetNames;
    property LogicalName : string read GetLogicalName write SetLogicalName;

    property OnBeforeOpen: TDABeforeOpenDatasetEvent read GetOnBeforeOpen write SetOnBeforeOpen;
    property OnAfterOpen: TDAAfterOpenDatasetEvent read GetOnAfterOpen write SetOnAfterOpen;
    property OnOpenError: TDAOpenDatasetErrorEvent read GetOnOpenError write SetOnOpenError;

  end;

  IDADatasetEx = interface(IDADataset)
    ['{BB588B03-620E-43AD-B77E-EFD35F303112}']
    function GetBOF: boolean; safecall;
    procedure Refresh; safecall;
    function GetBookMark: pointer; safecall;
    procedure GotoBookmark(Bookmark: TBookmark); safecall;
    procedure FreeBookmark(Bookmark: TBookmark); safecall;

    function GetState : TDatasetState; safecall;
    property State : TDatasetState read GetState;
  end;

  { IDAEditableDataset }
  IDAEditableDataset = interface(IDADatasetEx)
    ['{D3E2147F-65B3-4D9D-8614-7270011FA7D5}']
    procedure Edit; safecall;
    procedure Insert; safecall;
    procedure Post; safecall;
    procedure Cancel; safecall;
    procedure Append; safecall;
    procedure Delete; safecall;

    procedure Prior; safecall;
    procedure First; safecall;
    procedure Last; safecall;

    procedure AddRecord(const  FieldNames : array of string; const FieldValues : array of Variant); safecall;

    procedure EnableEventHandlers; safecall;
    procedure DisableEventHandlers; safecall;
  end;

  { IDAStoredProcedure
      Provides access to stored database procedures.
      IDAStoredProcedure objects are created using the method IDAConnection.NewStoredProcedure.}
  IDAStoredProcedure = interface(IDASQLCommand)
    ['{6D9C806F-65A5-43B3-8F07-4ED782A13A0A}']
    // Properties readers/writers
    function GetStoredProcedureName: string; safecall;
    procedure SetStoredProcedureName(const Name: string); safecall;

    // Methods
    function Execute: integer; safecall;

    // Properties
    property StoredProcedureName: string read GetStoredProcedureName write SetStoredProcedureName;
  end;

  { IDADatasetPersist }
  IDADatasetPersist = interface
    ['{D6F850CD-9204-4953-A54F-1E622AA993B6}']
    function Persist(const aQuery: IDADataset; MaxRecords: integer; out Data: IROStream): integer;
  end;

  { IDADatasetResolver }
  IDADatasetResolver = interface
    ['{D6F850CD-9204-4953-A54F-1E622AA993B6}']
    procedure Resolve(const Data: IROStream; const aQuery: IDADataset; MaxErrors: integer);
  end;

  { IDALoginInfoAware }
  IDALoginInfoAware = interface
  ['{755615F0-4208-459A-B1C4-97EA5A3DB346}']
    function GetLoginInfo : TDALoginInfo;
    procedure SetLoginInfo(aValue : TDALoginInfo);

    property LoginInfo : TDALoginInfo read GetLoginInfo write SetLoginInfo;
  end;

  { TDALoginInfoAware }
  TDALoginInfoAware = class(TInterfacedObject, IDALoginInfoAware)
  private
    fLoginInfo : TDALoginInfo;

  protected
    { IDALoginInfoAware }
    function GetLoginInfo : TDALoginInfo;
    procedure SetLoginInfo(aValue : TDALoginInfo);

    { IInterface }
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;

  end;

  { IDASimpleClonedCursorsSupport }
  IDASimpleClonedCursorsSupport = interface
  ['{39D05665-5B13-4EC3-B31E-D39CBEA52AC6}']
    function GetSimpleCloneSource : TObject;
  end;

  IDAMemDatasetBatchAdding = interface
  ['{73A4A297-2938-46EB-8D0C-2F8FB58046E2}']
    function AllocRecordBuffer: PChar;
    procedure FreeRecordBuffer(var Buffer: PChar);
    function GetFieldNativeBuffer(Buffer: PChar; Field: TField): Pointer;
    function MakeBlobFromString(Blob:String): pointer;
    procedure AppendBuffer(Buffer: Pchar);
    procedure SetNullMask(Buffer: PChar; Field: TField; const Value: boolean);
    procedure SetAnsiString(NativeBuf: Pointer; Field: TField; const Value: Ansistring);
    procedure SetWideString(NativeBuf: Pointer; Field: TField; const Value: Widestring);
    procedure FinalizeBatchAdding;
  end;

    { TDADataSource }
  TDABaseDataSource = class(TDataSource)
  end;

const
  DADataTypeNames: array[Low(TDADataType)..High(TDADataType)] of string = ('Unknown',
    'String',
    'DateTime',
    'Float',
    'Currency',
    'AutoInc',
    'Integer',
    'LargeInt',
    'Boolean',
    'Memo',
    'Blob',
    'WideString',
    'WideMemo',
    'LargeAutoInc',
    'Byte',
    'ShortInt',
    'Word',
    'SmallInt',
    'Cardinal',
    'LargeUInt',
    'Guid',
    'Xml',
    'Decimal',
    'SingleFloat');
  DADataTypesMappings: array[TDADataType] of TFieldType = (
    ftUnknown, ftString, ftDateTime, ftFloat, ftCurrency, ftAutoInc, ftInteger,
    ftLargeInt, ftBoolean, ftMemo, ftBlob, ftWideString,
    {$IFNDEF DELPHI10UP}ftMemo{$ELSE}ftWideMemo{$ENDIF DELPHI10UP},
    ftLargeInt, ftSmallint, ftSmallint, ftWord, ftSmallint, ftInteger, ftLargeint,
    ftGuid, ftWideString, ftFMTBcd, ftFloat);

function VCLTypeToDAType(aFieldType: TFieldType): TDADataType;
function DATypeToVCLType(aDAType: TDADataType): TFieldType;

{ Cross-platform GetTickCount }
function ROGetTickCount: Cardinal;

{ Variant converters }
function GetVarBoolean(const Value: Variant): boolean;
function GetVarCurrency(const Value: Variant): currency;
function GetVarDateTime(const Value: Variant): TDateTime;
function GetVarFloat(const Value: Variant): double;
function GetVarInteger(const Value: Variant): integer;
function GetVarString(const Value: Variant): string;
function GetVarInt64(const Value: Variant): Int64;
function GetVarWideString(const Value: Variant): WideString;
function GetVarByte(const Value: Variant): Byte;
function GetVarShortInt(const Value: Variant): ShortInt;
function GetVarWord(const Value: Variant): Word;
function GetVarSmallInt(const Value: Variant): SmallInt;
function GetVarCardinal(const Value: Variant): Cardinal;
function GetVarLargeUInt(const Value: Variant): Int64;
function GetVarGuid(const Value: Variant): TGuid;
function GetVarXml(const Value: Variant): IXMLNode;
function GetVarDecimal(const Value: Variant): TBCD;
function GetVarSingleFloat(const Value: Variant): Single;
function TestDefaultValue(const DefaultValue: string; DataType: TDADataType): Boolean;

{ Misc }
function NewDatasetParam(anArray : TDADatasetParamArray; Name : string; Value : Variant) : TDADatasetParam;
function NewDatasetRequestInfo(anArray : TDADatasetRequestInfoArray;
                               DatasetName : string;
                               ParamNames : array of string;
                               ParamValues : array of variant;
                               IncludeSchema : boolean = FALSE;
                               MaxRecords : integer = -1) : TDADatasetRequestInfo;

implementation

uses
  {$IFDEF DataAbstract_Trial}
  Forms, Dialogs, //Windows,
  {$ENDIF DataAbstract_Trial}
  TypInfo, Variants,
  uDARes, uROBinaryHelpers, {uDAClasses, uDADataTable,} uDAWhere
  {$IFDEF MSWINDOWS}
  ,Windows
  {$ENDIF}
  {$IFDEF LINUX}
  ,Libc
  {$ENDIF LINUX};

{ Cross-platform GetTickCount }
{$IFDEF LINUX}
// This has been grabbed from IdGlobal.pas. Needs to be tested under Kylix just in case
function ROGetTickCount: Cardinal;
var
  tv: timeval;
begin
  gettimeofday(tv, nil);
  {$RANGECHECKS OFF}
  Result := int64(tv.tv_sec) * 1000 + tv.tv_usec div 1000;
  {$RANGECHECKS ON}
end;
{$ENDIF}
{$IFDEF MSWINDOWS}
function ROGetTickCount: Cardinal;
begin
  result := Windows.GetTickCount;
end;
{$ENDIF}

{ Variant converters }
function GetVarBoolean(const Value: Variant): boolean;
begin
  if VarIsNull(Value) then
    result := FALSE
  else
    result := Value;
end;

function GetVarCurrency(const Value: Variant): currency;
begin
  if VarIsNull(Value) then
    result := 0
  else
    result := Value;
end;

function GetVarDateTime(const Value: Variant): TDateTime;
begin
  if VarIsNull(Value) then
    result := 0
  else
    result := Value;
end;

function GetVarFloat(const Value: Variant): double;
begin
  if VarIsNull(Value) then
    result := 0
  else
    result := Value;
end;

function GetVarInteger(const Value: Variant): integer;
begin
  if VarIsNull(Value) then
    result := 0
  else
    result := Value;
end;

function GetVarString(const Value: Variant): string;
begin
  if VarIsNull(Value) then
    result := ''
  else
    result := Value;
end;

function GetVarInt64(const Value: Variant): Int64;
begin
  if VarIsNull(Value) then
    result := 0
  else
    result := Value;
end;

function GetVarWideString(const Value: Variant): WideString;
begin
  if VarIsnull(Value) then
    Result := ''
  else
    Result := Value;
end;

function GetVarByte(const Value: Variant): Byte;
begin
  if VarIsnull(Value) then
    Result := 0
  else
    Result := Value;
end;

function GetVarShortInt(const Value: Variant): ShortInt;
begin
  if VarIsnull(Value) then
    Result := 0
  else
    Result := Value;
end;

function GetVarWord(const Value: Variant): Word;
begin
  if VarIsnull(Value) then
    Result := 0
  else
    Result := Value;
end;

function GetVarSmallInt(const Value: Variant): SmallInt;
begin
  if VarIsnull(Value) then
    Result := 0
  else
    Result := Value;
end;

function GetVarCardinal(const Value: Variant): Cardinal;
begin
  if VarIsnull(Value) then
    Result := 0
  else
    Result := Value;
end;

function GetVarLargeUInt(const Value: Variant): Int64;
begin
  if VarIsnull(Value) then
    Result := 0
  else
    Result := Value;
end;

function GetVarGuid(const Value: Variant): TGuid;
begin
  if VarIsnull(Value) then
    FillChar(Result, sizeof(Result), 0)
  else
    Result := StringToGuid(Value);
end;

function GetVarXml(const Value: Variant): IXMLNode;
var
  lDoc: IXMLDocument;
begin
  if VarIsnull(Value) then
    Result := nil
  else begin
    lDoc := NewROXmlDocument;
    lDoc.New;
    lDoc.XML := Value;
    Result := lDoc.DocumentNode;
  end;
end;

function GetVarDecimal(const Value: Variant): TBCD;
begin
  Result := VariantToBCD(Value);
end;

function GetVarSingleFloat(const Value: Variant): Single;
begin
  if VarIsnull(Value) then
    Result := 0
  else
    Result := Value;
end;


function TestDefaultValue(const DefaultValue: string; DataType: TDADataType): Boolean;
var
  aDecimal: TDecimal;
begin
  try
    case DataType of
      datString: ;
      datDateTime: VarAsType(DefaultValue, varDate);
      datFloat: VarAsType(DefaultValue, varDouble);
      datDecimal: if not VarByteArrayToDecimal(DefaultValue,aDecimal) then VarAsType(DefaultValue, VarFMTBcd);
      datCurrency: VarAsType(DefaultValue, varCurrency);
      datAutoInc,
      datInteger: VarAsType(DefaultValue, varInteger);
      datLargeInt: VarAsType(DefaultValue, varInt64);
      datBoolean: VarAsType(DefaultValue, varBoolean);
      datMemo: VarAsType(DefaultValue, varString);
      datBlob: begin Result := False; exit; end;
      datWideString: VarAsType(DefaultValue, varOleStr);
      datWideMemo: VarAsType(DefaultValue, varOleStr);
    else
      begin
        result := false;
        exit;
      end;
    end;
    result := true;
  except
    result := false;
  end;
end;

{ EDADriverLoadException }

constructor EDADriverLoadException.Create(anErrorCode: integer;
  const anErrorMessage: string);
begin
  inherited Create(anErrorMessage);

  fErrorCode := anErrorCode;
end;

function VCLTypeToDAType(aFieldType: TFieldType): TDADataType;
begin
  result := datUnknown;
  case aFieldType of
    ftUnknown: result := datUnknown;

    ftAutoInc: result := datAutoInc;

    ftGuid: Result:= datGuid;

    ftFixedChar,
    ftString: result := datString;

    ftLargeint: result := datLargeInt;

    ftSmallint: Result := datSmallInt;
    ftWord: Result:= datWord;
    ftInteger:  result := datInteger;

    ftFloat: result := datFloat;
    ftBCD,
    ftFMTBcd: Result := datDecimal;
    ftCurrency: result := datCurrency;

    ftTimeStamp,
      ftDate,
      ftTime,
      ftDateTime: result := datDateTime;

    ftMemo,
      ftFmtMemo: result := datMemo;

    ftBytes, ftTypedBinary,
      ftVarBytes,
      ftBlob,
      ftGraphic,
      ftOraBlob,
      ftOraClob: result := datBlob;

    ftBoolean: result := datBoolean;
    ftWideString: Result := datWideString;
    {$IFDEF DELPHI10UP}
    ftWideMemo: Result:= datWideMemo;
    {$ENDIF DELPHI10UP}
  else
    RaiseError(err_FieldTypeNotSupported, [GetEnumName(TypeInfo(TFieldType), Ord(aFieldType)), Ord(aFieldType)]);
  end;
end;

function DATypeToVCLType(aDAType: TDADataType): TFieldType;
begin
  result := DADataTypesMappings[aDAType];
end;

{ Misc }
function NewDatasetParam(anArray : TDADatasetParamArray; Name : string; Value : Variant) : TDADatasetParam;
begin
  result := anArray.Add;
  result.Name := Name;
  result.Value := Value;
end;

function NewDatasetRequestInfo(anArray : TDADatasetRequestInfoArray;
                               DatasetName : string;
                               ParamNames : array of string;
                               ParamValues : array of variant;
                               IncludeSchema : boolean = FALSE;
                               MaxRecords : integer = -1) : TDADatasetRequestInfo;
var i : integer;
begin
  if (Length(ParamNames)<>Length(ParamValues))
    then raise EROUserError.Create('ParamNames and ParamValues arrays don''t contain the same number of items');

  result := anArray.Add;

  result.DatasetName := DatasetName;
  result.MaxRecords := MaxRecords;
  result.IncludeSchema := IncludeSchema;

  if (Length(ParamNames)>0) then begin
    result.Params := TDADatasetParamArray.Create;
    for i := 0 to (Length(ParamNames)-1) do
      NewDatasetParam(result.Params, ParamNames[i], ParamValues[i]);
  end
  else result.Params := NIL;
end;

{ TDAStatementCollection }

function TDAStatementCollection.Add: TDAStatement;
begin
  result := TDAStatement(inherited Add);
end;

function TDAStatementCollection.FindItem(const aName: string; const aStatementName: string=''; const aConnectionType: string = ''; aReturnDefault: Boolean = false): TDAStatement;
var
  i: integer;
  lDef, lStatement:TDAStatement;
begin
  result := nil;
  lDef := nil;
  for i := 0 to (Count - 1) do begin
    lStatement := Items[i] as TDAStatement;
    if lStatement.Default then lDef := lStatement;
    if
      ((aConnectionType <> '') and (SameText(lStatement.ConnectionType, aConnectionType))) or
      SameText(lStatement.Connection, aName) and
       ((aStatementName = '') or SameText(lStatement.Name, aStatementName)) then begin
      result := lStatement;
      exit;
    end;
  end;
  if aReturnDefault then result := lDef;
end;

constructor TDAStatementCollection.Create(aOwner: TPersistent; aSQLCommand: TDASQLCommand);
begin
  inherited Create(aOwner, TDAStatement);
  FAllowEmptyName := True;
  fSQLCommand := aSQLCommand;
end;

function TDAStatementCollection.GetItemName(
  anItem: TCollectionItem): string;
begin
  result := GetPropValue(anItem, 'Connection', TRUE);
end;

function TDAStatementCollection.GetStatements(
  Index: integer): TDAStatement;
begin
  result := TDAStatement(inherited Items[Index])
end;

function TDAStatementCollection.SetItemName(anItem: TCollectionItem;
  const aName: string): string;
begin
  SetPropValue(anItem, 'Connection', aName);
end;

procedure TDAStatementCollection.SetStatements(Index: integer;
  const Value: TDAStatement);
begin
  Statements[Index].Assign(Value);
end;

function TDAStatementCollection.StatementByName(
  const aName: string): TDAStatement;
begin
  result := TDAStatement(inherited ItemByName(aName));
end;

{ TDABaseField }

procedure TDABaseField.Assign(Source: TPersistent);
begin
  if (Source is TDABaseField) then begin
    AssignField(TDABaseField(Source));
  end
  else begin
    inherited;
  end;
end;

procedure TDABaseField.AssignField(Source: TDABaseField);
begin
  fSize := Source.fSize;
  fDescription := Source.fDescription;
  fName := Source.fName;
  fDataType := Source.fDataType;
  fValue := Source.fValue;
  fBlobType := Source.fBlobType;
  fGeneratorName := Source.GeneratorName;
  FDecimalPrecision := Source.FDecimalPrecision;
  FDecimalScale := Source.FDecimalScale;
end;

{procedure TDABaseField.FixSize;
begin
  if (fDataType <> datString) then fSize := 0;
end;}

function TDABaseField.GetDataType: TDADataType;
begin
  if not HasValidDictionaryField then begin
    result := fDataType
  end
  else begin
    result := GetDictionaryField().DataType;
  end;
end;

function TDABaseField.GetDescription: string;
begin
  if not HasValidDictionaryField then begin
    result := fDescription;
  end
  else begin
    result := GetDictionaryField().Description;
  end;
end;

function TDABaseField.GetName: string;
begin
  result := fName
end;

function TDABaseField.GetSize: integer;
begin
  if (DataType <> datString) and (DataType <> datWideString) then begin
    result := 0;
  end
  else begin
    if not HasValidDictionaryField then begin
      result := fSize
    end
    else begin
      result := GetDictionaryField().Size;
    end;
  end;
end;

function TDABaseField.GetValue: Variant;
begin
  result := fValue
end;

procedure TDABaseField.SetDataType(Value: TDADataType);
begin
  fDataType := Value;
  //FixSize();
end;

procedure TDABaseField.SetDescription(const Value: string);
begin
  fDescription := Value;
end;

procedure TDABaseField.SetName(const Value: string);
var
  lOldName: string;
begin
  lOldName := fName;
  fName := Value;
  if lOldName <> '' then
    (Collection as TSearcheableCollection).TriggerOnItemRenamed(lOldName, fName);
end;

procedure TDABaseField.SetSize(Value: integer);
begin
  fSize := Value;
  //FixSize();
end;

procedure TDABaseField.SetValue(const aValue: Variant);
begin
  fValue := aValue
end;

function TDABaseField.GetAsBoolean: boolean;
begin
  result := GetVarBoolean(Value);
  //if VarIsNull(Value) then result := FALSE else result := Value;
end;

function TDABaseField.GetAsCurrency: currency;
begin
  result := GetVarCurrency(Value);
  //if VarIsNull(Value) then result := 0 else result := Value;
end;

function TDABaseField.GetAsDateTime: TDateTime;
begin
  result := GetVarDateTime(Value);
  //if VarIsNull(Value) then result := 0 else result := Value;
end;

function TDABaseField.GetAsFloat: double;
begin
  result := GetVarFloat(Value);
  //if VarIsNull(Value) then result := 0 else result := Value;
end;

function TDABaseField.GetAsInteger: integer;
begin
  result := GetVarInteger(Value);
  //if VarIsNull(Value) then result := 0 else result := Value;
end;

function TDABaseField.GetAsString: string;
begin
  result := GetVarString(Value);
  //if VarIsNull(Value) then result := '' else result := Value;
end;

function TDABaseField.GetAsVariant: variant;
begin
  result := Value
end;

procedure TDABaseField.SetAsBoolean(const aValue: boolean);
begin
  Value := aValue;
end;

procedure TDABaseField.SetAsCurrency(const aValue: currency);
begin
  Value := aValue;
end;

procedure TDABaseField.SetAsDateTime(const aValue: TDateTime);
begin
  Value := aValue;
end;

procedure TDABaseField.SetAsFloat(const aValue: double);
begin
  Value := aValue;
end;

procedure TDABaseField.SetAsString(const aValue: string);
begin
  Value := aValue;
end;

procedure TDABaseField.SetAsVariant(const aValue: variant);
begin
  Value := aValue;
end;

procedure TDABaseField.SetAsInteger(const aValue: integer);
begin
  Value := aValue;
end;

function TDABaseField.GetDisplayName: string;
begin
  //result := Format('%s %-20s [%s, %d]', [GetName, '', GetEnumName(TypeInfo(TDADataType), Ord(DataType)), Size]);
  result := GetName;
end;

function TDABaseField.GetNamePath: string;
begin
  if (Collection <> nil) then
    result := Collection.GetNamePath + Name
  else
    result := inherited GetNamePath;

  result := inherited GetNamePath;
end;

function TDABaseField.GetDictionaryEntry: string;
begin
  result := fDictionaryEntry
end;

procedure TDABaseField.SetDictionaryEntry(const Value: string);
begin
  fDictionaryEntry := Value
end;

function TDABaseField.FindDictionaryField: TDACustomField;
var
  lOwner: TObject;
  lHasDict: IDAHasDataDictionary;
  lDictionary: IDADataDictionary;
begin
  result := nil;
  if DictionaryEntry = '' then exit;

  lDictionary := TDACustomFieldCollection(Collection).DataDictionary;

  { No Dictionary assigned? then try getting dictionary from owning Schema }
  if not Assigned(lDictionary) then begin
    lOwner := TDACustomFieldCollection(Collection).Owner;
    if not (lOwner is TDADataSet) then exit;

    lOwner := TDADatasetCollection(TDADataSet(lOwner).Collection).Owner;
//    if not (lOwner is TDASchema) then exit;

//    lDictionary := TDASchema(lOwner).DataDictionary;
    if Supports(lOwner, IDAHasDataDictionary, lHasDict) then
      lDictionary := lHasDict.DataDictionary;
  end;

  if Assigned(lDictionary) then
    result := lDictionary.Fields.FindField(DictionaryEntry);
end;

function TDABaseField.GetDictionaryField: TDACustomField;
begin
  result := FindDictionaryField();
  if not Assigned(result) then
    RaiseError('Dictionary entry %s not found for field %s', [DictionaryEntry, Name])
end;

function TDABaseField.HasValidDictionaryField: Boolean;
begin
  result := (DictionaryEntry <> '') and
    Assigned(FindDictionaryField());
end;

function TDABaseField.IsCompatibleV4: boolean;
begin
  Result:=False;
end;

function TDABaseField.StoreDataType: Boolean;
begin
  result := MergeDatadictionaries or not HasValidDictionaryField();
end;


function TDABaseField.StoreDecimalPrecision: Boolean;
begin
  Result:= (MergeDatadictionaries or (FDecimalPrecision <>0)) and not IsCompatibleV4;
end;

function TDABaseField.StoreDecimalScale: Boolean;
begin
  Result:= (MergeDatadictionaries or (FDecimalScale <>0)) and not IsCompatibleV4;
end;

function TDABaseField.StoreGeneratorName: Boolean;
begin
  result := MergeDatadictionaries or not HasValidDictionaryField();
end;

function TDABaseField.StoreDescription: Boolean;
begin
  result := MergeDatadictionaries or not HasValidDictionaryField();
end;

function TDABaseField.StoreSize: Boolean;
begin
  result := MergeDatadictionaries or  (((DataType = datString) or (DataType = datWideString)) and (not HasValidDictionaryField()));
end;

function TDABaseField.GetBlobType: TDABlobType;
begin
  if HasValidDictionaryField
    then result := GetDictionaryField().BlobType
    else result := fBlobType
end;

function TDABaseField.GetGeneratorName: string;
begin
  if not HasValidDictionaryField then begin
    result := fGeneratorName
  end
  else begin
    result := GetDictionaryField().GeneratorName;
  end;

end;


procedure TDABaseField.SetBlobType(const Value: TDABlobType);
begin
  fBlobType := Value;
end;

function TDABaseField.StoreBlobType: boolean;
begin
  result := HasValidDictionaryField;
end;

procedure TDABaseField.Clear;
begin
  Value := Null;
end;

procedure TDABaseField.SetGeneratorName(const aValue: string);
begin
  fGeneratorName := aValue
end;

procedure TDABaseField.SetDisplayName(const Value: string);
begin
  inherited;
  fName := Value;
end;

function TDABaseField.GetAsLargeInt: int64;
begin
  Result := GetVarInt64(Value);
end;

procedure TDABaseField.SetAsLargeInt(const aValue: Int64);
begin
  Value := aValue;
end;

function TDABaseField.GetAsWideString: Widestring;
begin
  Result := GetVarWideString(Value);
end;

procedure TDABaseField.SetAsWideString(const aValue: Widestring);
begin
  Value := aValue;
end;

function TDABaseField.GetIsNull: boolean;
begin
  result := VarIsNull(Value);
end;


function TDABaseField.GetBlobSize: Integer;
var
  v: Variant;
begin
  v := GetValue;
  if VarIsArray(v) then result := VarArrayHighBound(V, 1) - VarArrayLowBound(V, 1) + 1
  else if VarIsStr(v) then result := Length(v) else
  Result := 0;
end;

function TDABaseField.GetAsByte: Byte;
begin
  result := GetVarByte(Value);
end;

function TDABaseField.GetAsCardinal: Cardinal;
begin
  result := GetVarCardinal(Value);
end;

function TDABaseField.GetAsDecimal: TBcd;
begin
  result := GetVarDecimal(Value);
end;

function TDABaseField.GetAsGuid: TGUID;
begin
  result := GetVarGuid(Value);
end;

function TDABaseField.GetAsLargeUInt: Int64;
begin
  Result := GetVarInt64(Value);
end;

function TDABaseField.GetAsShortInt: ShortInt;
begin
  result := GetVarShortInt(Value);
end;

function TDABaseField.GetAsSingle: Single;
begin
  result := GetVarSingleFloat(Value);
end;

function TDABaseField.GetAsSmallInt: SmallInt;
begin
  result := GetVarSmallInt(Value);
end;

function TDABaseField.GetAsWord: Word;
begin
  result := GetVarWord(Value);
end;

function TDABaseField.GetAsXml: IXMLNode;
begin
  result := GetVarXml(Value);
end;

procedure TDABaseField.SetAsByte(const Value: Byte);
begin
  self.Value := Value;
end;

procedure TDABaseField.SetAsCardinal(const Value: Cardinal);
begin
  self.Value := Value;
end;

procedure TDABaseField.SetAsDecimal(const Value: TBcd);
begin
  self.Value := BCDToVariant(Value);
end;

procedure TDABaseField.SetAsGuid(const Value: TGUID);
begin
  self.Value := GuidToString(Value);
end;

procedure TDABaseField.SetAsLargeUInt(const Value: Int64);
begin
  self.Value := Value;
end;

procedure TDABaseField.SetAsShortInt(const Value: ShortInt);
begin
  self.Value := Value;
end;

procedure TDABaseField.SetAsSingle(const Value: Single);
begin
  self.Value := Value;
end;

procedure TDABaseField.SetAsSmallInt(const Value: SmallInt);
begin
  self.Value := Value;
end;

procedure TDABaseField.SetAsWord(const Value: Word);
begin
  self.Value := Value;
end;

procedure TDABaseField.SetAsXml(const Value: IXMLNode);
begin
  if Value = nil then
    Self.Value := null
  else
    self.Value := Value.XML;
end;

procedure TDABaseField.SetDecimalPrecision(const Value: Integer);
begin
  FDecimalPrecision := Value;
end;

function TDABaseField.GetDecimalPrecision: Integer;
begin
  if not HasValidDictionaryField then begin
    result := FDecimalPrecision
  end
  else begin
    result := GetDictionaryField().DecimalPrecision;
  end;
end;

function TDABaseField.GetDecimalScale: Integer;
begin
  if not HasValidDictionaryField then begin
    result := FDecimalScale
  end
  else begin
    result := GetDictionaryField().DecimalScale;
  end;
end;

procedure TDABaseField.SetDecimalScale(const Value: Integer);
begin
  FDecimalScale := Value;
end;

function TDABaseField.MergeDatadictionaries: Boolean;
var
  lOwner: TObject;
  lSchema: IDASchema;
begin
  result := false;
  if DictionaryEntry = '' then exit;

  lOwner := TDACustomFieldCollection(Collection).Owner;
  if not (lOwner is TDADataSet) then exit;

  lOwner := TDADatasetCollection(TDADataSet(lOwner).Collection).Owner;

  if Supports(lOwner, IDASchema, lSchema) then
    result := lSchema.MergeDataDictionaries;
end;

{ TDACustomField }

constructor TDACustomField.Create(Collection: TCollection);
begin
  inherited;

  fServerAutoRefresh := FALSE;
  fCustomAttributes := TStringList.Create;
  fVisible := TRUE;
  fLogChanges := TRUE;
end;

destructor TDACustomField.Destroy;
begin
  fCustomAttributes.Free;
  inherited;
end;

function TDACustomField.GetInPrimaryKey: boolean;
begin
  result := fInPrimaryKey
end;

function TDACustomField.GetRegExpression: string;
begin
  if not HasValidDictionaryField
    then result := fRegExpression
    else result := GetDictionaryField().RegExpression;
end;

function TDACustomField.GetDefaultValue: string;
begin
  if not HasValidDictionaryField
    then result := fDefaultValue
    else result := GetDictionaryField().DefaultValue;
end;

function TDACustomField.GetRequired: boolean;
begin
  if not HasValidDictionaryField
    then result := fRequired
    else result := GetDictionaryField().Required;
end;

function TDACustomField.GetDisplayLabel: string;
begin
  if not HasValidDictionaryField
    then result := fDisplayLabel
    else result := GetDictionaryField().DisplayLabel;

  if (result='') then result := Name;
end;

function TDACustomField.GetDisplayWidth: integer;
begin
  if not HasValidDictionaryField
    then result := fDisplayWidth
    else result := GetDictionaryField().DisplayWidth;
end;

function TDACustomField.GetEditMask: string;
begin
  if not HasValidDictionaryField
    then result := fEditMask
    else result := GetDictionaryField().EditMask;
end;

function TDACustomField.GetReadOnly: boolean;
begin
  if not HasValidDictionaryField
    then result := fReadOnly
    else result := GetDictionaryField().ReadOnly;
end;

function TDACustomField.GetVisible: boolean;
begin
  if not HasValidDictionaryField
    then result := fVisible
    else result := GetDictionaryField().Visible;
end;

function TDACustomField.GetDisplayFormat: string;
begin
  if not HasValidDictionaryField
    then result := fDisplayFormat
    else result := GetDictionaryField().DisplayFormat;
end;

function TDACustomField.GetAlignment: TAlignment;
begin
  if not HasValidDictionaryField
    then result := fAlignment
    else result := GetDictionaryField().Alignment;
end;

function TDACustomField.GetEditFormat: string;
begin
  if not HasValidDictionaryField
    then result := fEditFormat
    else result := GetDictionaryField().EditFormat;
end;

procedure TDACustomField.SetInPrimaryKey(const Value: boolean);
begin
  fInPrimaryKey := Value
end;

procedure TDACustomField.SetRegExpression(const Value: string);
begin
  fRegExpression := Value
end;

procedure TDACustomField.LoadFromFile(const aFileName: string);
begin
  if (fField<>nil) then begin
    if (fField is TBlobField) then TBlobField(fField).LoadFromFile(aFileName)
  end
  else RaiseError(err_FieldIsNotBound);
end;

procedure TDACustomField.SaveToFile(const aFileName: string);
begin
  if (fField<>nil) then begin
    if (fField is TBlobField) then TBlobField(fField).SaveToFile(aFileName)
  end
  else RaiseError(err_FieldIsNotBound);
end;

procedure TDACustomField.LoadFromStream(const aStream: IROStream);
begin
  LoadFromStream(aStream.Stream);
end;

procedure TDACustomField.SaveToStream(const aStream: IROStream);
begin
  SaveToStream(aStream.Stream);
end;

function TDACustomField.GetValue: Variant;
begin
  if Assigned(fField) then begin
    if fField.IsNull then Result := Null else
    {$IFNDEF FPC}
      if fField is TWideStringField then result := TWideStringField(fField).Value else
    {$ENDIF}
    {$IFDEF DELPHI10UP}
      if fField is TWideMemoField then result := TWideMemoField(fField).Value else
    {$ENDIF DELPHI10UP}
      result := fField.Value;
  end
  else result := Null;
end;

procedure TDACustomField.SetValue(const Value: Variant);
var
  aDecimal: TDecimal;
begin
  if Assigned(fField) then begin
    {$IFNDEF FPC}
    if (fField is TWideStringField) and not VarIsNull( Value ) then
      TWideStringField(fField).Value := Value else
    {$ENDIF}
    {$IFDEF DELPHI10UP}
    if (fField is TWideMemoField) and not VarIsNull( Value ) then
      fField.AsWideString := Value else
    {$ENDIF DELPHI10UP}
    if (fField is TLargeintField) and not VarIsNull( Value ) then
      TLargeintField(fField).Value := Value else
    if VarByteArrayToDecimal(Value,aDecimal) then
      SetAsDecimal(DecimalToBCD(aDecimal)) else
    fField.Value := Value
  end
  else RaiseError(err_FieldIsNotBound);
end;

procedure TDACustomField.Bind(aField: TField);
begin
  fField := aField;

  if Assigned(fField) then begin
    fField.DisplayLabel := DisplayLabel;
    fField.DisplayWidth := DisplayWidth;
    {$IFNDEF FPC}
    fField.EditMask := EditMask;
    {$ENDIF FPC}
    fField.ReadOnly := ReadOnly;
    fField.Required := Required;
    fField.Visible := Visible;
    fField.Alignment := Alignment;

    if (fField is TNumericField) then begin
      TNumericField(fField).DisplayFormat := DisplayFormat;
      TNumericField(fField).EditFormat := EditFormat;
    end

    else if (fField is TDateTimeField) then begin
      TDateTimeField(fField).DisplayFormat := DisplayFormat
    end
{$IFNDEF FPC}
    else if (fField is TFMTBCDField) then begin
      TFMTBCDField(fField).Precision := DecimalPrecision;
      TFMTBCDField(fField).Size := DecimalScale;
    end

    else if (fField is TBCDField) then begin
      TBCDField(fField).Precision := DecimalPrecision;
      TBCDField(fField).Size := DecimalScale;
    end
{$ENDIF FPC}
    else if (fField is TBlobField) then begin
{$IFDEF DELPHI10UP}
      if TBlobField(fField).BlobType <> ftWideMemo then
{$ENDIF}
        TBlobField(fField).BlobType := BlobTypeMappings[BlobType];
     end;

    fField.OnValidate := InternalOnValidate;
    fField.OnChange := InternalOnChange;

    {fField.Lookup := Lookup;
    if (LookupSource<>NIL) then
      with TDADataSource(LookupSource) do
        if Assigned(DataTable)
          then fField.LookupDataSet := DataTable.Dataset;

    fField.LookupKeyFields := LookupKeyFields;
    fField.LookupCache := LookupCache;
    fField.LookupResultField := LookupResultField;
    fField.KeyFields := KeyFields;}
  end;
end;

procedure TDACustomField.Unbind;
begin
  if (fField=NIL) then Exit;

  fField.OnChange := nil;
  fField.OnSetText := nil;
  fField.OnGetText := nil;
  fField.OnValidate := nil;

  fField := nil;
end;

function TDACustomField.GetTableField: string;
begin
  result := fTableField
end;

procedure TDACustomField.SetTableField(const Value: string);
begin
  fTableField := Value;
end;

procedure TDACustomField.SetName(const Value: string);
var
  updatesc: boolean;
begin
  updatesc := (fTableField = '') or (fTableField = Name);

  inherited;

  if updatesc then fTableField := Value;
end;

function TDACustomField.GetCustomAttributes: TStrings;
begin
  result := fCustomAttributes
end;

procedure TDACustomField.SetCustomAttributes(const Value: TStrings);
begin
  fCustomAttributes.Assign(Value);
end;

procedure TDACustomField.Assign(Source: TPersistent);
begin
  if (Source is TDACustomField) then begin
    AssignField(TDACustomField(Source));
  end
  else begin
    inherited;
  end;
end;

procedure TDACustomField.AssignField(Source: TDABaseField);
var
  lSource: TDACustomField;
begin
  inherited;
  lSource := TDACustomField(Source);

  fField := nil; { Assigned DAField will always be unbound }
  fTableField := lSource.fTableField;
  fRequired := lSource.fRequired;
  fInPrimaryKey := lSource.fInPrimaryKey;
  fRegExpression := lSource.fRegExpression;
  fDefaultValue := lSource.fDefaultValue;
  fDictionaryEntry := lSource.fDictionaryEntry;
  fDisplayWidth := lSource.fDisplayWidth;
  fDisplayLabel := lSource.fDisplayLabel;
  fDisplayFormat := lSource.DisplayFormat;

  fReadOnly := lSource.fReadOnly;
  fVisible := lSource.fVisible;
  fEditMask := lSource.fEditMask;
  fLogChanges := lSource.fLogChanges;
  fCalculated := lSource.fCalculated;
  fServerCalculated := lSource.fServerCalculated;

  fEditFormat := lSource.EditFormat;
  fAlignment := lSource.Alignment;

  fOnChange := lSource.OnChange;
  {fOnGetText  := lSource.OnGetText;
  fOnSetText  := lSource.OnSetText;}
  fOnValidate := lSource.OnValidate;

  fLookupCache := lSource.LookupCache;
  fLookupKeyFields := lSource.LookupKeyFields;
  fLookupResultField := lSource.LookupResultField;
  fKeyFields := lSource.KeyFields;
  fLookupSource := lSource.LookupSource;
  fLookup := lSource.Lookup;

  //fCustomAttributes.Assign(lSource.fCustomAttributes);
  fCustomAttributes.Text := lSource.fCustomAttributes.Text;

  fServerAutoRefresh := lSource.ServerAutoRefresh;
  fGeneratorName := lSource.GeneratorName;

  fBusinessClassID := lSource.BusinessClassID;
end;

procedure TDACustomField.InternalOnChange(Sender: TField);
begin
  if not (Collection as TDACustomFieldCollection).FieldEventsDisabled then
  begin
    if assigned(TDACustomFieldCollection(Collection).OnFieldAfterUpdate) then
      TDACustomFieldCollection(Collection).OnFieldAfterUpdate(Self);
    if Assigned(fOnChange) then
      fOnChange(Self);
  end;
end;

procedure TDACustomField.InternalOnValidate(Sender: TField);
begin
  if not (Collection as TDACustomFieldCollection).FieldEventsDisabled then
  begin
    if assigned(TDACustomFieldCollection(Collection).OnFieldBeforeUpdate) then
      TDACustomFieldCollection(Collection).OnFieldBeforeUpdate(Self);
    if Assigned(fOnValidate) then
      fOnValidate(Self);
  end;
end;

function TDACustomField.IsCompatibleV4: boolean;
begin
  if Assigned(FieldCollection) then
    Result := FieldCollection.IsCompatibleV4
  else
    Result := inherited IsCompatibleV4;
end;

procedure TDACustomField.SetDisplayLabel(const aValue: string);
begin
  fDisplayLabel := aValue;
  if Assigned(fField) then fField.DisplayLabel := aValue;
end;

procedure TDACustomField.SetRequired(const aValue: boolean);
begin
  fRequired := aValue;
  if Assigned(fField) then fField.Required := aValue;
end;

procedure TDACustomField.SetVisible(const aValue: boolean);
begin
  fVisible := aValue;
  if Assigned(fField) then fField.Visible := aValue;
end;

procedure TDACustomField.SetDisplayWidth(const aValue: integer);
begin
  fDisplayWidth := aValue;
  if Assigned(fField) then fField.DisplayWidth := aValue;
end;

procedure TDACustomField.SetEditMask(const aValue: string);
begin
  fEditMask := aValue;
  {$IFNDEF FPC}
  if Assigned(fField) then fField.EditMask := aValue;
  {$ENDIF}
end;

procedure TDACustomField.SetReadOnly(const aValue: boolean);
begin
  fReadOnly := aValue;
  if Assigned(fField) then fField.ReadOnly := aValue;
end;

procedure TDACustomField.SetDisplayFormat(const Value: string);
begin
  fDisplayFormat := Value;
  if Assigned(fField) then begin
    if (fField is TNumericField) then
      TNumericField(fField).DisplayFormat := Value
    else if (fField is TDateTimeField) then
      TDateTimeField(fField).DisplayFormat := Value;
  end;
end;


function TDACustomField.StoredExpression: Boolean;
begin
  Result:= not IsCompatibleV4;
end;

function TDACustomField.StoreDisplayLabel: Boolean;
begin
  result := MergeDatadictionaries or (not HasValidDictionaryField()) and (fDisplayLabel <> '') and (fDisplayLabel <> Name);
end;


function TDACustomField.StoredServerCalculated: Boolean;
begin
  Result:= not IsCompatibleV4;
end;

function TDAField.GetDisplayName: string;
begin
  result := Format('%s [%s, %d', [fName, GetEnumName(TypeInfo(TDADataType), Ord(DataType)), Size]);

  if Required then
    result := result+', REQUIRED';

  result := result+']'
end;

function TDACustomField.GetOwner: TPersistent;
begin
  result := Collection;
end;

function TDACustomField.GetNamePath: string;
begin
  if (Collection <> nil) and (Collection.Owner <> nil) and (Collection.Owner is TComponent) then
    result := TComponent(Collection.Owner).Name + '.' + FName
  else
    result := FName;
end;

procedure TDACustomField.SetAlignment(const Value: TAlignment);
begin
  fAlignment := Value;
  if Assigned(fField) then fField.Alignment := Value;
end;

procedure TDACustomField.SetEditFormat(const Value: string);
begin
  fEditFormat := Value;

  if Assigned(fField) then begin
    if (fField is TNumericField) then TNumericField(fField).EditFormat := Value
  end;
end;

procedure TDACustomField.SetKeyFields(const Value: string);
begin
  fKeyFields := Value;
  if Assigned(fField)
    then fField.KeyFields := Value;
end;

procedure TDACustomField.SetLookupCache(const Value: boolean);
begin
  fLookupCache := Value;
  if Assigned(fField)
    then fField.LookupCache := Value;
end;

procedure TDACustomField.SetLookupKeyFields(const Value: string);
begin
  fLookupKeyFields := Value;
  if Assigned(fField)
    then fField.LookupKeyFields := Value;
end;

procedure TDACustomField.SetLookupResultField(const Value: string);
begin
  fLookupResultField := Value;
  if Assigned(fField)
    then fField.LookupResultField := Value;
end;

procedure TDACustomField.SetLookupSource(const Value: TDataSource);
begin
  if Assigned(Value) and not (Value is TDABaseDataSource) then raise Exception.Create('LookupSource must be a TDADataSource');

  fLookupSource := Value;
  if Assigned(fField) then
    if Assigned(Value)
      then fField.LookupDataSet := Value.DataSet
      else fField.LookupDataSet := nil;
end;

procedure TDACustomField.SetCalculated(const Value: boolean);
begin
  fCalculated := Value;
  if Value then begin
    fLookup := FALSE;
    fServerCalculated := false;
  end;
end;

procedure TDACustomField.SetLookup(const Value: boolean);
begin
  fLookup := Value;
  if Value then begin
    fCalculated := FALSE;
  end;
end;

function TDACustomField.GetFieldCollection: TDACustomFieldCollection;
begin
  result := TDACustomFieldCollection(Collection);
end;

procedure TDACustomField.SetBlobType(const Value: TDABlobType);
begin
  inherited;

  if Assigned(fField) and (fField is TBlobField)
    then TBlobField(fField).BlobType := BlobTypeMappings[Value];
end;

function TDACustomField.GetServerAutoRefresh: boolean;
begin
  result := fServerAutoRefresh
end;

procedure TDACustomField.SetServerAutoRefresh(const Value: boolean);
begin
  fServerAutoRefresh := Value;
end;

function TDACustomField.GetLogChanges: boolean;
begin
  if not HasValidDictionaryField
    then result := fLogChanges
    else result := GetDictionaryField().fLogChanges;
  result := Result and not (fCalculated or fLookup)
end;

function TDACustomField.StoreProperties: boolean;
begin
  result := MergeDatadictionaries or not HasValidDictionaryField();
end;

function TDACustomField.GetOldValue: Variant;
begin
  if Assigned(fField)
    then result := fField.OldValue
    else result := Unassigned;
end;

function TDACustomField.GetSQLOrigin: string;
begin
  if fSQLOrigin=''
    then result := TableField
    else result := fSQLOrigin;
end;

procedure TDACustomField.FocusControl;
begin
  if Assigned(fField)
    then fField.FocusControl;
end;

{procedure TDACustomField.SetBusinessRulesID(const Value: string);
begin
  BusinessClassID := Value;
end;

function TDACustomField.GetBusinessRulesID: string;
begin
  result := BusinessClassID;
end;}

function TDACustomField.GetBusinessClassID: string;
begin
  if not HasValidDictionaryField
    then result := fBusinessClassID
    else result := GetDictionaryField().BusinessClassID;
end;

procedure TDACustomField.SetBusinessClassID(const Value: string);
begin
  fBusinessClassID := Value;
end;

procedure TDACustomField.LoadFromStream(const aStream: TStream);
begin
  if (fField<>nil) then begin
    if (fField is TBlobField) then TBlobField(fField).LoadFromStream(aStream)
  end
  else RaiseError(err_FieldIsNotBound);
end;

procedure TDACustomField.SaveToStream(const aStream: TStream);
begin
  if (fField<>nil) then begin
    if (fField is TBlobField) then TBlobField(fField).SaveToStream(aStream)
  end
  else RaiseError(err_FieldIsNotBound);
end;

function TDACustomField.GetBlobSize: Integer;
begin
  if fField is TBlobField then
    result := TBlobField(fField).BlobSize
  else
    Result := 0;
end;

procedure TDACustomField.SetServerCalculated(const Value: Boolean);
begin
  fServerCalculated := Value;
  if Value then begin
    Readonly := True;
    LogChanges := False;
    Calculated := False;
    InPrimaryKey := False;
  end;
end;

procedure TDACustomField.SetExpression(const Value: string);
begin
  fExpression := Value;
  if value <> '' then
    Calculated := true; // will unset lookup & server calculated
end;

function TDACustomField.GetAsBoolean: boolean;
begin
  if Assigned(fField) then
    Result:= fField.AsBoolean
  else
    Result:= inherited GetAsBoolean;
end;

function TDACustomField.GetAsCurrency: currency;
begin
  if Assigned(fField) then
    Result:= fField.AsCurrency
  else
    Result:= inherited GetAsCurrency;
end;

function TDACustomField.GetAsDateTime: TDateTime;
begin
  if Assigned(fField) then
    Result:= fField.AsDateTime
  else
    Result:= inherited GetAsDateTime;
end;

function TDACustomField.GetAsFloat: double;
begin
  if Assigned(fField) then
    Result:= fField.AsFloat
  else
    Result:= inherited GetAsFloat;
end;

function TDACustomField.GetAsInteger: integer;
begin
  if Assigned(fField) then
    Result:= fField.AsInteger
  else
    Result:= inherited GetAsInteger;
end;

function TDACustomField.GetAsLargeInt: int64;
begin
  if Assigned(fField) and (fField.DataType = ftLargeInt) then
    Result:= TLargeintField(fField).AsLargeint
  else
    result:= inherited GetAsLargeInt;
end;

function TDACustomField.GetAsString: string;
begin
  if Assigned(fField) then
    Result:= fField.AsString
  else
    Result:= inherited GetAsString;
end;

function TDACustomField.GetAsVariant: variant;
begin
  if Assigned(fField) then
    Result:= fField.AsVariant
  else
    Result:= inherited GetAsVariant;
end;

function TDACustomField.GetAsWideString: Widestring;
begin
  if Assigned(fField) and (fField.DataType = ftWideString) then begin
    if GetIsNull then
      Result:=''
    else
     {$IFNDEF FPC}
      Result := TWideStringField(fField).Value;
     {$ELSE}
      REsult:= inherited GetAsWideString;
     {$ENDIF}
  end
  {$IFDEF DELPHI10UP}
  else if Assigned(fField) and (fField.DataType = ftWideMemo) then
    Result := TWideMemoField(fField).Value
  {$ENDIF}
  else
    Result := inherited GetAsWideString;
end;

function TDACustomField.GetIsNull: boolean;
begin
  if Assigned(fField) then
    Result:= fField.IsNull
  else
    Result:= inherited GetIsNull;
end;

procedure TDACustomField.SetAsBoolean(const aValue: boolean);
begin
  if Assigned(fField) then 
    fField.AsBoolean := aValue
  else
    inherited SetAsBoolean(aValue);  
end;

procedure TDACustomField.SetAsCurrency(const aValue: currency);
begin
  if Assigned(fField) then
    fField.AsCurrency := aValue
  else
    inherited SetAsCurrency(aValue);
end;

procedure TDACustomField.SetAsDateTime(const aValue: TDateTime);
begin
  if Assigned(fField) then
    fField.AsDateTime := aValue
  else
    inherited SetAsDateTime(aValue);
end;

procedure TDACustomField.SetAsFloat(const aValue: double);
begin
  if Assigned(fField) then
    fField.AsFloat := aValue
  else
    inherited SetAsFloat(aValue);  
end;

procedure TDACustomField.SetAsInteger(const aValue: integer);
begin
  if Assigned(fField) then 
    fField.AsInteger := aValue
  else
    inherited SetAsInteger(aValue);  
end;

procedure TDACustomField.SetAsLargeInt(const aValue: Int64);
begin
  if Assigned(fField) and (fField.DataType = ftLargeInt) then
    TLargeintField(fField).AsLargeInt := aValue
  else
    inherited SetAsLargeInt(aValue);
end;

procedure TDACustomField.SetAsString(const aValue: string);
begin
  if Assigned(fField) then
    fField.AsString := aValue
  else
    inherited SetAsString(aValue);
end;

procedure TDACustomField.SetAsVariant(const aValue: variant);
begin
  if Assigned(fField) then
    fField.AsVariant := aValue
  else
    inherited SetAsVariant(aValue);
end;

procedure TDACustomField.SetAsWideString(const aValue: Widestring);
begin
{$IFNDEF FPC}
  if (fField<>nil) and (fField.DataType = ftWideString) then TWideStringField(fField).Value := aValue else
{$ENDIF}
{$IFDEF DELPHI10UP}
  if (fField<>nil) and (fField.DataType = ftWideMemo) then TWideMemoField(fField).Value := aValue else
{$ENDIF}
  inherited SetAsWideString(aValue);
end;

function TDACustomField.GetAsByte: Byte;
begin
  Result := GetAsSmallInt;
end;

function TDACustomField.GetAsCardinal: Cardinal;
begin
  Result := GetAsInteger;
end;

function TDACustomField.GetAsDecimal: TBcd;
begin
{$IFNDEF FPC}
  if Assigned(fField) and (fField.DataType = ftFmtBcd) then
    result := TFMTBCDField(fField).AsBCD
  else
{$ENDIF}
    result := inherited GetAsDecimal;
end;

function TDACustomField.GetAsGuid: TGUID;
begin
{$IFNDEF FPC}
  if Assigned(fField) and (fField.DataType = ftGuid) then
    result := TGuidField(fField).AsGuid
  else
{$ENDIF}
    result := inherited GetAsGuid;
end;

function TDACustomField.GetAsLargeUInt: Int64;
begin
  result := GetAsLargeInt;
end;

function TDACustomField.GetAsShortInt: ShortInt;
begin
  Result := GetAsSmallInt;
end;

function TDACustomField.GetAsSingle: Single;
begin
  if Assigned(fField) then
    result := fField.AsFloat
  else
    Result := inherited GetAsSingle;
end;

function TDACustomField.GetAsSmallInt: SmallInt;
begin
  if Assigned(fField) and (fField.DataType = ftSmallint) then
    result := TSmallintField(fField).Value
  else
    result := inherited GetAsSmallInt;
end;

function TDACustomField.GetAsWord: Word;
begin
  if Assigned(fField) and (fField.DataType = ftWord) then
    result := TWordField(fField).AsInteger
  else
    result := inherited GetAsWord;
end;

function TDACustomField.GetAsXml: IXMLNode;
var
  s: string;
  lDoc: IXMLDocument;
begin
  s := GetAsWideString;
  if s = '' then result := nil else begin
    lDoc := NewROXmlDocument;
    lDoc.New;
    lDoc.XML := s;
    Result := lDoc.DocumentNode;
  end;
end;

procedure TDACustomField.SetAsByte(const Value: Byte);
begin
  SetAsSmallInt(Value);
end;

procedure TDACustomField.SetAsCardinal(const Value: Cardinal);
begin
  SetAsInteger(Value);
end;

procedure TDACustomField.SetAsDecimal(const Value: TBcd);
begin
{$IFNDEF FPC}
  if (fField<>nil) and (fField.DataType = ftFMTBcd) then
    TFMTBCDField(fField).Value := Value
  else
{$ENDIF}
    inherited SetAsDecimal(Value);
end;

procedure TDACustomField.SetAsGuid(const Value: TGUID);
begin
{$IFNDEF FPC}
  if (fField<>nil) and (fField.DataType = ftGuid) then
    TGuidField(fField).AsGuid := Value
  else
{$ENDIF}
    inherited SetAsGuid(Value);
end;

procedure TDACustomField.SetAsLargeUInt(const Value: Int64);
begin
  SetAsLargeInt(Value);
end;

procedure TDACustomField.SetAsShortInt(const Value: ShortInt);
begin
  SetAsSmallInt(Value);
end;

procedure TDACustomField.SetAsSingle(const Value: Single);
begin
  if Assigned(fField) then 
    SetAsFloat(Value)
  else
    inherited SetAsSingle(Value);  
end;

procedure TDACustomField.SetAsSmallInt(const Value: SmallInt);
begin
  if Assigned(fField) and (fField.DataType = ftSmallint) then
    TSmallintField(fField).Value := Value
  else
    inherited SetAsSmallInt(Value);
end;

procedure TDACustomField.SetAsWord(const Value: Word);
begin
  if Assigned(fField) and (fField.DataType = ftWord) then
    TWordField(fField).AsInteger := Value
  else
    inherited SetAsWord(Value);
end;

procedure TDACustomField.SetAsXml(const Value: IXMLNode);
begin
  if (Value = nil) then
    AsVariant := Null
  else begin
    SetAsWideString(Value.Xml);
  end;
end;

procedure TDACustomField.SetDecimalPrecision(const Value: Integer);
begin
  inherited;
  if Assigned(fField) then begin
{$IFNDEF FPC}
    if fField is TFMTBCDField then TFMTBCDField(fField).Precision:=Value
    else if fField is TBCDField then TBCDField(fField).Precision:=Value;
{$ENDIF FPC}
  end;
end;

function TDACustomField.GetDecimalPrecision: Integer;
begin
  Result:=inherited GetDecimalPrecision;
  if Assigned(fField) then begin
{$IFNDEF FPC}
    if fField is TFMTBCDField then Result := TFMTBCDField(fField).Precision
    else if fField is TBCDField then Result := TBCDField(fField).Precision;
{$ENDIF FPC}
  end;
end;

function TDACustomField.GetDecimalScale: Integer;
begin
  Result:=inherited GetDecimalScale;
  if Assigned(fField) then begin
{$IFNDEF FPC}
    if fField is TFMTBCDField then Result := TFMTBCDField(fField).Size
    else if fField is TBCDField then Result := TBCDField(fField).Size;
{$ENDIF FPC}
  end;
end;

procedure TDACustomField.SetDecimalScale(const Value: Integer);
begin
  inherited;
  if Assigned(fField) then begin
{$IFNDEF FPC}
    if fField is TFMTBCDField then TFMTBCDField(fField).Size:=Value
    else if fField is TBCDField then TBCDField(fField).Size:=Value;
{$ENDIF FPC}
  end;
end;

{ TDACustomFieldCollection }

constructor TDACustomFieldCollection.Create(aOwner: TPersistent; aFieldClass: TDAFieldClass);
begin
  inherited Create(aOwner, aFieldClass);
end;

function TDACustomFieldCollection.Add: TDAField;
begin
  result := TDAField(inherited Add);
end;

function TDACustomFieldCollection.Add(const aName: string; aType: TDADataType; aSize: integer): TDACustomField;
begin
  result := Add;
  result.Name := aName;
  result.DataType := aType;
  result.Size := aSize;
end;

procedure TDACustomFieldCollection.Bind(aDataset: TDataset);
var
  i: integer;
  lDAField: TDACustomField;
  lField: TField;
begin
  Check(aDataset = nil, err_InvalidDataset);
  try
    for i := 0 to (Count - 1) do begin
      lDAField := Fields[i];
      lField := aDataset.FindField(lDAField.SQLOrigin);
      if (not Assigned(lField)) and (not lDAField.Calculated) and not (lDAField.ServerCalculated) and not (lDAField.Lookup) then
        RaiseError(err_CannotFindField, [lDAField.SQLOrigin])
      else
        lDAField.Bind(lField);
    end;
  except
    Unbind;
    raise;
  end;
end;

procedure TDACustomFieldCollection.Assign(Source: TPersistent);
begin
  if (Source is TDACustomFieldCollection) then begin
    AssignFieldCollection(TDACustomFieldCollection(Source));
  end
  else
    inherited;
end;

procedure TDACustomFieldCollection.AssignFieldCollection(Source: TDACustomFieldCollection);
var
  i: integer;
  src: TDACustomFieldCollection;
  fld: TDAField;
begin
  src := TDACustomFieldCollection(Source);

  Clear;

  if not Assigned(Source) then Exit;

  for i := 0 to (src.Count - 1) do begin
    fld := Add;
    fld.AssignField(src[i]);
  end;
end;

function TDACustomFieldCollection.FieldByName(const aName: string): TDACustomField;
begin
  result := TDACustomField(inherited ItemByName(aName))
end;

function TDACustomFieldCollection.FindField(const aName: string): TDACustomField;
begin
  result := TDACustomField(inherited FindItem(aName))
end;

function TDACustomFieldCollection.GetFields(Index: integer): TDACustomField;
begin
  result := TDACustomField(inherited Items[Index])
end;

procedure TDACustomFieldCollection.SetFields(Index: integer; const Value: TDACustomField);
begin
  Fields[Index].Assign(Value);
end;

procedure TDACustomFieldCollection.Unbind;
var
  i: integer;
begin
  for i := 0 to (Count - 1) do
    Fields[i].Unbind;
end;

{ TDAFieldCollection }

constructor TDAFieldCollection.Create(aOwner: TPersistent);
begin
  inherited Create(aOwner, TDAField);
end;

function TDAFieldCollection.FieldByName(const aName: string): TDAField;
begin
  result := TDAField(inherited ItemByName(aName))
end;

function TDAFieldCollection.FindField(const aName: string): TDAField;
begin
  result := TDAField(inherited FindItem(aName))
end;

function TDAFieldCollection.GetFields(Index: integer): TDAField;
begin
  result := TDAField(inherited Items[Index])
end;

procedure TDAFieldCollection.SetFields(Index: integer; const Value: TDAField);
begin
  Fields[Index].Assign(Value);
end;

{ TDAParam }

function TDAParam.GetParamType: TDAParamType;
begin
  result := fParamType;
end;

procedure TDAParam.LoadFromFile(const aFileName: string);
begin
  LoadFromStream(NewROStream(TFileStream.Create(aFileName, fmOpenRead), TRUE));
end;

procedure TDAParam.SaveToFile(const aFileName: string);
begin
  SaveToStream(NewROStream(TFileStream.Create(aFileName, fmCreate), TRUE));
end;

procedure TDAParam.LoadFromStream(const aStream: IROStream);
begin
  Value := VariantBinaryFromRawBinary(aStream.Stream);
end;

procedure TDAParam.SaveToStream(const aStream: IROStream);
begin
  VariantBinaryToRawBinary(Value, aStream.Stream);
end;

procedure TDAParam.SetParamType(Value: TDAParamType);
begin
  fParamType := Value;
end;

procedure TDAParam.AssignField(Source: TDABaseField);
begin
  inherited;
  if Source is TDAParam then
    ParamType := TDAParam(Source).ParamType;
end;

{ TDAParamCollection }

function TDAParamCollection.Add: TDAParam;
begin
  result := TDAParam(inherited Add)
end;

constructor TDAParamCollection.Create(aOwner: TPersistent);
begin
  inherited Create(aOwner, TDAParam);
end;

function TDAParamCollection.FindParam(
  const aParamName: string): TDAParam;
begin
  result := TDAParam(inherited FindItem(aParamName));
end;

function TDAParamCollection.GetParams(Index: integer): TDAParam;
begin
  result := TDAParam(inherited Items[Index])
end;

function TDAParamCollection.ParamByName(const aName: string): TDAParam;
begin
  result := TDAParam(inherited ItembyName(aName))
end;

procedure TDAParamCollection.ReadValues(InputParams: TParams);
var
  i: integer;
  par: TDAParam;
begin
  for i := 0 to (Count - 1) do begin
    par := Params[i];
    par.Value := InputParams.ParamByName(par.Name).Value;
  end;
end;

procedure TDAParamCollection.SetParams(Index: integer; const Value: TDAParam);
begin
  Params[Index].Assign(Value);
end;

procedure TDAParamCollection.WriteValues(OutputParams: TParams);
var
  i: integer;
  par: TDAParam;
  outpar: TParam;
begin
  for i := 0 to (Count - 1) do begin
    par := Params[i];
    outpar := OutputParams.ParamByName(par.Name);
    if par.DataType = datBlob then begin
      outpar.DataType := ftBlob;
      outpar.Value := VariantBinaryToString(par.Value);
      { ToDo: make sure this is valid for ALL Data Drivers, only tested with IBX so far. mh. }
    end
    else begin
      outpar.Value := par.Value;
    end;
    //outpar.Size := par.Size; // Seems to fix an ADO problem with size of parameters with SDAC
  end;
end;

procedure TDAParamCollection.Assign(Source: TPersistent);
begin
  if (Source is TDAParamCollection) then begin
    AssignParamCollection(TDAParamCollection(Source))
  end
  else
    inherited;
end;

procedure TDAParamCollection.AssignParamCollection(Source: TDAParamCollection);
var
  i: integer;
begin
  Clear;
  for i := 0 to (Source.Count - 1) do
    Add.AssignField(Source[i]);
end;

function TDAParamCollection.GetHasInputParams: boolean;
var
  i: Integer;
begin
  result := false;
  for i := 0 to Count-1 do begin
    if Params[i].ParamType in [daptUnknown, daptInput, daptInputOutput] then begin
      result := true;
      exit;
    end;
  end; { for }
end;

{ TDASQLCommand }

procedure TDASQLCommand.Assign(aSource: TPersistent);
var
  lSource: TDASQLCommand;
begin
  if (aSource is TDASQLCommand) then begin
    lSource := TDASQLCommand(aSource);
    fName := lSource.fName;
    fDescription := lSource.fDescription;
    fStatements.Assign(lSource.fStatements);
    fParams.Assign(lSource.fParams);
    fCustomAttributes.Assign(lSource.CustomAttributes);
  end
  else begin
    inherited;
  end;
end;

constructor TDASQLCommand.Create(Collection: TCollection);
begin
  inherited;
  fIsPublic := true;
  fStatements := TDAStatementCollection.Create(nil, Self);
  fParams := TDAParamCollection.Create(nil);
  fCustomAttributes := TStringList.Create;
end;

destructor TDASQLCommand.Destroy;
begin
  fCustomAttributes.Free;
  fStatements.Free;
  fParams.Free;

  inherited;
end;

function TDASQLCommand.GetDisplayName: string;
begin
  result := Name;
end;

function TDASQLCommand.GetParams: TDAParamCollection;
begin
  result := fParams;
end;

function TDASQLCommand.GetSQLCommandCollection: TDASQLCommandCollection;
begin
  result := TDASQLCommandCollection(Collection);
end;

function TDASQLCommand.ParamByName(const aName: string): TDAParam;
begin
  result := fParams.ParamByName(aName)
end;

procedure TDASQLCommand.SetCustomAttributes(const Value: TStrings);
begin
  fCustomAttributes.Assign(Value);
end;

procedure TDASQLCommand.SetDisplayName(const Value: string);
begin
  inherited;
  SetName(Value);
end;

procedure TDASQLCommand.SetName(const Value: string);
var
  lOldName: string;
begin
  lOldName := fName;
  fName := Value;
  if lOldName <> '' then
    (Collection as TSearcheableCollection).TriggerOnItemRenamed(lOldName, fName);
end;

procedure TDASQLCommand.SetParams(const Value: TDAParamCollection);
begin
  fParams.Assign(Value);
end;

procedure TDASQLCommand.SetStatements(const Value: TDAStatementCollection);
begin
  fStatements.Assign(Value);
end;

function TDASQLCommand.GetStatements(): TDAStatementCollection;
begin
  result := fStatements;
end;


{ TDADataset }

procedure TDADataset.Assign(aSource: TPersistent);
var
  lSource: TDADataset;
begin
  if (aSource is TDADataset) then begin
    inherited; { Need to work the TDASQLCommand, too}
    lSource := TDADataset(aSource);
    fFields.Assign(lSource.Fields);
  end
  else begin
    inherited;
  end;
end;

constructor TDADataset.Create(Collection: TCollection);
begin
  inherited;
  fFields := TDAFieldCollection.Create(self);
  fBusinessRulesServer := TDABusinessRuleScript.Create();
  fBusinessRulesClient := TDAClientBusinessRuleScript.Create();
end;

destructor TDADataset.Destroy;
begin
  FreeAndNil(fFields);
  FreeAndNil(fBusinessRulesServer);
  FreeAndNil(fBusinessRulesClient);
  inherited;
end;

function TDADataset.FieldByName(const aName: string): TDAField;
begin
  result := Fields.FieldByName(aName)
end;

function TDADataset.FindField(const aName: string): TDAField;
begin
  result := Fields.FindField(aName)
end;

procedure TDADataset.SetBusinessRulesClient(const Value: TDAClientBusinessRuleScript);
begin
  fBusinessRulesClient.Assign(Value);
end;

procedure TDADataset.SetBusinessRulesServer(const Value: TDABusinessRuleScript);
begin
  fBusinessRulesServer.Assign(Value);
end;

procedure TDADataset.SetFields(const Value: TDAFieldCollection);
begin
  fFields.Assign(Value);
end;

{ TDASQLCommandCollection }

function TDASQLCommandCollection.Add: TDASQLCommand;
begin
  result := TDASQLCommand(inherited Add)
end;

constructor TDASQLCommandCollection.Create(aOwner: TComponent);
begin
  inherited Create(aOwner, GetItemClass);
end;

function TDASQLCommandCollection.GetItemClass: TDASQLCommandClass;
begin
  result := TDASQLCommand;
end;

function TDASQLCommandCollection.GetSQLCommands(
  Index: integer): TDASQLCommand;
begin
  result := TDASQLCommand(inherited Items[Index]);
end;

procedure TDASQLCommandCollection.SetSQLCommands(Index: integer;
  const Value: TDASQLCommand);
begin
  SQLCommands[Index].Assign(Value);
end;

function TDASQLCommandCollection.SQLCommandByName(
  const aName: string): TDASQLCommand;
begin
  result := TDASQLCommand(inherited ItemByName(aName));
end;

{ TDADatasetCollection }

function TDADatasetCollection.Add: TDADataset;
begin
  result := TDADataset(inherited Add);
end;

function TDADatasetCollection.DatasetByName(const aName: string): TDADataset;
begin
  result := TDADataset(inherited ItemByName(aName));
end;

function TDADatasetCollection.FindDatasetByName(const aName: string): TDADataset;
begin
  result := TDADataset(inherited FindItem(aName));
end;

function TDADatasetCollection.GetDatasets(Index: integer): TDADataset;
begin
  result := TDADataset(inherited Items[Index]);
end;

function TDADatasetCollection.GetItemClass: TDASQLCommandClass;
begin
  result := TDADataset;
end;

procedure TDADatasetCollection.SetDatasets(Index: integer;
  const Value: TDADataset);
begin
  Datasets[Index].Assign(Value);
end;

{ TDAConnectionCollection }

function TDAConnectionCollection.Add: TDAConnection;
begin
  result := TDAConnection(inherited Add);
end;

procedure TDAConnectionCollection.ClearDefaults(iExceptFor: TDAConnection);
var
  i: integer;
begin
  for i := 0 to Count - 1 do begin
    if (Connections[i] <> iExceptFor) then Connections[i].Default := false;
  end;
end;

function TDAConnectionCollection.ConnectionByName(
  const aName: string): TDAConnection;
begin
  result := TDAConnection(inherited ItemByName(aName));
end;

constructor TDAConnectionCollection.Create(aOwner: TPersistent);
begin
  inherited Create(aOwner, TDAConnection);
end;

function TDAConnectionCollection.FindConnection(const aName,
  aType: string): TDAConnection;
var
  i: Integer;
begin
  if aName <> '' then begin
    for i := 0 to Count -1 do begin
      if GetConnections(i).Name = aName then begin
        Result := GetConnections(i);
        exit;
      end;
    end;
  end;
  if aType <> '' then begin
    for i := 0 to Count -1 do begin
      if GetConnections(i).ConnectionType = aType then begin
        Result := GetConnections(i);
        exit;
      end;
    end;
  end;
  result := nil;
end;

function TDAConnectionCollection.GetConnections(
  Index: integer): TDAConnection;
begin
  result := TDAConnection(inherited Items[Index]);
end;

function TDAConnectionCollection.GetDefaultConnection: TDAConnection;
begin
  result := inherited GetDefaultItem as TDAConnection;
end;

function TDAConnectionCollection.ItemName: string;
begin
  result := 'connection';
end;

procedure TDAConnectionCollection.SetConnections(Index: integer;
  const Value: TDAConnection);
begin
  Connections[Index].Assign(Value);
end;

{ TDAConnection }

procedure TDAConnection.Assign(aSource: TPersistent);
var
  lSource: TDAConnection;
begin
  if (aSource is TDAConnection) then begin
    lSource := TDAConnection(aSource);
    fDescription := lSource.fDescription;
    ConnectionString := lSource.ConnectionString;
    ConnectionType := lSource.ConnectionType;
    fName := '_____' + lSource.fName;
    fDefault := false;
  end
  else begin
    inherited;
  end;
end;

function TDAConnection.GetConnectionString: string;
begin
  result := fConnectionString;
end;

function TDAConnection.GetDisplayName: string;
begin
  if (Trim(Name) = '') then
    result := '<Noname>'
  else
    result := Name;

  //if Default then result := result+' - [Default]';
end;

procedure TDAConnection.SetConnectionString(const aValue: string);
begin
  if fConnectionString <> aValue then
    fConnectionString := aValue;
end;

procedure TDAConnection.SetDefault(const Value: boolean);
begin
  if (fDefault <> Value) then begin
    fDefault := Value;
    if Default then begin
      (Collection as TDAConnectionCollection).ClearDefaults(self);
    end;
  end;
end;

procedure TDAConnection.SetDisplayName(const Value: string);
begin
  inherited;
  SetName(Value);
end;

procedure TDAConnection.SetName(const Value: string);
var
  lOldName: string;
begin
  if (Value <> fName) then begin
    lOldName := fName;
    fName := Value;
    if lOldName <> '' then
      (Collection as TDAConnectionCollection).TriggerOnItemRenamed(lOldName, fName);
  end;
end;

{ TDAStatement }

procedure TDAStatement.Assign(aSource: TPersistent);
var
  lSource: TDAStatement;
begin
  if (aSource is TDAStatement) then begin
    lSource := TDAStatement(aSource);
    fSQL := lSource.fSQL;
    fStatementType := lSource.fStatementType;
    fConnection := lSource.fConnection;
    fColumnMappings.Assign(lSource.fColumnMappings);
    fTargetTable := lSource.fTargetTable;
  end
  else begin
    inherited;
  end;
end;

constructor TDAStatement.Create(Collection: TCollection);
begin
  inherited;
  fColumnMappings := TDAColumnMappingCollection.Create(Self);
end;

destructor TDAStatement.Destroy;
begin
  fColumnMappings.Free;

  inherited;
end;

function TDAStatement.GetNeedsParams: boolean;
var
  lParams: TParams;
  lSQL: string;
begin
  lParams := TParams.Create;
  try
    { Bug in ParseSQL modified passed in string; use UniqueString to prevent
      corrupting the original! }
    lSQL := SQL;
    UniqueString(lSQL);
    lParams.ParseSQL(lSQL, TRUE);
    result := (lParams.Count > 0);
  finally
    lParams.Free;
  end;
end;

function TDAStatement.GetStatementCollection: TDAStatementCollection;
begin
  result := TDAStatementCollection(Collection);
end;

procedure TDAStatement.SetColumnMappings(
  const Value: TDAColumnMappingCollection);
begin
  fColumnMappings.Assign(Value);
end;

procedure TDAStatement.SetSQL(const Value: string);
begin
  fSQL := Value;
end;

function TDAStatement.StoreSQL: Boolean;
begin
  Result := fStatementType <> stAutoSQL; 
end;

{ TDAColumnMappingCollection }

function TDAColumnMappingCollection.Add: TDAColumnMapping;
begin
  result := TDAColumnMapping(inherited Add);
end;

procedure TDAColumnMappingCollection.AssignColumnMapping(aSource: TPersistent);
var
  i: Integer;
begin
  Clear;
  for i := 0 to TDAColumnMappingCollection(aSource).Count -1 do begin
    Add.AssignFieldMapping(TDAColumnMappingCollection(aSource)[i]);
  end;
end;

constructor TDAColumnMappingCollection.Create(aOwner: TPersistent);
begin
  inherited Create(aOwner, TDAColumnMapping);
end;

function TDAColumnMappingCollection.FindMappingByDatasetField(
  const aDatasetField: string): TDAColumnMapping;
var
  i: integer;
begin
  result := nil;

  for i := 0 to (Count - 1) do
    if SameText(ColumnMappings[i].DatasetField, aDatasetField) then begin
      result := ColumnMappings[i];
      Exit;
    end;
end;

function TDAColumnMappingCollection.GetColumnMappings(
  Index: integer): TDAColumnMapping;
begin
  result := TDAColumnMapping(inherited Items[Index])
end;

function TDAColumnMappingCollection.GetItemName(
  anItem: TCollectionItem): string;
begin
  result := TDAColumnMapping(anItem).DatasetField;
end;

function TDAColumnMappingCollection.MappingByDatasetField(
  const aDatasetField: string): TDAColumnMapping;
begin
  result := TDAColumnMapping(inherited ItemByName(aDatasetField))
end;

function TDAColumnMappingCollection.MappingByTableField(
  const aTableField: string): TDAColumnMapping;
var
  i: integer;
begin
  result := nil;

  for i := 0 to (Count - 1) do
    if SameText(ColumnMappings[i].TableField, aTableField) then begin
      result := ColumnMappings[i];
      Exit;
    end;

  RaiseError('Cannot find mapping for table field %s', [aTableField]);
end;

procedure TDAColumnMappingCollection.SetColumnMappings(Index: integer;
  const Value: TDAColumnMapping);
begin
  TDAColumnMapping(inherited Items[Index]).AssignTo(Value);
end;

function TDAColumnMappingCollection.SetItemName(anItem: TCollectionItem;
  const aName: string): string;
begin
  TDAColumnMapping(anItem).DatasetField := aName;
end;

{ TDAWhere }

function TDAWhere.GetProperName(aField: TDACustomField) : string;
begin
  if fClientFields
    then result := ClientFieldPrefix+aField.Name
    else result := aField.TableField
end;

function TDAWhere.AddCondition(const FieldName: string;
  Condition: TDASQLCondition; const Value: Variant; SkipIfEmptyValue: boolean = TRUE): boolean;
var
  isstr, isnull, isfloat, isCurr: boolean;
  fld: TDACustomField;
  fieldnametouse : string;
  str: string;
  oldDecimalSeparator: Char;
begin
  result := FALSE;

  fld := fFields.FindField(FieldName);

  isnull := VarIsNull(Value) or (VarIsType(Value, [varString, varOleStr]) and (Value = ''))
  or (VarIsType(Value, [varDate]) and (Value = 0));
  if isnull and SkipIfEmptyValue then Exit;
  if fLastWasCondition then
  begin
    case fDefaultOperator of
      doAnd: AddOperator(opAND);
      doOr: AddOperator(opOR);
    end;
  end;
  fLastWasCondition := True;

  if fld <> nil then
    fieldnametouse := GetProperName(fld) // Changed by AleF: WHERE clauses cannot work with field aliases like "FieldA as XYZ"
      else
    fieldnametouse := FieldName;

  fClause := fClause + '(' + fieldnametouse + ' ' + StrSQLCondition[Condition] + ' ';

  isstr := (fld <> nil) and (fld.DataType in [datWideString, datWideMemo, datString, datDateTime, datMemo]);
  isfloat := (fld <> nil) and (fld.DataType in [datFloat, datSingleFloat]);
  isCurr :=(fld <> nil) and (fld.DataType in [datCurrency]);

  case Condition of
    cIsNull, cIsNotNull:begin
        fClause := TrimRight(fClause) + ')';
      end;
    else begin
        if isstr then begin
          str:=VarToStr(Value);
          if Condition = cIn then
            fClause := fClause + '(' + str + '))'
          else
            fClause := fClause + '''' + str + ''')'
        end
        else begin
          if isfloat or isCurr then begin
            oldDecimalSeparator := DecimalSeparator;
            DecimalSeparator := '.';
            try
              if isfloat then str:= FloatToStr(Value)
              else str:=CurrToStrF(Value,ffGeneral,4);
            finally
              DecimalSeparator := oldDecimalSeparator;
            end;
          end
          else
            str:=VarToStr(Value);
          if Condition = cIn then
            fClause := fClause + '(' + str + '))'
          else
            fClause := fClause + str + ')';
        end;
      end;
  end;
  result := TRUE;
  Changed := True;

  if Assigned(OnChange) then OnChange(Self);
end;

procedure TDAWhere.AddValueGroup(const FieldName: string;
  const Values: array of Variant);
var
  fld: TDAField;
  isstr: boolean;
  cnt, i: integer;
  fieldnametouse : string;
begin
  fld := fFields.FieldByName(FieldName);

  if fLastWasCondition then
  begin
    case fDefaultOperator of
      doAnd: AddOperator(opAND);
      doOr: AddOperator(opOR);
    end;
  end;
  fLastWasCondition := True;

  fieldnametouse := GetProperName(fld); // Changed by AleF: WHERE clauses cannot work with field aliases like "FieldA as XYZ"

  if (Length(Values) > 0) then begin
    isstr := (fld.DataType in [datWideString, datWideMemo, datString, datDateTime, datMemo]);

    fClause := fClause + '(' + fieldnametouse + ' ' + StrSQLCondition[cIn] + ' (';

    cnt := High(Values);
    for i := 0 to cnt do begin
      if isstr then
        fClause := fClause + '''' + VarToStr(Values[i]) + ''''
      else
        fClause := fClause + VarToStr(Values[i]) + '';

      if (i < cnt) then fClause := fClause + ', ';
    end;
    fClause := fClause + '))';
  end;
  Changed := True;
  if Assigned(OnChange) then OnChange(Self);
end;

constructor TDAWhere.Create(const aFields: TDAFieldCollection; aClientFields : boolean);
begin
  inherited Create;
  fDefaultOperator := doAnd;
  fFields := aFields;
  fClientFields := aClientFields;
end;

{$WARN SYMBOL_DEPRECATED OFF} // Delphi warns you about implementing a method that's deprecated in the interface.

procedure TDAWhere.OpenBraket;
begin
  OpenBracket();
end;

procedure TDAWhere.CloseBraket;
begin
  CloseBracket();
end;

{$WARN SYMBOL_DEPRECATED ON}

procedure TDAWhere.OpenBracket;
begin
  fClause := fClause + '(';
  Changed := True;
  if Assigned(OnChange) then OnChange(Self);
end;

procedure TDAWhere.CloseBracket;
begin
  fClause := fClause + ')';
  Changed := True;
  if Assigned(OnChange) then OnChange(Self);
end;

procedure TDAWhere.AddOperator(aOperator: TDASQLOperator);
begin
  fClause := fClause + ' ' + StrSQLOperator[aOperator] + ' ';
  Changed := True;
  fLastWasCondition := False;
  if Assigned(OnChange) then OnChange(Self);
end;

procedure TDAWhere.Clear;
begin
  fClause := '';
  fLastWasCondition := false;
  Changed := True;
  if Assigned(OnChange) then OnChange(Self);
end;

procedure TDAWhere.AddText(const someText: string; MapClientFields : boolean = TRUE);
var s : string;
    i : integer;
begin
  s := someText;

  if MapClientFields then begin
    for i := 0 to (Fields.Count-1) do
      s := StringReplace(s, ClientFieldPrefix+Fields[i].Name, Fields[i].TableField, [rfReplaceAll, rfIgnoreCase]);
  end;

  fClause := fClause + s;

  Changed := True;
  if Assigned(OnChange) then OnChange(Self);
end;

procedure TDAWhere.AddSpaces(Count: integer = 1);
var
  i: integer;
begin
  for i := 1 to Count do
    fClause := fClause + ' ';

  Changed := True;
  if Assigned(OnChange) then OnChange(Self);
end;

function TDAWhere.GetEmpty: boolean;
begin
  result := Trim(fClause)=''
end;

function TDAWhere.GetNotEmpty: boolean;
begin
  result := not Empty
end;

function TDAWhere.AddConditions(const FieldNames: array of string;
  const Conditions: array of TDASQLCondition;
  const Values: array of Variant;
  const Operator: TDASQLOperator): integer;
var i : integer;
    isnull : boolean;
    oldclause : string;
    oldonchange : TNotifyEvent;
begin
  result := 0;
  oldclause := fClause;
  oldonchange := OnChange;
  OnChange := NIL;
  try
  for i := 0 to Length(FieldNames)-1 do begin
    isnull := VarIsNull(Values[i]) or (VarIsType(Values[i], [varString, varOleStr]) and (Values[i] = ''));
    if isnull then Continue;

    if NotEmpty then AddOperator(Operator);
    AddCondition(FieldNames[i], Conditions[i], Values[i], TRUE);
    Inc(result);
  end;
  finally
    // This is to avoid OnChange fireing for each condition in the loop above
    OnChange := oldonchange;
    Changed := True;
    if Assigned(OnChange) then OnChange(Self);
  end;
end;

function TDAWhere.AddCondition(const FieldName: string;
  Condition: TDASQLCondition): boolean;
begin
  Result:=AddCondition(FieldName,Condition,0);
end;

{ TDAColumnMapping }

procedure TDAColumnMapping.Assign(aSource: TPersistent);
var
  lSource: TDAColumnMapping;
begin
  if (aSource is TDAColumnMapping) then begin
    lSource := TDAColumnMapping(aSource);
    fDatasetField := lSource.fDatasetField;
    fTableField := lSource.fTableField;
  end
  else begin
    inherited;
  end;
end;

procedure TDAColumnMapping.AssignFieldMapping(aSource: TPersistent);
var
  lSource: TDAColumnMapping;
begin
  lSource := TDAColumnMapping(aSource);
  fDatasetField := lSource.fDatasetField;
  fTableField := lSource.fTableField;
  fSQLOrigin := lSource.fSQLOrigin;
end;

function TDAColumnMapping.GetSQLOrigin: string;
begin
  if (fSQLOrigin='')
    then result := TableField
    else result := fSQLOrigin
end;

procedure TDAColumnMapping.SetDatasetField(const Value: string);
begin
  fDatasetField := Trim(Value);
end;

procedure TDAColumnMapping.SetSQLOrigin(const Value: string);
begin
  fSQLOrigin:= Trim(Value)
end;

procedure TDAColumnMapping.SetTableField(const Value: string);
begin
  fTableField := Trim(Value);
end;

function TDAColumnMapping.StoreSQLOrigin: Boolean;
begin
  result := (fSQLOrigin <> fTableField) and (Trim(fSQLOrigin)<>'')
end;

{ TDAClientBusinessRuleScript }

constructor TDAClientBusinessRuleScript.Create;
begin
  inherited;
  fRunOnClientAndServer := true;
  fCompileOnServer := true;
end;

{ TDADriverForeignKey }

function TDADriverForeignKey.GetValue(const Index: Integer): string;
begin
  result := fValues[Index];
end;

procedure TDADriverForeignKey.SetValue(const Index: Integer; const Value: string);
begin
  fValues[Index] := Value;
end;

{ TDADriverForeignKeyCollection }

constructor TDADriverForeignKeyCollection.Create(aOwner: TPersistent);
begin
  inherited Create(aOwner, TDADriverForeignKey);
end;

function TDADriverForeignKeyCollection.Add: TDADriverForeignKey;
begin
  result := TDADriverForeignKey(inherited Add());
end;

function TDADriverForeignKeyCollection.GetForeignKeys(Index: integer): TDADriverForeignKey;
begin
  result := TDADriverForeignKey(inherited Items[Index]);
end;

procedure TDADriverForeignKeyCollection.SetForeignKeys(Index: integer; const Value: TDADriverForeignKey);
begin
  inherited Items[Index].Assign(Value);
end;

{ TDAUpdateRuleCollection }

function TDAUpdateRuleCollection.Add: TDAUpdateRule;
begin
  result := inherited Add() as TDAUpdateRule;
end;

constructor TDAUpdateRuleCollection.Create(aOwner : TComponent);
begin
  inherited Create(aOwner, TDAUpdateRule);
end;

function TDAUpdateRuleCollection.GetUpdateRules(
  Index: integer): TDAUpdateRule;
begin
  result := TDAUpdateRule(inherited Items[Index]);
end;

function TDAUpdateRuleCollection.UpdateRuleByName(
  const aName: string): TDAUpdateRule;
begin
  result := ItemByName(aName) as TDAUpdateRule
end;

{ TDAUpdateRule }

procedure TDAUpdateRule.Assign(aSource: TPersistent);
var
  lSource: TDAUpdateRule;
begin
  lSource := aSource as TDAUpdateRule;
  fDatasetName := lSource.fDatasetName;
  fName := lSource.fName;
  fDoUpdate := lSource.fDoUpdate;
  fDoInsert := lSource.fDoInsert;
  fDoDelete := lSource.fDoDelete;
  fFailureBehavior := lSource.fFailureBehavior;
end;

constructor TDAUpdateRule.Create(aCollection: TCollection);
begin
  inherited;

  fDoUpdate := true;
  fDoInsert := true;
  fDoDelete := true;
  fFailureBehavior := fbRaiseException;
end;

function TDAUpdateRule.GetChangeTypes: TDAChangeTypes;
begin
  result := [];
  if DoUpdate then Include(result,ctUpdate);
  if DoInsert then Include(result,ctInsert);
  if DoDelete then Include(result,ctDelete);
end;

function TDAUpdateRule.GetDisplayName: string;
begin
  result := Name;
  if (result='') then result := '<Unknown>';
end;

{ TDADatasetRelationshipCollection }

function TDADatasetRelationshipCollection.Add: TDADatasetRelationship;
begin
  result := inherited Add() as TDADatasetRelationship;
end;

constructor TDADatasetRelationshipCollection.Create(aOwner: TComponent);
begin
  inherited Create(aOwner, TDADatasetRelationship);
end;

procedure TDADatasetRelationshipCollection.GetDetails(const aMasterDatasetName: string; aList: TDADatasetRelationshipList);
var i : integer;
begin
  aList.Clear;
  for i := 0 to (Count-1) do begin
    if SameText(aMasterDatasetName, RelationShips[i].MasterDatasetName) then begin
      aList.Add(RelationShips[i]);
    end;
  end;
end;

function TDADatasetRelationshipCollection.GetRelationShips(
  Index: integer): TDADatasetRelationship;
begin
  result := TDADatasetRelationship(inherited Items[Index]);
end;

function TDADatasetRelationshipCollection.RelationShipByName(
  const aName: string): TDADatasetRelationship;
begin
  result := ItemByName(aName) as TDADatasetRelationship;
end;

{ TDADatasetRelationship }

procedure TDADatasetRelationship.Assign(Source: TPersistent);
var src : TDADatasetRelationship;
begin
  if (Source is TDADatasetRelationship) then begin
    src := TDADatasetRelationship(Source);

    Name := src.Name;
    MasterDatasetName := src.MasterDatasetName;
    MasterFields := src.MasterFields;
    DetailDatasetName := src.DetailDatasetName;
    DetailFields := src.DetailFields;
  end
  else inherited;
end;

function TDADatasetRelationship.GetDisplayName: string;
begin
  result := Format('%s: %s (%s) --> %s (%s)', [fName, fDetailDatasetName, fDetailFields, fMasterDatasetName, fMasterFields]);
end;

{ TDADatasetRelationshipList }

function TDADatasetRelationshipList.Add(
  aRelationship: TDADatasetRelationship): integer;
begin
  result := inherited Add(aRelationship)
end;

function TDADatasetRelationshipList.GetItems(
  Index: integer): TDADatasetRelationship;
begin
  result := TDADatasetRelationship(inherited Items[Index]);
end;

{ TDALoginInfoAware }

function TDALoginInfoAware._AddRef: Integer;
begin
  result := -1;
end;

function TDALoginInfoAware._Release: Integer;
begin
  result := -1;
end;

function TDALoginInfoAware.GetLoginInfo: TDALoginInfo;
begin
  result := fLoginInfo
end;

procedure TDALoginInfoAware.SetLoginInfo(aValue: TDALoginInfo);
begin
  fLoginInfo := aValue;
end;

{ TDAJoinDataTableCollection }

constructor TDAJoinDataTableCollection.Create(aOwner : TComponent);
begin
  inherited Create(aOwner, TDAJoinDataTable);
end;

function TDAJoinDataTableCollection.GetJoinDataTables(Index: integer): TDAJoinDataTable;
begin
  result := TDAJoinDataTable(inherited Items[Index]);
end;

procedure TDAJoinDataTableCollection.SetJoinDataTables(Index: integer; const Value: TDAJoinDataTable);
begin
  JoinTables[Index].Assign(Value);
end;

{
function TDAJoinedTableCollection.GetItemClass: TDASQLCommandClass;
begin
  result := TDAJoinedTable;
end;
}

function TDAJoinDataTableCollection.Add: TDAJoinDataTable;
begin
  result := TDAJoinDataTable(inherited Add);
end;

function TDAJoinDataTableCollection.JoinTableByName(const aName: string): TDAJoinDataTable;
begin
  result := TDAJoinDataTable(inherited ItemByName(aName));
end;

function TDAJoinDataTableCollection.FindJoinTableByName(const aName: string): TDAJoinDataTable;
begin
  result := TDAJoinDataTable(inherited FindItem(aName));
end;

{ TDAJoinSourceTableCollection }

function TDAJoinSourceTableCollection.GetJoinSourceTables(Index: integer): TDAJoinSourceTable;
begin
  result := TDAJoinSourceTable(inherited Items[Index])
end;

procedure TDAJoinSourceTableCollection.SetJoinSourceTables(Index: integer; const Value: TDAJoinSourceTable);
begin
  TDAJoinSourceTable(inherited Items[Index]).AssignTo(Value);
end;

constructor TDAJoinSourceTableCollection.Create(aOwner: TPersistent);
begin
  inherited Create(aOwner, TDAJoinSourceTable);
end;

function TDAJoinSourceTableCollection.Add: TDAJoinSourceTable;
begin
  result := TDAJoinSourceTable(inherited Add);
end;

function TDAJoinSourceTableCollection.JoinSourceTableByName(const aName: string): TDAJoinSourceTable;
begin
  result := TDAJoinSourceTable(inherited ItemByName(aName));
end;
{
function TDAJoinedTableItemCollection.GetItemClass: TDAJoinedTableItem;
begin
  result := TDAJoinedTableItem;
end;
}

{ TDAJoinDataTable }
constructor TDAJoinDataTable.Create(Collection: TCollection);
begin
  inherited;
  fJoinSourceTables := TDAJoinSourceTableCollection.Create(self);
end;

destructor TDAJoinDataTable.Destroy;
begin
  FreeAndNil(fJoinSourceTables);
  inherited;
end;

procedure TDAJoinDataTable.Assign(aSource: TPersistent);
var
  lSource: TDAJoinDataTable;
begin
  if (aSource is TDAJoinDataTable) then begin
    inherited; { Need to work the TDASQLCommand, too}
    lSource := TDAJoinDataTable(aSource);
    fJoinSourceTables.Assign(lSource.fJoinSourceTables);
    fMasterTable:= lSource.fMasterTable;
  end
  else begin
    inherited;
  end;
end;

procedure TDAJoinDataTable.SetJoinSourceTables(const Value: TDAJoinSourceTableCollection);
begin
  fJoinSourceTables.Assign(Value);
end;

function TDAJoinDataTable.GetParams: TDAParamCollection;
begin
  result := nil;
end;

procedure TDAJoinDataTable.SetParams(const Value: TDAParamCollection);
begin
  // Do Nothing
end;

function TDAJoinDataTable.GetStatements(): TDAStatementCollection;
begin
  result := nil;
end;

procedure TDAJoinDataTable.SetStatements(const Value: TDAStatementCollection);
begin
  // Do Nothing
end;

function TDAJoinDataTable.GetSQLCommandCollection: TDASQLCommandCollection;
begin
  result := nil;
end;


{ TDAJoinSourceTable }
constructor TDAJoinSourceTable.Create(Collection: TCollection);
begin
  inherited;
  fJoinConditions := TDAJoinConditionCollection.Create(Self);
end;

function TDAJoinSourceTable.GetDisplayName: string;
begin
  if (Trim(Name) = '') then
    result := '<Noname>'
  else
    result := Name;
end;

procedure TDAJoinSourceTable.SetName(const Value: string);
var
  lOldName: string;
begin
  lOldName := fName;
  fName := Value;
  if lOldName <> '' then
    (Collection as TSearcheableCollection).TriggerOnItemRenamed(lOldName, fName);
end;

procedure TDAJoinSourceTable.Assign(aSource: TPersistent);
var
  lSource: TDAJoinSourceTable;
begin
  if (aSource is TDAJoinSourceTable) then begin
    lSource := TDAJoinSourceTable(aSource);
    fName:= lSource.fName;
    fJoinType:= lSource.fJoinType;
    fJoinConditions.Assign(lSource.fJoinConditions);    
  end
  else begin
    inherited;
  end;
end;

{ TDAJoinConditionCollection }
constructor TDAJoinConditionCollection.Create(aOwner: TPersistent);
begin
  inherited Create(aOwner, TDAJoinCondition);
end;

function TDAJoinConditionCollection.Add: TDAJoinCondition;
begin
  result := TDAJoinCondition(inherited Add);
end;

constructor TDADatasetRelationship.Create(Collection: TCollection);
begin
  inherited Create(Collection);
  fRelationshipType := rtForeignKey;
end;

{ TDATableFieldCollectionItem }

procedure TDATableFieldCollectionItem.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TDATableFieldCollectionItem then begin
    self.FFieldName := TDATableFieldCollectionItem(Source).FieldName;
    self.FTableName := TDATableFieldCollectionItem(Source).TableName;
  end;
end;


{ TDAQueryBuilder }

procedure TDAQueryBuilder.AddCrossJoin(ATable: string);
begin
  with FMainTable.JoinSourceTables.Add do begin
    JoinType := jtCross;
    Name := ATable;
  end;
end;

procedure TDAQueryBuilder.AddGroupBy(ATable, AField: string);
begin
  with TDAGroupByItem(FGroupByCollection.Add) do begin
    TableName := aTable;
    FieldName := AField;
  end;
end;

procedure TDAQueryBuilder.AddJoin(AJoinTable, AJoinFieldName,
  AJoinToTableName, AJoinToFieldName: string; AJoinType: TDAJoinType);
begin
  with FMainTable.JoinSourceTables.Add do begin
    JoinType := AJoinType;
    Name := AJoinTable;
    with JoinConditions.Add do begin
      FromTableName := AJoinTable;
      FromFieldName := AJoinFieldName;
      ToTableName := AJoinToTableName;
      ToFieldName := AJoinToFieldName;
    end;
  end;
end;

procedure TDAQueryBuilder.AddJoin(AJoinTable: string;
  AJoinFieldNames: array of string; AJoinToTableName: string;
  AJoinToFieldNames: array of string; AJoinType: TDAJoinType);
var
  i: integer;
begin
  if High(AJoinToFieldNames) <> High(AJoinFieldNames) then raise Exception.Create('Can''t create join: AJoinFieldNames and AJoinToFieldNames should contain equal members count');
  with FMainTable.JoinSourceTables.Add do begin
    JoinType := AJoinType;
    Name := AJoinTable;
    For i:=0 to High(AJoinToFieldNames) do
      with JoinConditions.Add do begin
        FromTableName := AJoinTable;
        FromFieldName := AJoinFieldNames[i];
        ToTableName := AJoinToTableName;
        ToFieldName := AJoinToFieldNames[i];
      end;
  end;
end;

procedure TDAQueryBuilder.AddOrderBy(ATable, AField: string);
begin
  with TDAOrderByItem(FOrderByCollection.Add) do begin
    TableName := aTable;
    FieldName := AField;
  end;
end;

procedure TDAQueryBuilder.AddSelect(ATable, AField: string);
begin
  with TDASelectItem(FSelectCollection.Add) do begin
    TableName := aTable;
    FieldName := AField;
  end;
end;

procedure TDAQueryBuilder.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TDAQueryBuilder then begin
    FMainTable.Assign(TDAQueryBuilder(Source).MainTable);
    FSelectCollection.Assign(TDAQueryBuilder(Source).Select);
    FGroupByCollection.Assign(TDAQueryBuilder(Source).GroupBy);
    FOrderByCollection.Assign(TDAQueryBuilder(Source).OrderBy);
    FOptions:=TDAQueryBuilder(Source).FOptions;
    FConnection:=TDAQueryBuilder(Source).Connection;
    if (TDAQueryBuilder(Source).FWhere <> nil) or (FWhere <> nil) then
      Where.Xml:=TDAQueryBuilder(Source).Where.Xml;
  end;
end;

procedure TDAQueryBuilder.Clear;
begin
  FMainTable.MasterTable := '';
  FMainTable.JoinSourceTables.Clear;
  FSelectCollection.Clear;
  if FWhere <> nil then FWhere.Clear;
  FGroupByCollection.Clear;
  FOrderByCollection.Clear;
end;

constructor TDAQueryBuilder.Create;
begin
  inherited Create;
  FSelectCollection := TDASelectCollection.Create(TDASelectItem);
  FMainTable := TDAJoinDataTable.Create(nil);
  FGroupByCollection := TDAGroupByCollection.Create(TDAGroupByItem);
  FOrderByCollection := TDAOrderByCollection.Create(TDAOrderByItem);
  FColumnMapping := TDAColumnMappingCollection.Create(Self);
  FWhere := nil; 
  FOptions := [];
  Clear;
end;

function TDAQueryBuilder.CreateGroupByClause: string;
var
  i: integer;
begin
  Result := '';
  for i := 0 to GroupBy.Count - 1 do begin
    if i <> 0 then Result := Result + ', ';
    with TDAGroupByItem(GroupBy.Items[i]) do
      Result := Result + GenerateFieldName(TableName, FieldName);
  end;
end;

function TDAQueryBuilder.CreateOrderByClause: string;
var
  i: integer;
begin
  Result := '';
  for i := 0 to OrderBy.Count - 1 do begin
    if i <> 0 then Result := Result + ', ';
    with TDAOrderByItem(OrderBy.Items[i]) do
      Result := Result + GenerateFieldName(TableName, FieldName);
  end;
end;

function TDAQueryBuilder.CreateSelectClause: string;
var
  i,j: integer;
  lflds: TDAFieldCollection;
  lquotedtablename: string;
begin
  Result := '';
  if Select.Count = 0 then begin
    if not (qboGenerateSimpleSelect in FOptions) and Assigned(FConnection) then begin
      FConnection.GetTableFields(MainTable.MasterTable, lflds);
      if Assigned(lflds) then try
       if MainTable.JoinSourceTables.Count =0 then
         lquotedtablename := ''
       else
         lquotedtablename:=QuoteIdentifierIfNeeded(MainTable.MasterTable)+'.';
       For i:= 0 to lflds.Count -1 do
         Result := Result + lquotedtablename+QuoteFieldNameIfNeeded(MainTable.MasterTable, lflds.Fields[i].Name)+', '
      finally
        lFlds.Free;
      end;
      For j:= 0 to MainTable.JoinSourceTables.Count - 1 do
        with TDAJoinSourceTable(MainTable.JoinSourceTables.Items[j]) do begin
          lquotedtablename:=QuoteIdentifierIfNeeded(Name)+'.';
          FConnection.GetTableFields(name, lflds);
          if Assigned(lflds) then try
            For i:= 0 to lflds.Count -1 do
              Result := Result + lquotedtablename+QuoteFieldNameIfNeeded(Name, lflds.Fields[i].Name)+', '
          finally
            lFlds.Free;
          end;
        end;
    end;
  end else begin
    for i := 0 to Select.Count - 1 do begin
      with TDASelectItem(Select.Items[i]) do
        Result := Result + GenerateFieldName(TableName, FieldName)+', ';
    end;
  end;
  if Length(Result) > 2 then SetLength(Result, Length(Result)-2);
  if Result = '' then Result:='*';
end;

function TDAQueryBuilder.CreateWhereClause: string;
begin
  if FWhere = nil then
    Result := ''
  else
    Result := FWhere.CreateWhereClause;
end;

destructor TDAQueryBuilder.Destroy;
begin
  FColumnMapping.Free;
  FWhere.Free;
  FOrderByCollection.Free;
  FGroupByCollection.Free;
  FSelectCollection.Free;
  FMainTable.Free;
  inherited;
end;

function TDAQueryBuilder.GenerateFieldName(aTablename,
  aFieldName: string; aProcessMapping: Boolean): string;
begin
  if aProcessMapping then aFieldName:= GetMappingTableField(aFieldName);
  if aTableName <> '' then
    Result := QuoteIdentifierIfNeeded(aTableName) + '.' + QuoteFieldNameIfNeeded(aTableName, aFieldName)
  else
    Result := QuoteFieldNameIfNeeded(aTableName, aFieldName);
end;

function TDAQueryBuilder.GenerateSelectSQL: string;
const
  c_Indent = '   ';
  c_Lenght = 47;

  function CompactString(AStr: String): string;
  var
    p,p1: Pchar;
    s: string;
  begin
    Result:='';
    p:=Pchar(AStr);
    repeat
      p1:=p;
      repeat
        p1:=StrPos(p1, ',');
        if p1 <> nil then inc(p1);
      until (p1 = nil) or (p1-p > c_lenght);
      if p1 = nil then begin
        s:=p;
      end else begin
        inc(p1);
        SetString(s,p, p1-p);
      end;
      p:=p1;
      Result:=Result+sLineBreak +c_Indent+ s;
    until p = nil;
  end;

var
  lSelect, lTable, lWhere, lGroupBy, lOrderBy: string;
begin
  Validate;
  lSelect := CompactString(CreateSelectClause);
  lTable := CreateTableClause;
  lWhere := CreateWhereClause;
  lGroupBy := CreateGroupByClause;
  lOrderBy := CreateOrderByClause;
  Result :=
    'SELECT' +  lSelect + sLinebreak +
    'FROM' + sLineBreak + c_Indent + lTable;
  if (qboGenerateDynamicWhereStatement in Options) and (lWhere = '') then lWhere := '{WHERE}';
  if lWhere <> '' then Result := Result + sLineBreak + 'WHERE' + sLineBreak + c_Indent + lWhere;
  if lGroupBy <> '' then Result := Result + sLineBreak + 'GROUP BY' + sLineBreak + c_Indent + lGroupBy;
  if lOrderBy <> '' then Result := Result + sLineBreak + 'ORDER BY' + sLineBreak + c_Indent + lOrderBy;
end;

function TDAQueryBuilder.GetMappingTableField(
  const aDataSetField: string): string;
var
  lColumnMapping: TDAColumnMapping;
begin
  lColumnMapping := FColumnMapping.FindMappingByDatasetField(aDataSetField);
  if Assigned(lColumnMapping) then
    Result := lColumnMapping.TableField
  else
    Result := aDataSetField;
end;

function TDAQueryBuilder.GetWhereBuilder: TDASQLWhereBuilder;
begin
  if FWhere = nil then FWhere := CreateWhereBuilder;
  Result:= FWhere;
end;

function TDAQueryBuilder.IdentifierNeedsQuoting(
  const iIdentifier: string): boolean;
var
  i: integer;
begin
  if Assigned(Connection) then
    Result := Connection.IdentifierNeedsQuoting(iIdentifier)
  else begin
    Result := False;
    for i := 1 to Length(iIdentifier) do begin
      Result := not (iIdentifier[i] in ['a'..'z', 'A'..'Z', '0'..'9', '_', '.']);
      if Result then Break;
    end;
  end;
end;

function TDAQueryBuilder.QuoteFieldNameIfNeeded(const aTableName,
  aFieldName: string): string;
begin
  if Assigned(Connection) then
    Result := Connection.QuoteFieldNameIfNeeded(aTableName, aFieldName)
  else
    Result := {aTableName + '.' +} QuoteIdentifierIfNeeded(aFieldName);
end;

function TDAQueryBuilder.QuoteIdentifier(
  const iIdentifier: string): string;
begin
  if Assigned(Connection) then
    Result := Connection.QuoteIdentifier(iIdentifier)
  else
    Result := '''' + iIdentifier + '''';
end;

function TDAQueryBuilder.QuoteIdentifierIfNeeded(
  const iIdentifier: string): string;
begin
  if Assigned(Connection) then
    Result := Connection.QuoteIdentifierIfNeeded(iIdentifier)
  else if IdentifierNeedsQuoting(iIdentifier) then
    Result := QuoteIdentifier(iIdentifier)
  else
    Result := iIdentifier;
end;

procedure TDAQueryBuilder.SetColumnMapping(
  const Value: TDAColumnMappingCollection);
begin
  FColumnMapping.AssignColumnMapping(Value);
end;

procedure TDAQueryBuilder.Validate;
begin
  if FMainTable.MasterTable = '' then raise Exception.Create('Please specify MainTable.MasterTable');
end;

{ TDAWhereBuilder }

const
  c_DAWhereBuilderLocalName = 'query';
  c_DAWhereBuilderNamespaceURI = 'http://www.remobjects.com/schemas/dataabstract/queries/5.0';
  c_DAWhereBuilderwhere = 'where';
procedure TDAWhereBuilder.Clear;
begin
  FreeAndNil(FExpression);
  FColumnMapping.Clear;
  fParams.Clear;
end;

constructor TDAWhereBuilder.Create;
begin
  inherited Create;
  FColumnMapping := TDAColumnMappingCollection.Create(nil);
  fParams := TDAParamCollection.Create(nil);
end;

destructor TDAWhereBuilder.Destroy;
begin
  Clear;
  fParams.Free;
  FColumnMapping.Free;
  inherited Destroy;
end;

function TDAWhereBuilder.ExpressionToXmlNode(
  const aExpression: TDAWhereExpression): IXMLNode;
var
  doc: IXMLDocument;
  el: IXMLNode;
begin
  doc := NewROXmlDocument;
  doc.New(c_DAWhereBuilderLocalName);
  el := doc.DocumentNode;
  el.AddAttribute('xmlns', c_DAWhereBuilderNamespaceURI);
  el.AddAttribute('version', '5.0');
  WriteToXml(el,aExpression);
  result := doc.DocumentNode;
end;

function TDAWhereBuilder.getXml: WideString;
begin
  Result:= ExpressionToXmlNode(fExpression).Document.XML;
end;

function TDAWhereBuilder.IsEmpty: Boolean;
begin
  Result:= fExpression = nil;
end;

function TDAWhereBuilder.NewBinaryExpression(aLeft,
  aRight: TDAWhereExpression; anOp: TDABinaryOperator): TDAWhereExpression;
begin
  Result := TDABinaryExpression.Create(Self, aLeft, aRight, anOp);
end;

function TDAWhereBuilder.NewConstant(const aValue: Variant;
  aType: TDADataType): TDAWhereExpression;
begin
  Result := TDAConstantExpression.Create(Self, aValue, aType);
end;

function TDAWhereBuilder.NewField(
  const aTableName,aFieldName: string): TDAWhereExpression;
begin
  Result := TDAFieldExpression.Create(Self, aTableName,aFieldName);
end;

function TDAWhereBuilder.NewList(
  const aValues: array of TDAWhereExpression): TDAWhereExpression;
begin
  result := TDAListExpression.Create(Self, aValues);
end;

function TDAWhereBuilder.NewMacro(const aName: string;
  const aValues: array of TDAWhereExpression): TDAWhereExpression;
begin
  Result := TDAMacroExpression.Create(Self, aName, aValues);
end;

function TDAWhereBuilder.NewMacro(const aName: string): TDAWhereExpression;
begin
  Result := TDAMacroExpression.Create(Self, aName);
end;

function TDAWhereBuilder.NewNull: TDAWhereExpression;
begin
  Result := TDANullExpression.Create(Self);
end;

function TDAWhereBuilder.NewParameter(
  const aParameterName: string): TDAWhereExpression;
begin
  Result := TDAParameterExpression.Create(Self, aParameterName);
end;

function TDAWhereBuilder.NewUnaryExpression(
  anExpression: TDAWhereExpression;
  anOp: TDAUnaryOperator): TDAWhereExpression;
begin
  Result := TDAUnaryExpression.Create(Self, anExpression, anOp);
end;

function TDAWhereBuilder.ReadFromXml(xr: IXmlNode): TDAWhereExpression;
begin
  xr := SelectNodeLocal(xr, c_DAWhereBuilderwhere);
  if (xr = nil) then raise Exception.Create('"'+c_DAWhereBuilderwhere+'" tag expected');
  if xr.ChildrenCount > 0 then
    Result := TDAWhereExpression.ParseExpression(self, xr.FirstChild)
  else
    Result := nil;  
end;

procedure TDAWhereBuilder.SetColumnMapping(
  const Value: TDAColumnMappingCollection);
begin
  FColumnMapping.Assign(Value);
end;

procedure TDAWhereBuilder.SetParams(const Value: TDAParamCollection);
begin
  fParams.Assign(Value);
end;

procedure TDAWhereBuilder.setXml(const aValue: WideString);
begin
  Clear;
  fExpression:=XMLToExpression(aValue);
end;

procedure TDAWhereBuilder.WriteToXml(sw: IXmlNode; const aExpression: TDAWhereExpression);
begin
  sw := sw.Add(c_DAWhereBuilderwhere);
  if aExpression <> nil then
     aExpression.WriteToXml(sw);
end;

function TDAWhereBuilder.XMLToExpression(
  const aXML: widestring): TDAWhereExpression;
var
  doc: IXMLDocument;
  el: IXMLNode;
begin
  doc := NewROXmlDocument;
  doc.New();
  doc.XML := aXML;
  el := doc.DocumentNode;
  if (el.LocalName <> c_DAWhereBuilderLocalName) or (el.NamespaceURI <> c_DAWhereBuilderNamespaceURI) then raise Exception.Create('Not a DataAbstract query xml');
  Result:= ReadFromXml(el);
end;

{ TDAWhereExpression }

constructor TDAWhereExpression.Create(anOwner: TDAWhereBuilder);
begin
  inherited Create;
  fOwner := anOwner;
end;

class function TDAWhereExpression.ParseExpression(aOwner: TDAWhereBuilder;
  xr: IXmlNode): TDAWhereExpression;
begin
  Result := CreateWhereExpression(aOwner, xr.LocalName);
  Result.ReadFromXml(xr);
end;

{ TDAUnionDataTable }
constructor TDAUnionDataTable.Create(Collection: TCollection);
begin
  inherited;
  fSourceTables := TDAUnionSourceTableCollection.Create(Self);
end;

destructor TDAUnionDataTable.Destroy;
begin
  FreeAndNil(fSourceTables);
  inherited;
end;

procedure TDAUnionDataTable.SetSourceTables(Value: TDAUnionSourceTableCollection);
begin
  fSourceTables.Assign(Value);
end;

{ TDAUnionSourceTableCollection }
function TDAUnionSourceTableCollection.Add: TDAUnionSourceTable;
begin
  result := inherited Add() as TDAUnionSourceTable;
end;

constructor TDAUnionSourceTableCollection.Create(aOwner : TPersistent);
begin
  inherited Create(aOwner, TDAUnionSourceTable);
end;

function TDAUnionSourceTableCollection.GetUnionSourceTables(
  Index: integer): TDAUnionSourceTable;
begin
  result := TDAUnionSourceTable(inherited Items[Index]);
end;

function TDAUnionSourceTableCollection.UnionSourceTableByName(
  const aName: string): TDAUnionSourceTable;
begin
  result := ItemByName(aName) as TDAUnionSourceTable
end;

{ TDAUnionSourceTable }
procedure TDAUnionSourceTable.Assign(Source: TPersistent);
begin
  if Source is TDAUnionSourceTable then begin
    Name := TDAUnionSourceTable(Source).Name;
    IsReadonly := TDAUnionSourceTable(Source).IsReadOnly;
    ColumnMappings.Assign(TDAUnionSourceTable(Source).ColumnMappings);
  end;
end;

constructor TDAUnionSourceTable.Create(Collection: TCollection);
begin
  inherited;
  fColumnMappings := TDAColumnMappingCollection.Create(Self);
end;

destructor TDAUnionSourceTable.Destroy;
begin
  FreeAndNil(fColumnMappings);
  inherited;
end;

procedure TDAUnionSourceTable.SetColumnMappings(const Value: TDAColumnMappingCollection);
begin
  fColumnMappings.Assign(Value);
end;

{ TDAUnionDataTableCollection }
constructor TDAUnionDataTableCollection.Create(aOwner : TComponent);
begin
  inherited Create(aOwner, TDAUnionDataTable);
end;

function TDAUnionDataTableCollection.GetUnionDataTables(Index: integer): TDAUnionDataTable;
begin
  result := TDAUnionDataTable(inherited Items[Index]);
end;

procedure TDAUnionDataTableCollection.SetUnionDataTables(Index: integer; const Value: TDAUnionDataTable);
begin
  UnionDataTables[Index].Assign(Value);
end;

function TDAUnionDataTableCollection.Add: TDAUnionDataTable;
begin
  result := TDAUnionDataTable(inherited Add);
end;

function TDAUnionDataTableCollection.UnionDataTableByName(const aName: string): TDAUnionDataTable;
begin
  result := TDAUnionDataTable(inherited ItemByName(aName));
end;

function TDAUnionDataTableCollection.FindUnionDataTableByName(const aName: string): TDAUnionDataTable;
begin
  result := TDAUnionDataTable(inherited FindItem(aName));
end;



{ TDASQLWhereBuilder }

constructor TDASQLWhereBuilder.Create(AConnection: IDAConnection);
begin
  inherited Create;
  FConnection:= AConnection;
end;

constructor TDASQLWhereBuilder.Create(AQueryBuilder: TDAQueryBuilder);
begin
  inherited Create;
  FQueryBuilder:= AQueryBuilder;
end;

function TDASQLWhereBuilder.CreateWhereClause: string;
begin
  Result:= ProcessExpression(Expression);
end;


function TDASQLWhereBuilder.GenerateFieldName(aTablename,
  aFieldName: string): string;
begin
  aFieldName:= GetMappingTableField(aFieldName);
  if FQueryBuilder <> nil then
    Result := FQueryBuilder.GenerateFieldName(aTablename,aFieldName,False)
  else
  if FConnection <> nil then begin
     if aTableName <> '' then
        Result := FConnection.QuoteIdentifierIfNeeded(aTableName) + '.' + FConnection.QuoteFieldNameIfNeeded(aTableName, aFieldName)
      else
        Result := FConnection.QuoteFieldNameIfNeeded(aTableName, aFieldName);
  end;
end;

function TDASQLWhereBuilder.GenerateParameter(
  const aParameterName: string): string;
begin
  Result:= ':'+aParameterName;
end;

function TDASQLWhereBuilder.GenerateParamName: String;
begin
  fId := fId + 1;
  result := Format('P%d', [fId]);
end;

function TDASQLWhereBuilder.GetMappingTableField(
  const aDataSetField: string): string;
var
  lColumnMapping: TDAColumnMapping;
begin
  lColumnMapping := FColumnMapping.FindMappingByDatasetField(aDataSetField);
  if Assigned(lColumnMapping) then
    Result := lColumnMapping.TableField
  else
    Result := aDataSetField;
end;

function TDASQLWhereBuilder.ProcessConstantExpression(
  AExpression: TDAWhereExpression): string;
const
  const_prefix = 'DACONST_';
begin
  With Params.Add do begin
    ParamType := daptInput;
    Value := TDAConstantExpression(AExpression).Value;
    DataType := TDAConstantExpression(AExpression).aType;
    Name := GenerateParamName();
    Result:= GenerateParameter(Name);
  end;
end;

function TDASQLWhereBuilder.ProcessExpression(
  AExpression: TDAWhereExpression): string;
begin
  Result := '';
  if AExpression = nil then Exit;
  if AExpression is TDABinaryExpression then Result := ProcessBinaryExpression(TDABinaryExpression(AExpression))
  else if AExpression is TDAUnaryExpression then Result := ProcessUnaryExpression(TDAUnaryExpression(AExpression))
  else if AExpression is TDAConstantExpression then Result := ProcessConstantExpression(TDAConstantExpression(AExpression))
  else if AExpression is TDAListExpression then Result := ProcessListExpression(TDAListExpression(AExpression))
  else if AExpression is TDAParameterExpression then Result := ProcessParameterExpression(TDAParameterExpression(AExpression))
  else if AExpression is TDAFieldExpression then Result := ProcessFieldExpression(TDAFieldExpression(AExpression))
  else if AExpression is TDANullExpression then Result := ProcessNullExpression(TDANullExpression(AExpression))
  else if AExpression is TDAMacroExpression then Result := ProcessMacroExpression(TDAMacroExpression(AExpression))
  else ;
end;

function TDASQLWhereBuilder.ProcessFieldExpression(
  AExpression: TDAWhereExpression): string;
begin
  with TDAFieldExpression(AExpression) do
    Result:= GenerateFieldName(TableName, FieldName);
end;

function TDASQLWhereBuilder.ProcessListExpression(
  AExpression: TDAWhereExpression): string;
var
  i: integer;
begin
  Result := '';
  with TDAListExpression(AExpression) do
    for i := 0 to Count - 1 do begin
      if i > 0 then Result := Result + ', ';
      Result := Result + ProcessExpression(Item[i]);
    end;
end;

function TDASQLWhereBuilder.ProcessMacroExpression(
  AExpression: TDAWhereExpression): string;
var
  s1: string;
  i: integer;
begin
  with TDAMacroExpression(AExpression) do begin
    Result := '{' + Name;
    s1 := '}';
    if Count > 0 then begin
      Result := Result + '(';
      for i := 0 to Count - 1 do begin
        if i > 0 then Result := Result + ', ';
        Result := Result + ProcessExpression(Item[i]);
      end;
      Result := Result + ')';
    end;
  end;
  Result := Result + s1;
end;

function TDASQLWhereBuilder.ProcessParameterExpression(
  AExpression: TDAWhereExpression): string;
begin
  with TDAParameterExpression(AExpression) do
    Result := GenerateParameter(ParameterName);
end;

{$IFDEF DataAbstract_Trial}
{$INCLUDE DataAbstract_Trial.inc}
{$ENDIF DataAbstract_Trial}

end.