sdengine.hpp

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

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)/* overload */;
	void __fastcall Truncate(void);
	
/* Hoisted overloads: */
	
protected:
	inline void __fastcall  SetSize(const __int64 NewSize){ TStream::SetSize(NewSize); }
	
public:
	inline __int64 __fastcall  Seek(const __int64 Offset, Classes::TSeekOrigin Origin){ return TStream::Seek(Offset, Origin); }
	
};


class DELPHICLASS TSDStoredProc;
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);
	virtual void __fastcall PSExecute(void);
	virtual AnsiString __fastcall PSGetTableName();
	virtual Db::TParams* __fastcall PSGetParams(void);
	virtual void __fastcall PSSetCommandText(const AnsiString CommandText);
	virtual void __fastcall PSSetParams(Db::TParams* AParams);
	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(push, 4)
struct TIndexDesc
{
	AnsiString Name;
	AnsiString Fields;
	AnsiString DescFields;
	Word iFldsInKey;
	Word bPrimary;
	Word bUnique;
} ;
#pragma pack(pop)

typedef DynamicArray<TIndexDesc >  TIndexDescArray;

typedef DynamicArray<int >  SDEngine__71;

class DELPHICLASS TSDTable;
class PASCALIMPLEMENTATION TSDTable : public TSDDataSet 
{
	typedef TSDDataSet inherited;
	
private:
	AnsiString FTableName;
	AnsiString FOrderByFields;
	AnsiString FWhereText;
	bool FFieldsIndex;
	bool FDefaultIndex;
	Db::TIndexDefs* FIndexDefs;
	Db::TMasterDataLink* FMasterLink;
	AnsiString FIndexName;
	DynamicArray<TIndexDesc >  FIndexDescs;
	DynamicArray<int >  FIndexFieldMap;
	int FIndexFieldCount;
	bool FStoreDefs;
	bool FReadOnly;
	Db::TParams* FParams;
	bool FQuoteIdent;
	void __fastcall CheckMasterRange(void);
	bool __fastcall FieldDefsStored(void);
	bool __fastcall GetExists(void);
	AnsiString __fastcall GetIndexFieldNames();
	AnsiString __fastcall GetIndexName();
	AnsiString __fastcall GetFieldListWithDesc(const AnsiString AFields, const AnsiString ADescFields);
	AnsiString __fastcall GetMasterFields();
	AnsiString __fastcall ReplaceSemicolon2Comma(const AnsiString AStr);
	bool __fastcall IndexDefsStored(void);
	void __fastcall MasterChanged(System::TObject* Sender);
	void __fastcall MasterDisabled(System::TObject* Sender);
	void __fastcall RefreshParams(void);
	void __fastcall ReleaseHandle(bool SaveRes);
	void __fastcall SetDataSource(Db::TDataSource* Value);
	void __fastcall SetIndexField(int Index, Db::TField* Value);
	void __fastcall SetIndexDefs(Db::TIndexDefs* Value);
	void __fastcall SetIndexFieldNames(const AnsiString Value);
	void __fastcall SetIndex(const AnsiString Value, bool FieldsIndex);
	void __fastcall SetIndexName(const AnsiString Value);
	void __fastcall SetMasterFields(const AnsiString Value);
	void __fastcall SetReadOnly(bool Value);
	void __fastcall SetTableName(const AnsiString Value);
	void __fastcall SetLinkRanges(Classes::TList* MasterFields);
	void __fastcall SetParamsFromMasterDataSet(void);
	void __fastcall ApplyRange(void);
	void __fastcall CancelRange(void);
	void __fastcall UpdateRange(void);
	
protected:
	virtual Sdcommon::TISqlCommand* __fastcall ISqlCmdCreate(void);
	void __fastcall ISqlDeleteTable(void);
	void __fastcall ISqlEmptyTable(void);
	virtual void __fastcall CreateHandle(void);
	virtual void __fastcall ExecuteCursor(void);
	virtual void __fastcall DataEvent(Db::TDataEvent Event, int Info);
	virtual void __fastcall DoOnNewRecord(void);
	AnsiString __fastcall GenOrderBy();
	virtual bool __fastcall GetCanModify(void);
	int __fastcall GetCurrentIndex(void);
	virtual Db::TDataSource* __fastcall GetDataSource(void);
	Db::TField* __fastcall GetIndexField(int Index);
	int __fastcall GetIndexFieldCount(void);
	virtual bool __fastcall GetIsIndexField(Db::TField* Field);
	AnsiString __fastcall GetSQLText();
	virtual void __fastcall InternalClose(void);
	virtual void __fastcall InternalDelete(void);
	virtual void __fastcall InternalPost(void);
	virtual void __fastcall InternalOpen(void);
	void __fastcall SwitchToIndex(void);
	void __fastcall ClearIndexDescs(void);
	void __fastcall UpdateIndexDescs(void);
	virtual void __fastcall UpdateIndexDefs(void);
	__property Db::TMasterDataLink* MasterLink = {read=FMasterLink};
	
public:
	__fastcall virtual TSDTable(Classes::TComponent* AOwner);
	__fastcall virtual ~TSDTable(void);
	void __fastcall CreateTable(void);
	void __fastcall DeleteTable(void);
	void __fastcall EmptyTable(void);
	void __fastcall GetIndexNames(Classes::TStrings* List);
	__property bool Exists = {read=GetExists, nodefault};
	__property int IndexFieldCount = {read=GetIndexFieldCount, nodefault};
	__property Db::TField* IndexFields[int Index] = {read=GetIndexField, write=SetIndexField};
	
__published:
	__property bool DefaultIndex = {read=FDefaultIndex, write=FDefaultIndex, default=1};
	__property FieldDefs  = {stored=FieldDefsStored};
	__property Db::TIndexDefs* IndexDefs = {read=FIndexDefs, write=SetIndexDefs, stored=IndexDefsStored};
	__property AnsiString IndexFieldNames = {read=GetIndexFieldNames, write=SetIndexFieldNames};
	__property AnsiString IndexName = {read=GetIndexName, write=SetIndexName};
	__property AnsiString MasterFields = {read=GetMasterFields, write=SetMasterFields};
	__property Db::TDataSource* MasterSource = {read=GetDataSource, write=SetDataSource};
	__property bool ReadOnly = {read=FReadOnly, write=SetReadOnly, default=0};
	__property bool StoreDefs = {read=FStoreDefs, write=FStoreDefs, default=0};
	__property AnsiString TableName = {read=FTableName, write=SetTableName};
	__property UpdateMode  = {default=0};
	__property UpdateObject ;
};


class DELPHICLASS TSDScript;
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();
	Db::TParams* __fastcall GetMacros(void);
	Word __fastcall GetMacroCount(void);
	int __fastcall GetParamsCount(void);
	TSDSession* __fastcall GetDBSession(void);
	AnsiString __fastcall GetSessionName();
	AnsiString __fastcall GetText();
	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};
};


//-- 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 */
using namespace Sdengine;
#pragma option pop	// -w-
#pragma option pop	// -Vx

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