sdcommon.hpp

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

// Borland C++ Builder
// Copyright (c) 1995, 2002 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'SDCommon.pas' rev: 6.00

#ifndef SDCommonHPP
#define SDCommonHPP

#pragma delphiheader begin
#pragma option push -w-
#pragma option push -Vx
#include <SDConsts.hpp>	// Pascal unit
#include <StrUtils.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <FMTBcd.hpp>	// Pascal unit
#include <DBCommon.hpp>	// Pascal unit
#include <TypInfo.hpp>	// Pascal unit
#include <DB.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <SysUtils.hpp>	// Pascal unit
#include <Forms.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 Sdcommon
{
//-- type declarations -------------------------------------------------------
typedef DynamicArray<Byte >  TBytes;

typedef TList TObjectList;
;

typedef void *TSDPtr;

typedef char *TSDCharPtr;

typedef void *TSDObjectPtr;

typedef char *TSDValueBuffer;

typedef char *TSDRecordBuffer;

typedef __int64 TInt64;

typedef Db::TDateTimeRec *PDateTimeRec;

typedef void *PSDCursor;

typedef short TSDEResult;

typedef DynamicArray<Byte >  TSDBlobData;

typedef DynamicArray<Byte >  TSDBlobDataArray[1];

typedef TBytes *PSDBlobDataArray;

#pragma option push -b
enum TISqlTransIsolation { itiDirtyRead, itiReadCommitted, itiRepeatableRead };
#pragma option pop

#pragma option push -b
enum TISqlServerType { istSQLBase, istOracle, istSQLServer, istSybase, istDB2, istInformix, istODBC, istInterbase, istFirebird, istMySQL, istPostgreSQL };
#pragma option pop

typedef AnsiString SDCommon__1[11];

class DELPHICLASS TISqlDatabase;
typedef TISqlDatabase* __fastcall (*TInitSqlDatabaseProc)(Classes::TStrings* ADbParams);

#pragma pack(push, 1)
struct TSDHandleRec
{
	Byte SrvType;
} ;
#pragma pack(pop)

typedef TSDHandleRec *PSDHandleRec;

#pragma option push -b
enum TSDSchemaType { stTables, stSysTables, stProcedures, stColumns, stProcedureParams, stIndexes, stPackages };
#pragma option pop

#pragma option push -b
enum TSDDatabaseParam { spMaxBindName, spMaxClientName, spMaxConnectString, spMaxDatabaseName, spMaxErrorMessage, spMaxErrorText, spMaxExtErrorMessage, spMaxJoinedTables, spLongIdentifiers, spShortIdentifiers, spMaxUserName, spMaxPasswordString, spMaxServerName, spMaxFieldName, spMaxTableName, spMaxSPName, spMaxFullTableName, spMaxFullSPName };
#pragma option pop

class DELPHICLASS ESDSqlLibError;
class PASCALIMPLEMENTATION ESDSqlLibError : public Db::EDatabaseError 
{
	typedef Db::EDatabaseError inherited;
	
public:
	#pragma option push -w-inl
	/* Exception.Create */ inline __fastcall ESDSqlLibError(const AnsiString Msg) : Db::EDatabaseError(Msg) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmt */ inline __fastcall ESDSqlLibError(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 ESDSqlLibError(int Ident)/* overload */ : Db::EDatabaseError(Ident) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall ESDSqlLibError(int Ident, const System::TVarRec * Args, const int Args_Size)/* overload */ : Db::EDatabaseError(Ident, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateHelp */ inline __fastcall ESDSqlLibError(const AnsiString Msg, int AHelpContext) : Db::EDatabaseError(Msg, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmtHelp */ inline __fastcall ESDSqlLibError(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 ESDSqlLibError(int Ident, int AHelpContext)/* overload */ : Db::EDatabaseError(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall ESDSqlLibError(System::PResStringRec ResStringRec, const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Db::EDatabaseError(ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~ESDSqlLibError(void) { }
	#pragma option pop
	
};


class DELPHICLASS ESDEngineError;
class PASCALIMPLEMENTATION ESDEngineError : public Db::EDatabaseError 
{
	typedef Db::EDatabaseError inherited;
	
private:
	int FNativeError;
	int FErrorCode;
	int FErrorPos;
	
public:
	__fastcall ESDEngineError(int AErrorCode, int ANativeError, const AnsiString Msg, int AErrorPos);
	__fastcall virtual ESDEngineError(int AErrorCode, int ANativeError, const AnsiString Msg);
	__property int ErrorCode = {read=FErrorCode, nodefault};
	__property int NativeError = {read=FNativeError, nodefault};
	__property int ErrorPos = {read=FErrorPos, nodefault};
public:
	#pragma option push -w-inl
	/* Exception.CreateFmt */ inline __fastcall ESDEngineError(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 ESDEngineError(int Ident)/* overload */ : Db::EDatabaseError(Ident) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall ESDEngineError(int Ident, const System::TVarRec * Args, const int Args_Size)/* overload */ : Db::EDatabaseError(Ident, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateHelp */ inline __fastcall ESDEngineError(const AnsiString Msg, int AHelpContext) : Db::EDatabaseError(Msg, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmtHelp */ inline __fastcall ESDEngineError(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 ESDEngineError(int Ident, int AHelpContext)/* overload */ : Db::EDatabaseError(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall ESDEngineError(System::PResStringRec ResStringRec, const System::TVarRec * Args, const int Args_Size, int AHelpContext)/* overload */ : Db::EDatabaseError(ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~ESDEngineError(void) { }
	#pragma option pop
	
};


typedef TMetaClass*ESDEngineErrorClass;

typedef TMetaClass*TISqlCommandClass;

class DELPHICLASS TISqlCommand;
class PASCALIMPLEMENTATION TISqlDatabase : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	bool FAcquiredHandle;
	bool FIsEnableBCD;
	bool FIsRTrimChar;
	bool FIsSingleConn;
	int FMaxFieldNameLen;
	int FMaxStringSize;
	int FBlobPieceSize;
	int FPrefetchRows;
	Classes::TStrings* FDbParams;
	TISqlTransIsolation FTransIsolation;
	bool FInTransaction;
	Classes::TNotifyEvent FResetBusyState;
	Classes::TNotifyEvent FResetIdleTimeOut;
	
protected:
	bool FAutoCommitDef;
	bool FAutoCommit;
	bool FCursorPreservedOnCommit;
	bool FCursorPreservedOnRollback;
	bool FTransSupported;
	bool FProcSupportsCursor;
	bool FProcSupportsCursors;
	virtual void __fastcall DoResetBusyState(void);
	virtual void __fastcall DoResetIdleTimeOut(void);
	virtual void __fastcall DoConnect(const AnsiString sDatabaseName, const AnsiString sUserName, const AnsiString sPassword) = 0 ;
	virtual void __fastcall DoDisconnect(bool Force) = 0 ;
	virtual void __fastcall DoCommit(void) = 0 ;
	virtual void __fastcall DoRollback(void) = 0 ;
	virtual void __fastcall DoStartTransaction(void) = 0 ;
	virtual void * __fastcall GetHandle(void);
	virtual void __fastcall SetAutoCommitOption(bool Value);
	virtual void __fastcall SetHandle(void * AHandle);
	
public:
	__fastcall virtual TISqlDatabase(Classes::TStrings* ADbParams);
	__fastcall virtual ~TISqlDatabase(void);
	virtual TISqlCommand* __fastcall CreateSqlCommand(void) = 0 ;
	virtual AnsiString __fastcall GetAutoIncSQL();
	virtual int __fastcall GetClientVersion(void) = 0 ;
	virtual int __fastcall GetServerVersion(void) = 0 ;
	virtual AnsiString __fastcall GetVersionString(void) = 0 ;
	virtual void __fastcall GetStoredProcNames(Classes::TStrings* List);
	virtual void __fastcall GetTableNames(AnsiString Pattern, bool SystemTables, Classes::TStrings* List);
	virtual void __fastcall GetFieldNames(const AnsiString TableName, Classes::TStrings* List);
	virtual TISqlCommand* __fastcall GetSchemaInfo(TSDSchemaType ASchemaType, AnsiString AObjectName);
	virtual void __fastcall Connect(const AnsiString sDatabaseName, const AnsiString sUserName, const AnsiString sPassword);
	virtual void __fastcall Disconnect(bool Force);
	virtual bool __fastcall TestConnected(void) = 0 ;
	virtual void __fastcall Commit(void);
	virtual void __fastcall Rollback(void);
	virtual void __fastcall StartTransaction(void);
	virtual int __fastcall ParamValue(TSDDatabaseParam Value);
	virtual void __fastcall SetTransIsolation(TISqlTransIsolation Value);
	virtual bool __fastcall SPDescriptionsAvailable(void);
	void __fastcall ResetBusyState(void);
	void __fastcall ResetIdleTimeOut(void);
	__property bool AcquiredHandle = {read=FAcquiredHandle, nodefault};
	__property bool AutoCommit = {read=FAutoCommit, nodefault};
	__property bool AutoCommitDef = {read=FAutoCommitDef, nodefault};
	__property bool IsEnableBCD = {read=FIsEnableBCD, nodefault};
	__property bool IsRTrimChar = {read=FIsRTrimChar, nodefault};
	__property bool IsSingleConn = {read=FIsSingleConn, nodefault};
	__property void * Handle = {read=GetHandle, write=SetHandle};
	__property int BlobPieceSize = {read=FBlobPieceSize, nodefault};
	__property bool CursorPreservedOnCommit = {read=FCursorPreservedOnCommit, nodefault};
	__property bool CursorPreservedOnRollback = {read=FCursorPreservedOnRollback, nodefault};
	__property bool InTransaction = {read=FInTransaction, nodefault};
	__property int MaxFieldNameLen = {read=FMaxFieldNameLen, nodefault};
	__property int MaxStringSize = {read=FMaxStringSize, nodefault};
	__property int PrefetchRows = {read=FPrefetchRows, nodefault};
	__property Classes::TStrings* Params = {read=FDbParams};
	__property bool ProcSupportsCursor = {read=FProcSupportsCursor, nodefault};
	__property bool ProcSupportsCursors = {read=FProcSupportsCursors, nodefault};
	__property TISqlTransIsolation TransIsolation = {read=FTransIsolation, write=FTransIsolation, nodefault};
	__property bool TransSupported = {read=FTransSupported, nodefault};
	__property Classes::TNotifyEvent OnResetBusyState = {read=FResetBusyState, write=FResetBusyState};
	__property Classes::TNotifyEvent OnResetIdleTimeOut = {read=FResetIdleTimeOut, write=FResetIdleTimeOut};
};


class DELPHICLASS TSDBufferList;
class PASCALIMPLEMENTATION TSDBufferList : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Classes::TList* FList;
	
public:
	__fastcall TSDBufferList(void);
	__fastcall virtual ~TSDBufferList(void);
	void __fastcall Clear(void);
	void * __fastcall StringToPtr(AnsiString S);
};


class DELPHICLASS TSDFieldDesc;
class PASCALIMPLEMENTATION TSDFieldDesc : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	System::SmallString<50>  FieldName;
	int FieldNo;
	Db::TFieldType FieldType;
	short DataType;
	int DataSize;
	int Offset;
	short Precision;
	short Scale;
	bool Required;
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TSDFieldDesc(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TSDFieldDesc(void) { }
	#pragma option pop
	
};