absbaseengine.hpp

Absolute Database 5.12 src. Absolute Database lets you forget the Borland Database Engine (BDE). Th

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

// (DO NOT EDIT: machine generated header) 'Absbaseengine.pas' rev: 10.00

#ifndef AbsbaseengineHPP
#define AbsbaseengineHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Dialogs.hpp>	// Pascal unit
#include <Controls.hpp>	// Pascal unit
#include <Math.hpp>	// Pascal unit
#include <Abspage.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit
#include <Absbase.hpp>	// Pascal unit
#include <Absmemory.hpp>	// Pascal unit
#include <Abscompression.hpp>	// Pascal unit
#include <Abssecurity.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Absconverts.hpp>	// Pascal unit
#include <Absvariant.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit
#include <Absexpressions.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Absbaseengine
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TABSBaseRecordManager;
class PASCALIMPLEMENTATION TABSBaseRecordManager : public System::TObject 
{
	typedef System::TObject inherited;
	
protected:
	__int64 FRecordCount;
	int FTableState;
	int FRecordBufferSize;
	
public:
	virtual void __fastcall Empty(int SessionID) = 0 ;
	virtual bool __fastcall AddRecord(int SessionID, char * RecordBuffer, Abstypes::TABSPageItemID &RecordID) = 0 ;
	virtual bool __fastcall UpdateRecord(int SessionID, char * RecordBuffer, const Abstypes::TABSPageItemID &RecordID) = 0 ;
	virtual bool __fastcall DeleteRecord(int SessionID, Abstypes::TABSPageItemID &RecordID) = 0 ;
	virtual void __fastcall GetRecordBuffer(int SessionID, Abstypes::TABSNavigationInfo &NavigationInfo) = 0 ;
	virtual int __fastcall CompareRecordID(const Abstypes::TABSPageItemID &RecordID1, const Abstypes::TABSPageItemID &RecordID2) = 0 ;
	virtual __int64 __fastcall GetApproximateRecNo(int SessionID, const Abstypes::TABSPageItemID &RecordID) = 0 ;
	__property __int64 RecordCount = {read=FRecordCount, write=FRecordCount};
	__property int TableState = {read=FTableState, write=FTableState, nodefault};
	__property int RecordBufferSize = {read=FRecordBufferSize, write=FRecordBufferSize, nodefault};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TABSBaseRecordManager(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSBaseRecordManager(void) { }
	#pragma option pop
	
};


typedef DynamicArray<__int64 >  ABSBaseEngine__3;

class DELPHICLASS TABSBaseFieldManager;
class DELPHICLASS TABSTableData;
class DELPHICLASS TABSDatabaseData;
class PASCALIMPLEMENTATION TABSDatabaseData : public System::TObject 
{
	typedef System::TObject inherited;
	
protected:
	_RTL_CRITICAL_SECTION FCSect;
	Classes::TList* FSessionList;
	Classes::TList* FTableDataList;
	AnsiString FDatabaseName;
	Abspage::TABSPageManager* FPageManager;
	bool FReadOnly;
	int FTryCount;
	int FDelayMS;
	bool FMultiUser;
	AnsiString FSessionName;
	
public:
	__fastcall TABSDatabaseData(void);
	__fastcall virtual ~TABSDatabaseData(void);
	void __fastcall Lock(void);
	void __fastcall Unlock(void);
	virtual void __fastcall ConnectSession(Absbase::TABSBaseSession* Session);
	virtual void __fastcall DisconnectSession(Absbase::TABSBaseSession* Session);
	virtual void __fastcall FreeIfNoSessionsConnected(void);
	virtual void __fastcall GetTablesList(Classes::TStrings* List);
	bool __fastcall TableExists(AnsiString TableName);
	virtual void __fastcall CreateDatabase(void);
	virtual TABSTableData* __fastcall CreateTableData(Absbase::TABSCursor* Cursor) = 0 ;
	virtual TABSTableData* __fastcall FindTableData(Absbase::TABSCursor* Cursor);
	virtual TABSTableData* __fastcall FindOrCreateTableData(Absbase::TABSCursor* Cursor);
	virtual int __fastcall GetNewObjectId(void) = 0 ;
	virtual void __fastcall Commit(int SessionID, bool DoFlushBuffers = true);
	virtual void __fastcall Rollback(int SessionID);
	virtual void __fastcall FlushBuffers(void);
	__property AnsiString DatabaseName = {read=FDatabaseName, write=FDatabaseName};
	__property Abspage::TABSPageManager* PageManager = {read=FPageManager, write=FPageManager};
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, nodefault};
	__property Classes::TList* SessionList = {read=FSessionList};
	__property bool MultiUser = {read=FMultiUser, write=FMultiUser, nodefault};
	__property AnsiString SessionName = {read=FSessionName, write=FSessionName};
};


class DELPHICLASS TABSBaseConstraintManager;
class PASCALIMPLEMENTATION TABSBaseConstraintManager : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Absbase::TABSConstraintDefs* FConstraintDefs;
	TABSTableData* FTableData;
	
public:
	void __fastcall LoadMetadata(Classes::TStream* Stream);
	void __fastcall SaveMetadata(Classes::TStream* Stream);
	__fastcall TABSBaseConstraintManager(TABSTableData* aTableData);
	__fastcall virtual ~TABSBaseConstraintManager(void);
	bool __fastcall CheckConstraints(int SessionID, char * NewRecordBuffer, char * OldRecordBuffer, bool ToInsert, const Abstypes::TABSPageItemID &CurrentRecordID, bool RaiseException);
	void __fastcall LinkObjectId(Absbase::TABSConstraintDef* ConstraintDef);
	void __fastcall LinkObjectIds(void);
	void __fastcall FillConstraintAutoNames(void);
	void __fastcall AddConstraintFromIndex(Absbase::TABSIndexDef* IndexDef);
	void __fastcall DeleteConstraintForIndexID(int IndexObjectID);
	__property Absbase::TABSConstraintDefs* ConstraintDefs = {read=FConstraintDefs, write=FConstraintDefs};
};


class DELPHICLASS TABSBaseIndexManager;
class DELPHICLASS TABSIndex;
class PASCALIMPLEMENTATION TABSBaseIndexManager : public System::TObject 
{
	typedef System::TObject inherited;
	
protected:
	TABSTableData* FTableData;
	Absbase::TABSIndexDefs* FIndexDefs;
	Classes::TList* FOpenIndexList;
	Abspage::TABSPageManager* FPageManager;
	Abspage::TABSPageManager* FTemporaryPageManager;
	bool FSynchronizingTemporaryIndexes;
	void __fastcall InternalCreateIndex(Absbase::TABSCursor* Cursor, Absbase::TABSIndexDef* IndexDef);
	TABSIndex* __fastcall InternalOpenIndex(int IndexID);
	
public:
	virtual void __fastcall LoadMetadata(Classes::TStream* Stream);
	virtual void __fastcall SaveMetadata(Classes::TStream* Stream);
	__fastcall TABSBaseIndexManager(TABSTableData* aTableData, Abspage::TABSPageManager* TempPageManager);
	__fastcall virtual ~TABSBaseIndexManager(void);
	Abspage::TABSPageManager* __fastcall GetPageManager(TABSIndex* Index);
	void __fastcall DropTemporaryIndexes(int SessionID);
	bool __fastcall IsIndexExists(Classes::TStringList* FieldNames, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList, int SessionID, Absbase::TABSFieldDefs* FieldDefs);
	int __fastcall FindIndex(Classes::TStringList* FieldNames, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList, int SessionID, Absbase::TABSFieldDefs* FieldDefs);
	int __fastcall CreateTemporaryIndex(Absbase::TABSCursor* Cursor, Classes::TStringList* FieldNamesList, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList);
	int __fastcall FindOrCreateIndex(Absbase::TABSCursor* Cursor, Classes::TStringList* FieldNamesList, Classes::TStringList* AscDescList, Classes::TStringList* CaseSensitivityList, bool &IsCreated);
	virtual void __fastcall CreateIndexDefs(Absbase::TABSIndexDefs* aIndexDefs);
	void __fastcall CreateIndexesByIndexDefs(Absbase::TABSCursor* Cursor);
	TABSIndex* __fastcall FindOpenIndex(int IndexID);
	int __fastcall CreateIndex(Absbase::TABSCursor* Cursor, Absbase::TABSIndexDef* IndexDef);
	TABSIndex* __fastcall OpenIndex(int IndexID);
	void __fastcall CloseIndex(int IndexID);
	void __fastcall DropIndex(int SessionID, int IndexID);
	void __fastcall DropAllIndexes(int SessionID);
	void __fastcall EmptyIndex(int SessionID, int IndexID);
	void __fastcall EmptyAllIndexes(int SessionID);
	void __fastcall GetRecordBuffer(int SessionID, Abstypes::TABSNavigationInfo &NavigationInfo, Abstypes::TABSIndexPositionCache* IndexPositionCache, int TableState);
	void __fastcall InsertRecord(Absbase::TABSCursor* Cursor);
	void __fastcall UpdateRecord(Absbase::TABSCursor* Cursor, bool BeforeNewRecordIsStored);
	void __fastcall DeleteRecord(Absbase::TABSCursor* Cursor);
	void __fastcall SynchronizeTemporaryIndexes(Absbase::TABSCursor* Cursor, bool &IsChanged);
	void __fastcall RenameField(AnsiString FieldName, AnsiString NewFieldName);
	__property Absbase::TABSIndexDefs* IndexDefs = {read=FIndexDefs};
	__property TABSTableData* TableData = {read=FTableData};
	__property Abspage::TABSPageManager* PageManager = {read=FPageManager};
};


class DELPHICLASS TABSRecordBitmap;
class PASCALIMPLEMENTATION TABSTableData : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	_RTL_CRITICAL_SECTION FCSect;
	bool FIsRepairing;
	
protected:
	Abspage::TABSPageManager* FPageManager;
	TABSDatabaseData* FDatabaseData;
	AnsiString FTableName;
	#pragma pack(push,1)
	Abscompression::TABSCompression FBLOBCompression;
	#pragma pack(pop)
	bool FActive;
	TABSBaseFieldManager* FFieldManager;
	TABSBaseConstraintManager* FConstraintManager;
	TABSBaseIndexManager* FIndexManager;
	TABSBaseRecordManager* FRecordManager;
	Classes::TList* FCursorList;
	bool FDisableTempFiles;
	void __fastcall FillDefsByObjectId(Absbase::TABSMetaObjectDefs* Defs);
	int __fastcall GetRecordBufferSize(void);
	virtual void __fastcall CreateRecordManager(void) = 0 ;
	virtual void __fastcall CreateFieldManager(Absbase::TABSFieldDefs* FieldDefs);
	virtual void __fastcall CreateIndexManager(Absbase::TABSIndexDefs* IndexDefs);
	virtual void __fastcall CreateConstraintManager(Absbase::TABSConstraintDefs* ConstraintDefs);
	virtual void __fastcall InitCursor(Absbase::TABSCursor* Cursor);
	
public:
	__fastcall TABSTableData(TABSDatabaseData* aDatabaseData);
	__fastcall virtual ~TABSTableData(void);
	void __fastcall Lock(void);