sdengine.hpp

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

// Borland C++ Builder
// Copyright (c) 1995, 1999 by Borland International
// All rights reserved

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

#ifndef SDEngineHPP
#define SDEngineHPP

#pragma delphiheader begin
#pragma option push -w-
#include <SDCommon.hpp>	// Pascal unit
#include <SDConsts.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;
#pragma pack(push, 4)
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, Extended Dummy) : Db::EDatabaseError(
		Ident, Dummy) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall ESDNoResultSet(int Ident, const System::TVarRec * Args
		, const int Args_Size) : 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) : Db::EDatabaseError(
		Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall ESDNoResultSet(int Ident, const System::TVarRec 
		* Args, const int Args_Size, int AHelpContext) : Db::EDatabaseError(Ident, Args, Args_Size, AHelpContext
		) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~ESDNoResultSet(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSDSessionList;
class DELPHICLASS TSDSession;
class DELPHICLASS TSDDatabase;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDSessionList : public System::TObject 
{
	typedef System::TObject inherited;
	
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*/};
};

#pragma pack(pop)

#pragma pack(push, 4)
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 pack(pop)

#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
	);

typedef void __fastcall (__closure *TConnectChangeEvent)(System::TObject* Sender, bool Connecting);

class DELPHICLASS TSDCustomDatabase;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDCustomDatabase : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Classes::TList* FDataSets;
	bool FStreamedConnected;
	Classes::TNotifyEvent FAfterConnect;
	Classes::TNotifyEvent FAfterDisconnect;
	Classes::TNotifyEvent FBeforeConnect;
	Classes::TNotifyEvent FBeforeDisconnect;
	
protected:
	bool FLoginPrompt;
	virtual void __fastcall DoConnect(void);
	virtual void __fastcall DoDisconnect(void);
	virtual bool __fastcall GetConnected(void);
	virtual Db::TDataSet* __fastcall GetDataSet(int Index);
	virtual int __fastcall GetDataSetCount(void);
	virtual void __fastcall Loaded(void);
	virtual void __fastcall RegisterClient(System::TObject* Client, TConnectChangeEvent Event);
	virtual void __fastcall SetConnected(bool Value);
	__property bool StreamedConnected = {read=FStreamedConnected, write=FStreamedConnected, nodefault};
		
	virtual void __fastcall UnRegisterClient(System::TObject* Client);
	
public:
	__fastcall virtual TSDCustomDatabase(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDCustomDatabase(void);
	virtual void __fastcall Open(void);
	void __fastcall Close(void);
	__property bool Connected = {read=GetConnected, write=SetConnected, default=0};
	__property Db::TDataSet* DataSets[int Index] = {read=GetDataSet};
	__property int DataSetCount = {read=GetDataSetCount, nodefault};
	__property bool LoginPrompt = {read=FLoginPrompt, write=FLoginPrompt, default=0};
	__property Classes::TNotifyEvent AfterConnect = {read=FAfterConnect, write=FAfterConnect};
	__property Classes::TNotifyEvent BeforeConnect = {read=FBeforeConnect, write=FBeforeConnect};
	__property Classes::TNotifyEvent AfterDisconnect = {read=FAfterDisconnect, write=FAfterDisconnect};
		
	__property Classes::TNotifyEvent BeforeDisconnect = {read=FBeforeDisconnect, write=FBeforeDisconnect
		};
};

#pragma pack(pop)

class DELPHICLASS TSDThreadTimer;
#pragma pack(push, 4)
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};
};

#pragma pack(pop)

class DELPHICLASS TSDDataSet;
#pragma pack(push, 4)
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;