unit uDAElevateDBDriver;

{----------------------------------------------------------------------------}
{ Data Abstract Library - Driver Library
{
{ compiler: Delphi 6 and up
{ platform: Win32
{
{ (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}

{$R DataAbstract_ElevateDBDriver_Glyphs.res}

interface
uses Classes, DB,
  uDAElevateDBInterfaces, edbType, edbcomps,
  uROClasses, uDAEngine, uDAInterfaces, uDAInterfacesEx, uDAUtils;

type { TDAElevateDBDriver }
  TDAElevateDBDriver = class(TDADriverReference)
  end;

  { TDAEElevateDBDriver }
  TDAEElevateDBDriver = class(uDAElevateDBInterfaces.TDAElevateDBDriver ,IDADriver40)
  protected
    function GetConnectionClass: TDAEConnectionClass; override;
    //procedure CustomizeConnectionObject(aConnection: TDAEConnection); override;
    //procedure DoSetTraceOptions(TraceActive: boolean; TraceFlags: TDATraceOptions; Callback: TDALogTraceEvent); override;

    { IDADriver }
    function GetDriverID: string; override; safecall;
    function GetDescription: string; override; safecall;
    // function GetMajVersion: byte; override; safecall;
    // function GetMinVersion: byte; override; safecall;
    procedure GetAuxDrivers(out List: IROStrings); override; safecall;
    procedure GetAuxParams(const AuxDriver: string; out List: IROStrings); override;
    function GetAvailableDriverOptions: TDAAvailableDriverOptions; override; safecall;
    // procedure Initialize; override; safecall;
    // procedure Finalize; override; safecall;
    // function GetDefaultCustomParameters: string; override; safecall;

    { IDADriver40 }
    function GetProviderDefaultCustomParameters(Provider: string): string; safecall;
  public
  end;

  IElevateDBEngineProperties = interface
    function GetBackupExtension: TEDBString;
    function GetCatalogExtension: TEDBString;
    function GetCatalogName: TEDBString;
    function GetConfigExtension: TEDBString;
    function GetConfigName: TEDBString;
    function GetConfigPath: TEDBString;
    function GetEncryptionPassword: TEDBString;
    function GetEngineType: TEDBEngineType;
    function GetLargeFileSupport: Boolean;
    function GetLicensedSessions: Integer;
    function GetLockExtension: TEDBString;
    function GetLogCategories: TEDBLogCategories;
    function GetLogExtension: TEDBString;
    function GetMaxLogFileSize: Integer;
    function GetServerAddress: TEDBString;
    function GetServerAuthorizedAddresses: TEDBStrings;
    function GetServerBlockedAddresses: TEDBStrings;
    function GetServerDeadSessionExpiration: Integer;
    function GetServerDeadSessionInterval: Integer;
    function GetServerDescription: TEDBString;
    function GetServerEncryptedOnly: Boolean;
    function GetServerJobCategory: TEDBString;
    function GetServerMaxDeadSessions: Integer;
    function GetServerName: TEDBString;
    function GetServerPort: Integer;
    function GetServerRunJobs: Boolean;
    function GetServerSessionTimeout: Integer;
    function GetServerThreadCacheSize: Integer;
    function GetSignature: TEDBString;
    function GetTableBlobExtension: TEDBString;
    function GetTableExtension: TEDBString;
    function GetTableIndexExtension: TEDBString;
    function GetTempTablesPathProperty: TEDBString;
    procedure SetBackupExtension(const Value: TEDBString);
    procedure SetCatalogExtension(const Value: TEDBString);
    procedure SetCatalogName(const Value: TEDBString);
    procedure SetConfigExtension(const Value: TEDBString);
    procedure SetConfigName(const Value: TEDBString);
    procedure SetConfigPath(const Value: TEDBString);
    procedure SetEncryptionPassword(const Value: TEDBString);
    procedure SetEngineType(const Value: TEDBEngineType);
    procedure SetLargeFileSupport(const Value: Boolean);
    procedure SetLicensedSessions(const Value: Integer);
    procedure SetLockExtension(const Value: TEDBString);
    procedure SetLogCategories(const Value: TEDBLogCategories);
    procedure SetLogExtension(const Value: TEDBString);
    procedure SetMaxLogFileSize(const Value: Integer);
    procedure SetServerAddress(const Value: TEDBString);
    procedure SetServerAuthorizedAddresses(const Value: TEDBStrings);
    procedure SetServerBlockedAddresses(const Value: TEDBStrings);
    procedure SetServerDeadSessionExpiration(const Value: Integer);
    procedure SetServerDeadSessionInterval(const Value: Integer);
    procedure SetServerDescription(const Value: TEDBString);
    procedure SetServerEncryptedOnly(const Value: Boolean);
    procedure SetServerJobCategory(const Value: TEDBString);
    procedure SetServerMaxDeadSessions(const Value: Integer);
    procedure SetServerName(const Value: TEDBString);
    procedure SetServerPort(const Value: Integer);
    procedure SetServerRunJobs(const Value: Boolean);
    procedure SetServerSessionTimeout(const Value: Integer);
    procedure SetServerThreadCacheSize(const Value: Integer);
    procedure SetSignature(const Value: TEDBString);
    procedure SetTableBlobExtension(const Value: TEDBString);
    procedure SetTableExtension(const Value: TEDBString);
    procedure SetTableIndexExtension(const Value: TEDBString);
    procedure SetTempTablesPath(const Value: TEDBString);
    property EngineType: TEDBEngineType read GetEngineType write SetEngineType;
    property Signature: TEDBString read GetSignature write SetSignature;
    property EncryptionPassword: TEDBString read GetEncryptionPassword write SetEncryptionPassword;
    property LargeFileSupport: Boolean read GetLargeFileSupport write SetLargeFileSupport;
    property LicensedSessions: Integer read GetLicensedSessions write SetLicensedSessions;
    property ConfigPath: TEDBString read GetConfigPath write SetConfigPath;
    property ConfigName: TEDBString read GetConfigName write SetConfigName;
    property ConfigExtension: TEDBString read GetConfigExtension write SetConfigExtension;
    property LockExtension: TEDBString read GetLockExtension write SetLockExtension;
    property LogExtension: TEDBString read GetLogExtension write SetLogExtension;
    property MaxLogFileSize: Integer read GetMaxLogFileSize write SetMaxLogFileSize;
    property LogCategories: TEDBLogCategories read GetLogCategories write SetLogCategories;
    property CatalogName: TEDBString read GetCatalogName write SetCatalogName;
    property CatalogExtension: TEDBString read GetCatalogExtension write SetCatalogExtension;
    property BackupExtension: TEDBString read GetBackupExtension write SetBackupExtension;
    property TableExtension: TEDBString read GetTableExtension write SetTableExtension;
    property TableIndexExtension: TEDBString read GetTableIndexExtension write SetTableIndexExtension;
    property TableBlobExtension: TEDBString read GetTableBlobExtension write SetTableBlobExtension;
    property TempTablesPath: TEDBString read GetTempTablesPathProperty write SetTempTablesPath;
    property ServerName: TEDBString read GetServerName write SetServerName;
    property ServerDescription: TEDBString read GetServerDescription write SetServerDescription;
    property ServerAddress: TEDBString read GetServerAddress write SetServerAddress;
    property ServerPort: Integer read GetServerPort write SetServerPort;
    property ServerThreadCacheSize: Integer read GetServerThreadCacheSize write SetServerThreadCacheSize;
    property ServerEncryptedOnly: Boolean read GetServerEncryptedOnly write SetServerEncryptedOnly;
    property ServerSessionTimeout: Integer read GetServerSessionTimeout write SetServerSessionTimeout;
    property ServerDeadSessionInterval: Integer read GetServerDeadSessionInterval write SetServerDeadSessionInterval;
    property ServerDeadSessionExpiration: Integer read GetServerDeadSessionExpiration write SetServerDeadSessionExpiration;
    property ServerMaxDeadSessions: Integer read GetServerMaxDeadSessions write SetServerMaxDeadSessions;
    property ServerAuthorizedAddresses: TEDBStrings read GetServerAuthorizedAddresses write SetServerAuthorizedAddresses;
    property ServerBlockedAddresses: TEDBStrings read GetServerBlockedAddresses write SetServerBlockedAddresses;
    property ServerRunJobs: Boolean read GetServerRunJobs write SetServerRunJobs;
    property ServerJobCategory: TEDBString read GetServerJobCategory write SetServerJobCategory;
  end;

  TElevateDBEngineProperties = class(TInterfacedObject,IElevateDBEngineProperties)
  protected
    function GetBackupExtension: TEDBString;
    function GetCatalogExtension: TEDBString;
    function GetCatalogName: TEDBString;
    function GetConfigExtension: TEDBString;
    function GetConfigName: TEDBString;
    function GetConfigPath: TEDBString;
    function GetEncryptionPassword: TEDBString;
    function GetEngineType: TEDBEngineType;
    function GetLargeFileSupport: Boolean;
    function GetLicensedSessions: Integer;
    function GetLockExtension: TEDBString;
    function GetLogCategories: TEDBLogCategories;
    function GetLogExtension: TEDBString;
    function GetMaxLogFileSize: Integer;
    function GetServerAddress: TEDBString;
    function GetServerAuthorizedAddresses: TEDBStrings;
    function GetServerBlockedAddresses: TEDBStrings;
    function GetServerDeadSessionExpiration: Integer;
    function GetServerDeadSessionInterval: Integer;
    function GetServerDescription: TEDBString;
    function GetServerEncryptedOnly: Boolean;
    function GetServerJobCategory: TEDBString;
    function GetServerMaxDeadSessions: Integer;
    function GetServerName: TEDBString;
    function GetServerPort: Integer;
    function GetServerRunJobs: Boolean;
    function GetServerSessionTimeout: Integer;
    function GetServerThreadCacheSize: Integer;
    function GetSignature: TEDBString;
    function GetTableBlobExtension: TEDBString;
    function GetTableExtension: TEDBString;
    function GetTableIndexExtension: TEDBString;
    function GetTempTablesPathProperty: TEDBString;
    procedure SetBackupExtension(const Value: TEDBString);
    procedure SetCatalogExtension(const Value: TEDBString);
    procedure SetCatalogName(const Value: TEDBString);
    procedure SetConfigExtension(const Value: TEDBString);
    procedure SetConfigName(const Value: TEDBString);
    procedure SetConfigPath(const Value: TEDBString);
    procedure SetEncryptionPassword(const Value: TEDBString);
    procedure SetEngineType(const Value: TEDBEngineType);
    procedure SetLargeFileSupport(const Value: Boolean);
    procedure SetLicensedSessions(const Value: Integer);
    procedure SetLockExtension(const Value: TEDBString);
    procedure SetLogCategories(const Value: TEDBLogCategories);
    procedure SetLogExtension(const Value: TEDBString);
    procedure SetMaxLogFileSize(const Value: Integer);
    procedure SetServerAddress(const Value: TEDBString);
    procedure SetServerAuthorizedAddresses(const Value: TEDBStrings);
    procedure SetServerBlockedAddresses(const Value: TEDBStrings);
    procedure SetServerDeadSessionExpiration(const Value: Integer);
    procedure SetServerDeadSessionInterval(const Value: Integer);
    procedure SetServerDescription(const Value: TEDBString);
    procedure SetServerEncryptedOnly(const Value: Boolean);
    procedure SetServerJobCategory(const Value: TEDBString);
    procedure SetServerMaxDeadSessions(const Value: Integer);
    procedure SetServerName(const Value: TEDBString);
    procedure SetServerPort(const Value: Integer);
    procedure SetServerRunJobs(const Value: Boolean);
    procedure SetServerSessionTimeout(const Value: Integer);
    procedure SetServerThreadCacheSize(const Value: Integer);
    procedure SetSignature(const Value: TEDBString);
    procedure SetTableBlobExtension(const Value: TEDBString);
    procedure SetTableExtension(const Value: TEDBString);
    procedure SetTableIndexExtension(const Value: TEDBString);
    procedure SetTempTablesPath(const Value: TEDBString);
  public
    property EngineType: TEDBEngineType read GetEngineType write SetEngineType;
    property Signature: TEDBString read GetSignature write SetSignature;
    property EncryptionPassword: TEDBString read GetEncryptionPassword write SetEncryptionPassword;
    property LargeFileSupport: Boolean read GetLargeFileSupport write SetLargeFileSupport;
    property LicensedSessions: Integer read GetLicensedSessions write SetLicensedSessions;
    property ConfigPath: TEDBString read GetConfigPath write SetConfigPath;
    property ConfigName: TEDBString read GetConfigName write SetConfigName;
    property ConfigExtension: TEDBString read GetConfigExtension write SetConfigExtension;
    property LockExtension: TEDBString read GetLockExtension write SetLockExtension;
    property LogExtension: TEDBString read GetLogExtension write SetLogExtension;
    property MaxLogFileSize: Integer read GetMaxLogFileSize write SetMaxLogFileSize;
    property LogCategories: TEDBLogCategories read GetLogCategories write SetLogCategories;
    property CatalogName: TEDBString read GetCatalogName write SetCatalogName;
    property CatalogExtension: TEDBString read GetCatalogExtension write SetCatalogExtension;
    property BackupExtension: TEDBString read GetBackupExtension write SetBackupExtension;
    property TableExtension: TEDBString read GetTableExtension write SetTableExtension;
    property TableIndexExtension: TEDBString read GetTableIndexExtension write SetTableIndexExtension;
    property TableBlobExtension: TEDBString read GetTableBlobExtension write SetTableBlobExtension;
    property TempTablesPath: TEDBString read GetTempTablesPathProperty write SetTempTablesPath;
    property ServerName: TEDBString read GetServerName write SetServerName;
    property ServerDescription: TEDBString read GetServerDescription write SetServerDescription;
    property ServerAddress: TEDBString read GetServerAddress write SetServerAddress;
    property ServerPort: Integer read GetServerPort write SetServerPort;
    property ServerThreadCacheSize: Integer read GetServerThreadCacheSize write SetServerThreadCacheSize;
    property ServerEncryptedOnly: Boolean read GetServerEncryptedOnly write SetServerEncryptedOnly;
    property ServerSessionTimeout: Integer read GetServerSessionTimeout write SetServerSessionTimeout;
    property ServerDeadSessionInterval: Integer read GetServerDeadSessionInterval write SetServerDeadSessionInterval;
    property ServerDeadSessionExpiration: Integer read GetServerDeadSessionExpiration write SetServerDeadSessionExpiration;
    property ServerMaxDeadSessions: Integer read GetServerMaxDeadSessions write SetServerMaxDeadSessions;
    property ServerAuthorizedAddresses: TEDBStrings read GetServerAuthorizedAddresses write SetServerAuthorizedAddresses;
    property ServerBlockedAddresses: TEDBStrings read GetServerBlockedAddresses write SetServerBlockedAddresses;
    property ServerRunJobs: Boolean read GetServerRunJobs write SetServerRunJobs;
    property ServerJobCategory: TEDBString read GetServerJobCategory write SetServerJobCategory;
  end;

  IElevateDBEngine = interface
    function EngineProperties: IElevateDBEngineProperties;
  end;

  IElevateDBSessionProperties = interface
    function GetForceBufferFlush: Boolean;
    function GetKeepConnections: Boolean;
    function GetKeepTablesOpen: Boolean;
    function GetProgressTimeInterval: Integer;
    function GetRecordChangeDetection: Boolean;
    function GetRecordLockProtocol: TEDBRecordLockProtocol;
    function GetRecordLockRetryCount: Integer;
    function GetRecordLockWaitTime: Integer;
    function GetRemoteAddress: TEDBString;
    function GetRemoteCompression: Integer;
    function GetRemoteEncryption: Boolean;
    function GetRemoteHost: TEDBString;
    function GetRemotePing: Boolean;
    function GetRemotePingInterval: Integer;
    function GetRemotePort: Integer;
    function GetRemoteService: TEDBString;
    function GetRemoteTimeout: Integer;
    function GetRemoteTrace: Boolean;
    function GetSessionType: TEDBSessionType;
    procedure SetForceBufferFlush(const Value: Boolean);
    procedure SetKeepTablesOpen(const Value: Boolean);
    procedure SetKeepConnections(const Value: Boolean);
    procedure SetProgressTimeInterval(const Value: Integer);
    procedure SetRecordChangeDetection(const Value: Boolean);
    procedure SetRecordLockProtocol(const Value: TEDBRecordLockProtocol);
    procedure SetRecordLockRetryCount(const Value: Integer);
    procedure SetRecordLockWaitTime(const Value: Integer);
    procedure SetRemoteAddress(const Value: TEDBString);
    procedure SetRemoteCompression(const Value: Integer);
    procedure SetRemoteEncryption(const Value: Boolean);
    procedure SetRemoteHost(const Value: TEDBString);
    procedure SetRemotePing(const Value: Boolean);
    procedure SetRemotePingInterval(const Value: Integer);
    procedure SetRemotePort(const Value: Integer);
    procedure SetRemoteService(const Value: TEDBString);
    procedure SetRemoteTimeout(const Value: Integer);
    procedure SetRemoteTrace(const Value: Boolean);
    procedure SetSessionType(const Value: TEDBSessionType);
    property ForceBufferFlush: Boolean read GetForceBufferFlush write SetForceBufferFlush;
    property KeepConnections: Boolean read GetKeepConnections write SetKeepConnections;
    property KeepTablesOpen: Boolean read GetKeepTablesOpen write SetKeepTablesOpen;
    property RecordLockProtocol: TEDBRecordLockProtocol read GetRecordLockProtocol write SetRecordLockProtocol;
    property RecordLockRetryCount: Integer read GetRecordLockRetryCount write SetRecordLockRetryCount;
    property RecordLockWaitTime: Integer read GetRecordLockWaitTime write SetRecordLockWaitTime;
    property RecordChangeDetection: Boolean read GetRecordChangeDetection write SetRecordChangeDetection;
    property ProgressTimeInterval: Integer read GetProgressTimeInterval write SetProgressTimeInterval;
    property SessionType: TEDBSessionType read GetSessionType write SetSessionType;
    property RemoteCompression: Integer read GetRemoteCompression write SetRemoteCompression;
    property RemoteEncryption: Boolean read GetRemoteEncryption write SetRemoteEncryption;
    property RemoteHost: TEDBString read GetRemoteHost write SetRemoteHost;
    property RemoteAddress: TEDBString read GetRemoteAddress write SetRemoteAddress;
    property RemotePort: Integer read GetRemotePort write SetRemotePort;
    property RemoteService: TEDBString read GetRemoteService write SetRemoteService;
    property RemoteTrace: Boolean read GetRemoteTrace write SetRemoteTrace;
    property RemoteTimeout: Integer read GetRemoteTimeout write SetRemoteTimeout;
    property RemotePing: Boolean read GetRemotePing write SetRemotePing;
    property RemotePingInterval: Integer read GetRemotePingInterval write SetRemotePingInterval;
  end;

  { TDAEEDBConnection }
  TDAEEDBConnection = class(TDAElevateDBConnection,IElevateDBEngine,IElevateDBSessionProperties)
  private
    FNativeSession: TEDBSession;
    fNativeDatabase: TEDBDatabase;
    FDataBasePath: String;
    FDataBaseName: string;
    procedure CheckConnected;
    function CreateConfigQuery: TDAEDataset;
  protected
    function GetForceBufferFlush: Boolean;
    function GetKeepConnections: Boolean;
    function GetKeepTablesOpen: Boolean;
    function GetProgressTimeInterval: Integer;
    function GetRecordChangeDetection: Boolean;
    function GetRecordLockProtocol: TEDBRecordLockProtocol;
    function GetRecordLockRetryCount: Integer;
    function GetRecordLockWaitTime: Integer;
    function GetRemoteAddress: TEDBString;
    function GetRemoteCompression: Integer;
    function GetRemoteEncryption: Boolean;
    function GetRemoteHost: TEDBString;
    function GetRemotePing: Boolean;
    function GetRemotePingInterval: Integer;
    function GetRemotePort: Integer;
    function GetRemoteService: TEDBString;
    function GetRemoteTimeout: Integer;
    function GetRemoteTrace: Boolean;
    function GetSessionType: TEDBSessionType;
    procedure SetForceBufferFlush(const Value: Boolean);
    procedure SetKeepTablesOpen(const Value: Boolean);
    procedure SetKeepConnections(const Value: Boolean);
    procedure SetProgressTimeInterval(const Value: Integer);
    procedure SetRecordChangeDetection(const Value: Boolean);
    procedure SetRecordLockProtocol(const Value: TEDBRecordLockProtocol);
    procedure SetRecordLockRetryCount(const Value: Integer);
    procedure SetRecordLockWaitTime(const Value: Integer);
    procedure SetRemoteAddress(const Value: TEDBString);
    procedure SetRemoteCompression(const Value: Integer);
    procedure SetRemoteEncryption(const Value: Boolean);
    procedure SetRemoteHost(const Value: TEDBString);
    procedure SetRemotePing(const Value: Boolean);
    procedure SetRemotePingInterval(const Value: Integer);
    procedure SetRemotePort(const Value: Integer);
    procedure SetRemoteService(const Value: TEDBString);
    procedure SetRemoteTimeout(const Value: Integer);
    procedure SetRemoteTrace(const Value: Boolean);
    procedure SetSessionType(const Value: TEDBSessionType);
  protected
    procedure SetConnected(Value: boolean); override; safecall;
    function CreateCustomConnection: TCustomConnection; override;
    //function CreateMacroProcessor: TDASQLMacroProcessor; override;
    function GetDatasetClass: TDAEDatasetClass; override;
    function GetStoredProcedureClass: TDAEStoredProcedureClass; override;
    procedure DoApplyConnectionString(aConnStrParser: TDAConnectionStringParser; aConnectionObject: TCustomConnection); override;
    // transaction support
    function DoBeginTransaction: integer; override;
    procedure DoCommitTransaction; override;
    procedure DoRollbackTransaction; override;
    function DoGetInTransaction: boolean; override;

    // procedure DoGetTableFields(const aTableName: string; out Fields: TDAFieldCollection); override;
    // procedure DoGetQueryFields(const aSQL: string; aParamsIfNeeded: TDAParamCollection; out Fields: TDAFieldCollection); override;
    // procedure DoGetViewFields(const aViewName: string; out Fields: TDAFieldCollection); override;

    // procedure DoGetStoredProcedureParams(const aStoredProcedureName: string; out Params: TDAParamCollection); override;
    // function DoGetLastAutoInc(const GeneratorName: string): integer; override;

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

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

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

    // function isAlive: Boolean; override; safecall;
    // function GetQueryBuilder: TDAQueryBuilder; override; safecall;

    { IDAUseGenerators }
    // function GetNextAutoinc(const GeneratorName: string): integer; safecall;
    { IElevateDBEngine }
    function EngineProperties: IElevateDBEngineProperties;
  public
    destructor Destroy; override;
  end;

  { TDAEElevDBQuery }
  TDAEElevDBQuery = class(TDAEDataset, IDASQLCommand , IDAMustSetParams)
  protected
    // procedure PrepareSQLStatement; override;
    procedure ClearParams; override;    
    function CreateDataset(aConnection: TDAEConnection): TDataset; override;
    procedure DoPrepare(Value: boolean); override; safecall;
    function DoExecute: integer; override; safecall;
    procedure DoSetSQL(const Value: string); override; safecall;
    function DoGetSQL: string; override; safecall;
    // function intVCLTypeToDAType(aFieldType: TFieldType): TDADataType;override;

    { IDASQLCommand }
    // procedure RefreshParams; override; safecall;
    function Execute: integer; override; safecall;
    // function DoGetRecordCount: integer; override;
    // function DoGetActive: boolean; override;
    // procedure DoSetActive(Value: boolean); override;
    // function DoGetBOF: boolean; override;
    // function DoGetEOF: boolean; override;
    // procedure DoNext; override;
    // function DoLocate(const KeyFields: string; const KeyValues: Variant; Options: TLocateOptions): Boolean; override;

    // IDAMustSetParams
    procedure SetParamValues(AParams: TDAParamCollection); override;{$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
    procedure GetParamValues(AParams: TDAParamCollection); override;{$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
  public
  end;

  { TDAEElevDBStoredProcedure }
  TDAEElevDBStoredProcedure = class(TDAEStoredProcedure, IDAStoredProcedure , IDAMustSetParams)
  protected
    // IDAStoredProcedure
    function GetStoredProcedureName: string; override; safecall;
    procedure SetStoredProcedureName(const Name: string); override; safecall;

    // procedure PrepareSQLStatement; override;
    function CreateDataset(aConnection: TDAEConnection): TDataset; override;
    procedure DoPrepare(Value: boolean); override; safecall;
    function DoExecute: integer; override; safecall;
    procedure DoSetSQL(const Value: string); override; safecall;
    function DoGetSQL: string; override; safecall;
    // function intVCLTypeToDAType(aFieldType: TFieldType): TDADataType;override;

    { IDASQLCommand }
    procedure RefreshParams; override; {$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
    function Execute: integer; override; safecall;
    // function DoGetRecordCount: integer; override;
    // function DoGetActive: boolean; override;
    // procedure DoSetActive(Value: boolean); override;
    // function DoGetBOF: boolean; override;
    // function DoGetEOF: boolean; override;
    // procedure DoNext; override;
    // function DoLocate(const KeyFields: string; const KeyValues: Variant; Options: TLocateOptions): Boolean; override;

    // IDAMustSetParams
    procedure SetParamValues(AParams: TDAParamCollection); override;{$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
    procedure GetParamValues(AParams: TDAParamCollection); override;{$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
  end;

procedure Register;

function GetDriverObject: IDADriver; stdcall;

implementation

uses SysUtils, uDADriverManager, uDARes, Variants, uDAMacroProcessors,
  Math, uDAHelpers, uROBinaryHelpers, Windows;

var
  _driver: TDAEDriver = nil;
   gEngineProperties: TElevateDBEngineProperties;

procedure Register;
begin
  RegisterComponents(DAPalettePageName, [TDAElevateDBDriver]);
end;

{$IFDEF DataAbstract_SchemaModelerOnly}
{$INCLUDE ..\DataAbstract_SchemaModelerOnly.inc}
{$ENDIF DataAbstract_SchemaModelerOnly}

function GetDriverObject: IDADriver;
begin
  {$IFDEF DataAbstract_SchemaModelerOnly}
  if not RunningInSchemaModeler then begin
    result := nil;
    exit;
  end;
  {$ENDIF}
  if (_driver = nil) then _driver := TDAEElevateDBDriver.Create(nil);
  result := _driver;
end;

{ TDAEEDBConnection }

procedure TDAEEDBConnection.DoApplyConnectionString(aConnStrParser: TDAConnectionStringParser; aConnectionObject: TCustomConnection);
var
  i: Integer;
  sName, sValue: string;
begin
  inherited;
  with aConnStrParser do begin
    if (Self.UserID <> '') then
      FNativeSession.LoginUser := Self.UserID
    else
      FNativeSession.LoginUser := UserID;

    if (Self.Password <> '') then
      FNativeSession.LoginPassword := Self.Password
    else
      FNativeSession.LoginPassword := Password;

    Session.RemoteAddress := Server;
//    Engine.ConfigPath := Database;
    FDataBasePath := Database;
    FDataBaseName := '';
    for i := 0 to AuxParamsCount - 1 do begin
      sName := AuxParamNames[i];
      if sName = '' then Continue;
      sValue := AuxParams[AuxParamNames[i]];
      // engine settings
      if SameText(sName,'EngineType') then begin
        if SameText(sValue,'etClient') then gEngineProperties.EngineType:=etClient
        else if SameText(sValue,'etServer') then gEngineProperties.EngineType:=etServer;
      end
      else if SameText(sName,'Signature') then gEngineProperties.Signature := sValue
      else if SameText(sName,'EncryptionPassword') then gEngineProperties.EncryptionPassword := sValue
      else if SameText(sName,'LargeFileSupport') then gEngineProperties.LargeFileSupport := StrToBoolDef(sValue, gEngineProperties.LargeFileSupport)
      else if SameText(sName,'LicensedSessions') then gEngineProperties.LicensedSessions := StrToIntDef(sValue, gEngineProperties.LicensedSessions)
      else if SameText(sName,'ConfigPath') then       gEngineProperties.ConfigPath := sValue
      else if SameText(sName,'ConfigName') then       gEngineProperties.ConfigName := sValue
      else if SameText(sName,'ConfigExtension') then  gEngineProperties.ConfigExtension := sValue
      else if SameText(sName,'LockExtension') then    gEngineProperties.LockExtension := sValue
      else if SameText(sName,'LogExtension') then     gEngineProperties.LogExtension := sValue
      else if SameText(sName,'MaxLogFileSize') then   gEngineProperties.MaxLogFileSize := StrToIntDef(sValue, gEngineProperties.MaxLogFileSize)
      else if SameText(sName,'CatalogName') then      gEngineProperties.CatalogName := sValue
      else if SameText(sName,'CatalogExtension') then gEngineProperties.CatalogExtension := sValue
      else if SameText(sName,'BackupExtension') then  gEngineProperties.BackupExtension := sValue
      else if SameText(sName,'TableExtension') then   gEngineProperties.TableExtension := sValue
      else if SameText(sName,'TableIndexExtension') then gEngineProperties.TableIndexExtension := sValue
      else if SameText(sName,'TableBlobExtension') then  gEngineProperties.TableBlobExtension := sValue
      else if SameText(sName,'TempTablesPath') then      gEngineProperties.TempTablesPath := sValue
      else if SameText(sName,'ServerName') then          gEngineProperties.ServerName := sValue
      else if SameText(sName,'ServerDescription') then   gEngineProperties.ServerDescription := sValue
      else if SameText(sName,'ServerPort') then          gEngineProperties.ServerPort := StrToIntDef(sValue, gEngineProperties.ServerPort)
      else if SameText(sName,'ServerThreadCacheSize') then gEngineProperties.ServerThreadCacheSize := StrToIntDef(sValue, gEngineProperties.ServerThreadCacheSize)
      else if SameText(sName,'ServerEncryptedOnly') then   gEngineProperties.ServerEncryptedOnly := StrToBoolDef(sValue, gEngineProperties.ServerEncryptedOnly)
      else if SameText(sName,'ServerSessionTimeout') then  gEngineProperties.ServerSessionTimeout := StrToIntDef(sValue, gEngineProperties.ServerSessionTimeout)
      else if SameText(sName,'ServerDeadSessionInterval') then gEngineProperties.ServerDeadSessionInterval := StrToIntDef(sValue, gEngineProperties.ServerDeadSessionInterval)
      else if SameText(sName,'ServerDeadSessionExpiration') then gEngineProperties.ServerDeadSessionExpiration := StrToIntDef(sValue, gEngineProperties.ServerDeadSessionExpiration)
      else if SameText(sName,'ServerMaxDeadSessions') then gEngineProperties.ServerMaxDeadSessions := StrToIntDef(sValue, gEngineProperties.ServerMaxDeadSessions)
      else if SameText(sName,'ServerRunJobs') then         gEngineProperties.ServerRunJobs := StrToBoolDef(sValue, gEngineProperties.ServerRunJobs)
      else if SameText(sName,'ServerJobCategory') then     gEngineProperties.ServerJobCategory := sValue
      // session settings
      else if SameText(sName,'ForceBufferFlush') then FNativeSession.ForceBufferFlush := StrToBoolDef(sValue, FNativeSession.ForceBufferFlush)
      else if SameText(sName,'KeepConnections') then FNativeSession.KeepConnections := StrToBoolDef(sValue, FNativeSession.KeepConnections)
      else if SameText(sName,'KeepTablesOpen') then FNativeSession.KeepTablesOpen := StrToBoolDef(sValue, FNativeSession.KeepTablesOpen)
      else if SameText(sName,'RecordLockProtocol') then begin
        if SameText(sValue,'lpPessimistic') then FNativeSession.RecordLockProtocol:=lpPessimistic
        else if SameText(sValue,'lpOptimistic') then FNativeSession.RecordLockProtocol:=lpOptimistic;
      end
      else if SameText(sName,'RecordLockRetryCount') then FNativeSession.RecordLockRetryCount := StrToIntDef(sValue, fNativeSession.RecordLockRetryCount)
      else if SameText(sName,'RecordLockWaitTime') then fNativeSession.RecordLockWaitTime := StrToIntDef(sValue, fNativeSession.RecordLockWaitTime)
      else if SameText(sName,'RecordChangeDetection') then FNativeSession.RecordChangeDetection := StrToBoolDef(sValue, FNativeSession.RecordChangeDetection)
      else if SameText(sName,'ProgressTimeInterval') then fNativeSession.ProgressTimeInterval := StrToIntDef(sValue, fNativeSession.ProgressTimeInterval)
      else if SameText(sName,'SessionType') then begin
        if SameText(sValue,'stLocal') then FNativeSession.SessionType:=stLocal
        else if SameText(sValue,'stRemote') then FNativeSession.SessionType:=stRemote;
      end
      else if SameText(sName,'RemoteCompression') then fNativeSession.RemoteCompression := StrToIntDef(sValue, fNativeSession.RemoteCompression)
      else if SameText(sName,'RemoteEncryption') then FNativeSession.RemoteEncryption := StrToBoolDef(sValue, FNativeSession.RemoteEncryption)
      else if SameText(sName,'RemoteHost') then fNativeSession.RemoteHost := sValue
      else if SameText(sName,'RemoteAddress') then fNativeSession.RemoteAddress := sValue
      else if SameText(sName,'RemotePort') then fNativeSession.RemotePort := StrToIntDef(sValue, fNativeSession.RemotePort)
      else if SameText(sName,'RemoteService') then fNativeSession.RemoteService := sValue
      else if SameText(sName,'RemoteTrace') then FNativeSession.RemoteTrace := StrToBoolDef(sValue, FNativeSession.RemoteTrace)
      else if SameText(sName,'RemoteTimeout') then fNativeSession.RemoteTimeout := StrToIntDef(sValue, fNativeSession.RemoteTimeout)
      else if SameText(sName,'RemotePing') then FNativeSession.RemotePing := StrToBoolDef(sValue, FNativeSession.RemotePing)
      else if SameText(sName,'RemotePingInterval') then fNativeSession.RemotePingInterval := StrToIntDef(sValue, fNativeSession.RemotePingInterval)
      //
      else if SameText(sName,'DataBaseName') then FDataBaseName:=sValue;
    end;
    fNativeDatabase.DatabaseName := FDataBaseName;
    fNativeDatabase.Database := FDataBaseName;
  end;
end;

function TDAEEDBConnection.DoBeginTransaction: integer;
begin
  CheckConnected;
  fNativeDatabase.StartTransaction(EmptyEDBStringsArray);
  Result := 0;
end;

procedure TDAEEDBConnection.DoCommitTransaction;
begin
  CheckConnected;
  fNativeDatabase.Commit;
end;

function TDAEEDBConnection.CreateCustomConnection: TCustomConnection;
begin
  FNativeSession := TEDBSession.Create(nil);
  FNativeSession.AutoSessionName:=True;
  fNativeDatabase := TEDBDatabase.Create(nil);
  fNativeDatabase.SessionName := FNativeSession.SessionName;
  result := fNativeDatabase;
end;

function TDAEEDBConnection.GetDatasetClass: TDAEDatasetClass;
begin
  result := TDAEElevDBQuery;
end;

function TDAEEDBConnection.GetStoredProcedureClass: TDAEStoredProcedureClass;
begin
  result := TDAEElevDBStoredProcedure;
end;

procedure TDAEEDBConnection.DoRollbackTransaction;
begin
  CheckConnected;
  fNativeDatabase.Rollback;
end;

function TDAEEDBConnection.DoGetInTransaction: boolean;
begin
  CheckConnected;
  Result := fNativeDatabase.InTransaction;
end;


procedure TDAEEDBConnection.SetConnected(Value: boolean);
begin
  if (fNativeDatabase <> nil) then
    if Value then begin
      FNativeSession.Connected:=True;
      ElevateDB_RegisterDatabase(CreateConfigQuery,fNativeDatabase.DatabaseName,FDataBasePath);
      fNativeDatabase.Connected:=True;
    end
    else begin
      fNativeDatabase.Connected:=False;
      FNativeSession.Connected:=False;
    end;
end;

procedure TDAEEDBConnection.CheckConnected;
begin
  if not fNativeDatabase.Connected then SetConnected(True);
end;

destructor TDAEEDBConnection.Destroy;
begin
  FNativeSession.Free;
  Engine.Active:=False;
  inherited;
end;

function TDAEEDBConnection.CreateConfigQuery: TDAEDataset;
begin
  Result:= GetDatasetClass.Create(Self);
  TEDBQuery(TDAEElevDBQuery(Result).Dataset).DatabaseName := ElevateDB_ConfigDBName;
end;

function TDAEEDBConnection.EngineProperties: IElevateDBEngineProperties;
begin
  Result:= gEngineProperties;
end;

function TDAEEDBConnection.GetForceBufferFlush: Boolean;
begin
  Result := FNativeSession.ForceBufferFlush;
end;

function TDAEEDBConnection.GetKeepConnections: Boolean;
begin
  Result := FNativeSession.KeepConnections;
end;

function TDAEEDBConnection.GetKeepTablesOpen: Boolean;
begin
  Result := FNativeSession.KeepTablesOpen;
end;

function TDAEEDBConnection.GetProgressTimeInterval: Integer;
begin
  Result := FNativeSession.ProgressTimeInterval;
end;

function TDAEEDBConnection.GetRecordChangeDetection: Boolean;
begin
  Result := FNativeSession.RecordChangeDetection;
end;

function TDAEEDBConnection.GetRecordLockProtocol: TEDBRecordLockProtocol;
begin
  Result := FNativeSession.RecordLockProtocol;
end;

function TDAEEDBConnection.GetRecordLockRetryCount: Integer;
begin
  Result := FNativeSession.RecordLockRetryCount;
end;

function TDAEEDBConnection.GetRecordLockWaitTime: Integer;
begin
  Result := FNativeSession.RecordLockWaitTime;
end;

function TDAEEDBConnection.GetRemoteAddress: TEDBString;
begin
  Result := FNativeSession.RemoteAddress;
end;

function TDAEEDBConnection.GetRemoteCompression: Integer;
begin
  Result := FNativeSession.RemoteCompression;
end;

function TDAEEDBConnection.GetRemoteEncryption: Boolean;
begin
  Result := FNativeSession.RemoteEncryption;
end;

function TDAEEDBConnection.GetRemoteHost: TEDBString;
begin
  Result := FNativeSession.RemoteHost;
end;

function TDAEEDBConnection.GetRemotePing: Boolean;
begin
  Result := FNativeSession.RemotePing;
end;

function TDAEEDBConnection.GetRemotePingInterval: Integer;
begin
  Result := FNativeSession.RemotePingInterval;
end;

function TDAEEDBConnection.GetRemotePort: Integer;
begin
  Result := FNativeSession.RemotePort;
end;

function TDAEEDBConnection.GetRemoteService: TEDBString;
begin
  Result := FNativeSession.RemoteService;
end;

function TDAEEDBConnection.GetRemoteTimeout: Integer;
begin
  Result := FNativeSession.RemoteTimeout;
end;

function TDAEEDBConnection.GetRemoteTrace: Boolean;
begin
  Result := FNativeSession.RemoteTrace;
end;

function TDAEEDBConnection.GetSessionType: TEDBSessionType;
begin
  Result := FNativeSession.SessionType;
end;

procedure TDAEEDBConnection.SetForceBufferFlush(const Value: Boolean);
begin
  FNativeSession.ForceBufferFlush := Value;
end;

procedure TDAEEDBConnection.SetKeepConnections(const Value: Boolean);
begin
  FNativeSession.KeepConnections := Value;
end;

procedure TDAEEDBConnection.SetKeepTablesOpen(const Value: Boolean);
begin
  FNativeSession.KeepTablesOpen := Value;
end;

procedure TDAEEDBConnection.SetProgressTimeInterval(const Value: Integer);
begin
  FNativeSession.ProgressTimeInterval := Value;
end;

procedure TDAEEDBConnection.SetRecordChangeDetection(const Value: Boolean);
begin
  FNativeSession.RecordChangeDetection := Value;
end;

procedure TDAEEDBConnection.SetRecordLockProtocol(
  const Value: TEDBRecordLockProtocol);
begin
  FNativeSession.RecordLockProtocol := Value;
end;

procedure TDAEEDBConnection.SetRecordLockRetryCount(const Value: Integer);
begin
  FNativeSession.RecordLockRetryCount := Value;
end;

procedure TDAEEDBConnection.SetRecordLockWaitTime(const Value: Integer);
begin
  FNativeSession.RecordLockWaitTime := Value;
end;

procedure TDAEEDBConnection.SetRemoteAddress(const Value: TEDBString);
begin
  FNativeSession.RemoteAddress := Value;
end;

procedure TDAEEDBConnection.SetRemoteCompression(const Value: Integer);
begin
  FNativeSession.RemoteCompression := Value;
end;

procedure TDAEEDBConnection.SetRemoteEncryption(const Value: Boolean);
begin
  FNativeSession.RemoteEncryption := Value;
end;

procedure TDAEEDBConnection.SetRemoteHost(const Value: TEDBString);
begin
  FNativeSession.RemoteHost := Value;
end;

procedure TDAEEDBConnection.SetRemotePing(const Value: Boolean);
begin
  FNativeSession.RemotePing := Value;
end;

procedure TDAEEDBConnection.SetRemotePingInterval(const Value: Integer);
begin
  FNativeSession.RemotePingInterval := Value;
end;

procedure TDAEEDBConnection.SetRemotePort(const Value: Integer);
begin
  FNativeSession.RemotePort := Value;
end;

procedure TDAEEDBConnection.SetRemoteService(const Value: TEDBString);
begin
  FNativeSession.RemoteService := Value;
end;

procedure TDAEEDBConnection.SetRemoteTimeout(const Value: Integer);
begin
  FNativeSession.RemoteTimeout := Value;
end;

procedure TDAEEDBConnection.SetRemoteTrace(const Value: Boolean);
begin
  FNativeSession.RemoteTrace := Value;
end;

procedure TDAEEDBConnection.SetSessionType(const Value: TEDBSessionType);
begin
  FNativeSession.SessionType := Value;
end;

function TDAEEDBConnection.GetSPSelectSyntax(
  HasArguments: Boolean): string;
begin
  Result:= ''; // not supported!
end;

{ TDAEElevateDBDriver }

procedure TDAEElevateDBDriver.GetAuxDrivers(out List: IROStrings);
begin
  inherited;
 // List.Add('Driver1');
 // List.Add('Driver2');
end;

procedure TDAEElevateDBDriver.GetAuxParams(const AuxDriver: string;
  out List: IROStrings);
begin
  inherited;
  List.Add('DataBaseName=<string>');
  List.Add('ForceBufferFlush=(True,False)');
  List.Add('KeepConnections=(True,False)');
  List.Add('KeepTablesOpen=(True,False)');
  List.Add('RecordLockProtocol=(lpPessimistic,lpOptimistic)');
  List.Add('RecordLockRetryCount=<number>');
  List.Add('RecordLockWaitTime=<number>');
  List.Add('RecordChangeDetection=(True,False)');
  List.Add('ProgressTimeInterval=<number>');
  List.Add('SessionType=(stLocal,stRemote)');
  List.Add('RemoteCompression=<number>');
  List.Add('RemoteEncryption=(True,False)');
  List.Add('RemoteHost=<string>');
  List.Add('RemoteAddress=<string>');
  List.Add('RemotePort=<number>');
  List.Add('RemoteService=<string>');
  List.Add('RemoteTrace=(True,False)');
  List.Add('RemoteTimeout=<number>');
  List.Add('RemotePing=(True,False)');
  List.Add('RemotePingInterval=<number>');
  List.Add('');
  List.Add('=== Global Engine Options ===');
  List.Add('EngineType=(etClient,etServer)');
  List.Add('Signature=<string>');
  List.Add('EncryptionPassword=<string>');
  List.Add('LargeFileSupport=(True,False)');
  List.Add('LicensedSessions=<number>');
  List.Add('ConfigPath=<string>');
  List.Add('ConfigName=<string>');
  List.Add('ConfigExtension=<string>');
  List.Add('LockExtension=<string>');
  List.Add('LogExtension=<string>');
  List.Add('MaxLogFileSize=<number>');
  List.Add('CatalogName=<string>');
  List.Add('CatalogExtension=<string>');
  List.Add('BackupExtension=<string>');
  List.Add('TableExtension=<string>');
  List.Add('TableIndexExtension=<string>');
  List.Add('TableBlobExtension=<string>');
  List.Add('TempTablesPath=<string>');
  List.Add('ServerName=<string>');
  List.Add('ServerDescription=<string>');
  List.Add('ServerPort=<number>');
  List.Add('ServerThreadCacheSize=<number>');
  List.Add('ServerEncryptedOnly=(True,False)');
  List.Add('ServerSessionTimeout=<number>');
  List.Add('ServerDeadSessionInterval=<number>');
  List.Add('ServerDeadSessionExpiration=<number>');
  List.Add('ServerMaxDeadSessions=<number>');
  List.Add('ServerRunJobs=(True,False)');
  List.Add('ServerJobCategory=<string>');
end;

function TDAEElevateDBDriver.GetAvailableDriverOptions: TDAAvailableDriverOptions;
begin
  Result:=[doServerName, doDatabaseName, doLogin, doCustom];
end;

function TDAEElevateDBDriver.GetConnectionClass: TDAEConnectionClass;
begin
  result := TDAEEDBConnection;
end;


function TDAEElevateDBDriver.GetDescription: string;
begin
  result := 'ElevateDB Driver'{$IFDEF DataAbstract_SchemaModelerOnly} + SchemaModelerOnly{$ENDIF};
end;

function TDAEElevateDBDriver.GetDriverID: string;
begin
  result := 'ElevateDB';
end;

function TDAEElevateDBDriver.GetProviderDefaultCustomParameters(
  Provider: string): string;
begin
  Result:='DataBaseName=<please specify>';
end;

{ TDAEElevDBQuery }

procedure TDAEElevDBQuery.ClearParams;
begin
  inherited;
  TEDBQuery(Dataset).Params.Clear;
end;

function TDAEElevDBQuery.CreateDataset(aConnection: TDAEConnection): TDataset;
begin
  Result := TEDBQuery.Create(nil);
  TEDBQuery(Result).SessionName := TDAEEDBConnection(aConnection).fNativeDatabase.SessionName;
  TEDBQuery(Result).DatabaseName := TDAEEDBConnection(aConnection).fNativeDatabase.DatabaseName;
end;

function TDAEElevDBQuery.DoExecute: integer;
begin
  TEDBQuery(Dataset).ExecSQL;
  Result:=TEDBQuery(Dataset).RowsAffected;
end;

function TDAEElevDBQuery.DoGetSQL: string;
begin
  Result := TEDBQuery(Dataset).SQL.Text;
end;

procedure TDAEElevDBQuery.DoPrepare(Value: boolean);
begin
//nothing
  TEDBQuery(Dataset).Prepared:= Value;
end;

procedure TDAEElevDBQuery.DoSetSQL(const Value: string);
begin
  TEDBQuery(Dataset).SQL.Text := Value;
end;

function TDAEElevDBQuery.Execute: integer;
begin
  SetParamValues(GetParams);
  Result:= DoExecute;
  GetParamValues(GetParams);
end;

procedure TDAEElevDBQuery.GetParamValues(AParams: TDAParamCollection);
begin
  GetParamValuesStd(AParams, TEDBQuery(Dataset).Params);
end;

procedure TDAEElevDBQuery.SetParamValues(AParams: TDAParamCollection);
begin
  SetParamValuesStd(AParams, TEDBQuery(Dataset).Params);
end;

{ TDAEElevDBStoredProcedure }

function TDAEElevDBStoredProcedure.CreateDataset(aConnection: TDAEConnection): TDataset;
begin
  result := TEDBStoredProc.Create(nil);
  TEDBStoredProc(Result).SessionName := TDAEEDBConnection(aConnection).fNativeDatabase.SessionName;
  TEDBStoredProc(Result).DatabaseName := TDAEEDBConnection(aConnection).fNativeDatabase.DatabaseName;
end;

function TDAEElevDBStoredProcedure.Execute: integer;
begin
  TEDBStoredProc(Dataset).Prepare;
  SetParamValues(GetParams);
  Result:= DoExecute;
  //Result:=TEDBStoredProc(Dataset).RecordCount;
  GetParamValues(GetParams);
end;

function TDAEElevDBStoredProcedure.DoGetSQL: string;
begin
  Result := '';
end;

procedure TDAEElevDBStoredProcedure.DoPrepare(Value: boolean);
begin
  TEDBStoredProc(Dataset).Prepared:=Value;
end;

procedure TDAEElevDBStoredProcedure.DoSetSQL(const Value: string);
begin
  //
end;

procedure TDAEElevDBStoredProcedure.GetParamValues(
  AParams: TDAParamCollection);
begin
  GetParamValuesStd(AParams, TEDBStoredProc(Dataset).Params);
end;

function TDAEElevDBStoredProcedure.GetStoredProcedureName: string;
begin
  Result := TEDBStoredProc(Dataset).StoredProcName;
end;

procedure TDAEElevDBStoredProcedure.RefreshParams;
var
  lField: TField;
  i: integer;
  par: TDAParam;
begin
  DoPrepare(False);
  DoPrepare(True);
  RefreshParamsStd(TEDBStoredProc(Dataset).Params);
  For i:=0 to TEDBStoredProc(Dataset).FieldCount-1 do begin
    par := GetParams.Add;
    lField:=TEDBStoredProc(Dataset).Fields[i];
    par.Name := lField.Name;
    par.DataType := intVCLTypeToDAType(lField.DataType);
    par.ParamType := daptOutput;
    par.Size := lField.Size;
  end;
end;

procedure TDAEElevDBStoredProcedure.SetParamValues(
  AParams: TDAParamCollection);
begin
  SetParamValuesStd(AParams, TEDBStoredProc(Dataset).Params);
end;

procedure TDAEElevDBStoredProcedure.SetStoredProcedureName(
  const Name: string);
begin
  TEDBStoredProc(Dataset).StoredProcName := Name;
end;

function TDAEElevDBStoredProcedure.DoExecute: integer;
begin
  TEDBStoredProc(Dataset).ExecProc;
  Result:=0;
end;

{ TElevateDBEngineProperties }

function TElevateDBEngineProperties.GetBackupExtension: TEDBString;
begin
  Result := edbcomps.Engine.BackupExtension;
end;

function TElevateDBEngineProperties.GetCatalogExtension: TEDBString;
begin
  Result := edbcomps.Engine.CatalogExtension;
end;

function TElevateDBEngineProperties.GetCatalogName: TEDBString;
begin
  Result := edbcomps.Engine.CatalogName;
end;

function TElevateDBEngineProperties.GetConfigExtension: TEDBString;
begin
  Result := edbcomps.Engine.ConfigExtension;
end;

function TElevateDBEngineProperties.GetConfigName: TEDBString;
begin
  Result := edbcomps.Engine.ConfigName;
end;

function TElevateDBEngineProperties.GetConfigPath: TEDBString;
begin
  Result := edbcomps.Engine.ConfigPath;
end;

function TElevateDBEngineProperties.GetEncryptionPassword: TEDBString;
begin
  Result := edbcomps.Engine.EncryptionPassword;
end;

function TElevateDBEngineProperties.GetEngineType: TEDBEngineType;
begin
  Result := edbcomps.Engine.EngineType;
end;

function TElevateDBEngineProperties.GetLargeFileSupport: Boolean;
begin
  Result := edbcomps.Engine.LargeFileSupport;
end;

function TElevateDBEngineProperties.GetLicensedSessions: Integer;
begin
  Result := edbcomps.Engine.LicensedSessions;
end;

function TElevateDBEngineProperties.GetLockExtension: TEDBString;
begin
  Result := edbcomps.Engine.LockExtension;
end;

function TElevateDBEngineProperties.GetLogCategories: TEDBLogCategories;
begin
  Result := edbcomps.Engine.LogCategories;
end;

function TElevateDBEngineProperties.GetLogExtension: TEDBString;
begin
  Result := edbcomps.Engine.LogExtension;
end;

function TElevateDBEngineProperties.GetMaxLogFileSize: Integer;
begin
  Result := edbcomps.Engine.MaxLogFileSize;
end;

function TElevateDBEngineProperties.GetServerAddress: TEDBString;
begin
  Result := edbcomps.Engine.ServerAddress;
end;

function TElevateDBEngineProperties.GetServerAuthorizedAddresses: TEDBStrings;
begin
  Result := edbcomps.Engine.ServerAuthorizedAddresses;
end;

function TElevateDBEngineProperties.GetServerBlockedAddresses: TEDBStrings;
begin
  Result := edbcomps.Engine.ServerBlockedAddresses;
end;

function TElevateDBEngineProperties.GetServerDeadSessionExpiration: Integer;
begin
  Result := edbcomps.Engine.ServerDeadSessionExpiration;
end;

function TElevateDBEngineProperties.GetServerDeadSessionInterval: Integer;
begin
  Result := edbcomps.Engine.ServerDeadSessionInterval;
end;

function TElevateDBEngineProperties.GetServerDescription: TEDBString;
begin
  Result := edbcomps.Engine.ServerDescription;
end;

function TElevateDBEngineProperties.GetServerEncryptedOnly: Boolean;
begin
  Result := edbcomps.Engine.ServerEncryptedOnly;
end;

function TElevateDBEngineProperties.GetServerJobCategory: TEDBString;
begin
  Result := edbcomps.Engine.ServerJobCategory;
end;

function TElevateDBEngineProperties.GetServerMaxDeadSessions: Integer;
begin
  Result := edbcomps.Engine.ServerMaxDeadSessions;
end;

function TElevateDBEngineProperties.GetServerName: TEDBString;
begin
  Result := edbcomps.Engine.ServerName;
end;

function TElevateDBEngineProperties.GetServerPort: Integer;
begin
  Result := edbcomps.Engine.ServerPort;
end;

function TElevateDBEngineProperties.GetServerRunJobs: Boolean;
begin
  Result := edbcomps.Engine.ServerRunJobs;
end;

function TElevateDBEngineProperties.GetServerSessionTimeout: Integer;
begin
  Result := edbcomps.Engine.ServerSessionTimeout;
end;

function TElevateDBEngineProperties.GetServerThreadCacheSize: Integer;
begin
  Result := edbcomps.Engine.ServerThreadCacheSize;
end;

function TElevateDBEngineProperties.GetSignature: TEDBString;
begin
  Result := edbcomps.Engine.Signature;
end;

function TElevateDBEngineProperties.GetTableBlobExtension: TEDBString;
begin
  Result := edbcomps.Engine.TableBlobExtension;
end;

function TElevateDBEngineProperties.GetTableExtension: TEDBString;
begin
  Result := edbcomps.Engine.TableExtension;
end;

function TElevateDBEngineProperties.GetTableIndexExtension: TEDBString;
begin
  Result := edbcomps.Engine.TableIndexExtension;
end;

function TElevateDBEngineProperties.GetTempTablesPathProperty: TEDBString;
begin
  Result := edbcomps.Engine.TempTablesPath;
end;

procedure TElevateDBEngineProperties.SetBackupExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.BackupExtension := Value;
end;

procedure TElevateDBEngineProperties.SetCatalogExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.CatalogExtension := Value;
end;

procedure TElevateDBEngineProperties.SetCatalogName(
  const Value: TEDBString);
begin
  edbcomps.Engine.CatalogName := Value;
end;

procedure TElevateDBEngineProperties.SetConfigExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.ConfigExtension := Value;
end;

procedure TElevateDBEngineProperties.SetConfigName(
  const Value: TEDBString);
begin
  edbcomps.Engine.ConfigName := Value;
end;

procedure TElevateDBEngineProperties.SetConfigPath(
  const Value: TEDBString);
begin
  edbcomps.Engine.ConfigPath := Value;
end;

procedure TElevateDBEngineProperties.SetEncryptionPassword(
  const Value: TEDBString);
begin
  edbcomps.Engine.EncryptionPassword := Value;
end;

procedure TElevateDBEngineProperties.SetEngineType(
  const Value: TEDBEngineType);
begin
  edbcomps.Engine.EngineType := Value;
end;

procedure TElevateDBEngineProperties.SetLargeFileSupport(
  const Value: Boolean);
begin
  edbcomps.Engine.LargeFileSupport := Value;
end;

procedure TElevateDBEngineProperties.SetLicensedSessions(
  const Value: Integer);
begin
  edbcomps.Engine.LicensedSessions := Value;
end;

procedure TElevateDBEngineProperties.SetLockExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.LockExtension := Value;
end;

procedure TElevateDBEngineProperties.SetLogCategories(
  const Value: TEDBLogCategories);
begin
  edbcomps.Engine.LogCategories := Value;
end;

procedure TElevateDBEngineProperties.SetLogExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.LogExtension := Value;
end;

procedure TElevateDBEngineProperties.SetMaxLogFileSize(
  const Value: Integer);
begin
  edbcomps.Engine.MaxLogFileSize := Value;
end;

procedure TElevateDBEngineProperties.SetServerAddress(
  const Value: TEDBString);
begin
  edbcomps.Engine.ServerAddress := Value;
end;

procedure TElevateDBEngineProperties.SetServerAuthorizedAddresses(
  const Value: TEDBStrings);
begin
  edbcomps.Engine.ServerAuthorizedAddresses := Value;
end;

procedure TElevateDBEngineProperties.SetServerBlockedAddresses(
  const Value: TEDBStrings);
begin
  edbcomps.Engine.ServerBlockedAddresses := Value;
end;

procedure TElevateDBEngineProperties.SetServerDeadSessionExpiration(
  const Value: Integer);
begin
  edbcomps.Engine.ServerDeadSessionExpiration := Value;
end;

procedure TElevateDBEngineProperties.SetServerDeadSessionInterval(
  const Value: Integer);
begin
  edbcomps.Engine.ServerDeadSessionInterval := Value;
end;

procedure TElevateDBEngineProperties.SetServerDescription(
  const Value: TEDBString);
begin
  edbcomps.Engine.ServerDescription := Value;
end;

procedure TElevateDBEngineProperties.SetServerEncryptedOnly(
  const Value: Boolean);
begin
  edbcomps.Engine.ServerEncryptedOnly := Value;
end;

procedure TElevateDBEngineProperties.SetServerJobCategory(
  const Value: TEDBString);
begin
  edbcomps.Engine.ServerJobCategory := Value;
end;

procedure TElevateDBEngineProperties.SetServerMaxDeadSessions(
  const Value: Integer);
begin
  edbcomps.Engine.ServerMaxDeadSessions := Value;
end;

procedure TElevateDBEngineProperties.SetServerName(
  const Value: TEDBString);
begin
  edbcomps.Engine.ServerName := Value;
end;

procedure TElevateDBEngineProperties.SetServerPort(const Value: Integer);
begin
  edbcomps.Engine.ServerPort := Value;
end;

procedure TElevateDBEngineProperties.SetServerRunJobs(
  const Value: Boolean);
begin
  edbcomps.Engine.ServerRunJobs := Value;
end;

procedure TElevateDBEngineProperties.SetServerSessionTimeout(
  const Value: Integer);
begin
  edbcomps.Engine.ServerSessionTimeout := Value;
end;

procedure TElevateDBEngineProperties.SetServerThreadCacheSize(
  const Value: Integer);
begin
  edbcomps.Engine.ServerThreadCacheSize := Value;
end;

procedure TElevateDBEngineProperties.SetSignature(const Value: TEDBString);
begin
  edbcomps.Engine.Signature := Value;
end;

procedure TElevateDBEngineProperties.SetTableBlobExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.TableBlobExtension := Value;
end;

procedure TElevateDBEngineProperties.SetTableExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.TableExtension := Value;
end;

procedure TElevateDBEngineProperties.SetTableIndexExtension(
  const Value: TEDBString);
begin
  edbcomps.Engine.TableIndexExtension := Value;
end;

procedure TElevateDBEngineProperties.SetTempTablesPath(
  const Value: TEDBString);
begin
  edbcomps.Engine.TempTablesPath := Value;
end;

exports
  GetDriverObject name func_GetDriverObject;

initialization
  _driver := nil;
  RegisterDriverProc(GetDriverObject);
  gEngineProperties := TElevateDBEngineProperties.Create;
finalization
  gEngineProperties := nil;
  UnregisterDriverProc(GetDriverObject);
  FreeAndNIL(_driver);
end.