begin
    if (CheckNullFlag(Parts[i].FieldNo, RecordBuffer)) then
     (KeyBuffer+Parts[i].OffsetInFullKeyBuffer)^ := BTreeKeyIsNull
    else
     begin
      (KeyBuffer+Parts[i].OffsetInFullKeyBuffer)^ := BTreeKeyIsNotNull;
      Move((RecordBuffer+Parts[i].OffsetInRecordBuffer)^,
           (KeyBuffer+Parts[i].OffsetInFullKeyBuffer+BTreeNullFlagSize)^,
           Parts[i].FullSize-BTreeNullFlagSize);
     end;
   end;
end;// MakeFullKeyFromRecordBuffer


//------------------------------------------------------------------------------
// compare two short keys in index order sense
//------------------------------------------------------------------------------
function TMYLDBRecordKeyRef.CompareShortKeys(KeyBuffer1, KeyBuffer2: PChar;
                                           MayUseFullKeys: Boolean=False;
                                           SessionID: TMYLDBSessionID = INVALID_SESSION_ID;
                                           Reference1: PChar=nil; Reference2: PChar=nil): Integer;
var
  i: Integer;
  IsNull1, IsNull2: Boolean;
  FullKey1, FullKey2: PChar;
  bGetFullKeys: Boolean;
begin
  Result := 0;
  for i := 0 to CompareFieldCount-1 do
   begin
    IsNull1 := ((KeyBuffer1 + Parts[i].OffsetInShortKeyBuffer)^ = BTreeKeyIsNull);
    IsNull2 := ((KeyBuffer2 + Parts[i].OffsetInShortKeyBuffer)^ = BTreeKeyIsNull);
    Result := CompareValueBuffersForOrder(
               KeyBuffer1 + Parts[i].OffsetInShortKeyBuffer + BTreeNullFlagSize,
               KeyBuffer2 + Parts[i].OffsetInShortKeyBuffer + BTreeNullFlagSize,
               Parts[i].DataType,
               Parts[i].DataType,
               IsNull1,
               IsNull2,
               Min(FCompareLengths[i],Parts[i].ShortSize-Parts[i].AddedSize),
               Parts[i].CaseInsensitive);

    // if short keys are equal, and cannot compare Full keys => assume equal
    if ((Result = 0) and (not MayUseFullKeys) and (Parts[i].AddedSize <> 0)) then
      break
    else
    // if short keys are equal, can compare Full keys?
    if ((Result = 0) and (MayUseFullKeys) and (Parts[i].AddedSize <> 0) and
        (Reference2 <> nil)) then
      begin
        // check whether the full strings are really equal (not only truncated)
        (KeyBuffer1 + Parts[i].OffsetInShortKeyBuffer + BTreeNullFlagSize +
        Parts[i].ShortSize - Parts[i].AddedSize-1)^ := #1;
        try
          bGetFullKeys := (CompareValueBuffersForOrder(
                 KeyBuffer1 + Parts[i].OffsetInShortKeyBuffer + BTreeNullFlagSize,
                 KeyBuffer2 + Parts[i].OffsetInShortKeyBuffer + BTreeNullFlagSize,
                 Parts[i].DataType,
                 Parts[i].DataType,
                 IsNull1,
                 IsNull2,
                 Min(FCompareLengths[i],Parts[i].ShortSize-Parts[i].AddedSize),
                 Parts[i].CaseInsensitive) <> 0);
        finally
          (KeyBuffer1 + Parts[i].OffsetInShortKeyBuffer + BTreeNullFlagSize +
           Parts[i].ShortSize - Parts[i].AddedSize-1)^ := #0;
        end;

        if (bGetFullKeys) then
          begin
            FullKey1 := AllocFullKeyBuffer;
            FullKey2 := AllocFullKeyBuffer;
            try
              // make full key 1 from assigned record buffer?
              if (Reference1 = nil) then
                MakeFullKeyFromRecordBuffer(LRecordBuffer, FullKey1)
              else
                // retreive full key2 by reference in index page
                RetrieveFullKeyByRecordID(PMYLDBRecordID(Reference1)^, FullKey1, SessionID);
              // retreive full key2 by reference in index page
              RetrieveFullKeyByRecordID(PMYLDBRecordID(Reference2)^, FullKey2, SessionID);
              Result := CompareFullKeys(FullKey1, FullKey2);
            finally
              FreeAndNilKeyBuffer(FullKey1);
              FreeAndNilKeyBuffer(FullKey2);
            end;
            break;
          end;
      end
    else
      begin
        if (Parts[i].Descending) then
         Result := -Result;

        if (Result <> 0) then
         break;
      end;
   end;
end;// CompareShortKeys


//------------------------------------------------------------------------------
// compare two keys in index order sense
//------------------------------------------------------------------------------
function TMYLDBRecordKeyRef.CompareFullKeys(KeyBuffer1, KeyBuffer2: PChar): Integer;
var
  i: Integer;
  IsNull1, IsNull2: Boolean;
begin
  Result := 0;
  for i := 0 to CompareFieldCount-1 do
   begin
    IsNull1 := ((KeyBuffer1 + Parts[i].OffsetInFullKeyBuffer)^ = BTreeKeyIsNull);
    IsNull2 := ((KeyBuffer2 + Parts[i].OffsetInFullKeyBuffer)^ = BTreeKeyIsNull);
    Result := CompareValueBuffersForOrder(
               KeyBuffer1 + Parts[i].OffsetInFullKeyBuffer + BTreeNullFlagSize,
               KeyBuffer2 + Parts[i].OffsetInFullKeyBuffer + BTreeNullFlagSize,
               Parts[i].DataType,
               Parts[i].DataType,
               IsNull1,
               IsNull2,
               FCompareLengths[i],
               Parts[i].CaseInsensitive);
    if (Parts[i].Descending) then
     Result := -Result;
    if (Result <> 0) then
     break;
   end;
end;// CompareFullKeys


//------------------------------------------------------------------------------
// SetPartialCompare
//------------------------------------------------------------------------------
procedure TMYLDBRecordKeyRef.SetPartialCompare(RecordBuffer: PChar; PartialCompare: Boolean);
var
  i: Integer;
begin
  for i := 0 to PartCount-1 do
    begin
      if PartialCompare and (not CheckNullFlag(Parts[i].FieldNo, RecordBuffer)) then
        begin
          if (IsStringFieldType(Parts[i].DataType)) then
            if (IsWideStringFieldType(Parts[i].DataType)) then
              FCompareLengths[i] := Length(WideString(PWideChar(RecordBuffer+Parts[i].OffsetInRecordBuffer)))
            else
              FCompareLengths[i] := StrLen(RecordBuffer+Parts[i].OffsetInRecordBuffer)
          else
            FCompareLengths[i] := -1;
        end
      else
        FCompareLengths[i] := -1;
    end;
end;// SetPartialCompare




////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBPageKeyRef
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// Create
//------------------------------------------------------------------------------
constructor TMYLDBPageKeyRef.Create;
begin
  PartCount := 1;
  Parts[0].OffsetInShortKeyBuffer := 0;
  Parts[0].OffsetInFullKeyBuffer := 0;
  Parts[0].ShortSize := sizeof(TMYLDBPageNo);
  Parts[0].FullSize := sizeof(TMYLDBPageNo);
  Parts[0].AddedSize := 0;
  Parts[0].DataType := bftSignedInt32;
  Parts[0].Descending := False;
  FShortKeySize := sizeof(TMYLDBPageNo);
  FFullKeySize := sizeof(TMYLDBPageNo);
  FKeyIsReference := False;
  FReferenceSize := sizeof(Word);
end;// Create


//------------------------------------------------------------------------------
// CompareShortKeys
//------------------------------------------------------------------------------
function TMYLDBPageKeyRef.CompareShortKeys(KeyBuffer1, KeyBuffer2: PChar;
                          MayUseFullKeys: Boolean=False;
                          SessionID: TMYLDBSessionID = INVALID_SESSION_ID;
                          Reference1: PChar=nil; Reference2: PChar=nil): Integer;
begin
  if (PMYLDBPageNo(KeyBuffer1)^ < PMYLDBPageNo(KeyBuffer2)^) then
    Result := -1
  else
  if (PMYLDBPageNo(KeyBuffer1)^ > PMYLDBPageNo(KeyBuffer2)^) then
    Result := 1
  else
    Result := 0;
end;// CompareShortKeys


//------------------------------------------------------------------------------
// CompareFullKeys
//------------------------------------------------------------------------------
function TMYLDBPageKeyRef.CompareFullKeys(KeyBuffer1, KeyBuffer2: PChar): Integer;
begin
  Result := CompareShortKeys(KeyBuffer1, KeyBuffer2);
end;// CompareFullKeys




////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBBTreePageController
//
////////////////////////////////////////////////////////////////////////////////

//------------------------------------------------------------------------------
// get IsRoot
//------------------------------------------------------------------------------
function TMYLDBBTreePage.GetIsRoot: Boolean;
begin
  Result := PMYLDBBTreePageHeader(PageData)^.IsRoot;
end;// GetIsRoot


//------------------------------------------------------------------------------
// set IsRoot
//------------------------------------------------------------------------------
procedure TMYLDBBTreePage.SetIsRoot(Value: Boolean);
begin
  PMYLDBBTreePageHeader(PageData)^.IsRoot := Value;
end;// SetIsRoot


//------------------------------------------------------------------------------
// get IsLeaf
//------------------------------------------------------------------------------
function TMYLDBBTreePage.GetIsLeaf: Boolean;
begin
  Result := PMYLDBBTreePageHeader(PageData)^.IsLeaf;
end;// GetIsLeaf


//------------------------------------------------------------------------------
// set IsLeaf
//------------------------------------------------------------------------------
procedure TMYLDBBTreePage.SetIsLeaf(Value: Boolean);
begin
  PMYLDBBTreePageHeader(PageData)^.IsLeaf := Value;
end;// SetIsLeaf


//------------------------------------------------------------------------------
// get Left page No
//------------------------------------------------------------------------------
function TMYLDBBTreePage.GetLeftPageNo: TMYLDBPageNo;
begin
  Result := PMYLDBBTreePageHeader(PageData)^.LeftPageNo;
end;// GetLeftPageNo


//------------------------------------------------------------------------------
// set LeftPageNo
//------------------------------------------------------------------------------
procedure TMYLDBBTreePage.SetLeftPageNo(Value: TMYLDBPageNo);
begin
  PMYLDBBTreePageHeader(PageData)^.LeftPageNo := Value;
end;// SetLeft


//------------------------------------------------------------------------------
// get right PageNo
//------------------------------------------------------------------------------
function TMYLDBBTreePage.GetRightPageNo: TMYLDBPageNo;
begin
  Result := PMYLDBBTreePageHeader(PageData)^.RightPageNo;
end;// GetRightPageNo


//------------------------------------------------------------------------------
// set Right PageNo
//------------------------------------------------------------------------------
procedure TMYLDBBTreePage.SetRightPageNo(Value: TMYLDBPageNo);
begin
  PMYLDBBTreePageHeader(PageData)^.RightPageNo := Value;
end;// SetRightPageNo


//------------------------------------------------------------------------------
// get (page has keys or only references?)
//------------------------------------------------------------------------------
function TMYLDBBTreePage.GetHasKeys: Boolean;
begin
  Result := PMYLDBBTreePageHeader(PageData)^.HasKeys;
end;// GetHasKeys


//------------------------------------------------------------------------------
// set HasKeys
//------------------------------------------------------------------------------
procedure TMYLDBBTreePage.SetHasKeys(Value: Boolean);
begin
  PMYLDBBTreePageHeader(PageData)^.HasKeys := Value;
end;// SetHasKeys


//------------------------------------------------------------------------------
// get (key has suffix?)
//-