abstypes.pas

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

    doRAND,
    doROUND,
    doSIGN,
    doSIN,
    doSQR,
    doSQRT
 );

//------------------------------------------------------------------------------
// record types
//------------------------------------------------------------------------------

 // used in ABSMemEngine for saving / loading table to stream
 TABSMemoryTableFileHeader = packed record
  Signature:            array [0..3] of char ;
  Version:              Double;
  RecordCount:          TABSRecordNo;
  // compression params
  UncompressedSize:     Int64;
  NumBlocks:            Int64;
  BlockSize:            Integer;
  CompressionAlgorithm: Byte;
  CompressionMode:      Byte;
  NameLength:           Byte;
 end; // 43 bytes

 TABSIndexPosition = TObject;
 TABSSearchInfo = Pointer;

  // bookmark information type
  TABSBookmarkFlag = (abfCurrent, abfBOF, abfEOF, abfInserted);
  TABSBookmarkInfo = packed record
   BookmarkData: TABSRecordID;      // record ID
   BookmarkFlag: TABSBookmarkFlag;  // bookmark flag
  end;
  PABSBookmarkInfo = ^TABSBookmarkInfo;

 TABSSequenceValue = Int64;

 TABSTimeoutParams = record
  RetryCount:   Word;
  Timeout:      Integer;
 end;

 //------------------------- Search types --------------------------------------
  TABSKeyIndex = (kiLookup, kiRangeStart, kiRangeEnd, kiCurRangeStart,
    kiCurRangeEnd, kiSave);
  TABSSearchCondition = (scNone,scEqual,scLower,scGreater,scLowerEqual,scGreaterEqual);
  TABSKeySearchType = (kstFirst,kstLast,kstAny);

  PABSKeyBuffer = ^TABSKeyBuffer;
  TABSKeyBuffer = packed record
    Modified: Boolean;
    Exclusive: Boolean;
    FieldCount: Integer;
  end;

  TABSNavigationInfo = packed record
    // in
    GetRecordMode:    TABSGetRecordMode;
    IndexID:          TABSObjectID; // current index id (INVALID_OBJECT_ID if no active index)
    // in and out
    RecordID:         TABSRecordID;
    RecordBuffer:     TABSRecordBuffer;
    FirstPosition:    Boolean;
    LastPosition:     Boolean;
    // out
    GetRecordResult:  TABSGetRecordResult;
  end;

  TABSDateTimeExtractField = (dtefYear, dtefMonth, dtefDay, dtefHour, dtefMinute, dtefSecond);

////////////////////////////////////////////////////////////////////////////////
//
// TABSIndexPositionCache
//
////////////////////////////////////////////////////////////////////////////////

  TABSIndexPositionCache = class(TObject)
   public
    Position:   Pointer;      // last used position in index
    IndexID:    TABSObjectID; // last used index
    RecordID:   TABSRecordID; // last used RecordID
    TableState: Integer;      // table state actual on caching moment

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


////////////////////////////////////////////////////////////////////////////////
//
// TABSScanSearchCondition
//
////////////////////////////////////////////////////////////////////////////////

  TABSScanSearchCondition = class(TObject)
   public
    Expression:                Pointer; // if nil then KeyBuffer will be used
    // index scan key info
    Condition:                 TABSSearchCondition;
    KeyRecordBuffer:           TABSRecordBuffer; // if nil then Expression will be used
    KeyRecordBufferSize:       Integer;
    KeyFieldCount:             Integer;
    IndexID:                   TABSObjectID;
    CreatedFromExpression:     Boolean;
    ParentExpressions:         TList;
    ParentExpressionNodes:     TList;
    FExternalKeyRecordBuffer:  Boolean;
    PartialCompare:            Boolean;

    procedure ClearKeyRecordBuffer;

    constructor Create(ExternalKeyRecordBuffer: Boolean);
    destructor Destroy; override;
    procedure Assign(ScanSearchCondition: TABSScanSearchCondition);
  end;

  TABSExtractedConditionInfo = packed record
    KeyRecordBuffer:           TABSRecordBuffer;
    ExtractedExpressionNode:   Pointer;
    Expression:                Pointer; // if nil then KeyBuffer will be used
  end;
  PABSExtractedConditionInfo = ^TABSExtractedConditionInfo;

////////////////////////////////////////////////////////////////////////////////
//
// TABSScanSearchConditionArray
//
////////////////////////////////////////////////////////////////////////////////

  TABSScanSearchConditionArray = class(TObject)
   public
    Items:    array of TABSScanSearchCondition;
    Count:    Integer;

    constructor Create;
    destructor Destroy; override;
    procedure Delete(ItemNo: Integer);
    procedure AddExpression(Expression: Pointer);
    procedure AddCondition(ScanSearchCondition: TABSScanSearchCondition);
   private
    procedure TryToExtendMultiFieldIndexCondition(ConditionNo: Integer; IndexDef: Pointer; Expressions: TList);
   public
    procedure CreateIndexScanConditionsFromExpressions(IndexDefs: Pointer; SessionID: TABSSessionID);
    procedure RemoveUnusedConditionsCreatedFromExpressions(var ScanConditionNo, ScanEndConditionNo: Integer);
    procedure ExtractChosenConditionsFromExpressions(ScanConditionNo, ScanEndConditionNo: Integer);
    procedure ReturnExtractedConditionsToExpressions(ScanConditionNo, ScanEndConditionNo: Integer);
  end;

 // ORDER BY clause element
 TABSSortSpecification = record
   TableName: string;   // table or its pseudonym
   ColumnName: string;  // field name or pseudonym
   Descending: Boolean; // ASC | DESC
 end;
  

//----------------------- Field Types ------------------------------------------

 PABSDate = ^TABSDate;
 TABSDate = Integer;  // Number of days from Christmas ( -5 883 516 .. 5 883 516 )

 PABSTime = ^TABSTime;
 TABSTime = Integer; // Number of milliseconds from day begin ( 0 .. 24*60*60*1000 )

 PABSDateTime = ^TABSDateTime;
 TABSDateTime = packed record  // Total 8 byte
   Date: TABSDate;  // Number of days from Christmas ( -5 883 516 .. 5 883 516 )
   Time: TABSTime; // Number of milliseconds from day begin ( 0 .. 24*60*60*1000 )
 end;//TABSDateTime                                                = 86 400 000

 PABSLogical = ^TABSLogical;
 //TABSLogical = ByteBool;
 TABSLogical = WordBool; //TDataset using WordBool

 PABSCurrency = ^TABSCurrency;
 //TABSCurrency = Currency;
 TABSCurrency = Double;  // Overflow fix

 PABSGuid = ^TABSGuid;
 TABSGuid = TGuid;

//------------------------------------------------------------------------------
// Delphi 4,5 types
//------------------------------------------------------------------------------

{$IFNDEF D6H}
 PWord = ^Word;
 PInteger = ^Integer;
 PByte = ^Byte;
 PCardinal = ^Cardinal;
{$ENDIF}

TABSIntegerArray = class;

TABSPagesArray = TABSIntegerArray;


////////////////////////////////////////////////////////////////////////////////
//
// TABSIntegerArray
//
////////////////////////////////////////////////////////////////////////////////

 TABSIntegerArray = class(TObject)
   public
     Items:          array of Integer;
     ItemCount:      Integer;
     AllocBy:        Integer;
     deAllocBy:      Integer;
     MaxAllocBy:     Integer;
     AllocItemCount: Integer;

     constructor Create(
      size: Integer = 0;
      DefaultAllocBy: Integer = 10;
      MaximumAllocBy: Integer = 100
     );
     destructor Destroy; override;
     procedure SetSize(newSize: Integer);
     procedure Assign(v: TABSIntegerArray);
     procedure Append(value: Integer);
     procedure Insert(ItemNo: Integer; value: Integer);
     procedure Delete(ItemNo: Integer);
     procedure MoveTo(itemNo, newItemNo: Integer);
     procedure CopyTo(
                      var ar: array of Integer;
                      itemNo, iCount: Integer
                      );
     function IsValueExists(value: Integer): Boolean;
     function IndexOf(value: Integer): Integer;
 end; // TABSIntegerArray


////////////////////////////////////////////////////////////////////////////////
//
// TABSPtrArray
//
////////////////////////////////////////////////////////////////////////////////
(*
 TABSPtrArray = class(TObject)
   private
    FItems:           array of Pointer;
    FSizes:           array of Integer;
    FOverallSize:     Integer;
    FItemCount:       Integer;
    FAllocBy:         Integer;
    FDeAllocBy:       Integer;
    FMaxAllocBy:      Integer;
    FAllocItemCount:  Integer;
    FMemoryManager:   TABSMemoryManager;
   public
//     constructor Create(
//                        Size, MaxAllocBy, AllocBy, DeAllocaBy: Integer = 0;
//                        MemoryManager: TABSMemoryManager = nil
//                         );
//     destructor Destroy; override;
     procedure SetSize(NewSize: Integer); virtual; abstract;
     procedure Append(
                      Buffer:     Pointer;
                      BufferSize: Integer;
                      CopyFlag:   Boolean = False // to copy buffer contents or not
                      ); virtual; abstract;
 end; // TABSPtrArray
*)



 TABSSortedStringPtrArray = class(TList);



////////////////////////////////////////////////////////////////////////////////
//
// Compressed Stream Block Headers Array and related stuff
//
////////////////////////////////////////////////////////////////////////////////

 TABSBLOBDescriptor = packed record
  BlockSize:             Integer; // block size
  NumBlocks:             Int64;  // number of blocks
  UncompressedSize:      Int64; // size of uncompressed data
  StartPosition:         Int64; // position in stream where first block header is stored
  CompressionAlgorithm:  Byte; // compression algorithm
  CompressionMode:       Byte; // compression mode (0-9)
  Reserved:              array [0..1] of Byte;
 end; // TABSBLOBDescriptor - 32 bytes
 PABSBLOBDescriptor = ^TABSBLOBDescriptor;

 // blob descriptor that stores for each blob value
 TABSPartialBLOBDescriptor = packed record
  NumBlocks:             Integer; // number of blocks
  UncompressedSize:      Int64; // size of uncompressed data
 end; // TABSPartialBLOBDescriptor - 8 bytes
 PABSPartialBLOBDescriptor = ^TABSPartialBLOBDescriptor;

 // blob descriptor that stores for each blob value
 TABSPartialTemporaryBLOBDescriptor = packed record
  NumBlocks:             Integer; // number of blocks
  UncompressedSize:      Int64; // size of uncompressed data
  CompressedSize:        Int64; // size of compressed data
 end; // TABSPartialTemporaryBLOBDescriptor - 8 bytes
 PABSPartialTemporaryBLOBDescriptor = ^TABSPartialTemporaryBLOBDescriptor;

 TABSCompressedStreamBlockHeader = packed record
       CompressedSize:      Integer; // packed block size
       UncompressedSize:    Integer; // unpacked block size
       Crc32:               Cardinal; // check sum for this block page
       OffsetToNextHeader:  Int64;  // offset from beginning of the compressed stream
                                    // to next block header
 end; // 20

 TABSCompressedStreamBlockHeadersArray = class
    private
     AllocBy:             Int64;
     DeAllocBy:           Int64;
     MaxAllocBy:          Int64;
     AllocItemCount:      Int64;
    public
     Items:               array of TABSCompressedStreamBlockHeader;
     Positions:           array of Int64; // block positions
     ItemCount:           Int64; // all files quantity (including deleted files)
    public
     constructor Create;
     destructor Destroy; override;
     procedure SetSize(NewSize: Int64);
     procedure AppendItem(Value: TABSCompressedStreamBlockHeader; Pos: Int64);
     function FindPosition(Pos: Int64) : Integer;
   end; // TABSCompressedStreamBlockHeadersArray


{
const
 // size in bytes of the compressed stream header (16)
 ABSCompressedStreamBlockHeaderSize = sizeof(TABSCompressedStreamHeader);
 // size in bytes of the compressed stream block header (16)
 ABSCompressedStreamBlockHeaderSize = sizeof(TABSCompressedStreamBlockHeader);
}


 TABSDiskBLOBCache = packed record
  NumBlocks:             Integer; // number of blocks
  UncompressedSize:      Int64; // size of uncompressed data
  Modified:              Boolean;
  BlobData:              PChar;
 end;// TABSDiskBLOBCache
 PABSDiskBLOBCache = ^TABSDiskBLOBCache;
 PPABSDiskBLOBCache = ^PABSDiskBLOBCache;

 TABSDiskBLOBHeader = packed record
  BlobID:                Word;
  NumBlocks:             Integer; // number of blocks
  CompressedSize:        Int64; // size of compressed data
  UncompressedSize:      Int64; // size of uncompressed data
 end;// TABSDiskBLOBHeader
 PABSDiskBLOBHeader = ^TABSDiskBLOBHeader;


 TABSPageListLink = packed record
  StartPageNo: TABSPageNo;
  StartOffset: Word;
  ItemCount: TABSPageNo;
 end;


////////////////////////////////////////////////////////////////////////////////
//
// TABSBitsArray
//
////////////////////////////////////////////////////////////////////////////////


  TABSBitsArray = class (TObject)
   private
    FBits:              PChar;
    FBitCount:          Integer; // total number of bits
    FNonZeroBitCount:   Integer; // number of bits equal to 1
    FBitsTable:         array [0..255] of byte;
   protected
    function GetNonZeroBitCount: Integer;
    procedure SetSize(NewSize: Integer);
   public
    procedure LoadFromStream(Stream: TStream);
    procedure SaveToStream(Stream: TStream);
    constructor Create;
    destructor Destroy; override;
    function GetBit(BitNo: Integer): Boolean;