); override;
    function CreateSearchInfo: TMYLDBSearchInfo; override;
    procedure FreeSearchInfo(SearchInfo: TMYLDBSearchInfo); override;
   private
    function GetCurrentPosition(
                                 SessionID:           TMYLDBSessionID;
                                 Restart:             Boolean;
                                 GoForward:           Boolean;
                                 StartScanCondition:  TMYLDBScanSearchCondition;
                                 RecordBuffer:        TMYLDBRecordBuffer;
                                 RecordID:            TMYLDBRecordID;
                                 SearchInfo:          TMYLDBSearchInfo
                               ): Boolean;
    function GetEndPosition(
                                 SessionID:           TMYLDBSessionID;
                                 GoForward:           Boolean;
                                 StartScanCondition:  TMYLDBScanSearchCondition;
                                 EndScanCondition:    TMYLDBScanSearchCondition;
                                 SearchInfo:          TMYLDBSearchInfo
                               ): Boolean;
   public
    function FindRecord(
                       SessionID:           TMYLDBSessionID;
                       Restart:             Boolean;
                       GoForward:           Boolean;
                       StartScanCondition:  TMYLDBScanSearchCondition;
                       EndScanCondition:    TMYLDBScanSearchCondition;
                       RecordBuffer:        TMYLDBRecordBuffer;
                       var RecordID:        TMYLDBRecordID;
                       SearchInfo:          TMYLDBSearchInfo
                       ): Boolean; override;
    // return 0 if record buffers are equal in this index
    // return 1 if Buffer1 is higher than Buffer 2 (Pos1 > Pos2)
    // return -1 if Buffer1 is lower than Buffer 2 (Pos1 < Pos2)
    function CompareRecordBuffersByIndex(
                        Buffer1: TMYLDBRecordBuffer;
                        Buffer2: TMYLDBRecordBuffer;
                        IndexFieldCount: Integer
                                        ): Integer; override;

    // return 0 if conditions are equal in this index
    // return 1 if Condition1 is higher than Condition2
    // return -1 if Condition1 is lower than Condition2
    function CompareConditions(
                    Condition1:   TMYLDBScanSearchCondition;
                    Condition2:   TMYLDBScanSearchCondition
                              ): Integer; override;
    // approximate record count between range conditions
    function GetApproxRangeRecordCount(
                    SessionID:         TMYLDBSessionID;
                    TableRecordCount:  TMYLDBRecordNo;
                    RangeCondition1:   TMYLDBScanSearchCondition;
                    RangeCondition2:   TMYLDBScanSearchCondition
                                      ): TMYLDBRecordNo; override;

    function CanInsertRecord(
                    SessionID:      TMYLDBSessionID;
                    RecordBuffer:   TMYLDBRecordBuffer
                            ): Boolean; override;
    function CanUpdateRecord(
                    SessionID:                        TMYLDBSessionID;
                    OldRecordBuffer, NewRecordBuffer: TMYLDBRecordBuffer
                            ): Boolean; override;
    procedure InsertRecord(Cursor: TMYLDBCursor); override;
    procedure UpdateRecord(Cursor: TMYLDBCursor; BeforeNewRecordIsStored: Boolean); override;
    procedure DeleteRecord(Cursor: TMYLDBCursor); override;

    function GetMaxEntriesPerPage: Integer; override;
    procedure GetRecordIDByIndexPosition(SessionID: TMYLDBSessionID; IndexPos: TMYLDBIndexPosition; var RecordID: TMYLDBRecordID); override;

    property KeyRef: TMYLDBRecordKeyRef read FKeyRef;
  end; // TMYLDBBTreeRecordIndex


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBBTreePageIndex
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBBTreePageIndex = class (TObject)
   protected
    FRootPageNo:        TMYLDBPageNo;
    FKeyRef:            TMYLDBPageKeyRef;
    LPageManager:       TMYLDBPageManager;
    FMaxRecordsOnPage:  Integer;

    function AddIndexPage(SessionID: TMYLDBSessionID): TMYLDBBTreePage;
    function GetIndexPage(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo): TMYLDBBTreePage;
    procedure PutIndexPage(Page: TMYLDBBTreePage);
    function GetFirstPosition(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath): Boolean;
    function GetLastPosition(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath): Boolean;
    function GetNextPosition(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath): Boolean;
    function GetPriorPosition(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath): Boolean;
    function GetPosition(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo; Position: TMYLDBKeyPath): Boolean;
    function GetPageValue(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath): Word;
    procedure SetPageValue(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath; Value: Word);
    function GetPageNo(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath): TMYLDBPageNo;
    function CanAddNewItem(OldValue: Integer; NewItemSize: Integer): Boolean; virtual; abstract;
    function FindPageForNewItem(SessionID: TMYLDBSessionID; ItemSize: Integer; var PageNo: TMYLDBPageNo): Boolean;
    procedure AddPageItem(SessionID: TMYLDBSessionID; ItemSize: Integer; PageNo: TMYLDBPageNo);
    procedure DeletePageItem(SessionID: TMYLDBSessionID; ItemSize: Integer; PageNo: TMYLDBPageNo; NewItemCount: Integer);

   public
    constructor Create(PageManager: TMYLDBPageManager);
    destructor Destroy; override;

    procedure CreateIndex(SessionID: TMYLDBSessionID);
    procedure DropIndex(SessionID: TMYLDBSessionID);
    procedure EmptyIndex(SessionID: TMYLDBSessionID);
    procedure OpenIndex(RootPageNo: TMYLDBPageNo);

    property KeyRef: TMYLDBPageKeyRef read FKeyRef;
    property RootPageNo: TMYLDBPageNo read FRootPageNo;
  end; // TMYLDBBTreePageIndex


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBBTreeRecordPageIndex
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBBTreeRecordPageIndex = class (TMYLDBBTreePageIndex)
   private
    FMaxRecordsOnPage:  Integer;

    function GetPageRecordCount(SessionID: TMYLDBSessionID; Position: TMYLDBKeyPath): Word;

   protected
    function CanAddNewItem(OldValue: Integer; NewItemSize: Integer): Boolean; override;

   public
    function FindPageForNewRecord(SessionID: TMYLDBSessionID; var PageNo: TMYLDBPageNo): Boolean;
    procedure AddRecord(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo; AddCount: Integer = 1);
    procedure DeleteRecord(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo; NewItemCount: Integer);

    function GetFirstRecordPage(SessionID: TMYLDBSessionID; var PageNo: TMYLDBPageNo): Boolean;
    function GetLastRecordPage(SessionID: TMYLDBSessionID; var PageNo: TMYLDBPageNo): Boolean;
    function GetNextRecordPage(SessionID: TMYLDBSessionID; CurrentPageNo: TMYLDBPageNo; var NextPageNo: TMYLDBPageNo): Boolean;
    function GetPriorRecordPage(SessionID: TMYLDBSessionID; CurrentPageNo: TMYLDBPageNo; var PriorPageNo: TMYLDBPageNo): Boolean;

    procedure GetRecordByRecNo(SessionID: TMYLDBSessionID; RecNo: TMYLDBRecordNo; var PageNo: TMYLDBPageNo; var RecNoOnPage: Integer);
    procedure GetRecNoByRecord(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo; RecNoOnPage: Integer; var RecNo: TMYLDBRecordNo);

    procedure Validate(SessionID: TMYLDBSessionID; StoredRecordCount: Integer);

    property MaxRecordsOnPage: Integer read FMaxRecordsOnPage write FMaxRecordsOnPage;
  end; // TMYLDBBTreeRecordPageIndex


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBBTreeBlobPageIndex
//
////////////////////////////////////////////////////////////////////////////////

  TMYLDBBTreeBlobPageIndex = class (TMYLDBBTreePageIndex)
   protected
    function CanAddNewItem(OldValue: Integer; NewItemSize: Integer): Boolean; override;

   public
    function FindPageForNewBlob(SessionID: TMYLDBSessionID; BlobSize: Integer; var PageNo: TMYLDBPageNo): Boolean;
    procedure AddBlob(SessionID: TMYLDBSessionID; BlobSize: Integer; PageNo: TMYLDBPageNo);
    procedure DeleteBlob(SessionID: TMYLDBSessionID; BlobSize: Integer; PageNo: TMYLDBPageNo);
    function GetBlobPageAllocatedSpace(SessionID: TMYLDBSessionID; PageNo: TMYLDBPageNo): Integer;
  end; // TMYLDBBTreeBlobPageIndex


implementation

uses MYLDBLocalEngine;

////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBBTreeKeyPath
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------
constructor TMYLDBKeyPath.Create;
begin
  Clear;
end;// Create


//------------------------------------------------------------------------------
// Clear
//------------------------------------------------------------------------------
procedure TMYLDBKeyPath.Clear;
begin
  Count := 0;
  ItemNo := 0;
end;// Clear


//------------------------------------------------------------------------------
// Assign
//------------------------------------------------------------------------------
procedure TMYLDBKeyPath.Assign(KeyPath: TMYLDBKeyPath);
begin
  Count := KeyPath.Count;
  ItemNo := KeyPath.ItemNo;
  PositionType := KeyPath.PositionType;
  IndexState := KeyPath.IndexState;
  Move(KeyPath.Items[0], Items[0], Count * sizeof(Items[0]));
end;// Assign


//------------------------------------------------------------------------------
// AddItem
//------------------------------------------------------------------------------
procedure TMYLDBKeyPath.AddItem(aPageNo: TMYLDBPageNo; aEntryNo, aEntryCount: Integer);
begin
  Items[ItemNo].PageNo := aPageNo;
  Items[ItemNo].EntryNo := aEntryNo;
  Items[ItemNo].EntryCount := aEntryCount;
  Inc(ItemNo);
  Inc(Count);
end;// AddItem


//------------------------------------------------------------------------------
// DeleteLastItem
//------------------------------------------------------------------------------
procedure TMYLDBKeyPath.DeleteLastItem;
begin
  Dec(ItemNo);
  Dec(Count);
end;// DeleteLastItem


//------------------------------------------------------------------------------
// IncLevel
//------------------------------------------------------------------------------
procedure TMYLDBKeyPath.IncLevel;
begin
  Inc(ItemNo);
end;// IncLevel


//------------------------------------------------------------------------------
// DecLevel
//------------------------------------------------------------------------------
procedure TMYLDBKeyPath.DecLevel;
begin
  Dec(ItemNo);
end;// DecLevel

//------------------------------------------------------------------------------
// GetCurrentPageNo
//------------------------------------------------------------------------------
function TMYLDBKeyPath.GetCurrentPageNo: TMYLDBPageNo;
begin
  Result := Items[ItemNo].PageNo;
end;// GetCurrentPageNo


//------------------------------------------------------------------------------
// SetCurrentPageNo
//------------------------------------------------------------------------------
procedure TMYLDBKeyPath.SetCurrentPageNo(Value: TMYLDBPageNo);
begin
  Items[ItemNo].PageNo := Value;
end;// SetCurrentPageNo


//------------------------------------------------------------------------------
// PageExists
//------------------------------------------------------------------------------
function TMYLDBKeyPath.PageExists(aPageNo: TMYLDBPageNo): Boolean;
var
  i: Integer;
begin
  Result := False;
  for i := 0 to Count-1 do
   if (Items[i].PageNo = aPageNo) then
    begin
     Result := True;
     break;
    end;
end;// PageExists


//------------------------------------------------------------------------------
// return 0, 1, -1 if (Self = aKeyPath), (Self > aKeyPath), (Self < aKeyPath)
//------------------------------------------------------------------------------
function TMYLDBKeyPath.Compare(aKeyPath: TMYLDBKeyPath): Integer;
var
  i: Integer;
begin
  if (Count <> aKeyPath.Count) then
   raise EMYLDBException.Create(20051, ErrorAInvalidIndexKeyPath);
  Result := 0;
  for i := 0 to Count-1 do
   begin
     if (Items[i].PageNo <> aKeyPath.Items[i].PageNo) then
      raise EMYLDBException.Create(20052, ErrorAInvalidIndexKeyPath);
     if (Items[i].EntryNo < aKeyPath.Items[i].EntryNo) then
      begin
       Result := -1;
       break;
      end
     else
      if (Items[i].EntryNo > aKeyPath.Items[i].EntryNo) then
       begin
        Result := 1;
        break;
       end;
   end;
end;// Compare