sdengine.hpp

SQLDirect Component Library is a light-weight Borland Database Engine replacement for Borland Delphi

// Borland C++ Builder
// Copyright (c) 1995, 2002 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'SDEngine.pas' rev: 6.00

#ifndef SDEngineHPP
#define SDEngineHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <SDCommon.hpp>	// Pascal unit
#include <SDConsts.hpp>	// Pascal unit
#include <RTLConsts.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <DBCommon.hpp>	// Pascal unit
#include <SyncObjs.hpp>	// Pascal unit
#include <DB.hpp>	// Pascal unit
#include <Forms.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Consts.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <SysInit.hpp>	// Pascal unit
#include <System.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Sdengine
{
//-- type declarations -------------------------------------------------------
#pragma option push -b
enum TSDServerType { stSQLBase, stOracle, stSQLServer, stSybase, stDB2, stInformix, stODBC, stInterbase, stFirebird, stMySQL, stPostgreSQL, stOLEDB };
#pragma option pop

class DELPHICLASS ESDNoResultSet;
class PASCALIMPLEMENTATION ESDNoResultSet : public Db::EDatabaseError 
{
	typedef Db::EDatabaseError inherited;
	
public:
	#pragma option push -w-inl
	/* Exception.Create */ inline __fastcall ESDNoResultSet(const AnsiString Msg) : Db::EDatabaseError(Msg) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmt */ inline __fastcall ESDNoResultSet(const AnsiString Msg, const System::TVarRec * Args, const int Args_Size) : Db::EDatabaseError(Msg, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateRes */ inline __fastcall ESDNoResultSet(int Ident)/* overload */ : Db::EDatabaseError(Ident) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall ESDNoResultSet(int Ident, const System::TVarRec * Args, const int Args_Size)/* overload */ : Db::EDatabaseError(Ident, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateHelp */ inline __fastcall ESDNoResultSet(const AnsiString Msg, int AHelpContext) : Db::EDatabaseError(Msg, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmtHelp */ inline __fastcall ESDNoResultSet(const AnsiString Msg, const System::TVarRec * Args, const int Args_Size, int AHelpContext) : Db::EDatabaseError(Msg, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResHelp */ inline __fastcall ESDNoResultSet(int Ident, int AHelpContext)/* overload */ : Db::EDatabaseError(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall ESDNoResultSet(System::PResStringRec ResStringRec, const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Db::EDatabaseError(ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~ESDNoResultSet(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSDSessionList;
class DELPHICLASS TSDSession;
class DELPHICLASS TSDDatabase;
class PASCALIMPLEMENTATION TSDSessionList : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	TSDSession* operator[](int Index) { return Sessions[Index]; }
	
private:
	Classes::TThreadList* FSessions;
	Classes::TBits* FSessionNumbers;
	void __fastcall AddSession(TSDSession* ASession);
	void __fastcall CloseAll(void);
	int __fastcall GetCount(void);
	TSDSession* __fastcall GetSession(int Index);
	TSDSession* __fastcall GetSessionByName(const AnsiString SessionName);
	
public:
	__fastcall TSDSessionList(void);
	__fastcall virtual ~TSDSessionList(void);
	TSDDatabase* __fastcall FindDatabase(const AnsiString DatabaseName);
	TSDSession* __fastcall FindSession(const AnsiString SessionName);
	void __fastcall GetSessionNames(Classes::TStrings* List);
	TSDSession* __fastcall OpenSession(const AnsiString SessionName);
	__property int Count = {read=GetCount, nodefault};
	__property TSDSession* List[AnsiString SessionName] = {read=GetSessionByName};
	__property TSDSession* Sessions[int Index] = {read=GetSession/*, default*/};
};


class PASCALIMPLEMENTATION TSDSession : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Classes::TList* FDatabases;
	bool FDefault;
	bool FKeepConnections;
	Classes::TList* FDBParams;
	bool FAutoSessionName;
	bool FUpdatingAutoSessionName;
	AnsiString FSessionName;
	int FSessionNumber;
	int FLockCount;
	bool FActive;
	bool FStreamedActive;
	bool FSQLHourGlass;
	Controls::TCursor FSQLWaitCursor;
	void __fastcall AddDatabase(TSDDatabase* Value);
	void __fastcall CheckInactive(void);
	void __fastcall ClearDBParams(void);
	TSDDatabase* __fastcall DoFindDatabase(const AnsiString DatabaseName, Classes::TComponent* AOwner);
	TSDDatabase* __fastcall DoOpenDatabase(const AnsiString DatabaseName, Classes::TComponent* AOwner);
	bool __fastcall GetActive(void);
	TSDDatabase* __fastcall GetDatabase(int Index);
	int __fastcall GetDatabaseCount(void);
	void __fastcall LockSession(void);
	void __fastcall MakeCurrent(void);
	void __fastcall RemoveDatabase(TSDDatabase* Value);
	bool __fastcall SessionNameStored(void);
	void __fastcall SetActive(bool Value);
	void __fastcall SetAutoSessionName(bool Value);
	void __fastcall SetSessionName(const AnsiString Value);
	void __fastcall SetSessionNames(void);
	void __fastcall StartSession(bool Value);
	void __fastcall UnlockSession(void);
	void __fastcall InternalAddDatabase(const AnsiString ARemoteDatabase, TSDServerType AServerType, Classes::TStrings* List);
	void __fastcall UpdateAutoSessionName(void);
	void __fastcall ValidateAutoSession(Classes::TComponent* AOwner, bool AllSessions);
	
protected:
	virtual void __fastcall Loaded(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	virtual void __fastcall SetName(const AnsiString NewName);
	
public:
	__fastcall virtual TSDSession(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDSession(void);
	void __fastcall Close(void);
	void __fastcall CloseDatabase(TSDDatabase* Database);
	TSDDatabase* __fastcall FindDatabase(const AnsiString DatabaseName);
	void __fastcall GetDatabaseNames(Classes::TStrings* List);
	void __fastcall GetDatabaseParams(const AnsiString ARemoteDatabase, TSDServerType AServerType, Classes::TStrings* List);
	void __fastcall GetStoredProcNames(const AnsiString DatabaseName, Classes::TStrings* List);
	void __fastcall GetFieldNames(const AnsiString DatabaseName, const AnsiString TableName, Classes::TStrings* List);
	void __fastcall GetTableNames(const AnsiString DatabaseName, const AnsiString Pattern, bool SystemTables, Classes::TStrings* List);
	void __fastcall Open(void);
	TSDDatabase* __fastcall OpenDatabase(const AnsiString DatabaseName);
	__property int DatabaseCount = {read=GetDatabaseCount, nodefault};
	__property TSDDatabase* Databases[int Index] = {read=GetDatabase};
	__property Controls::TCursor SQLWaitCursor = {read=FSQLWaitCursor, write=FSQLWaitCursor, nodefault};
	
__published:
	__property bool Active = {read=GetActive, write=SetActive, default=0};
	__property bool AutoSessionName = {read=FAutoSessionName, write=SetAutoSessionName, default=0};
	__property bool KeepConnections = {read=FKeepConnections, write=FKeepConnections, default=1};
	__property AnsiString SessionName = {read=FSessionName, write=SetSessionName, stored=SessionNameStored};
	__property bool SQLHourGlass = {read=FSQLHourGlass, write=FSQLHourGlass, default=1};
};


#pragma option push -b
enum TSDTransIsolation { tiDirtyRead, tiReadCommitted, tiRepeatableRead };
#pragma option pop

#pragma option push -b
enum TSDDesignDBOption { ddoIsDefaultDatabase, ddoStoreConnected };
#pragma option pop

typedef Set<TSDDesignDBOption, ddoIsDefaultDatabase, ddoStoreConnected>  TSDDesignDBOptions;

typedef void __fastcall (__closure *TSDLoginEvent)(TSDDatabase* Database, Classes::TStrings* LoginParams);

class DELPHICLASS TSDCustomDatabase;
class PASCALIMPLEMENTATION TSDCustomDatabase : public Db::TCustomConnection 
{
	typedef Db::TCustomConnection inherited;
	
public:
	#pragma option push -w-inl
	/* TCustomConnection.Create */ inline __fastcall virtual TSDCustomDatabase(Classes::TComponent* AOwner) : Db::TCustomConnection(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCustomConnection.Destroy */ inline __fastcall virtual ~TSDCustomDatabase(void) { }
	#pragma option pop
	
};


class DELPHICLASS TSDThreadTimer;
class PASCALIMPLEMENTATION TSDThreadTimer : public Classes::TThread 
{
	typedef Classes::TThread inherited;
	
private:
	TSDDatabase* FDatabase;
	int FInterval;
	Classes::TNotifyEvent FOnTimer;
	void __fastcall SetInterval(int Value);
	void __fastcall SetOnTimer(Classes::TNotifyEvent Value);
	
protected:
	DYNAMIC void __fastcall Timer(void);
	virtual void __fastcall Execute(void);
	
public:
	__fastcall TSDThreadTimer(TSDDatabase* ADatabase, bool CreateSuspended);
	__fastcall virtual ~TSDThreadTimer(void);
	__property int Interval = {read=FInterval, write=SetInterval, default=1000};
	__property Classes::TNotifyEvent OnTimer = {read=FOnTimer, write=SetOnTimer};
};


class DELPHICLASS TSDDataSet;
class PASCALIMPLEMENTATION TSDDatabase : public TSDCustomDatabase 
{
	typedef TSDCustomDatabase inherited;
	
private:
	TSDTransIsolation FTransIsolation;
	bool FKeepConnection;
	bool FTemporary;
	bool FAcquiredHandle;
	Classes::TStrings* FParams;
	int FRefCount;
	TSDSession* FSession;
	AnsiString FSessionName;
	AnsiString FDatabaseName;
	AnsiString FRemoteDatabase;
	TSDServerType FServerType;
	Sdcommon::TISqlDatabase* FSqlDatabase;
	TSDDesignDBOptions FDesignOptions;
	int FIdleTimeOut;
	TSDThreadTimer* FTimer;
	bool FIdleTimeoutStarted;
	bool FIsConnectionBusy;
	int FClientVersion;
	int FServerVersion;
	AnsiString FVersion;
	TSDLoginEvent FOnLogin;
	void __fastcall CheckActive(void);
	void __fastcall CheckInactive(void);
	void __fastcall CheckInTransaction(void);
	void __fastcall CheckNotInTransaction(void);
	void __fastcall CheckDatabaseName(void);
	void __fastcall CheckRemoteDatabase(AnsiString &Password);
	void __fastcall CheckSessionName(bool Required);
	bool __fastcall ConnectedStored(void);
	void * __fastcall GetHandle(void);
	int __fastcall GetIdleTimeOut(void);
	bool __fastcall GetIsSQLBased(void);
	bool __fastcall GetInTransaction(void);
	AnsiString __fastcall GetVersion();
	Word __fastcall GetServerMajor(void);
	Word __fastcall GetServerMinor(void);
	Word __fastcall GetClientMajor(void);
	Word __fastcall GetClientMinor(void);
	void __fastcall IdleTimerHandler(System::TObject* Sender);
	void __fastcall Login(Classes::TStrings* LoginParams);
	void __fastcall BusyStateReset(System::TObject* Sender);
	void __fastcall IdleTimeOutReset(System::TObject* Sender);
	void __fastcall ResetServerInfo(void);
	void __fastcall SetDatabaseName(const AnsiString Value);
	void __fastcall SetDesignOptions(TSDDesignDBOptions Value);
	void __fastcall SetHandle(void * Value);
	void __fastcall SetIdleTimeOut(int Value);
	void __fastcall SetKeepConnection(bool Value);
	void __fastcall SetParams(Classes::TStrings* Value);
	void __fastcall SetRemoteDatabase(const AnsiString Value);
	void __fastcall SetServerType(TSDServerType Value);
	void __fastcall SetSessionName(const AnsiString Value);
	void __fastcall SetTransIsolation(TSDTransIsolation Value);
	void __fastcall UpdateTimer(int NewTimeout);
	
protected:
	__property Sdcommon::TISqlDatabase* SqlDatabase = {read=FSqlDatabase};
	__property bool AcquiredHandle = {read=FAcquiredHandle, nodefault};
	void __fastcall InitSqlDatabase(const AnsiString ADatabaseName, const AnsiString AUserName, const AnsiString APassword, void * AHandle);
	void __fastcall DoneSqlDatabase(void);
	void __fastcall InternalClose(bool Force);
	void __fastcall ISqlGetStoredProcNames(Classes::TStrings* List);
	void __fastcall ISqlGetTableNames(AnsiString Pattern, bool SystemTables, Classes::TStrings* List);
	void __fastcall ISqlGetFieldNames(const AnsiString TableName, Classes::TStrings* List);
	int __fastcall ISqlParamValue(Sdcommon::TSDDatabaseParam Value);
	virtual void __fastcall DoConnect(void);
	virtual void __fastcall DoDisconnect(void);
	virtual bool __fastcall GetConnected(void);
	virtual Db::TDataSet* __fastcall GetDataSet(int Index);
	virtual TSDDataSet* __fastcall GetSDDataSet(int Index);
	virtual void __fastcall Loaded(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	virtual void __fastcall RegisterClient(System::TObject* Client, Db::TConnectChangeEvent Event = 0x0);
	virtual void __fastcall UnRegisterClient(System::TObject* Client);
	
public: