unit MYLDBMemEngine;

{$I MYLDBVer.inc}

interface

uses SysUtils, Classes, Math,

// MYLDBoluteDatabase units

     {$IFDEF DEBUG_LOG}
     MYLDBDebug,
     {$ENDIF}
     MYLDBExcept,
     MYLDBBase,
     MYLDBBaseEngine,
     MYLDBBTree,
     MYLDBPage,
     MYLDBMemory,
     MYLDBCompression,
     MYLDBSecurity,
     MYLDBTypes,
     MYLDBExpressions,
     MYLDBConverts,
     MYLDBConst;

type

  TMYLDBMemoryPageManager = class;

////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBMemoryDatabaseData
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBMemoryDatabaseData = class (TMYLDBDatabaseData)
   private
    FLastObjectID: TMYLDBLastObjectID;
   public
    constructor Create;
    destructor Destroy; override;
    // create table data
    function CreateTableData(Cursor: TMYLDBCursor): TMYLDBTableData; override;
    procedure ConnectSession(Session: TMYLDBBaseSession); override;

    function GetNewObjectId: TMYLDBObjectID; override;
  end; // TMYLDBMemoryDatabaseData


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBMemoryRecordManager
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBMemoryRecordManager = class (TMYLDBBaseRecordManager)
   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: TMYLDBRecordNo): TMYLDBRecordNo;
    // returns position of the record specified by record id,
    // or INVALID_ID8 if the record with this id does not exists
    function GetTablePositionByRecordID(
              RecordNo:           TMYLDBRecordNo
                                        ): TMYLDBRecordNo;
    // return result for attempt of getting record relatively to first position
    // and set RecordID to new record ID
    function GetRecordFromFirstPosition(
            GetRecordMode: TMYLDBGetRecordMode;
            var RecordID: Integer
                                       ): TMYLDBGetRecordResult;
    // return result for attempt of getting record relatively to last position
    // and set RecordID to new record ID
    function GetRecordFromLastPosition(
            GetRecordMode: TMYLDBGetRecordMode;
            var RecordID: Integer
                                      ): TMYLDBGetRecordResult;
    // return result for attempt of getting record relatively any position
    // and set RecordID to new record ID
    function GetRecordFromAnyPosition(
            GetRecordMode: TMYLDBGetRecordMode;
            var RecordID: Integer
                                      ): TMYLDBGetRecordResult;
   protected
    procedure SetRecordCount(NewRecordCount: Integer);
   public
    constructor Create(
                        RecordBufferSize:     Integer;
                        AllocRecordsBy:       Integer
                      );
    destructor Destroy; override;

    procedure Empty(SessionID: TMYLDBSessionID); override;

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


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBMemoryTableData
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBMemoryTableData = class (TMYLDBTableData)
   private
    FLoadedRecordCount: Integer;
    FAllocRecordsBy:    Integer;

   protected
    procedure CreateRecordManager; override;
    procedure CreateFieldManager(FieldDefs: TMYLDBFieldDefs); override;
    procedure CreateIndexManager(IndexDefs: TMYLDBIndexDefs); override;
    procedure CreateConstraintManager(ConstraintDefs: TMYLDBConstraintDefs); override;
    //procedure CreateSequenceManager;
    //procedure BuildSequences;
    procedure LoadTableHeader(
              Stream:             TStream;
              var BLOBDescriptor: TMYLDBBLOBDescriptor
                              );
    procedure SaveTableHeader(
              Stream:             TStream;
              var BLOBDescriptor: TMYLDBBLOBDescriptor
                              );
    //procedure LoadSequencesFromStream(Stream: TStream);
    //procedure SaveSequencesToStream(Stream: TStream);
    procedure LoadBLOBDataFromStream(
            RecordBuffer: TMYLDBRecordBuffer;
            FieldNo:      Integer;
            Stream:       TStream
                                 );
    procedure LoadRecordFromStream(
            RecordBuffer: TMYLDBRecordBuffer;
            Stream:       TStream
                                 );
    procedure PrepareRecordBufferForSave(
            RecordBuffer:             TMYLDBRecordBuffer;
            BLOBDescriptorList:       TList;
            BLOBDataList:             TList;
            BLOBPosition:             Int64
                                                );
    procedure SaveRecordToStream(
            RecordBuffer: TMYLDBRecordBuffer;
            Stream:       TStream
                                 );
    //procedure LoadRecordManager(Stream: TStream);
    //procedure SaveRecordManager(Stream: TStream);
    // return filter bitmap rec count
    function GetBitmapRecordCount(SessionID: TMYLDBSessionID): TMYLDBRecordNo; override;
    // return filter bitmap rec no by record id
    function GetBitmapRecNoByRecordID(RecordID: TMYLDBRecordID): TMYLDBRecordNo; override;
    // return filter bitmap rec no by record id
    function GetRecordIDByBitmapRecNo(RecordNo: TMYLDBRecordNo): TMYLDBRecordID; override;
   public
    constructor Create(
                        aDatabaseData: TMYLDBDatabaseData;
                        AllocRecordsBy: Integer = 1000
                      );
    destructor Destroy; override;

    procedure CreateTable(
                          Cursor: TMYLDBCursor;
                          FieldDefs: TMYLDBFieldDefs;
                          IndexDefs: TMYLDBIndexDefs;
                          ConstraintDefs: TMYLDBConstraintDefs
                         ); override;
    procedure DeleteTable(Cursor: TMYLDBCursor; DesignMode: Boolean = False); override;
    procedure EmptyTable(Cursor: TMYLDBCursor); override;
    procedure OpenTable(Cursor: TMYLDBCursor); override;
    procedure CloseTable(Cursor: TMYLDBCursor); override;

    procedure AddIndex(IndexDef: TMYLDBIndexDef; Cursor: TMYLDBCursor); override;
    procedure DeleteIndex(IndexID: TMYLDBObjectID; Cursor: TMYLDBCursor); override;

    //---------------------------------------------------------------------------
    // BLOB methods
    //---------------------------------------------------------------------------
    procedure WriteBLOBFieldToRecordBuffer(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              BLOBStream: TMYLDBStream
              ); override;

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

    function InternalCreateBlobStream(
              Cursor:   TMYLDBCursor;
              ToInsert: Boolean;
              FieldNo:  Integer;
              OpenMode: TMYLDBBLOBOpenMode
              ): TMYLDBStream; override;

    procedure GetDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar); override;

    procedure SetDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar); override;

    procedure FreeDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar); override;

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

    function InternalGetRecordCount(Cursor: TMYLDBCursor): TMYLDBRecordNo; override;
    // move cursor to specified position and set current record id in cursor
    procedure InternalSetRecNo(Cursor: TMYLDBCursor; RecNo: TMYLDBRecordNo); override;
    // get current record position from cursor
    function InternalGetRecNo(Cursor: TMYLDBCursor): TMYLDBRecordNo; override;

    function LastAutoincValue(FieldNo: Integer; Session: TMYLDBBaseSession): Int64; override;
  end; // TMYLDBMemoryTableData




////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBMemoryPageManager
//
////////////////////////////////////////////////////////////////////////////////


  TMYLDBMemoryPageManager = class (TMYLDBPageManager)
   protected
     FAllocatedPageMap:    TMYLDBBitsArray;
     FAllocatedPageCount:  TMYLDBPageNo;
     FAllocateBy:          Integer;
     LastAllocatedPageNo:  TMYLDBPageNo;
     FDataPtrs:            array of PChar;

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

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


implementation

uses

// MYLDBoluteDatabase units

  MYLDBLocalEngine;

////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBMemoryDatabaseData
//
////////////////////////////////////////////////////////////////////////////////


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


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


//------------------------------------------------------------------------------
// create table data
//------------------------------------------------------------------------------
function TMYLDBMemoryDatabaseData.CreateTableData(Cursor: TMYLDBCursor): TMYLDBTableData;
begin
 Result := TMYLDBMemoryTableData.Create(Self);
 Result.TableName := Cursor.TableName;
 FTableDataList.Add(Result);
end;


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


//------------------------------------------------------------------------------
// GetNewObjectId
//------------------------------------------------------------------------------