sdengine.hpp

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

protected:
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	virtual bool __fastcall SetDSFlag(int Flag, bool Value);
	virtual void __fastcall SetQuery(Classes::TStrings* Value);
	
public:
	__fastcall virtual TSDMacroQuery(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDMacroQuery(void);
	void __fastcall ExpandMacros(void);
	Db::TParam* __fastcall MacroByName(const AnsiString MacroName);
	
__published:
	__property char MacroChar = {read=FMacroChar, write=SetMacroChar, default=37};
	__property Word MacroCount = {read=GetMacroCount, nodefault};
	__property Db::TParams* Macros = {read=GetMacros, write=SetMacros, stored=false};
	__property Classes::TStrings* SQL = {read=FSQLPattern, write=SetQuery};
};

#pragma pack(pop)

class DELPHICLASS TSDUpdateSQL;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDUpdateSQL : public TSDDataSetUpdateObject 
{
	typedef TSDDataSetUpdateObject inherited;
	
private:
	TSDDataSet* FDataSet;
	TSDQuery* FQueries[4];
	Classes::TStrings* FSQLText[4];
	Classes::TStrings* __fastcall GetSQL(Db::TUpdateStatus StmtKind);
	Classes::TStrings* __fastcall GetSQLIndex(int Index);
	void __fastcall SetSQL(Db::TUpdateStatus StmtKind, Classes::TStrings* Value);
	void __fastcall SetSQLIndex(int Index, Classes::TStrings* Value);
	
protected:
	virtual TSDDataSet* __fastcall GetDataSet(void);
	TSDQuery* __fastcall GetQuery(Db::TUpdateKind UpdateKind);
	virtual TSDQuery* __fastcall GetQueryEx(Db::TUpdateStatus StmtKind);
	virtual void __fastcall SetDataSet(TSDDataSet* ADataSet);
	void __fastcall SQLChanged(System::TObject* Sender);
	
public:
	__fastcall virtual TSDUpdateSQL(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDUpdateSQL(void);
	virtual void __fastcall Apply(Db::TUpdateKind UpdateKind);
	void __fastcall ExecSQL(Db::TUpdateKind UpdateKind);
	void __fastcall SetParams(Db::TUpdateKind UpdateKind);
	__property DataSet ;
	__property TSDQuery* Query[Db::TUpdateKind UpdateKind] = {read=GetQuery};
	__property Classes::TStrings* SQL[Db::TUpdateStatus StmtKind] = {read=GetSQL, write=SetSQL};
	__property TSDQuery* QueryEx[Db::TUpdateStatus StmtKind] = {read=GetQueryEx};
	
__published:
	__property Classes::TStrings* RefreshSQL = {read=GetSQLIndex, write=SetSQLIndex, index=0};
	__property Classes::TStrings* ModifySQL = {read=GetSQLIndex, write=SetSQLIndex, index=1};
	__property Classes::TStrings* InsertSQL = {read=GetSQLIndex, write=SetSQLIndex, index=2};
	__property Classes::TStrings* DeleteSQL = {read=GetSQLIndex, write=SetSQLIndex, index=3};
};

#pragma pack(pop)

class DELPHICLASS TSDBlobStream;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDBlobStream : public Classes::TStream 
{
	typedef Classes::TStream inherited;
	
private:
	Db::TBlobField* FField;
	TSDDataSet* FDataSet;
	char *FBuffer;
	Db::TBlobStreamMode FMode;
	int FFieldNo;
	bool FOpened;
	bool FModified;
	int FPosition;
	DynamicArray<Byte >  FBlobData;
	int FBlobSize;
	bool FCached;
	int FCacheSize;
	int __fastcall GetBlobSize(void);
	
protected:
	virtual void __fastcall SetSize(int NewSize);
	
public:
	__fastcall TSDBlobStream(Db::TBlobField* Field, Db::TBlobStreamMode Mode);
	__fastcall virtual ~TSDBlobStream(void);
	virtual int __fastcall Read(void *Buffer, int Count);
	virtual int __fastcall Write(const void *Buffer, int Count);
	virtual int __fastcall Seek(int Offset, Word Origin);
	void __fastcall Truncate(void);
};

#pragma pack(pop)

class DELPHICLASS TSDStoredProc;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDStoredProc : public TSDDataSet 
{
	typedef TSDDataSet inherited;
	
private:
	AnsiString FProcName;
	Db::TParams* FParams;
	Word FOverLoad;
	bool FPrepared;
	bool FQueryMode;
	bool FExecCmd;
	void __fastcall ReleaseHandle(bool SaveRes);
	void __fastcall SetParamsList(Db::TParams* Value);
	void __fastcall ReadParamData(Classes::TReader* Reader);
	void __fastcall WriteParamData(Classes::TWriter* Writer);
	
protected:
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	void __fastcall BindParams(void);
	virtual void __fastcall CreateHandle(void);
	void __fastcall CreateParamDesc(void);
	virtual void __fastcall CloseCursor(void);
	virtual void __fastcall ExecuteCursor(void);
	virtual void __fastcall InternalOpen(void);
	bool __fastcall IsExecDirect(void);
	Word __fastcall GetParamsCount(void);
	virtual bool __fastcall SetDSFlag(int Flag, bool Value);
	void __fastcall SetOverLoad(Word Value);
	void __fastcall SetProcName(const AnsiString Value);
	void __fastcall SetPrepared(bool Value);
	void __fastcall SetPrepareCmd(bool Value, bool GenCursor);
	virtual Sdcommon::TISqlCommand* __fastcall ISqlCmdCreate(void);
	bool __fastcall ISqlDescriptionsAvailable(void);
	bool __fastcall ISqlNextResultSet(void);
	void __fastcall ISqlPrepareProc(void);
	void __fastcall ISqlExecProc(void);
	void __fastcall ISqlExecProcDirect(void);
	void __fastcall ISqlGetResults(void);
	
public:
	__fastcall virtual TSDStoredProc(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDStoredProc(void);
	virtual void __fastcall Disconnect(void);
	void __fastcall CopyParams(Db::TParams* Value);
	bool __fastcall DescriptionsAvailable(void);
	void __fastcall ExecProc(void);
	void __fastcall GetResults(void);
	bool __fastcall NextResultSet(void);
	Db::TParam* __fastcall ParamByName(const AnsiString Value);
	void __fastcall Prepare(void);
	void __fastcall UnPrepare(void);
	__property Word ParamCount = {read=GetParamsCount, nodefault};
	__property bool Prepared = {read=FPrepared, write=SetPrepared, nodefault};
	
__published:
	__property AnsiString StoredProcName = {read=FProcName, write=SetProcName};
	__property Word Overload = {read=FOverLoad, write=SetOverLoad, default=0};
	__property Db::TParams* Params = {read=FParams, write=SetParamsList, stored=false};
	__property UpdateObject ;
};

#pragma pack(pop)

#pragma pack(push, 4)
struct TIndexDesc
{
	AnsiString Name;
	AnsiString Fields;
	AnsiString DescFields;
	Word iFldsInKey;
	Word bPrimary;
	Word bUnique;
} ;
#pragma pack(pop)

typedef DynamicArray<TIndexDesc >  TIndexDescArray;

class DELPHICLASS TSDTable;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDTable : public TSDDataSet 
{
	typedef TSDDataSet inherited;
	
__published:
	__property UpdateMode ;
	__property UpdateObject ;
public:
	#pragma option push -w-inl
	/* TSDDataSet.Create */ inline __fastcall virtual TSDTable(Classes::TComponent* AOwner) : TSDDataSet(
		AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TSDDataSet.Destroy */ inline __fastcall virtual ~TSDTable(void) { }
	#pragma option pop
	
};

#pragma pack(pop)

class DELPHICLASS TSDScript;
#pragma pack(push, 4)
class PASCALIMPLEMENTATION TSDScript : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Classes::TStrings* FSQL;
	Classes::TStrings* FSQLPattern;
	bool FParamCheck;
	Db::TParams* FParams;
	TSDQuery* FQuery;
	bool FIgnoreParams;
	char FTermChar;
	char FMacroChar;
	Db::TParams* FMacros;
	bool FMacroCheck;
	bool FTransaction;
	Classes::TNotifyEvent FBeforeExecute;
	Classes::TNotifyEvent FAfterExecute;
	TSDDatabase* __fastcall GetDatabase(void);
	AnsiString __fastcall GetDatabaseName(void);
	Db::TParams* __fastcall GetMacros(void);
	Word __fastcall GetMacroCount(void);
	int __fastcall GetParamsCount(void);
	TSDSession* __fastcall GetDBSession(void);
	AnsiString __fastcall GetSessionName(void);
	AnsiString __fastcall GetText(void);
	void __fastcall CreateMacros(void);
	void __fastcall PatternChanged(System::TObject* Sender);
	void __fastcall SetDatabaseName(const AnsiString Value);
	void __fastcall SetMacroChar(const char Value);
	void __fastcall SetMacros(const Db::TParams* Value);
	void __fastcall SetParamsList(const Db::TParams* Value);
	void __fastcall SetQuery(const Classes::TStrings* Value);
	void __fastcall SetSessionName(const AnsiString Value);
	void __fastcall ReadParamData(Classes::TReader* Reader);
	void __fastcall WriteParamData(Classes::TWriter* Writer);
	void __fastcall ReadMacroData(Classes::TReader* Reader);
	void __fastcall WriteMacroData(Classes::TWriter* Writer);
	
protected:
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	void __fastcall CheckExecQuery(int LineNo, int StatementNo);
	virtual void __fastcall ExecuteScript(int StatementNo);
	
public:
	__fastcall virtual TSDScript(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDScript(void);
	void __fastcall ExecSQL(void);
	void __fastcall ExpandMacros(void);
	Db::TParam* __fastcall MacroByName(const AnsiString MacroName);
	Db::TParam* __fastcall ParamByName(const AnsiString Value);
	__property TSDSession* DBSession = {read=GetDBSession};
	__property TSDDatabase* Database = {read=GetDatabase};
	__property int ParamCount = {read=GetParamsCount, nodefault};
	__property AnsiString Text = {read=GetText};
	
__published:
	__property AnsiString DatabaseName = {read=GetDatabaseName, write=SetDatabaseName};
	__property bool IgnoreParams = {read=FIgnoreParams, write=FIgnoreParams, default=0};
	__property char MacroChar = {read=FMacroChar, write=SetMacroChar, default=37};
	__property bool MacroCheck = {read=FMacroCheck, write=FMacroCheck, default=1};
	__property Word MacroCount = {read=GetMacroCount, nodefault};
	__property Db::TParams* Macros = {read=GetMacros, write=SetMacros, stored=false};
	__property char TermChar = {read=FTermChar, write=FTermChar, default=59};
	__property AnsiString SessionName = {read=GetSessionName, write=SetSessionName};
	__property Classes::TStrings* SQL = {read=FSQLPattern, write=SetQuery};
	__property bool ParamCheck = {read=FParamCheck, write=FParamCheck, default=1};
	__property Db::TParams* Params = {read=FParams, write=SetParamsList, stored=false};
	__property bool Transaction = {read=FTransaction, write=FTransaction, nodefault};
	__property Classes::TNotifyEvent BeforeExecute = {read=FBeforeExecute, write=FBeforeExecute};
	__property Classes::TNotifyEvent AfterExecute = {read=FAfterExecute, write=FAfterExecute};
};

#pragma pack(pop)

//-- var, const, procedure ---------------------------------------------------
static const Shortint SDE_ERR_NONE = 0x0;
static const Shortint SDE_ERR_UPDATEABORT = 0xffffffff;
static const Shortint dsfOpened = 0x0;
static const Shortint dsfPrepared = 0x1;
static const Shortint dsfExecSQL = 0x2;
static const Shortint dsfTable = 0x3;
static const Shortint dsfFieldList = 0x4;
static const Shortint dsfIndexList = 0x5;
static const Shortint dsfStoredProc = 0x6;
static const Shortint dsfExecProc = 0x7;
static const Shortint dsfProcDesc = 0x8;
static const Shortint dsfProvider = 0xa;
extern PACKAGE TSDDatabase* DefDatabase;
extern PACKAGE TSDSession* Session;
extern PACKAGE TSDSessionList* Sessions;
extern PACKAGE Sdcommon::TInitSqlDatabaseProc InitSqlDatabaseProcs[12];
extern PACKAGE void __fastcall SetBusyState(void);
extern PACKAGE void __fastcall ResetBusyState(void);
extern PACKAGE Db::TUpdateStatus __fastcall UpdateKindToStatus(Db::TUpdateKind UpdateKind);
extern PACKAGE void __fastcall SDEError(short ErrorCode);
extern PACKAGE void __fastcall SDECheck(short Status);

}	/* namespace Sdengine */
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
using namespace Sdengine;
#endif
#pragma option pop	// -w-

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// SDEngine