absmemengine.pas

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

unit ABSMemEngine;

{$I ABSVer.inc}

interface

uses SysUtils, Classes, Math,

// AbsoluteDatabase units

     {$IFDEF DEBUG_LOG}
     ABSDebug,
     {$ENDIF}
     ABSExcept,
     ABSBase,
     ABSBaseEngine,
     ABSBTree,
     ABSPage,
     ABSMemory,
     ABSCompression,
     ABSSecurity,
     ABSTypes,
     ABSExpressions,
     ABSConverts,
     ABSConst;

type

  TABSMemoryPageManager = class;

////////////////////////////////////////////////////////////////////////////////
//
// TABSMemoryDatabaseData
//
////////////////////////////////////////////////////////////////////////////////


  TABSMemoryDatabaseData = class (TABSDatabaseData)
   private
    FLastObjectID: TABSLastObjectID;
   public
    constructor Create;
    destructor Destroy; override;
    // create table data
    function CreateTableData(Cursor: TABSCursor): TABSTableData; override;
    procedure ConnectSession(Session: TABSBaseSession); override;
    
    function GetNewObjectId: TABSObjectID; override;
  end; // TABSMemoryDatabaseData


////////////////////////////////////////////////////////////////////////////////
//
// TABSMemoryRecordManager
//
////////////////////////////////////////////////////////////////////////////////


  TABSMemoryRecordManager = class (TABSBaseRecordManager)
   private
    // record buffers
    FRecordBuffer:          PChar;
    // sequence of bits: 1 - for deleted record, 0 - for existing record
    FDeleteFlagBuffer:      PChar;
    FAllocatedRecordCount:  Integer;
    FAllocRecordsBy:        Integer;
    FFirstRecordID:         Integer;
    FLastRecordID:          Integer;
    FBitsTable:             array [0..255] of byte;
    FNoRecordsDeleted:      ByteBool;
   private
    // find record id by record position
    function FindRecord(RecordNo: TABSRecordNo): TABSRecordNo;
    // returns position of the record specified by record id,
    // or INVALID_ID8 if the record with this id does not exists
    function GetTablePositionByRecordID(
              RecordNo:           TABSRecordNo
                                        ): TABSRecordNo;
    // return result for attempt of getting record relatively to first position
    // and set RecordID to new record ID
    function GetRecordFromFirstPosition(
            GetRecordMode: TABSGetRecordMode;
            var RecordID: Integer
                                       ): TABSGetRecordResult;
    // return result for attempt of getting record relatively to last position
    // and set RecordID to new record ID
    function GetRecordFromLastPosition(
            GetRecordMode: TABSGetRecordMode;
            var RecordID: Integer
                                      ): TABSGetRecordResult;
    // return result for attempt of getting record relatively any position
    // and set RecordID to new record ID
    function GetRecordFromAnyPosition(
            GetRecordMode: TABSGetRecordMode;
            var RecordID: Integer
                                      ): TABSGetRecordResult;
   protected
    procedure SetRecordCount(NewRecordCount: Integer);
   public
    constructor Create(
                        RecordBufferSize:     Integer;
                        AllocRecordsBy:       Integer
                      );
    destructor Destroy; override;

    procedure Empty(SessionID: TABSSessionID); override;

    // add record and return its number
    function AddRecord(SessionID: TABSSessionID; RecordBuffer: TABSRecordBuffer; var RecordID: TABSRecordID): Boolean; override;
    // update record, return true if record was updated, false if record was deleted
    function UpdateRecord(SessionID: TABSSessionID; RecordBuffer: TABSRecordBuffer; RecordID: TABSRecordID): Boolean; override;
    // delete record, return true if record was deleted, false if record was deleted earlier
    function DeleteRecord(SessionID: TABSSessionID; var RecordID: TABSRecordID): Boolean; override;
    procedure GetRecordBuffer(SessionID: TABSSessionID; var NavigationInfo: TABSNavigationInfo); override;
    // return 0,1, or -1 if (1 = 2), (1 > 2) or (1 < 2)
    function CompareRecordID(RecordID1: TABSRecordID; RecordID2: TABSRecordID): Integer; override;
    // return record no
    function GetApproximateRecNo(SessionID: TABSSessionID; RecordID: TABSRecordID): TABSRecordNo; override;
    // add loaded record
    //procedure AddLoadedRecord(RecordBuffer: TABSRecordBuffer); override;
  end; // TABSMemoryRecordManager


////////////////////////////////////////////////////////////////////////////////
//
// TABSMemoryTableData
//
////////////////////////////////////////////////////////////////////////////////


  TABSMemoryTableData = class (TABSTableData)
   private
    FLoadedRecordCount: Integer;
    FAllocRecordsBy:    Integer;

   protected
    procedure CreateRecordManager; override;
    procedure CreateFieldManager(FieldDefs: TABSFieldDefs); override;
    procedure CreateIndexManager(IndexDefs: TABSIndexDefs); override;
    procedure CreateConstraintManager(ConstraintDefs: TABSConstraintDefs); override;
    //procedure CreateSequenceManager;
    //procedure BuildSequences;
    procedure LoadTableHeader(
              Stream:             TStream;
              var BLOBDescriptor: TABSBLOBDescriptor
                              );
    procedure SaveTableHeader(
              Stream:             TStream;
              var BLOBDescriptor: TABSBLOBDescriptor
                              );
    //procedure LoadSequencesFromStream(Stream: TStream);
    //procedure SaveSequencesToStream(Stream: TStream);
    procedure LoadBLOBDataFromStream(
            RecordBuffer: TABSRecordBuffer;
            FieldNo:      Integer;
            Stream:       TStream
                                 );
    procedure LoadRecordFromStream(
            RecordBuffer: TABSRecordBuffer;
            Stream:       TStream
                                 );
    procedure PrepareRecordBufferForSave(
            RecordBuffer:             TABSRecordBuffer;
            BLOBDescriptorList:       TList;
            BLOBDataList:             TList;
            BLOBPosition:             Int64
                                                );
    procedure SaveRecordToStream(
            RecordBuffer: TABSRecordBuffer;
            Stream:       TStream
                                 );
    //procedure LoadRecordManager(Stream: TStream);
    //procedure SaveRecordManager(Stream: TStream);
    // 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;
   public
    constructor Create(
                        aDatabaseData: TABSDatabaseData;
                        AllocRecordsBy: Integer = 1000
                      );
    destructor Destroy; 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 OpenTable(Cursor: TABSCursor); override;
    procedure CloseTable(Cursor: TABSCursor); 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;

    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;

    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;
  end; // TABSMemoryTableData




////////////////////////////////////////////////////////////////////////////////
//
// TABSMemoryPageManager
//
////////////////////////////////////////////////////////////////////////////////


  TABSMemoryPageManager = class (TABSPageManager)
   protected
     FAllocatedPageMap:    TABSBitsArray;
     FAllocatedPageCount:  TABSPageNo;
     FAllocateBy:          Integer;
     LastAllocatedPageNo:  TABSPageNo;
     FDataPtrs:            array of PChar;

   public
     procedure LoadFromStream(Stream: TStream); override;
     procedure SaveToStream(Stream: TStream); override;
     procedure InternalAddPage(aPage: TABSPage); override;
     procedure InternalRemovePage(PageNo: TABSPageNo); override;
     function InternalReadPage(aPage: TABSPage): Boolean; override;
     procedure InternalWritePage(aPage: TABSPage); override;

     constructor Create;
     destructor Destroy; override;
  end; // TABSMemoryPageManager


implementation

uses

// AbsoluteDatabase units

  ABSLocalEngine;

////////////////////////////////////////////////////////////////////////////////
//
// TABSMemoryDatabaseData
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// create
//------------------------------------------------------------------------------
constructor TABSMemoryDatabaseData.Create;
begin
 inherited Create;
 FPageManager := nil;
 DatabaseName := ABSMemoryDatabaseName;
 FLastObjectID := 0;
end;// Create


//------------------------------------------------------------------------------
// destroy
//------------------------------------------------------------------------------
destructor TABSMemoryDatabaseData.Destroy;
begin
 while (FTableDataList.Count > 0) do
  begin
    if (FTableDataList.Items[0] = nil) then
     raise EABSException.Create(10258,ErrorLNilPointer);
    TABSTableData(FTableDataList.Items[0]).DeleteTable(nil);
  end;
 inherited Destroy;
end;// Destroy


//------------------------------------------------------------------------------
// create table data
//------------------------------------------------------------------------------
function TABSMemoryDatabaseData.CreateTableData(Cursor: TABSCursor): TABSTableData;
begin
 Result := TABSMemoryTableData.Create(Self);
 Result.TableName := Cursor.TableName;
 FTableDataList.Add(Result);
end;


//------------------------------------------------------------------------------
// ConnectSession
//------------------------------------------------------------------------------
procedure TABSMemoryDatabaseData.ConnectSession(Session: TABSBaseSession);
begin
  Session.SessionID := 0;
  inherited ConnectSession(Session);
end;// ConnectSession


//------------------------------------------------------------------------------
// GetNewObjectId
//------------------------------------------------------------------------------
function TABSMemoryDatabaseData.GetNewObjectId: TABSObjectID;
begin
  Lock;
  try