// CodeGear C++Builder
// Copyright (c) 1995, 2021 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'ABSBase.pas' rev: 35.00 (Windows)

#ifndef AbsbaseHPP
#define AbsbaseHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#pragma pack(push,8)
#include <System.hpp>
#include <SysInit.hpp>
#include <System.SysUtils.hpp>
#include <System.Classes.hpp>
#include <ABSMemory.hpp>
#include <ABSCompression.hpp>
#include <ABSSecurity.hpp>
#include <ABSTypes.hpp>
#include <ABSConverts.hpp>
#include <ABSTypesRoutines.hpp>
#include <ABSVariant.hpp>
#include <ABSLexer.hpp>
#include <ABSExcept.hpp>
#include <ABSConst.hpp>

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

namespace Absbase
{
//-- forward type declarations -----------------------------------------------
struct TABSCursorPos;
class DELPHICLASS TABSMetaObjectDef;
class DELPHICLASS TABSFieldDef;
class DELPHICLASS TABSIndexColumn;
class DELPHICLASS TABSIndexDef;
class DELPHICLASS TABSConstraintDef;
class DELPHICLASS TABSConstraintDefNotNull;
class DELPHICLASS TABSConstraintDefCheck;
struct TABSConstraintColumn;
class DELPHICLASS TABSConstraintDefUnique;
class DELPHICLASS TABSConstraintDefPrimary;
class DELPHICLASS TABSMetaObjectDefs;
class DELPHICLASS TABSIndexDefs;
class DELPHICLASS TABSFieldDefs;
class DELPHICLASS TABSConstraintDefs;
struct TABSRestructureInfo;
class DELPHICLASS TABSCursor;
class DELPHICLASS TABSSessionComponentManager;
class DELPHICLASS TABSSessionNamedObject;
class DELPHICLASS TABSSessionNamedObjectSequenceValue;
class DELPHICLASS TABSBaseSession;
//-- type declarations -------------------------------------------------------
typedef void * TABSFilterRecord;

struct DECLSPEC_DRECORD TABSCursorPos
{
public:
	bool FirstPosition;
	bool LastPosition;
	Abstypes::TABSPageItemID RecordID;
};


typedef TABSCursorPos *PABSCursorPos;

class PASCALIMPLEMENTATION TABSMetaObjectDef : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::ShortString FName;
	int FObjectID;
	System::UnicodeString FSchemaName;
	int FSchemaID;
	
public:
	__fastcall TABSMetaObjectDef();
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property System::ShortString Name = {read=FName, write=FName};
	__property int ObjectID = {read=FObjectID, write=FObjectID, nodefault};
	__property System::UnicodeString SchemaName = {read=FSchemaName, write=FSchemaName};
	__property int SchemaID = {read=FSchemaID, write=FSchemaID, nodefault};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TABSMetaObjectDef() { }
	
};


class PASCALIMPLEMENTATION TABSFieldDef : public TABSMetaObjectDef
{
	typedef TABSMetaObjectDef inherited;
	
private:
	Abstypes::TABSBaseFieldType FBaseFieldType;
	Abstypes::TABSAdvancedFieldType FAdvancedFieldType;
	int FFieldSize;
	int FDiskDataSize;
	int FMemoryDataSize;
	int FDiskOffset;
	int FMemoryOffset;
	int FFieldNoReference;
	Absvariant::TABSVariant* FDefaultValue;
	System::TObject* FDefaultValueExpr;
	Abscompression::TABSCompressionAlgorithm FBLOBCompressionAlgorithm;
	System::Byte FBLOBCompressionMode;
	int FBLOBBlockSize;
	__int64 FAutoincIncrement;
	__int64 FAutoincInitialValue;
	__int64 FAutoincMinValue;
	__int64 FAutoincMaxValue;
	System::ByteBool FAutoincCycled;
	void __fastcall RecalcInternalSizes();
	void __fastcall CreateDefaultValueExprIfNeeded();
	
public:
	__fastcall TABSFieldDef();
	__fastcall virtual ~TABSFieldDef();
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	void __fastcall SetFieldDefDataType(Abstypes::TABSAdvancedFieldType AdvancedFieldType, int FieldSize = 0x0)/* overload */;
	void __fastcall SetFieldDefDataType(Abstypes::TABSBaseFieldType BaseFieldType, int FieldSize = 0x0)/* overload */;
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property Abstypes::TABSBaseFieldType BaseFieldType = {read=FBaseFieldType, write=FBaseFieldType, nodefault};
	__property Abstypes::TABSAdvancedFieldType AdvancedFieldType = {read=FAdvancedFieldType, write=FAdvancedFieldType, nodefault};
	__property int FieldSize = {read=FFieldSize, write=FFieldSize, nodefault};
	__property int DiskOffset = {read=FDiskOffset, write=FDiskOffset, nodefault};
	__property int MemoryOffset = {read=FMemoryOffset, write=FMemoryOffset, nodefault};
	__property int DiskDataSize = {read=FDiskDataSize, write=FDiskDataSize, nodefault};
	__property int MemoryDataSize = {read=FMemoryDataSize, write=FMemoryDataSize, nodefault};
	__property int FieldNoReference = {read=FFieldNoReference, write=FFieldNoReference, nodefault};
	__property Absvariant::TABSVariant* DefaultValue = {read=FDefaultValue, write=FDefaultValue};
	__property System::TObject* DefaultValueExpr = {read=FDefaultValueExpr};
	__property __int64 AutoincIncrement = {read=FAutoincIncrement, write=FAutoincIncrement};
	__property __int64 AutoincInitialValue = {read=FAutoincInitialValue, write=FAutoincInitialValue};
	__property __int64 AutoincMinValue = {read=FAutoincMinValue, write=FAutoincMinValue};
	__property __int64 AutoincMaxValue = {read=FAutoincMaxValue, write=FAutoincMaxValue};
	__property System::ByteBool AutoincCycled = {read=FAutoincCycled, write=FAutoincCycled, nodefault};
	__property Abscompression::TABSCompressionAlgorithm BLOBCompressionAlgorithm = {read=FBLOBCompressionAlgorithm, write=FBLOBCompressionAlgorithm, nodefault};
	__property System::Byte BLOBCompressionMode = {read=FBLOBCompressionMode, write=FBLOBCompressionMode, nodefault};
	__property int BLOBBlockSize = {read=FBLOBBlockSize, write=FBLOBBlockSize, nodefault};
};


enum DECLSPEC_DENUM TABSIndexType : unsigned char { itBTree, itAnotherOne };

class PASCALIMPLEMENTATION TABSIndexColumn : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::UnicodeString FFieldName;
	System::ByteBool FDescending;
	System::ByteBool FCaseInsensitive;
	int FMaxIndexedSize;
	
public:
	void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property System::UnicodeString FieldName = {read=FFieldName, write=FFieldName};
	__property System::ByteBool Descending = {read=FDescending, write=FDescending, nodefault};
	__property System::ByteBool CaseInsensitive = {read=FCaseInsensitive, write=FCaseInsensitive, nodefault};
	__property int MaxIndexedSize = {read=FMaxIndexedSize, write=FMaxIndexedSize, nodefault};
public:
	/* TObject.Create */ inline __fastcall TABSIndexColumn() : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TABSIndexColumn() { }
	
};


class PASCALIMPLEMENTATION TABSIndexDef : public TABSMetaObjectDef
{
	typedef TABSMetaObjectDef inherited;
	
	
private:
	typedef System::DynamicArray<TABSIndexColumn*> _TABSIndexDef__1;
	
	
private:
	TABSIndexType FIndexType;
	_TABSIndexDef__1 FIndexColumns;
	System::ByteBool FUnique;
	System::ByteBool FPrimary;
	int FRootPageNo;
	System::ByteBool FTemporary;
	int FSessionID;
	int FTableState;
	System::ByteBool FNeedRebuild;
	TABSIndexColumn* __fastcall GetIndexColumn(int Index);
	int __fastcall GetColumnCount();
	void __fastcall SetColumnCount(int Value);
	
public:
	__fastcall TABSIndexDef();
	__fastcall virtual ~TABSIndexDef();
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	void __fastcall AssignByNames(System::Classes::TStringList* FieldNames, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList);
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property TABSIndexType IndexType = {read=FIndexType, write=FIndexType, nodefault};
	__property TABSIndexColumn* Columns[int Index] = {read=GetIndexColumn};
	__property int ColumnCount = {read=GetColumnCount, write=SetColumnCount, nodefault};
	__property System::ByteBool Unique = {read=FUnique, write=FUnique, nodefault};
	__property System::ByteBool Primary = {read=FPrimary, write=FPrimary, nodefault};
	__property int RootPageNo = {read=FRootPageNo, write=FRootPageNo, nodefault};
	__property System::ByteBool Temporary = {read=FTemporary, write=FTemporary, nodefault};
	__property int SessionID = {read=FSessionID, write=FSessionID, nodefault};
	__property int TableState = {read=FTableState, write=FTableState, nodefault};
	__property System::ByteBool NeedRebuild = {read=FNeedRebuild, write=FNeedRebuild, nodefault};
};


class PASCALIMPLEMENTATION TABSConstraintDef : public TABSMetaObjectDef
{
	typedef TABSMetaObjectDef inherited;
	
private:
	Abstypes::TABSConstraintType FConstraintType;
	
public:
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	__property Abstypes::TABSConstraintType ConstraintType = {read=FConstraintType, write=FConstraintType, nodefault};
public:
	/* TABSMetaObjectDef.Create */ inline __fastcall TABSConstraintDef() : TABSMetaObjectDef() { }
	
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TABSConstraintDef() { }
	
};


class PASCALIMPLEMENTATION TABSConstraintDefNotNull : public TABSConstraintDef
{
	typedef TABSConstraintDef inherited;
	
private:
	System::ShortString FTableSchemaName;
	int FTableSchemaObjectID;
	System::ShortString FTableName;
	int FTableObjectID;
	System::ShortString FColumnName;
	int FColumnObjectID;
	
public:
	__fastcall TABSConstraintDefNotNull();
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	void __fastcall SetNames(System::UnicodeString ColumnName, System::UnicodeString TableName = System::UnicodeString(), System::UnicodeString SchemaName = System::UnicodeString());
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property System::ShortString TableSchemaName = {read=FTableSchemaName, write=FTableSchemaName};
	__property int TableSchemaObjectID = {read=FTableSchemaObjectID, write=FTableSchemaObjectID, nodefault};
	__property System::ShortString TableName = {read=FTableName, write=FTableName};
	__property int TableObjectID = {read=FTableObjectID, write=FTableObjectID, nodefault};
	__property System::ShortString ColumnName = {read=FColumnName, write=FColumnName};
	__property int ColumnObjectID = {read=FColumnObjectID, write=FColumnObjectID, nodefault};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TABSConstraintDefNotNull() { }
	
};


class PASCALIMPLEMENTATION TABSConstraintDefCheck : public TABSConstraintDef
{
	typedef TABSConstraintDef inherited;
	
private:
	System::ShortString FTableSchemaName;
	int FTableSchemaObjectID;
	System::ShortString FTableName;
	int FTableObjectID;
	System::ShortString FColumnName;
	int FColumnObjectID;
	Absvariant::TABSVariant* FMinValue;
	Absvariant::TABSVariant* FMaxValue;
	
public:
	__fastcall TABSConstraintDefCheck();
	__fastcall virtual ~TABSConstraintDefCheck();
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	void __fastcall SetNames(System::UnicodeString ColumnName, System::UnicodeString TableName = System::UnicodeString(), System::UnicodeString SchemaName = System::UnicodeString());
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property Absvariant::TABSVariant* MinValue = {read=FMinValue};
	__property Absvariant::TABSVariant* MaxValue = {read=FMaxValue};
	__property System::ShortString TableSchemaName = {read=FTableSchemaName, write=FTableSchemaName};
	__property int TableSchemaObjectID = {read=FTableSchemaObjectID, write=FTableSchemaObjectID, nodefault};
	__property System::ShortString TableName = {read=FTableName, write=FTableName};
	__property int TableObjectID = {read=FTableObjectID, write=FTableObjectID, nodefault};
	__property System::ShortString ColumnName = {read=FColumnName, write=FColumnName};
	__property int ColumnObjectID = {read=FColumnObjectID, write=FColumnObjectID, nodefault};
};


struct DECLSPEC_DRECORD TABSConstraintColumn
{
public:
	System::ShortString ColumnName;
	int ColumnObjectID;
};


class PASCALIMPLEMENTATION TABSConstraintDefUnique : public TABSConstraintDef
{
	typedef TABSConstraintDef inherited;
	
	
private:
	typedef System::DynamicArray<TABSConstraintColumn> _TABSConstraintDefUnique__1;
	
	
private:
	System::ShortString FTableSchemaName;
	int FTableSchemaObjectID;
	System::ShortString FTableName;
	int FTableObjectID;
	System::ShortString FIndexName;
	int FIndexObjectID;
	
public:
	_TABSConstraintDefUnique__1 Columns;
	__fastcall TABSConstraintDefUnique();
	__fastcall virtual ~TABSConstraintDefUnique();
	virtual void __fastcall Assign(TABSMetaObjectDef* Source);
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property System::ShortString TableSchemaName = {read=FTableSchemaName, write=FTableSchemaName};
	__property int TableSchemaObjectID = {read=FTableSchemaObjectID, write=FTableSchemaObjectID, nodefault};
	__property System::ShortString TableName = {read=FTableName, write=FTableName};
	__property int TableObjectID = {read=FTableObjectID, write=FTableObjectID, nodefault};
	__property System::ShortString IndexName = {read=FIndexName, write=FIndexName};
	__property int IndexObjectID = {read=FIndexObjectID, write=FIndexObjectID, nodefault};
};


class PASCALIMPLEMENTATION TABSConstraintDefPrimary : public TABSConstraintDefUnique
{
	typedef TABSConstraintDefUnique inherited;
	
public:
	__fastcall TABSConstraintDefPrimary();
public:
	/* TABSConstraintDefUnique.Destroy */ inline __fastcall virtual ~TABSConstraintDefPrimary() { }
	
};


class PASCALIMPLEMENTATION TABSMetaObjectDefs : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	TABSMetaObjectDef* operator[](int Index) { return this->Items[Index]; }
	
protected:
	Abstypes::TABSSortedStringPtrArray* FDefsList;
	int FLoadedItemCount;
	
private:
	virtual int __fastcall GetCount();
	TABSMetaObjectDef* __fastcall GetDef(int Index);
	void __fastcall SetDef(int Index, TABSMetaObjectDef* Value);
	virtual void __fastcall Add(TABSMetaObjectDef* MetaObjectDef);
	virtual TABSMetaObjectDef* __fastcall InternalAddCreated();
	
public:
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__fastcall TABSMetaObjectDefs();
	__fastcall virtual ~TABSMetaObjectDefs();
	virtual void __fastcall Assign(TABSMetaObjectDefs* Source);
	virtual void __fastcall Delete(int Index);
	virtual void __fastcall Insert(int Index, TABSMetaObjectDef* MetaObjectDef);
	virtual void __fastcall Move(int CurIndex, int NewIndex);
	virtual void __fastcall Clear();
	int __fastcall GetDefNumberByName(System::UnicodeString Name);
	TABSMetaObjectDef* __fastcall GetDefByName(System::UnicodeString Name);
	int __fastcall GetDefNumberByObjectId(int id);
	TABSMetaObjectDef* __fastcall GetDefByObjectId(int id);
	__property int Count = {read=GetCount, nodefault};
	__property TABSMetaObjectDef* Items[int Index] = {read=GetDef, write=SetDef/*, default*/};
};


class PASCALIMPLEMENTATION TABSIndexDefs : public TABSMetaObjectDefs
{
	typedef TABSMetaObjectDefs inherited;
	
public:
	TABSIndexDef* operator[](int Index) { return this->Items[Index]; }
	
private:
	virtual TABSIndexDef* __fastcall GetIndexDef(int Index);
	virtual void __fastcall SetIndexDef(int Index, TABSIndexDef* Value);
	virtual TABSMetaObjectDef* __fastcall InternalAddCreated();
	
public:
	bool __fastcall IsIndexExists(System::Classes::TStringList* FieldNames, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList, int SessionID, TABSFieldDefs* FieldDefs);
	int __fastcall FindIndex(System::Classes::TStringList* FieldNames, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList, int SessionID, TABSFieldDefs* FieldDefs);
	TABSIndexDef* __fastcall AddCreated();
	TABSIndexDef* __fastcall GetIndexDefByName(System::UnicodeString Name);
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property TABSIndexDef* Items[int Index] = {read=GetIndexDef, write=SetIndexDef/*, default*/};
public:
	/* TABSMetaObjectDefs.Create */ inline __fastcall TABSIndexDefs() : TABSMetaObjectDefs() { }
	/* TABSMetaObjectDefs.Destroy */ inline __fastcall virtual ~TABSIndexDefs() { }
	
};


class PASCALIMPLEMENTATION TABSFieldDefs : public TABSMetaObjectDefs
{
	typedef TABSMetaObjectDefs inherited;
	
public:
	TABSFieldDef* operator[](int Index) { return this->Items[Index]; }
	
private:
	HIDESBASE TABSFieldDef* __fastcall GetDef(int Index);
	HIDESBASE void __fastcall SetDef(int Index, TABSFieldDef* Value);
	virtual TABSMetaObjectDef* __fastcall InternalAddCreated();
	
public:
	TABSFieldDef* __fastcall AddCreated();
	TABSFieldDef* __fastcall GetFieldDefByName(System::UnicodeString Name);
	virtual void __fastcall RecalcFieldOffsets();
	int __fastcall GetMemoryRecordBufferSize();
	int __fastcall GetDiskRecordBufferSize();
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property TABSFieldDef* Items[int Index] = {read=GetDef, write=SetDef/*, default*/};
public:
	/* TABSMetaObjectDefs.Create */ inline __fastcall TABSFieldDefs() : TABSMetaObjectDefs() { }
	/* TABSMetaObjectDefs.Destroy */ inline __fastcall virtual ~TABSFieldDefs() { }
	
};


class PASCALIMPLEMENTATION TABSConstraintDefs : public TABSMetaObjectDefs
{
	typedef TABSMetaObjectDefs inherited;
	
public:
	TABSConstraintDef* operator[](int Index) { return this->Items[Index]; }
	
private:
	HIDESBASE TABSConstraintDef* __fastcall GetDef(int Index);
	HIDESBASE void __fastcall SetDef(int Index, TABSConstraintDef* Value);
	
public:
	virtual void __fastcall Assign(TABSMetaObjectDefs* Source);
	TABSConstraintDefNotNull* __fastcall AddNotNull();
	TABSConstraintDefCheck* __fastcall AddCheck();
	TABSConstraintDefPrimary* __fastcall AddPK();
	TABSConstraintDefUnique* __fastcall AddUnique();
	virtual void __fastcall LoadFromStream(System::Classes::TStream* Stream);
	virtual void __fastcall SaveToStream(System::Classes::TStream* Stream);
	__property TABSConstraintDef* Items[int Index] = {read=GetDef, write=SetDef/*, default*/};
public:
	/* TABSMetaObjectDefs.Create */ inline __fastcall TABSConstraintDefs() : TABSMetaObjectDefs() { }
	/* TABSMetaObjectDefs.Destroy */ inline __fastcall virtual ~TABSConstraintDefs() { }
	
};


struct DECLSPEC_DRECORD TABSRestructureInfo
{
public:
	Abscompression::TABSCompression FRestructureBLOBCompression;
	TABSFieldDefs* FRestructureFieldDefs;
	TABSIndexDefs* FRestructureIndexDefs;
	TABSConstraintDefs* FRestructureConstraintDefs;
};


class PASCALIMPLEMENTATION TABSCursor : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	bool FSettingProjection;
	System::UnicodeString FTableName;
	System::UnicodeString FIndexName;
	int FIndexID;
	bool FReadOnly;
	bool FExclusive;
	bool FInMemory;
	bool FTemporary;
	TABSBaseSession* FSession;
	bool FIsOpen;
	bool FPhysicalOrder;
	System::TObject* FCurrentRecordPositionInIndex;
	System::Byte *FCurrentRecordBuffer;
	System::Byte *FDistinctRecordBuffer;
	System::Byte *FEditRecordBuffer;
	Abssecurity::TABSPassword FPassword;
	TABSConstraintDefs* FConstraintDefs;
	Abscompression::TABSCompression FBLOBCompression;
	TABSFieldDefs* FFieldDefs;
	TABSFieldDefs* FVisibleFieldDefs;
	TABSIndexDefs* FIndexDefs;
	System::Classes::TList* FBLOBStreams;
	void *FRecordBitmap;
	Abstypes::TABSIndexPositionCache* FIndexPositionCache;
	bool FTableLockedByCursor;
	bool FBatchUpdate;
	bool FDisableTempFiles;
	bool FIsRepairing;
	
private:
	int FErrorCode;
	System::UnicodeString FErrorMessage;
	bool FIsDesignMode;
	int FRecordBufferSize;
	int FRecordSize;
	int FKeyBufferSize;
	int FKeyOffset;
	int FKeyFieldCount;
	int FFieldValuesOffset;
	int FCalculatedFieldsOffset;
	int FBookmarkOffset;
	void *FFilterExpression;
	void *FSQLFilterExpression;
	System::Byte *FKeyBuffer;
	System::Byte *FRangeStartBuffer;
	System::Byte *FRangeEndBuffer;
	bool FRangeStartExclusive;
	bool FRangeEndExclusive;
	int FRangeStartKeyFieldCount;
	int FRangeEndKeyFieldCount;
	int FDistinctFieldCount;
	
protected:
	void __fastcall SetIndexName(System::UnicodeString Value);
	
public:
	__property int RecordBufferSize = {read=FRecordBufferSize, write=FRecordBufferSize, nodefault};
	__property int RecordSize = {read=FRecordSize, write=FRecordSize, nodefault};
	__property int FieldValuesOffset = {read=FFieldValuesOffset, write=FFieldValuesOffset, nodefault};
	__property int CalculatedFieldsOffset = {read=FCalculatedFieldsOffset, write=FCalculatedFieldsOffset, nodefault};
	__property int BookmarkOffset = {read=FBookmarkOffset, write=FBookmarkOffset, nodefault};
	__property int KeyOffset = {read=FKeyOffset, write=FKeyOffset, nodefault};
	__property int KeyBufferSize = {read=FKeyBufferSize, write=FKeyBufferSize, nodefault};
	virtual void __fastcall CreateTable(TABSFieldDefs* FieldDefs, TABSIndexDefs* IndexDefs, TABSConstraintDefs* ConstraintDefs) = 0 ;
	virtual void __fastcall DeleteTable() = 0 ;
	virtual void __fastcall EmptyTable() = 0 ;
	virtual void __fastcall RenameTable(System::UnicodeString NewTableName) = 0 ;
	virtual void __fastcall InternalInitFieldDefs() = 0 ;
	virtual void __fastcall OpenTableByFieldDefs(TABSFieldDefs* FieldDefs, TABSIndexDefs* IndexDefs, TABSConstraintDefs* ConstraintDefs) = 0 ;
	virtual void __fastcall CloseTable() = 0 ;
	virtual void __fastcall LockTableData() = 0 ;
	virtual void __fastcall UnlockTableData() = 0 ;
	virtual bool __fastcall LockTable(Abstypes::TABSLockType LockType, int TryCount, int Delay, bool AllowXIRWAfterSIRW = true) = 0 ;
	virtual bool __fastcall UnlockTable(Abstypes::TABSLockType LockType, bool IgnoreIfNoLock = false) = 0 ;
	virtual void __fastcall RenameField(System::UnicodeString FieldName, System::UnicodeString NewFieldName);
	virtual TABSIndexDefs* __fastcall GetIndexDefs();
	virtual void __fastcall AddIndex(TABSIndexDef* IndexDef) = 0 ;
	virtual void __fastcall DeleteIndex(System::UnicodeString Name) = 0 ;
	virtual void __fastcall DeleteAllIndexes() = 0 ;
	virtual System::UnicodeString __fastcall FindOrCreateIndex(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList, bool &IsCreated) = 0 ;
	virtual bool __fastcall IndexExists(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList) = 0 ;
	bool __fastcall GetFieldData(int FieldNo, void * Buffer, System::PByte RecordBuffer);
	void __fastcall SetFieldData(int FieldNo, void * Buffer, System::PByte RecordBuffer);
	void __fastcall ClearStringFieldsGarbage(System::PByte RecordBuffer);
	void __fastcall GetFieldValue(Absvariant::TABSVariant* Value, int FieldNo, bool DirectAccess);
	void __fastcall SetFieldValue(Absvariant::TABSVariant* Value, int FieldNo, bool DirectAccess, System::PByte RecordBuffer = (System::PByte)(0x0));
	virtual void __fastcall CopyFieldValue(int SrcFieldNo, bool DirectAccess, int DestFieldNo, TABSCursor* DestCursor) = 0 ;
	System::PByte __fastcall AllocateRecordBuffer();
	virtual void __fastcall InternalInitRecord(System::PByte RecordBuffer, bool InsertMode) = 0 ;
	virtual void __fastcall FreeRecordBuffer(System::PByte &Buffer);
	System::PByte __fastcall AllocateKeyRecordBuffer();
	void __fastcall InternalInitKeyBuffer(System::PByte RecordBuffer);
	virtual __int64 __fastcall GetRecordCount() = 0 ;
	virtual Abstypes::TABSGetRecordResult __fastcall GetRecordBuffer(Abstypes::TABSGetRecordMode GetRecordMode) = 0 ;
	virtual void __fastcall SetRecNo(__int64 Value) = 0 ;
	virtual __int64 __fastcall GetRecNo() = 0 ;
	virtual int __fastcall CompareRecordsOrder(const Abstypes::TABSPageItemID &RecordID1, const Abstypes::TABSPageItemID &RecordID2) = 0 ;
	virtual void __fastcall InternalFirst() = 0 ;
	virtual void __fastcall InternalLast() = 0 ;
	void * __fastcall SavePosition();
	void __fastcall RestorePosition(void * Pos);
	void __fastcall FreePosition(void * Pos);
	virtual void __fastcall InternalInsert() = 0 ;
	virtual void __fastcall InternalEdit() = 0 ;
	virtual void __fastcall InternalCancel(bool ToInsert) = 0 ;
	virtual void __fastcall InternalPost(bool ToInsert) = 0 ;
	virtual void __fastcall InternalDelete() = 0 ;
	virtual bool __fastcall IsRecordLocked() = 0 ;
	void __fastcall DisableRecordBitmap();
	virtual void __fastcall ApplyDistinct(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList) = 0 ;
	void __fastcall ApplyProjection(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AliasList);
	virtual void __fastcall ActivateFilters(System::UnicodeString FilterText, bool CaseInsensitive, bool PartialKey) = 0 ;
	virtual void __fastcall DeactivateFilters() = 0 ;
	virtual bool __fastcall Locate(const System::UnicodeString KeyFields, const System::Variant &KeyValues, bool CaseInsensitive, bool PartialKey) = 0 ;
	virtual bool __fastcall FindKey(Abstypes::TABSSearchCondition SearchCondition) = 0 ;
	virtual bool __fastcall IsAnyRecordMatchCondition(const System::UnicodeString FieldName, const Abstypes::TABSDataOperator Operator, Absvariant::TABSVariant* const Value) = 0 ;
	bool __fastcall IsIndexApplied();
	bool __fastcall IsDistinctApplied();
	bool __fastcall IsFilterApplied();
	bool __fastcall IsRangeApplied();
	bool __fastcall IsViewRestricted();
	void __fastcall ResetRange();
	void __fastcall ApplyRange(System::PByte StartBuffer, System::PByte EndBuffer, int StartKeyFieldCount, int EndKeyFieldCount, bool StartExclusive, bool EndExclusive);
	void __fastcall SetSQLFilter(System::TObject* FilterExpr, System::TObject* ParentQueryAO, TABSCursor* ParentCursor);
	virtual Abscompression::TABSStream* __fastcall InternalCreateBlobStream(bool ToInsert, bool ToEdit, int FieldNo, Abstypes::TABSBLOBOpenMode OpenMode, bool CanDoGetRecordBuffer) = 0 ;
	virtual void __fastcall InternalCloseBLOB(int FieldNo) = 0 ;
	virtual void __fastcall ClearBLOBStreams(bool WriteOnly = false) = 0 ;
	virtual __int64 __fastcall LastAutoincValue(int FieldNo) = 0 ;
	virtual void __fastcall BeginBatchUpdate() = 0 ;
	virtual void __fastcall EndBatchUpdate() = 0 ;
	virtual void __fastcall CancelBatchUpdate() = 0 ;
	virtual bool __fastcall CheckConstraints(bool ToInsert) = 0 ;
	Abstypes::TABSPageItemID CurrentRecordID;
	int CurrentIndexID;
	bool FirstPosition;
	bool LastPosition;
	void *FilterRecord;
	void *Dataset;
	__property void * RecordBitmap = {read=FRecordBitmap, write=FRecordBitmap};
	__property Abstypes::TABSIndexPositionCache* IndexPositionCache = {read=FIndexPositionCache};
	__property int DistinctFieldCount = {read=FDistinctFieldCount, write=FDistinctFieldCount, nodefault};
	__property void * FilterExpression = {read=FFilterExpression, write=FFilterExpression};
	__property void * SQLFilterExpression = {read=FSQLFilterExpression, write=FSQLFilterExpression};
	__property System::Classes::TList* BLOBStreams = {read=FBLOBStreams};
	__property int ErrorCode = {read=FErrorCode, write=FErrorCode, nodefault};
	__property System::UnicodeString ErrorMessage = {read=FErrorMessage, write=FErrorMessage};
	__property bool IsDesignMode = {read=FIsDesignMode, write=FIsDesignMode, nodefault};
	__property System::UnicodeString TableName = {read=FTableName, write=FTableName};
	__property System::UnicodeString IndexName = {read=FIndexName, write=SetIndexName};
	__property int IndexID = {read=FIndexID, write=FIndexID, nodefault};
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, nodefault};
	__property bool Exclusive = {read=FExclusive, write=FExclusive, nodefault};
	__property bool InMemory = {read=FInMemory, write=FInMemory, nodefault};
	__property bool Temporary = {read=FTemporary, write=FTemporary, nodefault};
	__property TABSBaseSession* Session = {read=FSession, write=FSession};
	__property bool IsOpen = {read=FIsOpen, write=FIsOpen, nodefault};
	__property bool IsRepairing = {read=FIsRepairing, write=FIsRepairing, nodefault};
	__property __int64 RecordCount = {read=GetRecordCount};
	__property TABSFieldDefs* FieldDefs = {read=FFieldDefs};
	__property TABSFieldDefs* VisibleFieldDefs = {read=FVisibleFieldDefs};
	__property TABSIndexDefs* IndexDefs = {read=GetIndexDefs};
	__property TABSConstraintDefs* ConstraintDefs = {read=FConstraintDefs};
	__property Abscompression::TABSCompression BLOBCompression = {read=FBLOBCompression, write=FBLOBCompression};
	__property Abssecurity::TABSPassword Password = {read=FPassword, write=FPassword};
	__property int KeyFieldCount = {read=FKeyFieldCount, write=FKeyFieldCount, nodefault};
	__property System::PByte KeyBuffer = {read=FKeyBuffer, write=FKeyBuffer};
	__property System::PByte RangeStartBuffer = {read=FRangeStartBuffer, write=FRangeStartBuffer};
	__property System::PByte RangeEndBuffer = {read=FRangeEndBuffer, write=FRangeEndBuffer};
	__property bool RangeStartExclusive = {read=FRangeStartExclusive, write=FRangeStartExclusive, nodefault};
	__property bool RangeEndExclusive = {read=FRangeEndExclusive, write=FRangeEndExclusive, nodefault};
	__property int RangeStartKeyFieldCount = {read=FRangeStartKeyFieldCount, write=FRangeStartKeyFieldCount, nodefault};
	__property int RangeEndKeyFieldCount = {read=FRangeEndKeyFieldCount, write=FRangeEndKeyFieldCount, nodefault};
	__property System::PByte CurrentRecordBuffer = {read=FCurrentRecordBuffer, write=FCurrentRecordBuffer};
	__property System::PByte DistinctRecordBuffer = {read=FDistinctRecordBuffer, write=FDistinctRecordBuffer};
	__property System::PByte EditRecordBuffer = {read=FEditRecordBuffer, write=FEditRecordBuffer};
	__property bool PhysicalOrder = {read=FPhysicalOrder, write=FPhysicalOrder, nodefault};
	__property System::TObject* CurrentRecordPositionInIndex = {read=FCurrentRecordPositionInIndex, write=FCurrentRecordPositionInIndex};
	__property bool TableLockedByCursor = {read=FTableLockedByCursor, write=FTableLockedByCursor, nodefault};
	__property bool InBatchUpdate = {read=FBatchUpdate, write=FBatchUpdate, nodefault};
public:
	/* TObject.Create */ inline __fastcall TABSCursor() : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TABSCursor() { }
	
};


class PASCALIMPLEMENTATION TABSSessionComponentManager : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	/* TObject.Create */ inline __fastcall TABSSessionComponentManager() : System::TObject() { }
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSessionComponentManager() { }
	
};


class PASCALIMPLEMENTATION TABSSessionNamedObject : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	int FObjectID;
	System::ShortString FName;
	
public:
	__fastcall TABSSessionNamedObject(System::UnicodeString Name)/* overload */;
	__fastcall TABSSessionNamedObject(int ObjectID)/* overload */;
	__property System::ShortString Name = {read=FName, write=FName};
	__property int ObjectID = {read=FObjectID, write=FObjectID, nodefault};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSessionNamedObject() { }
	
};


class PASCALIMPLEMENTATION TABSSessionNamedObjectSequenceValue : public TABSSessionNamedObject
{
	typedef TABSSessionNamedObject inherited;
	
public:
	__int64 FValue;
	__fastcall TABSSessionNamedObjectSequenceValue(int ObjectID, __int64 Value);
	__property __int64 Value = {read=FValue, write=FValue};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSessionNamedObjectSequenceValue() { }
	
};


class PASCALIMPLEMENTATION TABSBaseSession : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::UnicodeString FDatabaseName;
	System::UnicodeString FDatabaseFileName;
	int FSessionID;
	bool FInTransaction;
	bool FReadOnly;
	bool FExclusive;
	bool FInMemory;
	System::UnicodeString FLogin;
	TABSSessionComponentManager* FSessionHandle;
	Abstypes::TABSSortedStringPtrArray* FSessionNamedObjectList;
	int FMaxSessionCount;
	bool FRepairNeeded;
	bool FMultiUser;
	System::UnicodeString FSessionName;
	
protected:
	virtual bool __fastcall GetConnected() = 0 ;
	virtual void __fastcall SetConnected(bool Value) = 0 ;
	virtual bool __fastcall GetSuppressDBHeaderErrors() = 0 ;
	virtual void __fastcall SetSuppressDBHeaderErrors(bool Value) = 0 ;
	
public:
	__fastcall TABSBaseSession();
	__fastcall virtual ~TABSBaseSession();
	virtual void __fastcall CreateDatabase() = 0 ;
	virtual void __fastcall DeleteDatabase() = 0 ;
	virtual void __fastcall RenameDatabase(System::UnicodeString NewDatabaseFileName) = 0 ;
	virtual void __fastcall GetTablesList(System::Classes::TStrings* List) = 0 ;
	virtual bool __fastcall TableExists(System::UnicodeString TableName) = 0 ;
	virtual void __fastcall SetObject(TABSSessionNamedObject* Value);
	virtual TABSSessionNamedObject* __fastcall GetObjectByName(System::UnicodeString ObjectName);
	virtual TABSSessionNamedObject* __fastcall GetObjectByID(int id);
	virtual void __fastcall DeleteObject(int id);
	virtual void __fastcall StartTransaction() = 0 ;
	virtual void __fastcall Commit(bool DoFlushBuffers = true) = 0 ;
	virtual void __fastcall Rollback() = 0 ;
	virtual void __fastcall FlushBuffers() = 0 ;
	__property bool Connected = {read=GetConnected, write=SetConnected, default=0};
	__property System::UnicodeString DatabaseFileName = {read=FDatabaseFileName, write=FDatabaseFileName};
	__property System::UnicodeString DatabaseName = {read=FDatabaseName, write=FDatabaseName};
	__property int SessionID = {read=FSessionID, write=FSessionID, nodefault};
	__property bool InTransaction = {read=FInTransaction, write=FInTransaction, nodefault};
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, nodefault};
	__property bool Exclusive = {read=FExclusive, write=FExclusive, nodefault};
	__property bool InMemory = {read=FInMemory, write=FInMemory, nodefault};
	__property System::UnicodeString Login = {read=FLogin, write=FLogin};
	__property TABSSessionComponentManager* SessionComponentManager = {read=FSessionHandle, write=FSessionHandle};
	__property int MaxSessionCount = {read=FMaxSessionCount, write=FMaxSessionCount, nodefault};
	__property bool RepairNeeded = {read=FRepairNeeded, write=FRepairNeeded, nodefault};
	__property bool SuppressDBHeaderErrors = {read=GetSuppressDBHeaderErrors, write=SetSuppressDBHeaderErrors, nodefault};
	__property bool MultiUser = {read=FMultiUser, write=FMultiUser, nodefault};
	__property System::UnicodeString SessionName = {read=FSessionName, write=FSessionName};
};


//-- var, const, procedure ---------------------------------------------------
}	/* namespace Absbase */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_ABSBASE)
using namespace Absbase;
#endif
#pragma pack(pop)
#pragma option pop

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