myldbdiskengine.pas

一个本地database引擎,支持中文T_Sql查询,兼容DELPHI标准数据库控件

    // Constructor
    constructor Create(PageManager: TMYLDBDiskPageManager; PageTypeID: TMYLDBPageTypeID);
    // Destructor
    destructor Destroy; override;

    // Create file
    procedure CreateFile(SessionID: TMYLDBSessionID);
    // Delete file. And free all file pages
    procedure DeleteFile(SessionID: TMYLDBSessionID; StartPageNo: TMYLDBPageNo = INVALID_PAGE_NO);
    // Open file (reading file header)
    procedure OpenFile(StartPageNo: TMYLDBPageNo);

    // Set File Size
    procedure SetFileSize(SessionID: TMYLDBSessionID;
                            NewSize: Integer; DecompressedSize: Integer;
                            CompressionAlgorithm: TMYLDBCompressionAlgorithm);
    // Get File Size
    procedure GetFileSize(SessionID: TMYLDBSessionID; var Size: Integer;
                          var DecompressedSize: Integer;
                          var CompressionAlgorithm: TMYLDBCompressionAlgorithm;
                          var FileWasChanged: Boolean;
                          SyncronizeAllowed: Boolean);
    function GetSize(SessionID: TMYLDBSessionID): Integer;

    // Read File Data
    procedure ReadFile(SessionID: TMYLDBSessionID; var Buffer; const Count: Integer; SynchronizeAllowed: Boolean = true);
    // Write File Data
    procedure WriteFile(SessionID: TMYLDBSessionID; const Buffer; const Count: Integer;
                        const Algorithm: TMYLDBCompressionAlgorithm = acaNone;
                        const CompressionMode: Integer = 0);

    function LockFile: Boolean;
    function UnlockFile: Boolean;
   public
    property PageManager: TMYLDBDiskPageManager read LPageManager;
    property StartPageNo: TMYLDBPageNo read FStartPageNo;
  end;// TMYLDBInternalDBTransactedAccessFile



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBInternalDBDirectAccessFile
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBInternalDBDirectAccessFile = class(TObject)
   private
    LPageManager: TMYLDBDiskPageManager;
    FStartPageNo: TMYLDBPageNo;
    FPageTypeID:  TMYLDBPageTypeID;
    FFileSize: Integer;
    FFilePages: TMYLDBIntegerArray;

   private
    // SetStartPageNo
    procedure SetStartPageNo(StartPageNo: TMYLDBPageNo);
    procedure ReadPageHeader(PageNo: TMYLDBPageNo; var PageHeader: TMYLDBDiskPageHeader;
                                             SkipFirstByte: Boolean = False);
    // raise if file is Closed
    procedure CheckFileOpened(OperationName: String);
    // return Count of File Pages
    function GetPageCountForDataSize(DataSize: Integer): Integer;
    // return Count of File Pages
    procedure GetPageNoAndOffsetForPosition(Position: Integer; var PagePosition: Integer; var Offset: word);
    procedure ReadPageList;
    // return real page No for file page (firstPageNo=0)
    function GoToPage(PagePosition: TMYLDBPageNo): TMYLDBPageNo;
    procedure InternalSeek(FileOffset: Integer; out PageNo: TMYLDBPageNo; out PageOffset: Word);
   public
    // Constructor
    constructor Create(PageManager: TMYLDBDiskPageManager; PageTypeID: TMYLDBPageTypeID);
    // Destructor
    destructor Destroy; override;

    // Create file
    procedure CreateFile(Size: Integer);
    // Delete file. And free all file pages
    procedure DeleteFile(StartPageNo: TMYLDBPageNo = INVALID_PAGE_NO);
    // Open file (reading file header)
    procedure OpenFile(StartPageNo: TMYLDBPageNo);

    // Get File Size
    function GetSize: Integer;

    // direct (without sessions and transactions) Read buffer from file
    procedure ReadBuffer(var Buffer; const Count: Integer; const Position: Integer = -1);
    // direct (without sessions and transactions) Write buffer from file
    procedure WriteBuffer(const Buffer; const Count: Integer; const Position: Integer = -1);

    function LockFile: Boolean;
    function UnlockFile: Boolean;
    function LockByte(ByteNo: Integer): Boolean;
    function UnlockByte(ByteNo: Integer): Boolean;
    function IsByteLocked(ByteNo: Integer): Boolean;
    function IsRegionLocked(ByteNo, ByteCount: Integer): Boolean;
   public
    property PageManager: TMYLDBDiskPageManager read LPageManager;
    property StartPageNo: TMYLDBPageNo read FStartPageNo;
  end;// TMYLDBInternalDBDirectAccessFile



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBActiveSessionsFile
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBActiveSessionsFile = class(TObject)
   private
    LPageManager:     TMYLDBDiskPageManager;
    FHandle:          TMYLDBInternalDBDirectAccessFile;
    FMaxSessionCount: Integer;

    function GetStartPageNo: TMYLDBPageNo;
   public
    constructor Create(PageManager: TMYLDBPageManager);
    destructor Destroy; override;
    function CreateFile(aMaxSessionCount: Integer): TMYLDBPageNo;
    procedure OpenFile(aStartPageNo: TMYLDBPageNo);
    procedure CloseFile;
    function MultiUserConnect: TMYLDBSessionID;
    procedure MultiUserDisconnect(SessionID: TMYLDBSessionID);
    function SingleUserConnect: Boolean;
    procedure SingleUserDisconnect;
    function GetDBFileConnectionsCount: Integer;

    property StartPageNo: TMYLDBPageNo read GetStartPageNo;
    property MaxSessionCount: Integer read FMaxSessionCount;
  end;// TMYLDBActiveSessionsFile



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBTableListFile
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBTableListFile = class(TObject)
   private
    LPageManager: TMYLDBDiskPageManager;
    FHandle:      TMYLDBInternalDBTransactedAccessFile;
    FTableList: array of TMYLDBTableListItem;

    function GetStartPageNo: TMYLDBPageNo;
    function GetTableIndex(TableName: String): Integer;
   public
    constructor Create(PageManager: TMYLDBPageManager);
    destructor Destroy; override;

    function CreateFile: TMYLDBPageNo;
    procedure OpenFile(aStartPageNo: TMYLDBPageNo);
    procedure CloseFile;

    procedure Load;
    procedure Save;

    procedure AddTable(
           TableID: TMYLDBTableID;
           TableName: String;
           MetadataFilePageNo,
           MostUpdatedFilePageNo,
           LocksFilePageNo: TMYLDBPageNo
                         );
    procedure RemoveTable(TableName: String);
    procedure OpenTable(
           TableName: String;
           out TableID: TMYLDBTableID;
           out MetadataFilePageNo: TMYLDBPageNo;
           out MostUpdatedFilePageNo: TMYLDBPageNo;
           out LocksFilePageNo: TMYLDBPageNo
                         );
    procedure RenameTable(TableName, NewTableName: String);
    function TableExists(TableName: String): Boolean;
    procedure GetTablesList(List: TStrings);

   public
    property StartPageNo: TMYLDBPageNo read GetStartPageNo;
  end;// TMYLDBTableListFile



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBTableLocksFile
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBTableLocksFile = class(TObject)
   private
    LPageManager:     TMYLDBDiskPageManager;
    FHandle:          TMYLDBInternalDBDirectAccessFile;
    FMaxSessionCount: Integer;

    function GetStartPageNo: TMYLDBPageNo;
    function GetTableLockByteNo(
                    SessionID: TMYLDBSessionID; LockType: TMYLDBLockType): Integer;
    function GetRecordLockByteNo(SessionID: TMYLDBSessionID): Integer;
    function GetRecordLockRecordIDByteNo(SessionID: TMYLDBSessionID): Integer;
   public
    constructor Create(PageManager: TMYLDBPageManager);
    destructor Destroy; override;
    function CreateFile(aMaxSessionCount: Integer): TMYLDBPageNo;
    procedure DeleteFile;
    procedure OpenFile(aStartPageNo: TMYLDBPageNo);
    procedure CloseFile;

    function LockTable(SessionID: TMYLDBSessionID; LockType: TMYLDBLockType): Boolean;
    function UnlockTable(SessionID: TMYLDBSessionID; LockType: TMYLDBLockType): Boolean;
    function IsTableLockedByAnyOtherSession(SessionID: TMYLDBSessionID;
                                            LockType: TMYLDBLockType): Boolean;
    function IsTableLockAllowed(SessionID: TMYLDBSessionID;
                                LockType: TMYLDBLockType;
                                AllowXIRWAfterSIRW: Boolean = True): Boolean;

    function LockRecord(
                        SessionID:  TMYLDBSessionID;
                        RecordID:   TMYLDBRecordID
                       ): Boolean;
    function UnlockRecord(
                          SessionID:  TMYLDBSessionID;
                          RecordID:   TMYLDBRecordID
                         ): Boolean;
    function IsRecordLockedByAnyOtherSession(
                          SessionID:  TMYLDBSessionID;
                          RecordID:   TMYLDBRecordID
                         ): Boolean;
    function LockFile: Boolean;
    function UnlockFile: Boolean;

    property MaxSessionCount: Integer read FMaxSessionCount;
    property StartPageNo: TMYLDBPageNo read GetStartPageNo;
  end;// TMYLDBTableLocksFile



////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBSystemDirectory
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBSystemDirectory = class(TObject)
   private
    LPageManager: TMYLDBDiskPageManager;
    FHandle:      TMYLDBInternalDBTransactedAccessFile;

    FFileList:    array of TMYLDBSystemDirectoryListItem;
   public
    constructor Create(PageManager: TMYLDBDiskPageManager);
    destructor Destroy; override;
    procedure CreateDirectory;
    procedure LoadDirectory;
    procedure SaveDirectory;
    procedure CreateFile(FileType: TMYLDBDBFileType; FirstPageNo: TMYLDBPageNo);
    function GetFileFirstPageNo(FileType: TMYLDBDBFileType): TMYLDBPageNo;
   public
    property PageManager: TMYLDBDiskPageManager read LPageManager;
  end;// TMYLDBSystemDirectory


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBTableLockList
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBTableLock = record
    LockType:         TMYLDBLockType;
    LocksFilePageNo:  TMYLDBPageNo;
    LockCount:        Integer;
    HasPhysicalLock:  Boolean;
    IsXIRWAfterSIRWAllowed: Boolean;
  end;
  PMYLDBTableLock = ^TMYLDBTableLock;

  TMYLDBTableLockList = class(TObject)
   private
     FLockList: TList;

     function FindLock(LockType: TMYLDBLockType; LocksFilePageNo: TMYLDBPageNo;
                       var ItemNo: Integer): Boolean; overload;
     function FindLock(LockType: TMYLDBLockType; LocksFilePageNo: TMYLDBPageNo; IsXIRWAfterSIRWAllowed: Boolean;
                       var ItemNo: Integer): Boolean; overload;
     // is lock1 stronger than lock2
     function IsLockStronger(LockType1, LockType2: TMYLDBLockType): Boolean;
   public
     constructor Create;
     destructor Destroy; override;
     procedure AddLock(LockType: TMYLDBLockType; LocksFilePageNo: TMYLDBPageNo; HasPhysicalLock: Boolean; IsXIRWAfterSIRWAllowed: Boolean = True);
     procedure RemoveLock(LockType: TMYLDBLockType; LocksFilePageNo: TMYLDBPageNo;
                          var HasPhysicalLock: Boolean; IgnoreCount: Boolean);
     function LockExists(LockType: TMYLDBLockType; LocksFilePageNo: TMYLDBPageNo): Boolean; overload;
     function LockExists(LockType: TMYLDBLockType; LocksFilePageNo: TMYLDBPageNo; IsXIRWAfterSIRWAllowed: Boolean): Boolean;overload;
     function StrongerLockExists(LockType: TMYLDBLockType; LocksFilePageNo: TMYLDBPageNo): Boolean;
     procedure SetPhysicalLock(ItemNo: Integer);
     function IsWeakerNonPhysicalLock(ItemNo: Integer; LockType: TMYLDBLockType): Boolean;
  end;// TMYLDBTableLockList


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBDatabaseTableLockManager
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBDatabaseTableLockManager = class(TObject)
   private
     FSessionLockList: TList;
     FMaxSessionCount: Integer;
     FCSect: TRTLCriticalSection;
     LPageManager: TMYLDBPageManager;

     procedure Lock;
     procedure Unlock;
     function AddSIRWLocksToULocks(SessionID: TMYLDBSessionID): Boolean;
     function SetPhysicalLockForWeakerLocks(SessionID: TMYLDBSessionID; LockType: TMYLDBLockType;
                        TableLocksFile: TMYLDBTableLocksFile): Boolean;

   public