david
e4d0fcb01d
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.RemObjects@46 b6239004-a887-0f4b-9937-50029ccdca16
1111 lines
36 KiB
ObjectPascal
1111 lines
36 KiB
ObjectPascal
unit uDADBISAMDriver;
|
|
|
|
{----------------------------------------------------------------------------}
|
|
{ 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.
|
|
{----------------------------------------------------------------------------}
|
|
|
|
{$IFDEF MSWINDOWS}
|
|
{$I ..\DataAbstract.inc}
|
|
{$ELSE}
|
|
{$I ../DataAbstract.inc}
|
|
{$ENDIF}
|
|
|
|
|
|
{$R DataAbstract_DBISAMDriver_Glyphs.res}
|
|
|
|
{$I dbisamvr.inc}
|
|
{$IFNDEF DBISAM_V4}
|
|
{$DEFINE DBISAM_V3}
|
|
{$ENDIF}
|
|
|
|
interface
|
|
|
|
uses DB, Classes, uDAEngine, uDAInterfaces, uROClasses, DBISAMTb, uDAUtils;
|
|
|
|
type
|
|
{ TDADBISAMDriver }
|
|
TDADBISAMDriver = class(TDADriverReference)
|
|
end;
|
|
|
|
{ IDBISAMConnection }
|
|
IDBISAMConnection = interface
|
|
['{C6222EF8-FBAE-42AE-B034-8FFAE8FF2578}']
|
|
end;
|
|
|
|
{ IDBISAMConnectionProperties
|
|
Provides access to common properties of DBISAM connections }
|
|
|
|
IDBISAMConnectionProperties = interface
|
|
['{41BAFCD6-D6EA-477E-B489-7EA6E05FFCC0}']
|
|
function GetForceBufferFlush: Boolean;
|
|
procedure SetForceBufferFlush(Value: Boolean);
|
|
function GetKeepConnections: Boolean;
|
|
procedure SetKeepConnections(Value: Boolean);
|
|
function GetLockProtocol: TLockProtocol;
|
|
procedure SetLockProtocol(Value: TLockProtocol);
|
|
function GetLockRetryCount: Byte;
|
|
procedure SetLockRetryCount(Value: Byte);
|
|
function GetLockWaitTime: Word;
|
|
procedure SetLockWaitTime(Value: Word);
|
|
function GetPrivateDir: string;
|
|
procedure SetPrivateDir(const Value: string);
|
|
function GetRemotePort: Integer;
|
|
procedure SetRemotePort(Value: Integer);
|
|
function GetRemoteService: string;
|
|
procedure SetRemoteService(const Value: string);
|
|
function GetRemoteTrace: Boolean;
|
|
procedure SetRemoteTrace(Value: Boolean);
|
|
{$IFDEF DBISAM_V3}
|
|
function GetRemoteType: TRemoteType;
|
|
procedure SetRemoteType(Value: TRemoteType);
|
|
{$ENDIF}
|
|
{$IFDEF DBISAM_V4}
|
|
function GetRemoteCompression: Byte;
|
|
procedure SetRemoteCompression(Value: Byte);
|
|
function GetRemoteEncryption: Boolean;
|
|
procedure SetRemoteEncryption(Value: Boolean);
|
|
function GetRemoteEncryptionPassword: string;
|
|
procedure SetRemoteEncryptionPassword(const Value: string);
|
|
function GetRemoteTimeout: Integer;
|
|
procedure SetRemoteTimeout(Value: Integer);
|
|
{$ENDIF}
|
|
|
|
procedure AddPassword( const aPassword: string);
|
|
procedure RemovePassword(const aPassword: string);
|
|
procedure RemoveAllPasswords;
|
|
|
|
property ForceBufferFlush: Boolean read GetForceBufferFlush write SetForceBufferFlush;
|
|
property KeepConnections: Boolean read GetKeepConnections write SetKeepConnections;
|
|
property LockProtocol: TLockProtocol read GetLockProtocol write SetLockProtocol;
|
|
property LockRetryCount: Byte read GetLockRetryCount write SetLockRetryCount;
|
|
property LockWaitTime: Word read GetLockWaitTime write SetLockWaitTime;
|
|
property PrivateDir: string read GetPrivateDir write SetPrivateDir;
|
|
property RemotePort: Integer read GetRemotePort write SetRemotePort;
|
|
property RemoteService: string read GetRemoteService write SetRemoteService;
|
|
property RemoteTrace: Boolean read GetRemoteTrace write SetRemoteTrace;
|
|
{$IFDEF DBISAM_V3}
|
|
property RemoteType: TRemoteType read GetRemoteType write SetRemoteType;
|
|
{$ENDIF}
|
|
{$IFDEF DBISAM_V4}
|
|
property RemoteCompression: Byte read GetRemoteCompression write SetRemoteCompression;
|
|
property RemoteEncryption: Boolean read GetRemoteEncryption write SetRemoteEncryption;
|
|
property RemoteEncryptionPassword: string read GetRemoteEncryptionPassword write SetRemoteEncryptionPassword;
|
|
property RemoteTimeout: Integer read GetRemoteTimeout write SetRemoteTimeout;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
{ TDBISAMConnection }
|
|
TDBISAMConnection = class(TDAConnectionWrapper)
|
|
private
|
|
fDatabase: TDBISAMDatabase;
|
|
fSession: TDBISAMSession;
|
|
|
|
protected
|
|
function GetConnected: Boolean; override;
|
|
procedure SetConnected(Value: Boolean); override;
|
|
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
|
|
property Database: TDBISAMDatabase read fDatabase;
|
|
property Session: TDBISAMSession read fSession;
|
|
end;
|
|
|
|
{ TDAEDBISAMDriver }
|
|
TDAEDBISAMDriver = class(TDAEDriver)
|
|
private
|
|
|
|
protected
|
|
function GetConnectionClass: TDAEConnectionClass; override;
|
|
|
|
// IDADriver
|
|
function GetDriverID: string; override;
|
|
function GetDescription: string; override;
|
|
|
|
procedure GetAuxParams(const AuxDriver: string; out List: IROStrings); override;
|
|
|
|
function GetAvailableDriverOptions: TDAAvailableDriverOptions; override;
|
|
function GetDefaultConnectionType(const AuxDriver: string): string; override; safecall;
|
|
public
|
|
end;
|
|
|
|
{ TDAEDBISAMConnection }
|
|
TDAEDBISAMConnection = class(TDAEConnection, IDBISAMConnection, IDBISAMConnectionProperties)
|
|
private
|
|
fConnection: TDBISAMConnection;
|
|
|
|
protected
|
|
// IDBISAMConnectionProperties
|
|
function GetForceBufferFlush: Boolean;
|
|
procedure SetForceBufferFlush(Value: Boolean);
|
|
function GetKeepConnections: Boolean;
|
|
procedure SetKeepConnections(Value: Boolean);
|
|
function GetLockProtocol: TLockProtocol;
|
|
procedure SetLockProtocol(Value: TLockProtocol);
|
|
function GetLockRetryCount: Byte;
|
|
procedure SetLockRetryCount(Value: Byte);
|
|
function GetLockWaitTime: Word;
|
|
procedure SetLockWaitTime(Value: Word);
|
|
function GetPrivateDir: string;
|
|
procedure SetPrivateDir(const Value: string);
|
|
function GetRemotePort: Integer;
|
|
procedure SetRemotePort(Value: Integer);
|
|
function GetRemoteService: string;
|
|
procedure SetRemoteService(const Value: string);
|
|
function GetRemoteTrace: Boolean;
|
|
procedure SetRemoteTrace(Value: Boolean);
|
|
{$IFDEF DBISAM_V3}
|
|
function GetRemoteType: TRemoteType;
|
|
procedure SetRemoteType(Value: TRemoteType);
|
|
{$ENDIF}
|
|
{$IFDEF DBISAM_V4}
|
|
function GetRemoteCompression: Byte;
|
|
procedure SetRemoteCompression(Value: Byte);
|
|
function GetRemoteEncryption: Boolean;
|
|
procedure SetRemoteEncryption(Value: Boolean);
|
|
function GetRemoteEncryptionPassword: string;
|
|
procedure SetRemoteEncryptionPassword(const Value: string);
|
|
function GetRemoteTimeout: Integer;
|
|
procedure SetRemoteTimeout(Value: Integer);
|
|
{$ENDIF}
|
|
procedure AddPassword( const aPassword: string);
|
|
procedure RemovePassword(const aPassword: string);
|
|
procedure RemoveAllPasswords;
|
|
|
|
// IDAConnection
|
|
function CreateCustomConnection: TCustomConnection; override;
|
|
function CreateMacroProcessor: TDASQLMacroProcessor; override;
|
|
|
|
function GetDatasetClass: TDAEDatasetClass; override;
|
|
procedure DoApplyConnectionString(aConnStrParser: TDAConnectionStringParser; aConnectionObject: TCustomConnection); override;
|
|
function DoBeginTransaction: Integer; override;
|
|
procedure DoCommitTransaction; override;
|
|
procedure DoRollbackTransaction; override;
|
|
function DoGetInTransaction: Boolean; override;
|
|
procedure DoGetTableNames(out List: IROStrings); override;
|
|
function DoGetLastAutoInc(const GeneratorName: string): integer; override;
|
|
procedure DoGetTableFields(const aTableName: string; out Fields: TDAFieldCollection);override;
|
|
function IdentifierNeedsQuoting(const iIdentifier: string): boolean; override; {$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
|
|
public
|
|
end;
|
|
|
|
{ TDAEDBISAMQuery }
|
|
TDAEDBISAMQuery = class(TDAEDataset, IDAMustSetParams)
|
|
private
|
|
protected
|
|
function CreateDataset(aConnection: TDAEConnection): TDataset; override;
|
|
procedure ClearParams; override;
|
|
function DoExecute: Integer; override;
|
|
function DoGetSQL: string; override;
|
|
procedure DoSetSQL(const Value: string); override;
|
|
procedure DoPrepare(Value: Boolean); override;
|
|
|
|
// IDAMustSetParams
|
|
{$IFDEF DBISAM_V4}
|
|
procedure RefreshParams; override;
|
|
{$ENDIF}
|
|
procedure SetParamValues(AParams: TDAParamCollection); override;{$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
|
|
procedure GetParamValues(AParams: TDAParamCollection); override;{$IFNDEF FPC_SAFECALL_BUG}safecall;{$ENDIF}
|
|
end;
|
|
|
|
const
|
|
DBISAM_DriverType = 'DBISAM';
|
|
|
|
procedure Register;
|
|
|
|
function GetDriverObject: IDADriver; stdcall;
|
|
|
|
implementation
|
|
|
|
uses
|
|
SysUtils, uDADriverManager, uDARes, uDAMacroProcessors, Variants,
|
|
uROBinaryHelpers;
|
|
|
|
var
|
|
_driver: TDAEDriver = nil;
|
|
dbisam_reservedwords: array of string;
|
|
|
|
procedure Register;
|
|
begin
|
|
RegisterComponents(DAPalettePageName, [TDADBISAMDriver]);
|
|
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 := TDAEDBISAMDriver.Create(nil);
|
|
result := _driver;
|
|
end;
|
|
|
|
{ TDBISAMConnection }
|
|
|
|
constructor TDBISAMConnection.Create(AOwner: TComponent);
|
|
begin
|
|
inherited;
|
|
|
|
fSession := TDBISAMSession.Create(Self);
|
|
fSession.AutoSessionName := TRUE;
|
|
|
|
fDatabase := TDBISAMDatabase.Create(Self);
|
|
fDatabase.SessionName := fSession.SessionName;
|
|
fDatabase.DatabaseName := 'DBISAMDB';
|
|
end;
|
|
|
|
function TDBISAMConnection.GetConnected: Boolean;
|
|
begin
|
|
result := fDatabase.Connected;
|
|
end;
|
|
|
|
procedure TDBISAMConnection.SetConnected(Value: Boolean);
|
|
begin
|
|
if not(csDestroying in fDatabase.ComponentState) then begin
|
|
try
|
|
fSession.Active := Value;
|
|
fDatabase.Connected := Value;
|
|
except
|
|
fSession.Active := FALSE;
|
|
fDatabase.Connected := FALSE;
|
|
raise;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TDAEDBISAMConnection }
|
|
|
|
procedure TDAEDBISAMConnection.DoApplyConnectionString(
|
|
aConnStrParser: TDAConnectionStringParser; aConnectionObject: TCustomConnection);
|
|
begin
|
|
inherited;
|
|
with aConnStrParser do begin
|
|
if (Self.UserID <> '') then
|
|
fConnection.Session.RemoteUser := Self.UserID
|
|
else
|
|
fConnection.Session.RemoteUser := UserID;
|
|
if (Self.Password <> '') then
|
|
fConnection.Session.RemotePassword := Self.Password
|
|
else
|
|
fConnection.Session.RemotePassword := Password;
|
|
|
|
if (Server <> '') then begin
|
|
// Remote connection
|
|
fConnection.Session.SessionType := stRemote;
|
|
fConnection.Session.RemoteHost := Server;
|
|
fConnection.Database.RemoteDatabase := Database;
|
|
if (AuxParams['RemotePort'] <> '') then
|
|
fConnection.Session.RemotePort := StrToInt(AuxParams['RemotePort']);
|
|
if (AuxParams['RemoteService'] <> '') then
|
|
fConnection.Session.RemoteService := AuxParams['RemoteService'];
|
|
if (AuxParams['RemoteTrace'] = 'False') then
|
|
fConnection.Session.RemoteTrace := False
|
|
else if (AuxParams['RemoteTrace'] = 'True') then
|
|
fConnection.Session.RemoteTrace := True;
|
|
{$IFDEF DBISAM_V3}
|
|
if (AuxParams['RemoteType'] = 'rtLAN') then
|
|
fConnection.Session.RemoteType := rtLAN
|
|
else if (AuxParams['RemoteType'] = 'rtInternet') then
|
|
fConnection.Session.RemoteType := rtInternet;
|
|
{$ENDIF}
|
|
{$IFDEF DBISAM_V4}
|
|
if (AuxParams['RemoteCompression'] <> '') then
|
|
if (StrToInt(AuxParams['RemoteCompression']) in [0..9]) then
|
|
fConnection.Session.RemoteCompression := StrToInt(AuxParams['RemoteCompression']);
|
|
if (AuxParams['RemoteEncryption'] = 'False') then
|
|
fConnection.Session.RemoteEncryption := False
|
|
else if (AuxParams['RemoteEncryption'] = 'True') then
|
|
fConnection.Session.RemoteEncryption := True;
|
|
if (AuxParams['RemoteEncryptionPassword'] <> '') then
|
|
fConnection.Session.RemoteEncryptionPassword := AuxParams['RemoteEncryptionPassword'];
|
|
if (AuxParams['RemoteTimeout'] <> '') then
|
|
fConnection.Session.RemoteTimeout := StrToInt(AuxParams['RemoteTimeout']);
|
|
{$ENDIF}
|
|
end
|
|
else begin
|
|
// Local connection
|
|
fConnection.Session.SessionType := stLocal;
|
|
fConnection.Database.Directory := Database;
|
|
end;
|
|
|
|
if (AuxParams['ForceBufferFlush'] = 'False') then
|
|
fConnection.Session.ForceBufferFlush := False
|
|
else if (AuxParams['ForceBufferFlush'] = 'True') then
|
|
fConnection.Session.ForceBufferFlush := True;
|
|
if (AuxParams['KeepConnections'] = 'False') then
|
|
begin
|
|
fConnection.Session.KeepConnections := False;
|
|
fConnection.Database.KeepConnection := False;
|
|
end
|
|
else if (AuxParams['KeepConnections'] = 'True') then
|
|
begin
|
|
fConnection.Session.KeepConnections := True;
|
|
fConnection.Database.KeepConnection := True;
|
|
end;
|
|
if (AuxParams['LockProtocol'] = 'lpOptimistic') then
|
|
fConnection.Session.LockProtocol := lpOptimistic
|
|
else if (AuxParams['LockProtocol'] = 'lpPessimistic') then
|
|
fConnection.Session.LockProtocol := lpPessimistic;
|
|
if (AuxParams['LockRetryCount'] <> '') then
|
|
fConnection.Session.LockRetryCount := StrToInt(AuxParams['LockRetryCount']);
|
|
if (AuxParams['LockWaitTime'] <> '') then
|
|
fConnection.Session.LockWaitTime := StrToInt(AuxParams['LockWaitTime']);
|
|
if (AuxParams['PrivateDir'] <> '') then
|
|
fConnection.Session.PrivateDir := AuxParams['PrivateDir'];
|
|
if (AuxParams['TablePassword'] <> '') then
|
|
begin
|
|
fConnection.Session.Active := True;
|
|
fConnection.Session.AddPassword(AuxParams['TablePassword']);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.DoBeginTransaction: integer;
|
|
begin
|
|
result := -1;
|
|
fConnection.Database.StartTransaction;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.DoCommitTransaction;
|
|
begin
|
|
with fConnection do
|
|
Database.Commit(Session.ForceBufferFlush);
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.CreateCustomConnection: TCustomConnection;
|
|
begin
|
|
result := TDBISAMConnection.Create(nil);
|
|
fConnection := TDBISAMConnection(result);
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetDatasetClass: TDAEDatasetClass;
|
|
begin
|
|
result := TDAEDBISAMQuery
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.DoGetTableNames(out List: IROStrings);
|
|
var
|
|
_database: string;
|
|
begin
|
|
List := TROStrings.Create;
|
|
if (fConnection.Session.SessionType = stLocal) then
|
|
_database := fConnection.Database.Directory
|
|
else
|
|
_database := fConnection.Database.RemoteDatabase;
|
|
|
|
fConnection.Session.GetTableNames(_database, List.Strings);
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.DoRollbackTransaction;
|
|
begin
|
|
fConnection.Database.Rollback;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.DoGetInTransaction: Boolean;
|
|
begin
|
|
result := fConnection.Database.InTransaction;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.CreateMacroProcessor: TDASQLMacroProcessor;
|
|
begin
|
|
result := TDADBISAMMacroProcessor.Create;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetForceBufferFlush: Boolean;
|
|
begin
|
|
result := fConnection.Session.ForceBufferFlush;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetForceBufferFlush(Value: Boolean);
|
|
begin
|
|
fConnection.Session.ForceBufferFlush := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetKeepConnections: Boolean;
|
|
begin
|
|
result := fConnection.Session.KeepConnections;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetKeepConnections(Value: Boolean);
|
|
begin
|
|
fConnection.Session.KeepConnections := Value;
|
|
fConnection.Database.KeepConnection := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetLockProtocol: TLockProtocol;
|
|
begin
|
|
result := fConnection.Session.LockProtocol;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetLockProtocol(Value: TLockProtocol);
|
|
begin
|
|
fConnection.Session.LockProtocol := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetLockRetryCount: Byte;
|
|
begin
|
|
result := fConnection.Session.LockRetryCount;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetLockRetryCount(Value: Byte);
|
|
begin
|
|
fConnection.Session.LockRetryCount := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetLockWaitTime: Word;
|
|
begin
|
|
result := fConnection.Session.LockWaitTime;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetLockWaitTime(Value: Word);
|
|
begin
|
|
fConnection.Session.LockWaitTime := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetPrivateDir: string;
|
|
begin
|
|
result := fConnection.Session.PrivateDir;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetPrivateDir(const Value: string);
|
|
begin
|
|
fConnection.Session.PrivateDir := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetRemotePort: Integer;
|
|
begin
|
|
result := fConnection.Session.RemotePort;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemotePort(Value: Integer);
|
|
begin
|
|
fConnection.Session.RemotePort := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetRemoteService: string;
|
|
begin
|
|
result := fConnection.Session.RemoteService;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemoteService(const Value: string);
|
|
begin
|
|
fConnection.Session.RemoteService := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetRemoteTrace: Boolean;
|
|
begin
|
|
result := fConnection.Session.RemoteTrace;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemoteTrace(Value: Boolean);
|
|
begin
|
|
fConnection.Session.RemoteTrace := Value;
|
|
end;
|
|
|
|
{$IFDEF DBISAM_V3}
|
|
|
|
function TDAEDBISAMConnection.GetRemoteType: TRemoteType;
|
|
begin
|
|
result := fConnection.Session.RemoteType;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemoteType(Value: TRemoteType);
|
|
begin
|
|
fConnection.Session.RemoteType := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{$IFDEF DBISAM_V4}
|
|
|
|
function TDAEDBISAMConnection.GetRemoteCompression: Byte;
|
|
begin
|
|
result := fConnection.Session.RemoteCompression;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemoteCompression(Value: Byte);
|
|
begin
|
|
fConnection.Session.RemoteCompression := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetRemoteEncryption: Boolean;
|
|
begin
|
|
result := fConnection.Session.RemoteEncryption;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemoteEncryption(Value: Boolean);
|
|
begin
|
|
fConnection.Session.RemoteEncryption := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetRemoteEncryptionPassword: string;
|
|
begin
|
|
result := fConnection.Session.RemoteEncryptionPassword;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemoteEncryptionPassword(const Value: string);
|
|
begin
|
|
fConnection.Session.RemoteEncryptionPassword := Value;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.GetRemoteTimeout: Integer;
|
|
begin
|
|
result := fConnection.Session.RemoteTimeout;
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.SetRemoteTimeout(Value: Integer);
|
|
begin
|
|
fConnection.Session.RemoteTimeout := Value;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TDAEDBISAMConnection.AddPassword( const aPassword: string);
|
|
begin
|
|
fConnection.Session.AddPassword(aPassword);
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.RemovePassword( const aPassword: string);
|
|
begin
|
|
fConnection.Session.RemovePassword(aPassword);
|
|
end;
|
|
|
|
procedure TDAEDBISAMConnection.RemoveAllPasswords;
|
|
begin
|
|
fConnection.Session.RemoveAllPasswords;
|
|
end;
|
|
|
|
function TDAEDBISAMConnection.DoGetLastAutoInc(
|
|
const GeneratorName: string): integer;
|
|
var
|
|
lQuery: IDADataset;
|
|
begin
|
|
Result:= inherited DoGetLastAutoInc(GeneratorName);
|
|
if GeneratorName <> '' then begin
|
|
lQuery:=GetDatasetClass.Create(Self);
|
|
try
|
|
lQuery.SQL := 'SELECT LASTAUTOINC('''+GeneratorName+''') from '+QuoteIdentifierIfNeeded(GeneratorName);
|
|
lQuery.Open;
|
|
Result := lQuery.Fields[0].AsInteger;
|
|
finally
|
|
lQuery:=nil;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF DELPHI10UP}
|
|
{$WARN SYMBOL_DEPRECATED OFF}
|
|
{$ENDIF DELPHI10UP}
|
|
procedure TDAEDBISAMConnection.DoGetTableFields(const aTableName: string;
|
|
out Fields: TDAFieldCollection);
|
|
var
|
|
i: integer;
|
|
pos1: integer;
|
|
fld: TDAField;
|
|
{$IFDEF DBISAM_V4}
|
|
lofld:TDBISAMFieldDef;
|
|
{$ELSE}
|
|
lofld:TFieldDef;
|
|
{$ENDIF}
|
|
s: string;
|
|
ltable: TDBISAMTable;
|
|
begin
|
|
Fields:=TDAFieldCollection.Create(nil);
|
|
ltable:=TDBISAMTable.Create(nil);
|
|
try
|
|
ltable.DatabaseName := fConnection.Database.DatabaseName;
|
|
ltable.SessionName := fConnection.Session.SessionName;
|
|
ltable.TableName := aTableName;
|
|
ltable.FieldDefs.Update;
|
|
for i:=0 to ltable.FieldDefs.Count-1 do begin
|
|
lofld:=ltable.FieldDefs[i];
|
|
fld:= Fields.Add;
|
|
fld.Name:= lofld.Name;
|
|
fld.DataType:= VCLTypeToDAType(lofld.DataType);
|
|
fld.Size:= lofld.Size;
|
|
fld.Required:= lofld.Required;
|
|
{$IFDEF DBISAM_V4}
|
|
fld.DefaultValue:=lofld.DefaultValue;
|
|
fld.Description:=lofld.Description;
|
|
{$ENDIF DBISAM_V4}
|
|
fld.ReadOnly:= DB.faReadonly in lofld.Attributes;
|
|
if fld.DataType = datAutoInc then fld.GeneratorName:= aTableName;
|
|
if fld.DataType = datDecimal then begin
|
|
case lofld.DataType of
|
|
ftBCD: begin
|
|
fld.DecimalPrecision:=20;
|
|
fld.DecimalScale:=lofld.Size;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
//pk
|
|
ltable.IndexDefs.Update;
|
|
For i:=0 to ltable.IndexDefs.Count - 1 do
|
|
if ixPrimary in ltable.IndexDefs[i].Options then begin
|
|
Pos1 := 1;
|
|
s:=ltable.IndexDefs[i].Fields;
|
|
while Pos1 <= Length(s) do begin
|
|
fld := Fields.FindField(ExtractFieldName(s, Pos1));
|
|
if fld <> nil then fld.InPrimaryKey:=True;
|
|
end;
|
|
end;
|
|
|
|
finally
|
|
ltable.free;
|
|
end;
|
|
end;
|
|
{$IFDEF DELPHI10UP}
|
|
{$WARN SYMBOL_DEPRECATED ON}
|
|
{$ENDIF DELPHI10UP}
|
|
|
|
function TDAEDBISAMConnection.IdentifierNeedsQuoting(
|
|
const iIdentifier: string): boolean;
|
|
begin
|
|
Result := inherited IdentifierNeedsQuoting(iIdentifier) or TestIdentifier(iIdentifier,dbisam_reservedwords);
|
|
end;
|
|
|
|
{ TDAEDBISAMDriver }
|
|
|
|
procedure TDAEDBISAMDriver.GetAuxParams(const AuxDriver: string; out List: IROStrings);
|
|
begin
|
|
inherited;
|
|
|
|
List.Add('ForceBufferFlush=False,True');
|
|
List.Add('KeepConnections=False,True');
|
|
List.Add('LockProtocol=lpOptimistic,lpPessimistic');
|
|
List.Add('LockRetryCount=');
|
|
List.Add('LockWaitTime=');
|
|
List.Add('PrivateDir=');
|
|
List.Add('RemotePort=');
|
|
List.Add('RemoteService=');
|
|
List.Add('RemoteTrace=False,True');
|
|
List.Add('TablePassword=');
|
|
{$IFDEF DBISAM_V3}
|
|
List.Add('RemoteType=rtLAN,rtInternet');
|
|
{$ENDIF}
|
|
{$IFDEF DBISAM_V4}
|
|
List.Add('RemoteCompression=');
|
|
List.Add('RemoteEncryption=False,True');
|
|
List.Add('RemoteEncryptionPassword=');
|
|
List.Add('RemoteTimeout=');
|
|
{$ENDIF}
|
|
|
|
List.Sorted := True;
|
|
end;
|
|
|
|
function TDAEDBISAMDriver.GetAvailableDriverOptions: TDAAvailableDriverOptions;
|
|
begin
|
|
result := [doServerName, doDatabaseName, doLogin, doCustom];
|
|
end;
|
|
|
|
function TDAEDBISAMDriver.GetConnectionClass: TDAEConnectionClass;
|
|
begin
|
|
result := TDAEDBISAMConnection
|
|
end;
|
|
|
|
function TDAEDBISAMDriver.GetDefaultConnectionType(
|
|
const AuxDriver: string): string;
|
|
begin
|
|
Result:=DBISAM_DriverType;
|
|
end;
|
|
|
|
function TDAEDBISAMDriver.GetDescription: string;
|
|
begin
|
|
{$IFDEF DBISAM_V3}
|
|
result := 'DBISAM3 Driver'{$IFDEF DataAbstract_SchemaModelerOnly} + SchemaModelerOnly{$ENDIF};
|
|
{$ENDIF}
|
|
{$IFDEF DBISAM_V4}
|
|
result := 'DBISAM4 Driver'{$IFDEF DataAbstract_SchemaModelerOnly} + SchemaModelerOnly{$ENDIF};
|
|
{$ENDIF}
|
|
end;
|
|
|
|
function TDAEDBISAMDriver.GetDriverID: string;
|
|
begin
|
|
{$IFDEF DBISAM_V3}
|
|
result := 'DBISAM3';
|
|
{$ENDIF}
|
|
{$IFDEF DBISAM_V4}
|
|
result := 'DBISAM4';
|
|
{$ENDIF}
|
|
end;
|
|
|
|
{ TDAEDBISAMQuery }
|
|
|
|
function TDAEDBISAMQuery.CreateDataset(aConnection: TDAEConnection): TDataset;
|
|
begin
|
|
result := TDBISAMQuery.Create(nil);
|
|
|
|
with TDBISAMQuery(result) do begin
|
|
DatabaseName := TDAEDBISAMConnection(aConnection).fConnection.Database.DatabaseName;
|
|
SessionName := TDAEDBISAMConnection(aConnection).fConnection.Session.SessionName;
|
|
ReadOnly := True;
|
|
RequestLive := True;
|
|
end;
|
|
end;
|
|
|
|
function TDAEDBISAMQuery.DoExecute: integer;
|
|
begin
|
|
with TDBISAMQuery(Dataset) do begin
|
|
ExecSQL;
|
|
result := RowsAffected;
|
|
end;
|
|
end;
|
|
|
|
function TDAEDBISAMQuery.DoGetSQL: string;
|
|
begin
|
|
result := TDBISAMQuery(Dataset).SQL.Text
|
|
end;
|
|
|
|
procedure TDAEDBISAMQuery.DoPrepare(Value: Boolean);
|
|
begin
|
|
TDBISAMQuery(Dataset).Prepared := Value;
|
|
end;
|
|
|
|
procedure TDAEDBISAMQuery.SetParamValues(AParams: TDAParamCollection);
|
|
var
|
|
i: integer;
|
|
par: uDAInterfaces.TDAParam;
|
|
{$IFDEF DBISAM_V4}
|
|
outpar: TDBISAMParam;
|
|
{$ELSE}
|
|
outpar: TParam;
|
|
{$ENDIF}
|
|
ft: TFieldType;
|
|
lParIsEmpty: Boolean;
|
|
begin
|
|
for i := 0 to (AParams.Count - 1) do begin
|
|
par := AParams[i];
|
|
outpar := TDBISAMQuery(Dataset).Params.ParamByName(par.Name);
|
|
|
|
ft := DATypeToVCLType(par.DataType);
|
|
{$IFNDEF DBISAM_V4}
|
|
case par.ParamType of
|
|
daptInput: outpar.ParamType := ptInput;
|
|
daptOutput: outpar.ParamType := ptOutput;
|
|
daptInputOutput: outpar.ParamType := ptInputOutput;
|
|
daptResult: outpar.ParamType := ptResult;
|
|
end;
|
|
{$ENDIF DBISAM_V3}
|
|
lParIsEmpty := VarIsEmpty(par.Value) or VarIsNull(par.Value);
|
|
|
|
if par.DataType = datBlob then begin
|
|
outpar.DataType := ftBlob;
|
|
if not (par.ParamType in [daptOutput, daptResult]) then begin
|
|
if lParIsEmpty then
|
|
outpar.Value := Null
|
|
else
|
|
outpar.Value := VariantBinaryToString(par.Value);
|
|
end;
|
|
end
|
|
else begin
|
|
if (outpar.DataType <> ft) and (ft <> ftUnknown) then outpar.DataType := ft;
|
|
if not (par.ParamType in [daptOutput, daptResult]) then outpar.Value := par.Value;
|
|
end;
|
|
|
|
if lParIsEmpty and (par.DataType <> datUnknown) then begin
|
|
if (outpar.DataType <> ft) and (ft <> ftUnknown) then outpar.DataType := ft;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TDAEDBISAMQuery.GetParamValues(AParams: TDAParamCollection);
|
|
var
|
|
i: integer;
|
|
par: uDAInterfaces.TDAParam;
|
|
begin
|
|
for i := 0 to (AParams.Count - 1) do begin
|
|
par := AParams[i];
|
|
if Par.ParamType in [daptOutput, daptInputOutput, daptResult] then
|
|
Par.Value := TDBISAMQuery(Dataset).Params.ParamByName(par.Name).Value;
|
|
end;
|
|
end;
|
|
|
|
procedure TDAEDBISAMQuery.DoSetSQL(const Value: string);
|
|
begin
|
|
TDBISAMQuery(Dataset).SQL.Text := Value;
|
|
end;
|
|
|
|
{$IFDEF DBISAM_V4}
|
|
procedure TDAEDBISAMQuery.RefreshParams;
|
|
var
|
|
i: Integer;
|
|
par: TDAParam;
|
|
outpar: TDBISAMParam;
|
|
ds: TDBISAMQuery;
|
|
begin
|
|
inherited;
|
|
ds := TDBISAMQuery(Dataset);
|
|
if not Assigned(ds.Params) then
|
|
Exit;
|
|
for i := 0 to ds.Params.Count -1 do begin
|
|
outpar := ds.Params[i];
|
|
|
|
par := self.ParamByName(outpar.Name);
|
|
|
|
if outpar.DataType <> ftUnknown then begin
|
|
par.DataType := VCLTypeToDAType(outpar.DataType);
|
|
end;
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
exports GetDriverObject name func_GetDriverObject;
|
|
|
|
procedure TDAEDBISAMQuery.ClearParams;
|
|
begin
|
|
inherited;
|
|
TDBISAMQuery(Dataset).Params.Clear;
|
|
end;
|
|
|
|
procedure dbisam_InitializeReservedWords;
|
|
begin
|
|
SetLength(dbisam_reservedwords, 220);
|
|
// sorted with TStringList.Sort (bds2007)
|
|
dbisam_reservedwords[0] := 'ABS';
|
|
dbisam_reservedwords[1] := 'ACOS';
|
|
dbisam_reservedwords[2] := 'ADD';
|
|
dbisam_reservedwords[3] := 'ALL';
|
|
dbisam_reservedwords[4] := 'ALLTRIM';
|
|
dbisam_reservedwords[5] := 'ALTER';
|
|
dbisam_reservedwords[6] := 'AND';
|
|
dbisam_reservedwords[7] := 'AS';
|
|
dbisam_reservedwords[8] := 'ASC';
|
|
dbisam_reservedwords[9] := 'ASCENDING';
|
|
dbisam_reservedwords[10] := 'ASIN';
|
|
dbisam_reservedwords[11] := 'AT';
|
|
dbisam_reservedwords[12] := 'ATAN';
|
|
dbisam_reservedwords[13] := 'ATAN2';
|
|
dbisam_reservedwords[14] := 'AUTOINC';
|
|
dbisam_reservedwords[15] := 'AVG';
|
|
dbisam_reservedwords[16] := 'BETWEEN';
|
|
dbisam_reservedwords[17] := 'BINARY';
|
|
dbisam_reservedwords[18] := 'BIT';
|
|
dbisam_reservedwords[19] := 'BLOB';
|
|
dbisam_reservedwords[20] := 'BLOCK';
|
|
dbisam_reservedwords[21] := 'BOOL';
|
|
dbisam_reservedwords[22] := 'BOOLEAN';
|
|
dbisam_reservedwords[23] := 'BOTH';
|
|
dbisam_reservedwords[24] := 'BY';
|
|
dbisam_reservedwords[25] := 'BYTES';
|
|
dbisam_reservedwords[26] := 'CAST';
|
|
dbisam_reservedwords[27] := 'CEIL';
|
|
dbisam_reservedwords[28] := 'CEILING';
|
|
dbisam_reservedwords[29] := 'CHAR';
|
|
dbisam_reservedwords[30] := 'CHARACTER';
|
|
dbisam_reservedwords[31] := 'CHARCASE';
|
|
dbisam_reservedwords[32] := 'CHARS';
|
|
dbisam_reservedwords[33] := 'COALESCE';
|
|
dbisam_reservedwords[34] := 'COLUMN';
|
|
dbisam_reservedwords[35] := 'COLUMNS';
|
|
dbisam_reservedwords[36] := 'COMMIT';
|
|
dbisam_reservedwords[37] := 'COMPRESS';
|
|
dbisam_reservedwords[38] := 'CONCAT';
|
|
dbisam_reservedwords[39] := 'CONSTRAINT';
|
|
dbisam_reservedwords[40] := 'COS';
|
|
dbisam_reservedwords[41] := 'COT';
|
|
dbisam_reservedwords[42] := 'COUNT';
|
|
dbisam_reservedwords[43] := 'CREATE';
|
|
dbisam_reservedwords[44] := 'CURRENT_DATE';
|
|
dbisam_reservedwords[45] := 'CURRENT_GUID';
|
|
dbisam_reservedwords[46] := 'CURRENT_TIME';
|
|
dbisam_reservedwords[47] := 'CURRENT_TIMESTAMP';
|
|
dbisam_reservedwords[48] := 'DAY';
|
|
dbisam_reservedwords[49] := 'DAYOFWEEK';
|
|
dbisam_reservedwords[50] := 'DAYOFYEAR';
|
|
dbisam_reservedwords[51] := 'DAYSFROMMSECS';
|
|
dbisam_reservedwords[52] := 'DECIMAL';
|
|
dbisam_reservedwords[53] := 'DEFAULT';
|
|
dbisam_reservedwords[54] := 'DEGREES';
|
|
dbisam_reservedwords[55] := 'DELETE';
|
|
dbisam_reservedwords[56] := 'DELIMITER';
|
|
dbisam_reservedwords[57] := 'DESC';
|
|
dbisam_reservedwords[58] := 'DESCENDING';
|
|
dbisam_reservedwords[59] := 'DESCRIPTION';
|
|
dbisam_reservedwords[60] := 'DISTINCT';
|
|
dbisam_reservedwords[61] := 'DROP';
|
|
dbisam_reservedwords[62] := 'DUPBYTE';
|
|
dbisam_reservedwords[63] := 'ELSE';
|
|
dbisam_reservedwords[64] := 'EMPTY';
|
|
dbisam_reservedwords[65] := 'ENCRYPTED';
|
|
dbisam_reservedwords[66] := 'ESCAPE';
|
|
dbisam_reservedwords[67] := 'EXCEPT';
|
|
dbisam_reservedwords[68] := 'EXISTS';
|
|
dbisam_reservedwords[69] := 'EXP';
|
|
dbisam_reservedwords[70] := 'EXPORT';
|
|
dbisam_reservedwords[71] := 'EXTRACT';
|
|
dbisam_reservedwords[72] := 'FALSE';
|
|
dbisam_reservedwords[73] := 'FLOAT';
|
|
dbisam_reservedwords[74] := 'FLOOR';
|
|
dbisam_reservedwords[75] := 'FLUSH';
|
|
dbisam_reservedwords[76] := 'FOR';
|
|
dbisam_reservedwords[77] := 'FORCEINDEXREBUILD';
|
|
dbisam_reservedwords[78] := 'FROM';
|
|
dbisam_reservedwords[79] := 'FULL';
|
|
dbisam_reservedwords[80] := 'GRAPHIC';
|
|
dbisam_reservedwords[81] := 'GROUP';
|
|
dbisam_reservedwords[82] := 'GUID';
|
|
dbisam_reservedwords[83] := 'HAVING';
|
|
dbisam_reservedwords[84] := 'HEADERS';
|
|
dbisam_reservedwords[85] := 'HOUR';
|
|
dbisam_reservedwords[86] := 'HOURSFROMMSECS';
|
|
dbisam_reservedwords[87] := 'IDENT_CURRENT';
|
|
dbisam_reservedwords[88] := 'IDENTITY';
|
|
dbisam_reservedwords[89] := 'IF';
|
|
dbisam_reservedwords[90] := 'IFNULL';
|
|
dbisam_reservedwords[91] := 'IMPORT';
|
|
dbisam_reservedwords[92] := 'IN';
|
|
dbisam_reservedwords[93] := 'INCLUDE';
|
|
dbisam_reservedwords[94] := 'INDEX';
|
|
dbisam_reservedwords[95] := 'INNER';
|
|
dbisam_reservedwords[96] := 'INSERT';
|
|
dbisam_reservedwords[97] := 'INT';
|
|
dbisam_reservedwords[98] := 'INTEGER';
|
|
dbisam_reservedwords[99] := 'INTERSECT';
|
|
dbisam_reservedwords[100] := 'INTERVAL';
|
|
dbisam_reservedwords[101] := 'INTO';
|
|
dbisam_reservedwords[102] := 'IS';
|
|
dbisam_reservedwords[103] := 'JOIN';
|
|
dbisam_reservedwords[104] := 'KEY';
|
|
dbisam_reservedwords[105] := 'LARGEINT';
|
|
dbisam_reservedwords[106] := 'LAST';
|
|
dbisam_reservedwords[107] := 'LASTAUTOINC';
|
|
dbisam_reservedwords[108] := 'LCASE';
|
|
dbisam_reservedwords[109] := 'LEADING';
|
|
dbisam_reservedwords[110] := 'LEFT';
|
|
dbisam_reservedwords[111] := 'LENGTH';
|
|
dbisam_reservedwords[112] := 'LIKE';
|
|
dbisam_reservedwords[113] := 'LOCALE';
|
|
dbisam_reservedwords[114] := 'LOG';
|
|
dbisam_reservedwords[115] := 'LOG10';
|
|
dbisam_reservedwords[116] := 'LONGVARBINARY';
|
|
dbisam_reservedwords[117] := 'LONGVARCHAR';
|
|
dbisam_reservedwords[118] := 'LOWER';
|
|
dbisam_reservedwords[119] := 'LTRIM';
|
|
dbisam_reservedwords[120] := 'MAJOR';
|
|
dbisam_reservedwords[121] := 'MAX';
|
|
dbisam_reservedwords[122] := 'MAXIMUM';
|
|
dbisam_reservedwords[123] := 'MEMO';
|
|
dbisam_reservedwords[124] := 'MIN';
|
|
dbisam_reservedwords[125] := 'MINIMUM';
|
|
dbisam_reservedwords[126] := 'MINOR';
|
|
dbisam_reservedwords[127] := 'MINSFROMMSECS';
|
|
dbisam_reservedwords[128] := 'MINUTE';
|
|
dbisam_reservedwords[129] := 'MOD';
|
|
dbisam_reservedwords[130] := 'MONEY';
|
|
dbisam_reservedwords[131] := 'MONTH';
|
|
dbisam_reservedwords[132] := 'MSECOND';
|
|
dbisam_reservedwords[133] := 'MSECSFROMMSECS';
|
|
dbisam_reservedwords[134] := 'NOBACKUP';
|
|
dbisam_reservedwords[135] := 'NOCASE';
|
|
dbisam_reservedwords[136] := 'NOCHANGE';
|
|
dbisam_reservedwords[137] := 'NOJOINOPTIMIZE';
|
|
dbisam_reservedwords[138] := 'NONE';
|
|
dbisam_reservedwords[139] := 'NOT';
|
|
dbisam_reservedwords[140] := 'NULL';
|
|
dbisam_reservedwords[141] := 'NUMERIC';
|
|
dbisam_reservedwords[142] := 'OCCURS';
|
|
dbisam_reservedwords[143] := 'ON';
|
|
dbisam_reservedwords[144] := 'OPTIMIZE';
|
|
dbisam_reservedwords[145] := 'OR';
|
|
dbisam_reservedwords[146] := 'ORDER';
|
|
dbisam_reservedwords[147] := 'OUTER';
|
|
dbisam_reservedwords[148] := 'PAGE';
|
|
dbisam_reservedwords[149] := 'PI';
|
|
dbisam_reservedwords[150] := 'POS';
|
|
dbisam_reservedwords[151] := 'POSITION';
|
|
dbisam_reservedwords[152] := 'POWER';
|
|
dbisam_reservedwords[153] := 'PRIMARY';
|
|
dbisam_reservedwords[154] := 'RADIANS';
|
|
dbisam_reservedwords[155] := 'RAND';
|
|
dbisam_reservedwords[156] := 'RANGE';
|
|
dbisam_reservedwords[157] := 'REDEFINE';
|
|
dbisam_reservedwords[158] := 'RENAME';
|
|
dbisam_reservedwords[159] := 'REPAIR';
|
|
dbisam_reservedwords[160] := 'REPEAT';
|
|
dbisam_reservedwords[161] := 'REPLACE';
|
|
dbisam_reservedwords[162] := 'RIGHT';
|
|
dbisam_reservedwords[163] := 'ROLLBACK';
|
|
dbisam_reservedwords[164] := 'ROUND';
|
|
dbisam_reservedwords[165] := 'RTRIM';
|
|
dbisam_reservedwords[166] := 'RUNSUM';
|
|
dbisam_reservedwords[167] := 'SECOND';
|
|
dbisam_reservedwords[168] := 'SECSFROMMSECS';
|
|
dbisam_reservedwords[169] := 'SELECT';
|
|
dbisam_reservedwords[170] := 'SET';
|
|
dbisam_reservedwords[171] := 'SIGN';
|
|
dbisam_reservedwords[172] := 'SIN';
|
|
dbisam_reservedwords[173] := 'SIZE';
|
|
dbisam_reservedwords[174] := 'SMALLINT';
|
|
dbisam_reservedwords[175] := 'SPACE';
|
|
dbisam_reservedwords[176] := 'SQRT';
|
|
dbisam_reservedwords[177] := 'START';
|
|
dbisam_reservedwords[178] := 'STDDEV';
|
|
dbisam_reservedwords[179] := 'STOP';
|
|
dbisam_reservedwords[180] := 'SUBSTRING';
|
|
dbisam_reservedwords[181] := 'SUM';
|
|
dbisam_reservedwords[182] := 'TABLE';
|
|
dbisam_reservedwords[183] := 'TAN';
|
|
dbisam_reservedwords[184] := 'TEXT';
|
|
dbisam_reservedwords[185] := 'TEXTOCCURS';
|
|
dbisam_reservedwords[186] := 'TEXTSEARCH';
|
|
dbisam_reservedwords[187] := 'THEN';
|
|
dbisam_reservedwords[188] := 'TIME';
|
|
dbisam_reservedwords[189] := 'TIMESTAMP';
|
|
dbisam_reservedwords[190] := 'TO';
|
|
dbisam_reservedwords[191] := 'TOP';
|
|
dbisam_reservedwords[192] := 'TRAILBYTE';
|
|
dbisam_reservedwords[193] := 'TRAILING';
|
|
dbisam_reservedwords[194] := 'TRANSACTION';
|
|
dbisam_reservedwords[195] := 'TRIM';
|
|
dbisam_reservedwords[196] := 'TRUE';
|
|
dbisam_reservedwords[197] := 'TRUNC';
|
|
dbisam_reservedwords[198] := 'TRUNCATE';
|
|
dbisam_reservedwords[199] := 'UCASE';
|
|
dbisam_reservedwords[200] := 'UNION';
|
|
dbisam_reservedwords[201] := 'UNIQUE';
|
|
dbisam_reservedwords[202] := 'UPDATE';
|
|
dbisam_reservedwords[203] := 'UPGRADE';
|
|
dbisam_reservedwords[204] := 'UPPER';
|
|
dbisam_reservedwords[205] := 'USER';
|
|
dbisam_reservedwords[206] := 'VALUES';
|
|
dbisam_reservedwords[207] := 'VARBINARY';
|
|
dbisam_reservedwords[208] := 'VARBYTES';
|
|
dbisam_reservedwords[209] := 'VARCHAR';
|
|
dbisam_reservedwords[210] := 'VERIFY';
|
|
dbisam_reservedwords[211] := 'VERSION';
|
|
dbisam_reservedwords[212] := 'WEEK';
|
|
dbisam_reservedwords[213] := 'WHERE';
|
|
dbisam_reservedwords[214] := 'WITH';
|
|
dbisam_reservedwords[215] := 'WORD';
|
|
dbisam_reservedwords[216] := 'WORDS';
|
|
dbisam_reservedwords[217] := 'WORK';
|
|
dbisam_reservedwords[218] := 'YEAR';
|
|
dbisam_reservedwords[219] := 'YEARSFROMMSECS';
|
|
end;
|
|
|
|
initialization
|
|
_driver := nil;
|
|
RegisterDriverProc(GetDriverObject);
|
|
dbisam_InitializeReservedWords;
|
|
finalization
|
|
dbisam_reservedwords := nil;
|
|
UnregisterDriverProc(GetDriverObject);
|
|
FreeAndNIL(_driver);
|
|
|
|
end.
|
|
|