sdengine.hpp

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

	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(void);
	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, TConnectChangeEvent Event);
	virtual void __fastcall UnRegisterClient(System::TObject* Client);
	
public:
	__fastcall virtual TSDDatabase(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDDatabase(void);
	void __fastcall ApplyUpdates(TSDDataSet* const * DataSets, const int DataSets_Size);
	void __fastcall CloseDataSets(void);
	void __fastcall Commit(void);
	void __fastcall ForceClose(void);
	void __fastcall GetFieldNames(const AnsiString TableName, Classes::TStrings* List);
	void __fastcall GetTableNames(const AnsiString Pattern, bool SystemTables, Classes::TStrings* List)
		;
	Db::TDataSet* __fastcall GetSchemaInfo(Sdcommon::TSDSchemaType ASchemaType, AnsiString AObjectName)
		;
	void __fastcall Rollback(void);
	void __fastcall StartTransaction(void);
	bool __fastcall TestConnected(void);
	void __fastcall ValidateName(const AnsiString Name);
	__property TSDDataSet* DataSets[int Index] = {read=GetSDDataSet};
	__property void * Handle = {read=GetHandle, write=SetHandle};
	__property bool InTransaction = {read=GetInTransaction, nodefault};
	__property bool IsSQLBased = {read=GetIsSQLBased, nodefault};
	__property TSDSession* Session = {read=FSession};
	__property bool Temporary = {read=FTemporary, write=FTemporary, nodefault};
	__property Word ClientMajor = {read=GetClientMajor, nodefault};
	__property Word ClientMinor = {read=GetClientMinor, nodefault};
	__property Word ServerMajor = {read=GetServerMajor, nodefault};
	__property Word ServerMinor = {read=GetServerMinor, nodefault};
	__property AnsiString Version = {read=GetVersion};
	
__published:
	__property bool Connected = {read=GetConnected, write=SetConnected, stored=ConnectedStored, nodefault
		};
	__property bool LoginPrompt = {read=FLoginPrompt, write=FLoginPrompt, default=1};
	__property AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
	__property TSDDesignDBOptions DesignOptions = {read=FDesignOptions, write=SetDesignOptions, default=2
		};
	__property int IdleTimeOut = {read=GetIdleTimeOut, write=SetIdleTimeOut, nodefault};
	__property bool KeepConnection = {read=FKeepConnection, write=SetKeepConnection, default=1};
	__property Classes::TStrings* Params = {read=FParams, write=SetParams};
	__property AnsiString RemoteDatabase = {read=FRemoteDatabase, write=SetRemoteDatabase};
	__property TSDServerType ServerType = {read=FServerType, write=SetServerType, default=0};
	__property AnsiString SessionName = {read=FSessionName, write=SetSessionName};
	__property TSDTransIsolation TransIsolation = {read=FTransIsolation, write=SetTransIsolation, default=1
		};
	__property AfterConnect ;
	__property AfterDisconnect ;
	__property BeforeConnect ;
	__property BeforeDisconnect ;
	__property TSDLoginEvent OnLogin = {read=FOnLogin, write=FOnLogin};
};

#pragma pack(pop)

struct TCacheRecInfo;
typedef TCacheRecInfo *PCacheRecInfo;

#pragma pack(push, 4)
struct TCacheRecInfo
{
	bool Applied;
	char *CurRec;
	char *OldRec;
} ;
#pragma pack(pop)

class DELPHICLASS TSDResultSet;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDResultSet : public Classes::TList 
{
	typedef Classes::TList inherited;
	
private:
	TSDDataSet* FDataSet;
	bool FIsBlobs;
	int FPosition;
	int FDeletedCount;
	bool FAllInCache;
	bool __fastcall GetAppliedRecords(int Index);
	TCacheRecInfo __fastcall GetCacheItem(int Index);
	char * __fastcall GetCurRecords(int Index);
	char * __fastcall GetOldRecords(int Index);
	Db::TUpdateStatus __fastcall GetUpdateStatusRecords(int Index);
	bool __fastcall GetFilterActivated(void);
	int __fastcall GetRecordCount(void);
	int __fastcall GetIndexOfRecord(int ARecNumber);
	int __fastcall GetNewRecordNumber(int AInsertedRecIndex);
	void __fastcall SetAppliedRecords(int Index, bool Value);
	void __fastcall SetCacheItem(int Index, const TCacheRecInfo &Value);
	void __fastcall SetCurRecords(int Index, char * Value);
	void __fastcall SetOldRecords(int Index, char * Value);
	void __fastcall SetUpdateStatusRecords(int Index, Db::TUpdateStatus Value);
	int __fastcall AddRecord(char * RecBuf);
	void __fastcall CopyRecBuf(const char * Source, const char * Dest);
	void __fastcall ClearCacheItem(int Index);
	void __fastcall DeleteCacheItem(int Index);
	bool __fastcall FetchRecord(void);
	bool __fastcall GetCurrRecord(void);
	bool __fastcall GetNextRecord(void);
	bool __fastcall GetPriorRecord(void);
	bool __fastcall GetRecord(char * Buffer, Db::TGetMode GetMode);
	bool __fastcall GotoNextRecord(void);
	bool __fastcall IsVisibleRecord(int Index);
	int __fastcall DeleteRecord(char * RecBuf);
	bool __fastcall IsInsertedRecord(int Index);
	int __fastcall InsertRecord(char * RecBuf, bool Append, bool SetCurrent);
	void __fastcall ModifyRecord(char * RecBuf);
	void __fastcall ModifyBlobData(Db::TField* Field, char * RecBuf, const Sdcommon::TBytes Value);
	bool __fastcall RecordFilter(char * RecBuf);
	int __fastcall UpdatesCancel(void);
	int __fastcall UpdatesCancelCurrent(void);
	int __fastcall UpdatesCommit(void);
	int __fastcall UpdatesPrepare(void);
	int __fastcall UpdatesRollback(void);
	
public:
	__fastcall TSDResultSet(TSDDataSet* ADataSet, bool IsBlobs);
	__fastcall virtual ~TSDResultSet(void);
	DYNAMIC void __fastcall Clear(void);
	bool __fastcall UpdatesCommitRecord(int Index);
	void __fastcall ExchangeRecords(int Index1, int Index2);
	void __fastcall FetchAll(void);
	bool __fastcall FindNextRecord(void);
	bool __fastcall FindPriorRecord(void);
	void __fastcall SetToBegin(void);
	void __fastcall SetToEnd(void);
	int __fastcall IndexOfRecord(char * RecBuf);
	__property bool AllInCache = {read=FAllInCache, nodefault};
	__property bool AppliedRecords[int Index] = {read=GetAppliedRecords, write=SetAppliedRecords};
	__property TCacheRecInfo CacheItems[int Index] = {read=GetCacheItem, write=SetCacheItem};
	__property char * CurRecords[int Index] = {read=GetCurRecords, write=SetCurRecords/*, default*/};
	__property char * OldRecords[int Index] = {read=GetOldRecords, write=SetOldRecords};
	__property TSDDataSet* DataSet = {read=FDataSet};
	__property Db::TUpdateStatus UpdateStatusRecords[int Index] = {read=GetUpdateStatusRecords, write=SetUpdateStatusRecords
		};
	__property int CurrentIndex = {read=FPosition, write=FPosition, nodefault};
	__property int RecordCount = {read=GetRecordCount, nodefault};
	__property bool FilterActivated = {read=GetFilterActivated, nodefault};
};

#pragma pack(pop)

#pragma pack(push, 1)
struct TSDRecInfo
{
	int RecordNumber;
	Db::TUpdateStatus UpdateStatus;
	Db::TBookmarkFlag BookmarkFlag;
} ;
#pragma pack(pop)

typedef TSDRecInfo *PSDRecInfo;

typedef bool TFieldIsNotNull;

typedef bool *PFieldIsNotNull;

#pragma option push -b
enum TDelayedUpdCmd { DelayedUpdCommit, DelayedUpdCancel, DelayedUpdCancelCurrent, DelayedUpdPrepare, 
	DelayedUpdRollback };
#pragma option pop

typedef Set<Shortint, 0, 15>  TDSFlags;

#pragma option push -b
enum TUpdateAction { uaFail, uaAbort, uaSkip, uaRetry, uaApplied };
#pragma option pop

typedef Set<Db::TUpdateKind, ukModify, ukDelete>  TUpdateKinds;

#pragma option push -b
enum SDEngine__8 { rtModified, rtInserted, rtDeleted, rtUnmodified };
#pragma option pop

typedef Set<SDEngine__8, rtModified, rtUnmodified>  TUpdateRecordTypes;

typedef void __fastcall (__closure *TUpdateErrorEvent)(Db::TDataSet* DataSet, Db::EDatabaseError* E, 
	Db::TUpdateKind UpdateKind, TUpdateAction &UpdateAction);

typedef void __fastcall (__closure *TUpdateRecordEvent)(Db::TDataSet* DataSet, Db::TUpdateKind UpdateKind
	, TUpdateAction &UpdateAction);

class DELPHICLASS TSDDataSetUpdateObject;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDDataSetUpdateObject : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
protected:
	virtual TSDDataSet* __fastcall GetDataSet(void) = 0 ;
	virtual void __fastcall SetDataSet(TSDDataSet* ADataSet) = 0 ;
	
public:
	virtual void __fastcall Apply(Db::TUpdateKind UpdateKind) = 0 ;
	__property TSDDataSet* DataSet = {read=GetDataSet, write=SetDataSet};
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TSDDataSetUpdateObject(Classes::TComponent* AOwner
		) : Classes::TComponent(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TSDDataSetUpdateObject(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDDataSet : public Db::TDataSet 
{
	typedef Db::TDataSet inherited;
	
private:
	bool FAutoRefresh;
	TDSFlags FDSFlags;
	TSDDatabase* FDatabase;
	AnsiString FDatabaseName;
	AnsiString FSessionName;
	Sdcommon::TISqlCommand* FSqlCmd;
	TSDResultSet* FRecCache;
	DynamicArray<int >  FFieldBufOffs;
	bool FClearFieldDefsOnClose;
	bool FCachedUpdates;
	bool FCacheBlobs;
	bool FUniDirectional;
	bool FDetachOnFetchAll;
	char *FFilterBuffer;
	bool FForceClosing;
	bool FGetNextResultSet;
	int FRecordSize;
	int FRecBufSize;
	int FBlobCacheOffs;
	int FRecInfoOffs;
	int FBookmarkOffs;
	TUpdateKinds FEnableUpdateKinds;
	Db::TUpdateMode FUpdateMode;
	TSDDataSetUpdateObject* FUpdateObject;
	TUpdateRecordTypes FUpdateRecordTypes;
	TUpdateErrorEvent FOnUpdateError;
	TUpdateRecordEvent FOnUpdateRecord;
	void __fastcall CheckDBSessionName(void);
	void __fastcall ClearBlobCache(char * RecBuf);
	HIDESBASE void __fastcall DoInternalOpen(bool IsExec);
	void __fastcall InitBlobCache(char * RecBuf);
	bool __fastcall FieldIsNull(void * FieldBuf);
	void __fastcall FieldSetNull(void * FieldBuf, bool bNull);
	bool __fastcall GetActiveRecBuf(char * &RecBuf);
	Sdcommon::TBytes __fastcall GetBlobData(Db::TField* Field, char * Buffer);
	int __fastcall GetBlobDataSize(Db::TField* Field, char * Buffer);
	void * __fastcall GetHandle(void);
	char * __fastcall GetOldRecord(void);
	TSDServerType __fastcall GetServerType(void);