sdengine.hpp

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

	__fastcall virtual TSDDatabase(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDDatabase(void);
	void __fastcall ApplyUpdates(const TSDDataSet* * 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 Connected  = {stored=ConnectedStored, default=0};
	__property LoginPrompt  = {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};
};


struct TCacheRecInfo;
typedef TCacheRecInfo *PCacheRecInfo;

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

class DELPHICLASS TSDResultSet;
class PASCALIMPLEMENTATION TSDResultSet : public Classes::TList 
{
	typedef Classes::TList inherited;
	
public:
	char * operator[](int Index) { return CurRecords[Index]; }
	
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);
	virtual 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(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;

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, Db::TUpdateAction &UpdateAction);

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

class DELPHICLASS TSDDataSetUpdateObject;
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
	
};


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);
	TSDSession* __fastcall GetDBSession(void);
	TUpdateKinds __fastcall GetEnableUpdateKinds(void);
	bool __fastcall GetUpdatesPending(void);
	TUpdateRecordTypes __fastcall GetUpdateRecordSet(void);
	void __fastcall InitBufferPointers(void);
	bool __fastcall RecordFilter(char * RecBuf);
	void __fastcall SetAutoRefresh(const bool Value);
	void __fastcall SetBlobData(Db::TField* Field, char * Buffer, Sdcommon::TBytes Value);
	void __fastcall SetDatabaseName(const AnsiString Value);
	void __fastcall SetDetachOnFetchAll(bool Value);
	void __fastcall SetSessionName(const AnsiString Value);
	void __fastcall SetEnableUpdateKinds(TUpdateKinds Value);
	HIDESBASE void __fastcall SetUniDirectional(const bool Value);
	virtual void __fastcall SetUpdateMode(const Db::TUpdateMode Value);
	void __fastcall SetUpdateRecordSet(TUpdateRecordTypes RecordTypes);
	void __fastcall SetUpdateObject(TSDDataSetUpdateObject* Value);
	
protected:
	__property TSDResultSet* RecCache = {read=FRecCache};
	__property Sdcommon::TISqlCommand* SqlCmd = {read=FSqlCmd};
	virtual Sdcommon::TISqlCommand* __fastcall ISqlCmdCreate(void);
	void __fastcall ISqlCloseResultSet(void);
	void __fastcall ISqlCnvtFieldData(Sdcommon::TISqlCommand* ASqlCmd, Sdcommon::TSDFieldDesc* AFieldDesc, char * Buffer, Db::TField* AField);
	void __fastcall ISqlCnvtFieldsBuffer(char * Buffer);
	bool __fastcall ISqlConnected(void);
	void __fastcall ISqlDetach(void);
	void __fastcall ISqlExecDirect(AnsiString Value);
	void __fastcall ISqlExecute(void);
	bool __fastcall ISqlFetch(void);
	void __fastcall ISqlInitFieldDefs(void);
	void __fastcall ISqlPrepare(AnsiString Value);
	bool __fastcall ISqlPrepared(void);
	int __fastcall ISqlGetRowsAffected(void);
	int __fastcall ISqlWriteBlob(int FieldNo, const char * Buffer, int Count);
	int __fastcall ISqlWriteBlobByName(AnsiString Name, const char * Buffer, int Count);
	
private:
	void __fastcall CacheInit(void);
	void __fastcall CacheDone(void);
	char * __fastcall CacheTempBuffer(void);
	
protected:
	Sdcommon::TSDExprParser* FExprFilter;
	Sdcommon::TSDExprParser* __fastcall CreateExprFilter(const AnsiString Text, Db::TFilterOptions Options);
	virtual void __fastcall PSEndTransaction(bool Commit);
	virtual int __fastcall PSExecuteStatement(const AnsiString ASQL, Db::TParams* AParams, void * ResultSet = (void *)(0x0));
	virtual AnsiString __fastcall PSGetQuoteChar();
	virtual Db::EUpdateError* __fastcall PSGetUpdateException(Sysutils::Exception* E, Db::EUpdateError* Prev);
	virtual bool __fastcall PSInTransaction(void);
	virtual bool __fastcall PSIsSQLBased(void);
	virtual bool __fastcall PSIsSQLSupported(void);
	virtual void __fastcall PSReset(void);
	virtual void __fastcall PSStartTransaction(void);
	virtual bool __fastcall PSUpdateRecord(Db::TUpdateKind UpdateKind, Db::TDataSet* Delta);
	virtual char * __fastcall AllocRecordBuffer(void);
	void __fastcall DestroySqlCommand(bool Force);
	void __fastcall ForceClose(void);
	virtual void __fastcall FreeRecordBuffer(char * &Buffer);
	void __fastcall CheckCachedUpdateMode(void);
	HIDESBASE void __fastcall CheckCanModify(void);
	void __fastcall CheckDatabaseName(void);
	virtual void __fastcall ClearCalcFields(char * Buffer);
	virtual void __fastcall CloseCursor(void);
	void __fastcall ClearFieldDefs(void);
	virtual void __fastcall CreateHandle(void) = 0 ;
	virtual void __fastcall DataEvent(Db::TDataEvent Event, int Info);
	virtual void __fastcall DestroyHandle(void);
	virtual bool __fastcall FindRecord(bool Restart, bool GoForward);
	virtual void __fastcall GetBookmarkData(char * Buffer, void * Data);
	virtual Db::TBookmarkFlag __fastcall GetBookmarkFlag(char * Buffer);
	int __fastcall GetBufferCount(void);
	virtual bool __fastcall GetCanModify(void);
	char * __fastcall GetFieldBuffer(int AFieldNo, char * RecBuf);
	int __fastcall GetFieldDataSize(Db::TField* Field);
	virtual int __fastcall GetRecNo(void);
	virtual Db::TGetResult __fastcall GetRecord(char * Buffer, Db::TGetMode GetMode, bool DoCheck);
	virtual int __fastcall GetRecordCount(void);
	virtual Word __fastcall GetRecordSize(void);
	Db::TUpdateStatus __fastcall GetRecordUpdateStatus(void);
	void __fastcall SetRecordUpdateStatus(Db::TUpdateStatus Value);
	virtual void __fastcall InitRecord(char * Buffer);