absbtree.pas

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

                                           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(PABSRecordID(Reference1)^, FullKey1, SessionID);
              // retreive full key2 by reference in index page
              RetrieveFullKeyByRecordID(PABSRecordID(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 TABSRecordKeyRef.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 TABSRecordKeyRef.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




////////////////////////////////////////////////////////////////////////////////
//
// TABSPageKeyRef
//
////////////////////////////////////////////////////////////////////////////////


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


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


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




////////////////////////////////////////////////////////////////////////////////
//
// TABSBTreePageController
//
////////////////////////////////////////////////////////////////////////////////

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


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


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


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


//------------------------------------------------------------------------------
// get Left page No
//------------------------------------------------------------------------------
function TABSBTreePage.GetLeftPageNo: TABSPageNo;
begin
  Result := PABSBTreePageHeader(PageData)^.LeftPageNo;
end;// GetLeftPageNo


//------------------------------------------------------------------------------
// set LeftPageNo
//------------------------------------------------------------------------------
procedure TABSBTreePage.SetLeftPageNo(Value: TABSPageNo);
begin
  PABSBTreePageHeader(PageData)^.LeftPageNo := Value;
end;// SetLeft


//------------------------------------------------------------------------------
// get right PageNo
//------------------------------------------------------------------------------
function TABSBTreePage.GetRightPageNo: TABSPageNo;
begin
  Result := PABSBTreePageHeader(PageData)^.RightPageNo;
end;// GetRightPageNo


//------------------------------------------------------------------------------
// set Right PageNo
//------------------------------------------------------------------------------
procedure TABSBTreePage.SetRightPageNo(Value: TABSPageNo);
begin
  PABSBTreePageHeader(PageData)^.RightPageNo := Value;
end;// SetRightPageNo


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


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


//------------------------------------------------------------------------------
// get (key has suffix?)
//------------------------------------------------------------------------------
function TABSBTreePage.GetHasSuffixes: Boolean;
begin
  Result := PABSBTreePageHeader(PageData)^.HasSuffixes;
end;// GetHasSuffixes


//------------------------------------------------------------------------------
// set KeyHasSuffix
//------------------------------------------------------------------------------
procedure TABSBTreePage.SetHasSuffixes(Value: Boolean);
begin
  PABSBTreePageHeader(PageData)^.HasSuffixes := Value;
end;// SetHasSuffixes


//------------------------------------------------------------------------------
// get key prefix size
//------------------------------------------------------------------------------
function TABSBTreePage.GetKeyPrefixSize: Word;
begin
  Result := PABSBTreePageHeader(PageData)^.KeyPrefixSize;
end;// GetKeyPrefixSize


//------------------------------------------------------------------------------
// set key prefix size
//--------------------------------------