absdiskengine.pas

Absolute Database 是来替代BDE[Borland数据库引擎]的用于Delphi 和 C++ Builder 开发用的数据库引擎. 它小巧, 高速, 健壮, 易于使用. 它能直接编译进

                   // out
                   var PageListLink: TABSPageListLink);
    procedure WriteLinkToBlobDataPageList(
                   SessionID: TABSSessionID;
                   PageItemID: TABSPageItemID;
                   PageListLink: TABSPageListLink);

    procedure WriteMultiPagesBlob(SessionID: TABSSessionID;
                      BlobCache: PABSDiskBLOBCache; var PageItemID: TABSPageItemID;
                      BlobHeader: TABSDiskBlobHeader);

    procedure InternalReadSmallBlob(SessionID: TABSSessionID;
            BlobCache: PABSDiskBLOBCache; PageItemID: TABSPageItemID);
    procedure InternalReadLargeBlob(SessionID: TABSSessionID;
            BlobCache: PABSDiskBLOBCache; PageItemID: TABSPageItemID);
    function IsProbablyLargeBlob(SessionID: TABSSessionID;
                                 PageItemID: TABSPageItemID): Boolean;
    procedure InternalReadBlob(SessionID: TABSSessionID;
            BlobCache: PABSDiskBLOBCache; PageItemID: TABSPageItemID);

    procedure InternalWriteSmallBlob(SessionID: TABSSessionID;
            BlobCache: PABSDiskBLOBCache; var PageItemID: TABSPageItemID);
    procedure InternalWriteLargeBlob(SessionID: TABSSessionID;
            BlobCache: PABSDiskBLOBCache; var PageItemID: TABSPageItemID);
    function IsSmallBlob(BlobSize: Int64): Boolean;
    procedure InternalWriteBlob(SessionID: TABSSessionID;
            BlobCache: PABSDiskBLOBCache; var PageItemID: TABSPageItemID);

    procedure InternalDeleteSmallBlob(SessionID: TABSSessionID;
                                 var PageItemID: TABSPageItemID);
    procedure InternalDeleteLargeBlob(SessionID: TABSSessionID;
                                 var PageItemID: TABSPageItemID);
    procedure InternalDeleteBlob(SessionID: TABSSessionID;
                                 var PageItemID: TABSPageItemID);

   public
    constructor Create(PageManager: TABSPageManager;
       FieldManager: TABSBaseFieldManager; RecordManager: TABSBaseRecordManager);
    destructor Destroy; override;
    procedure LoadMetadata(Stream: TStream);
    procedure SaveMetadata(Stream: TStream);
    procedure CreateBlobPageIndex;

    procedure Empty(SessionID: TABSSessionID);
    procedure Delete(SessionID: TABSSessionID);

    // RecordBuffer <-> disk pages
    procedure ReadBlob(SessionID: TABSSessionID; RecordBuffer: TABSRecordBuffer;
                       FieldNo: Integer);
    procedure WriteBlob(SessionID: TABSSessionID; RecordBuffer: TABSRecordBuffer;
                        FieldNo: Integer);
    procedure WriteBlobs(SessionID: TABSSessionID; RecordBuffer: TABSRecordBuffer);
    procedure DeleteBlob(SessionID: TABSSessionID; RecordBuffer: TABSRecordBuffer;
                        FieldNo: Integer);
    procedure DeleteBlobs(SessionID: TABSSessionID; RecordBuffer: TABSRecordBuffer);

    // Blob stream <-> RecordBuffer
    procedure CopyBlobFromRecordBufferToStream(SessionID: TABSSessionID;
        RecordBuffer: TABSRecordBuffer; FieldNo: Integer;
        var BLOBDescriptor: TABSBLOBDescriptor; Stream: TStream);
    procedure CopyBlobFromStreamToRecordBuffer(RecordBuffer: TABSRecordBuffer;
                        FieldNo: Integer; Stream: TABSStream);
    procedure ClearBlobInRecordBuffer(RecordBuffer: TABSRecordBuffer; FieldNo: Integer; ForceClear: Boolean = False);

    // RecordBuffer <-> Direct Blob Info (descriptor + binary data)
    procedure GetDirectBlobInfoFromRecordBuffer(SessionID: TABSSessionID;
        RecordBuffer: TABSRecordBuffer; FieldNo: Integer;
        var BLOBDescriptor: TABSPartialTemporaryBLOBDescriptor;
        var pBlobData: PChar);
    procedure SetDirectBlobInfoFromRecordBuffer(SessionID: TABSSessionID;
        RecordBuffer: TABSRecordBuffer; FieldNo: Integer;
        var BLOBDescriptor: TABSPartialTemporaryBLOBDescriptor;
        var pBlobData: PChar);


  end;// TABSDiskBlobManager




////////////////////////////////////////////////////////////////////////////////
//
// TABSDiskTableData
//
////////////////////////////////////////////////////////////////////////////////


  TABSDiskTableData = class (TABSTableData)
   private
    FTableID:                TABSTableID;
    FTableLocksFile:         TABSTableLocksFile;
    FTableMetadataFile:      TABSInternalDbTransactedAccessFile;
    FTableMostUpdatedFile:   TABSInternalDbTransactedAccessFile;
    FBlobManager:            TABSDiskBlobManager;
    FTemporaryPageManager:   TABSPageManager;
    FExclusive:              Boolean;
    FIsChangingTableList:    Boolean;
    FLastUsedTableState:     Integer;

    procedure CreateTableFiles;
    procedure DeleteTableFiles;
    procedure OpenTableFiles(MetadataFilePageNo: TABSPageNo;
                             MostUpdatedFilePageNo: TABSPageNo;
                             LocksFilePageNo: TABSPageNo);
    procedure FreeTableFiles;
    procedure LoadMetadataFile(SessionID: TABSSessionID);
    procedure SaveMetadataFile(SessionID: TABSSessionID);
    procedure SaveMostUpdated(SessionID: TABSSessionID);
  public
    procedure LoadMostUpdated(SessionID: TABSSessionID);
  private
    function GetDiskRecordBufferSize: Integer;
    procedure RebuildRecordPageIndex(SessionID: TABSSessionID);
    procedure ValidateAndRepairMostUpdatedAndRecordPageIndex(Cursor: TABSCursor);
    procedure ValidateRecordPageIndex(Cursor: TABSCursor);

   protected
    // return filter bitmap rec count
    function GetBitmapRecordCount(SessionID: TABSSessionID): TABSRecordNo; override;
    // return filter bitmap rec no by record id
    function GetBitmapRecNoByRecordID(RecordID: TABSRecordID): TABSRecordNo; override;
    // return filter bitmap rec no by record id
    function GetRecordIDByBitmapRecNo(RecordNo: TABSRecordNo): TABSRecordID; override;

    procedure CreateRecordManager; override;
    procedure CreateBlobManager;
    procedure CreateFieldManager(FieldDefs: TABSFieldDefs); override;
    procedure CreateIndexManager(IndexDefs: TABSIndexDefs); override;
    procedure CreateConstraintManager(ConstraintDefs: TABSConstraintDefs); override;


   public
    constructor Create(aDatabaseData: TABSDatabaseData);
    destructor Destroy; override;
    procedure FreeIfNoCursorsConnected;

    procedure ApplyChanges(SessionID: TABSSessionID; InTransaction: Boolean); override;
    procedure CancelChanges(SessionID: TABSSessionID; InTransaction: Boolean); override;

    procedure CreateTable(
                          Cursor: TABSCursor;
                          FieldDefs: TABSFieldDefs;
                          IndexDefs: TABSIndexDefs;
                          ConstraintDefs: TABSConstraintDefs
                         ); override;
    procedure DeleteTable(Cursor: TABSCursor; DesignMode: Boolean = False); override;
    procedure EmptyTable(Cursor: TABSCursor); override;
    procedure RenameTable(NewTableName: String; Cursor: TABSCursor); override;
    procedure OpenTable(Cursor: TABSCursor); override;
    procedure CloseTable(Cursor: TABSCursor); override;

    procedure RenameField(FieldName, NewFieldName: String); override;

    procedure AddIndex(IndexDef: TABSIndexDef; Cursor: TABSCursor); override;
    procedure DeleteIndex(IndexID: TABSObjectID; Cursor: TABSCursor); override;

    //---------------------------------------------------------------------------
    // BLOB methods
    //---------------------------------------------------------------------------
    procedure WriteBLOBFieldToRecordBuffer(
              Cursor:     TABSCursor;
              FieldNo:    Integer;
              BLOBStream: TABSStream
              ); override;

    procedure ClearBLOBFieldInRecordBuffer(
              RecordBuffer: TABSRecordBuffer;
              FieldNo:    Integer
              ); override;

    procedure ClearModifiedBLOBFieldsInRecordBuffer(RecordBuffer: TABSRecordBuffer);

    function InternalCreateBlobStream(
              Cursor:   TABSCursor;
              ToInsert: Boolean;
              FieldNo:  Integer;
              OpenMode: TABSBLOBOpenMode
              ): TABSStream; override;

    procedure GetDirectBlobData(
              Cursor:     TABSCursor;
              FieldNo:    Integer;
              RecordBuffer: TABSRecordBuffer;
              var BLOBDescriptor: TABSPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar); override;

    procedure SetDirectBlobData(
              Cursor:     TABSCursor;
              FieldNo:    Integer;
              RecordBuffer: TABSRecordBuffer;
              var BLOBDescriptor: TABSPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar); override;

    procedure FreeDirectBlobData(
              Cursor:     TABSCursor;
              FieldNo:    Integer;
              RecordBuffer: TABSRecordBuffer;
              var BLOBDescriptor: TABSPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar); override;

    function InsertRecord(var Cursor: TABSCursor): Boolean; override;
    function DeleteRecord(Cursor: TABSCursor): Boolean; override;
    function UpdateRecord(Cursor: TABSCursor): Boolean; override;

    procedure ClearBlobsCacheInRecordBuffer(Buffer: TABSRecordBuffer); override;
    function GetRecordBuffer(
                              Cursor:         TABSCursor;
                              GetRecordMode:  TABSGetRecordMode
                            ): TABSGetRecordResult; override;
    function Locate(Cursor: TABSCursor; SearchExpression: TABSExpression): Boolean; override;
    function FindKey(Cursor: TABSCursor; SearchCondition: TABSSearchCondition): Boolean; override;
    procedure SetRecNo(Cursor: TABSCursor; RecNo: TABSRecordNo); override;
    function GetRecNo(Cursor: TABSCursor): TABSRecordNo; override;
    function InternalGetRecordCount(Cursor: TABSCursor): TABSRecordNo; override;
    // move cursor to specified position and set current record id in cursor
    procedure InternalSetRecNo(Cursor: TABSCursor; RecNo: TABSRecordNo); override;
    // get current record position from cursor
    function InternalGetRecNo(Cursor: TABSCursor): TABSRecordNo; override;

    function LastAutoincValue(FieldNo: Integer; Session: TABSBaseSession): Int64; override;

    procedure Rollback(SessionID: TABSSessionID); override;

    // locking
    function LockTable(SessionID: TABSSessionID; LockType: TABSLockType;
                       TryCount, Delay: Integer;
                       AllowXIRWAfterSIRW: Boolean = True): Boolean;
    function UnlockTable(SessionID: TABSSessionID; LockType: TABSLockType; IgnoreIfNoLock: Boolean=False): Boolean;
    function LockRecord(SessionID: TABSSessionID; RecordID: TABSRecordID;
                        TryCount, Delay: Integer): Boolean;
    function UnlockRecord(SessionID: TABSSessionID; RecordID: TABSRecordID): Boolean;

  end; // TABSDiskTableData


////////////////////////////////////////////////////////////////////////////////
//
// TABSDatabaseFile
//
////////////////////////////////////////////////////////////////////////////////

  TABSDatabaseFile = class(TObject)
   private
    FFileName:  String;

    FAccessMode:  TABSAccessMode;
    FShareMode:   TABSShareMode;
    FAttrFlags:   DWORD;

    FHandle:      THandle;
    FIsOpened:  Boolean;
    DesignOpenCount:  Integer;
    FWasCriticalError: Boolean;
   private
    function AccessModeToWindowsMode(am: TABSAccessMode): DWORD;
    function ShareModeToWindowsMode(sm: TABSShareMode): DWORD;

    // if file closed then raise
    procedure CheckOpened(OperationName: String);
    // if file opened then raise
    procedure CheckClosed(OperationName: String);
    // Seek
    function InternalSeek(Offset: Int64): Boolean;
    procedure Seek(Offset: Int64; ErrorCode: Integer = 0);

    procedure SetPosition(Offset: Int64);
    function  GetPosition: Int64;

    procedure SetSize(NewSize: Int64);
    function  GetSize: Int64;
   public
    // Constructor
    constructor Create;
    // Destructor
    destructor Destroy; override;

    // Create and Open File
    procedure CreateAndOpenFile(FileName: String);
    // Delete File
    procedure DeleteFile(FileName: String);
    // Rename Closed File
    procedure RenameFile(OldFileName, NewFileName: String);

    // Open File
    procedure OpenFile(FileName: String; AccessMode: TABSAccessMode; ShareMode: TABSShareMode);
    // Close File
    procedure CloseFile;
    procedure OpenFileForDesignTime;
    procedure CloseFileForDesignTime;
    // if connection to the network file is lost, try to reopen it
    function ReopenDatabaseFile: Boolean;

    // Read Buffer
    procedure ReadBuffer(var Buffer; const Count: Int64; const Position: Int64; ErrorCode: Integer); overload;
    function ReadBuffer(var Buffer; const Count: Int64; const Position: Int64): Boolean; overload;
    // Write Buffer
    procedure WriteBuffer(const Buffer; const Count: Int64; const Position: Int64; ErrorCode: Integer);
    // Flush Buffers
    procedure FlushFileBuffers;

    // Lock Byte (return TRUE if success)
    function LockByte(Offset: Int64; Count: Integer = 1): Boolean;
    // Unlock Byte
    function UnlockByte(Offset: Int64; Count: Integer = 1): Boolean;
    // return TRUE if byte Locked
    function IsByteLocked(Offset: Int64): Boolean;
    // return FALSE if any byte of region is locked
    function IsRegionLocked(Offset: Int64; Count: Integer): Boolean;
    // find signature
    function FindSignature(var Offset: Int64): Boolean;
   public
    property FileName: String read FFileName;
    property Size: Int64 read GetSize write SetSize;
    property IsOpened: Boolean read FIsOpened;
    property Position: Int64 read GetPosition write SetPosition;
  end;// TABSDatabaseFile



////////////////////////////////////////////////////////////////////////////////
//
// TABSDatabaseFreeSpaceManager
//
////////////////////////////////////////////////////////////////////////////////


  TABSDatabaseFreeSpaceManager = class(TObject)
   private
    LPageManager: TABSDiskPageManager;

    FPageCountInExtent:         Integer;
    FPFSPage_PagesAddressed:    Integer;  // count of pages addressed by PFSPage