absdiskengine.~pas

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

                                      inBuf:                  pChar;
                                      Size:                   Integer;
                                      Password:               string
                                    ): Boolean;
  // decrypts specified buffer
  function ABSInternalDecryptBuffer(
                                      CryptoAlg:              TABSCryptoAlgorithm;
                                      inBuf:                  pChar;
                                      Size:                   Integer;
                                      Password:               string
                                    ): Boolean;

function IsOSCriticalError: Boolean;

implementation

uses ABSLocalEngine, ABSTempEngine;

{$IFNDEF D6H}
function RandomRange(const AFrom, ATo: Integer): Integer;
begin
  if AFrom > ATo then
    Result := Random(AFrom - ATo) + ATo
  else
    Result := Random(ATo - AFrom) + AFrom;
end;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////
//
// TABSDiskDatabaseData
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// OpenDatabase
//------------------------------------------------------------------------------
procedure TABSDiskDatabaseData.OpenDatabase(Session: TABSBaseSession; Exclusive: Boolean;
                                            var RepairNeeded: Boolean);
begin
  Lock;
  try
    FPageManager := TABSDiskPageManager.Create;
    try
      FMultiUser := Session.MultiUser;
      TABSDiskPageManager(FPageManager).OpenDatabase(DatabaseName, FPassword,
                       FReadOnly, RepairNeeded, Exclusive, FMultiUser);
      FPassword := TABSDiskPageManager(FPageManager).Password^;
      FPageSize := TABSDiskPageManager(FPageManager).PageSize;
      FPageCountInExtent := TABSDiskPageManager(FPageManager).DBHeader.PageCountInExtent;

      FSystemDir := TABSSystemDirectory.Create(TABSDiskPageManager(FPageManager));
      FSystemDir.LoadDirectory;
      FActiveSessionsFile := TABSActiveSessionsFile.Create(FPageManager);
      FActiveSessionsFile.OpenFile(FSystemDir.GetFileFirstPageNo(dbftActiveSessionsList));
      FMaxSessionCount := FActiveSessionsFile.MaxSessionCount;
      FTableListFile := TABSTableListFile.Create(TABSDiskPageManager(FPageManager));
      FTableListFile.OpenFile(FSystemDir.GetFileFirstPageNo(dbftTablesList));
      FTableListFile.Load;

      FTableLockManager := TABSDatabaseTableLockManager.Create(FMaxSessionCount, FPageManager);
    except
      CloseDatabase;
      raise;
    end;
  finally
   Unlock;
  end;
end;// OpenDatabase


//------------------------------------------------------------------------------
// CloseDatabase
//------------------------------------------------------------------------------
procedure TABSDiskDatabaseData.CloseDatabase;
begin
  Lock;
  try
    if (FSystemDir <> nil) then
      FreeAndNil(FSystemDir);
    if (FTableListFile <> nil) then
      FreeAndNil(FTableListFile);
    if (FActiveSessionsFile <> nil) then
      FreeAndNil(FActiveSessionsFile);
    if (FTableLockManager <> nil) then
      FreeAndNil(FTableLockManager);
    if (FPageManager <> nil) then
     begin
      TABSDiskPageManager(FPageManager).CloseDatabase;
      FreeAndNil(FPageManager);
     end;
  finally
   Unlock;
  end;
end;// CloseDatabase


//------------------------------------------------------------------------------
// GetPassword
//------------------------------------------------------------------------------
function TABSDiskDatabaseData.GetPassword: PABSPassword;
begin
 Result := @Fpassword;
end;//GetPassword


//------------------------------------------------------------------------------
// GetEncrypted
//------------------------------------------------------------------------------
function TABSDiskDatabaseData.GetEncrypted: Boolean;
begin
  Result := TABSDiskPageManager(FPageManager).Encrypted;
end;// GetEncrypted


//------------------------------------------------------------------------------
// AddTable
//------------------------------------------------------------------------------
procedure TABSDiskDatabaseData.AddTable(
       TableID: TABSTableID;
       TableName: String;
       MetadataFilePageNo, MostUpdatedFilePageNo, LocksFilePageNo: TABSPageNo
                     );
begin
  Lock;
  try
    FTableListFile.AddTable(TableID, TableName,
                            MetadataFilePageNo, MostUpdatedFilePageNo,
                            LocksFilePageNo);
    FTableListFile.Save;
  finally
   Unlock;
  end;
end;// AddTable


//------------------------------------------------------------------------------
// OpenTable
//------------------------------------------------------------------------------
procedure TABSDiskDatabaseData.OpenTable(TableName: String;
  out TableID: TABSTableID; out MetadataFilePageNo, MostUpdatedFilePageNo,
  LocksFilePageNo: TABSPageNo);
begin
  Lock;
  try
    if (FTableListFile = nil) then
      raise EABSException.Create(20129, ErrorANilPointer);
    FTableListFile.OpenTable(TableName, TableID,
                            MetadataFilePageNo, MostUpdatedFilePageNo,
                            LocksFilePageNo);
  finally
   Unlock;
  end;
end;// OpenTable


procedure TABSDiskDatabaseData.RemoveTable(TableName: String);
begin
  Lock;
  try
    if (FTableListFile = nil) then
      raise EABSException.Create(20130, ErrorANilPointer);
    FTableListFile.RemoveTable(TableName);
    FTableListFile.Save;
  finally
    Unlock;
  end;
end;

procedure TABSDiskDatabaseData.RenameTable(TableName,
  NewTableName: String);
begin
  Lock;
  try
    if (FTableListFile = nil) then
      raise EABSException.Create(20131, ErrorANilPointer);
    FTableListFile.RenameTable(TableName, NewTableName);
    FTableListFile.Save;
  finally
   Unlock;
  end;
end;


//------------------------------------------------------------------------------
// Create
//------------------------------------------------------------------------------
constructor TABSDiskDatabaseData.Create;
begin
  inherited Create;
  FPageManager := nil;
  FSystemDir := nil;
  FActiveSessionsFile := nil;
  FTableListFile := nil;
  FTableLockManager := nil;
  FSingleUserConnected := False;
end;// Create


//------------------------------------------------------------------------------
// Destroy
//------------------------------------------------------------------------------
destructor TABSDiskDatabaseData.Destroy;
begin
  CloseDatabase;
  inherited Destroy;
end;// Destroy


//------------------------------------------------------------------------------
// create table data
//------------------------------------------------------------------------------
function TABSDiskDatabaseData.CreateTableData(Cursor: TABSCursor): TABSTableData;
begin
  Lock;
  try
    Result := TABSDiskTableData.Create(Self);
    Result.TableName := Cursor.TableName;
    FTableDataList.Add(Result);
  finally
   Unlock;
  end;
end;// CreateTableData


//------------------------------------------------------------------------------
// CreateDatabase
//------------------------------------------------------------------------------
procedure TABSDiskDatabaseData.CreateDatabase;
begin
  Lock;
  try
    FPageManager := TABSDiskPageManager.Create;
    try
    TABSDiskPageManager(FPageManager).CreateAndOpenDatabase(DatabaseName,
                                                            FPassword,
                                                            FPageSize,
                                                            FPageCountInExtent);
      FSystemDir := TABSSystemDirectory.Create(TABSDiskPageManager(FPageManager));
      FActiveSessionsFile := TABSActiveSessionsFile.Create(FPageManager);
      FTableListFile := TABSTableListFile.Create(TABSDiskPageManager(FPageManager));
      try
        FSystemDir.CreateDirectory;
        FSystemDir.CreateFile(dbftActiveSessionsList, FActiveSessionsFile.CreateFile(MaxSessionCount));
        FSystemDir.CreateFile(dbftTablesList, FTableListFile.CreateFile);
        FSystemDir.SaveDirectory;
        FPageManager.ApplyChanges(SYSTEM_SESSION_ID);
      finally
      FreeAndNil(FTableListFile);
      FreeAndNil(FActiveSessionsFile);
      FreeAndNil(FSystemDir);
      end;
    finally
      TABSDiskPageManager(FPageManager).CloseDatabase;
      FPageManager.Free;
      FPageManager := nil;
    end;
  finally
   Unlock;
  end;
end;// CreateDatabase


//------------------------------------------------------------------------------
// ConnectSession
//------------------------------------------------------------------------------
procedure TABSDiskDatabaseData.ConnectSession(Session: TABSBaseSession);
var
  RepairNeeded: Boolean;
begin
  Lock;
  try
    if (FPageManager = nil) then
      begin
        OpenDatabase(Session, Session.Exclusive, RepairNeeded);
        Session.RepairNeeded := RepairNeeded;
        Session.MultiUser := FMultiUser;
      end;

{$IFDEF FILE_SERVER_VERSION}
    if (Session.MultiUser <> FMultiUser) then
      raise EABSException.Create(20235, ErrorAMultiUserOptionsConflict);
    if (Session.MultiUser) then
      Session.SessionID := FActiveSessionsFile.MultiUserConnect
    else
{$ENDIF}
      begin
        Session.SessionID := 0;
        if (not FSingleUserConnected) then
          begin
            FSingleUserConnected := FActiveSessionsFile.SingleUserConnect;
            if (not FSingleUserConnected) then
              FReadOnly := True;
          end;
      end;
    FSessionList.Add(Session);
  finally
    Unlock;
  end;
end;// ConnectSession


//------------------------------------------------------------------------------
// DisconnectSession
//------------------------------------------------------------------------------
procedure TABSDiskDatabaseData.DisconnectSession(Session: TABSBaseSession);
begin
  Lock;
  try
    try
{$IFDEF FILE_SERVER_VERSION}
      if (FSessionList.Count > 0) then
        if (Session.MultiUser) then
          FActiveSessionsFile.MultiUserDisconnect(Session.SessionID)
        else
{$ENDIF}
          if ((FSingleUserConnected) and (FSessionList.Count = 1)) then
            FActiveSessionsFile.SingleUserDisconnect;
    except
      if (not IsDesignMode) then
        raise;
    end;
    FSessionList.Remove(Session);
    if (FSessionList.Count = 0) then
      begin
        if (Session.InTransaction) then
          Session.Rollback;
        CloseDatabase;