dsintf.pas

多数代码可以直接在Delphi6和Delphi7环境下运行。部分涉及.NET技术内容的代码

        pFld1     : Pointer;        { NULL if blank }
        pFld2     : Pointer;        { NULL if blank }
        iUnits1   : LongWord;
        iUnits2   : LongWord
    ): Integer; stdcall;

    function GetProp(               { Get property }
        eProp       : DSProp;
        piPropValue : Pointer
    ): DBResult; stdcall;

    function SetProp(               { Set property }
        eProp      : DSProp;
        iPropValue : LongWord
    ): DBResult; stdcall;

    function SetFieldCalculation(   { Register fieldcalculation on this field }
        iClientData  : LongWord;       { Client data }
        pfCalc       : pfDSCalcField { Callback function, NULL to remove }
    ): DBResult; stdcall;

    function Reconcile(             { Reconcile update errors }
        DeltaPacket   : PSafeArray; { Delta data packet }
        ErrorPacket   : PSafeArray; { NULL if all changes accepted }
        iClientData   : LongWord;
        pfReconcile   : pfDSReconcile { Callback-fn (called for each error) }
    ): DBResult; stdcall;

    { Place Holders for aggregate functions that were moved into DSCursor }
    function Reserved1(Input: Pointer): DBResult; stdcall;
    function Reserved2(Input: Pointer): DBResult; stdcall;
    function Reserved3(Input: Pointer): DBResult; stdcall;

    function Refresh(               { Refresh dataset }
        NewPacket    : PSafeArray;  { New updated packet }
        iClientData  : LongWord;       { Client data }
        pfReconcile  : pfDSReconcile { Callback for resolving conflicts }
    ): DBResult; stdcall;

    function Reset: DBResult; stdcall; { Remove all data from dataset }

    function RollBack(              { Rollback changes to this savepoint }
        iSavePoint  : SAVEPOINT
    ): DBResult; stdcall;

    function GetEmbeddedDS(
        iFieldID  : LongWord;          { FieldID of embedded table (0 : get the first one) }
    out DsDet     : IDSBase         { Returns the ds of the embedded table }
    ): DBResult; stdcall;

    function MakeEmbedded(
        DsDet             : IDSBase;  { Embed this dataset }
        iFieldsLink       : LongWord;
        piFieldsM         : PLongWord;   { Fields in Master }
        piFieldsD         : PLongWord;   { Fields in Detail }
        pMasterFieldName  : PChar;    { Name of new link field in master, NULL if using default name }
        pDetailFieldName  : PChar     { Name of new link field in detail, NULL if using defaultname }
    ): DBResult; stdcall;

    function RefreshRecords(            { Refresh specific records }
        NewDataPacket   : PSafeArray;   { Datapacket containing refreshed records }
        iRecNo          : LongWord;        { Refresh this specific record (0 if more than one.Unique key req.) }
        iClientData     : LongWord;
        pfReconcile     : pfDSReconcile { (NULL) Callback for resolving conflicts }
    ): DBResult; stdcall;

    function ReleaseBlobs(          { Release all uncommitted blobs }
        iBlobId  : LongWord            { 0: all uncommitted blobs, otherwise : specific blob }
    ): DBResult; stdcall;

    function Clone(                 { Clones the structure of the dsbase, including details if any }
         iPType : LongWord;            { 0:normal-ds, 1:delta-ds, 2:error-ds }
         bRecurse : LongBool;           { TRUE:create complete tree-structure }
         bCloneOptParams: LongBool;     { TRUE:clone all optional parameters (normal only) }
         var DataSet: IDSBase       { Returned dsbase }
    ): DBResult; stdcall;

    function Reconcile_MD(
        pDsRec          : IDSBase;           { Ds for info }
        pDeltaPacket    : PSafeArray;        { Delta pickle }
        pErrorPacket    : PSafeArray;        { NULL if all changes accepted }
        iClientData     : LongWord;
        pfReconcile_MD  : pfDSReconcile_MD   { Callback-fn (called for each error) }
    ): DBResult; stdcall;

   function DropOptParameter(
           iFldNo: LongWord;    { 0 if not field attribute }
           pName: PChar      { Name of attribute to delete }
        ): DBResult; stdcall;
  end;

{ IDSCursor }

  IDSCursor = interface(IUnknown)
    ['{9E8D2FA4-591C-11D0-BF52-0020AF32BD64}']

    function InitCursor(            { Associate Cursor with a DataSet }
       DataSet: IDSBase
    ): DBResult; stdcall;

    function CloneCursor(           { Clone cursor from cursor }
       Cursor: IDSCursor
    ): DBResult; stdcall;

    function GetCursorProps(        { Get cursor properties }
    var p1: DSProps
    ): DBResult; stdcall;

    function GetIndexDescs(         { Get index descriptors }
        bCurrentOnly  : LongBool;       { Only return 'current' indexdesc, otherwise all }
    var IdxDesc       : DSIDXDesc
    ): DBResult; stdcall;

    function GetFieldDescs(         { Get field descriptors }
        p1  : pDSFLDDesc
    ): DBResult; stdcall;

    function GetCurrentRecord(      { Return record at current cursorposition }
        pRecBuf  : Pointer
    ): DBResult; stdcall;

    function GetRecordBlock(        { Return block of records }
        piRecs   : PLongWord;
        pRecBuf  : Pointer
    ): DBResult; stdcall;

    function GetCurrentBookMark(    { Get bookmark for current position }
        pBookMark  : Pointer
    ): DBResult; stdcall;

    function GetSequenceNumber(     { Get Sequence number of current position }
    var iSeq  : LongWord
    ): DBResult; stdcall;

    function GetRecordAttribute(    { Get record attribute of current position }
    var Attr  : DSAttr
    ): DBResult; stdcall;

    function GetRecordCount(        { Number of records in active view }
    var iRecs  : Integer
    ): DBResult; stdcall;

    function MoveToBOF: DBResult; stdcall; { Set to beginning of table (BOF) }

    function MoveToEOF: DBResult; stdcall; { Set to end of table (EOF) }

    function MoveRelative(i: Integer): DBResult; stdcall;

    function MoveToSeqNo(i: LongWord): DBResult; stdcall;

    function MoveToBookMark(        { Goto bookmark }
      pBookMark: Pointer
    ): DBResult; stdcall;

    function MoveToKey(             { Goto key }
        SearchCond  : DBSearchCond;
        iFields     : LongWord;
        iPartLen    : LongWord;
        pRecBuf     : Pointer
    ): DBResult; stdcall;


    function CompareBookMarks(      { Compare two bookmark (positions) -1, 0, 1 }
        pBookMark1  : Pointer;
        pBookMark2  : Pointer;
    var iCmp        : Integer
    ): DBResult; stdcall;

    function ExtractKey(            { Extract key from record }
        pRecBuf  : Pointer;
        pKeyBuf  : Pointer
    ): DBResult; stdcall;

    function GetRecordForKey(       { Return (first) record with given key }
        iFields   : LongWord;
        iPartLen  : LongWord;
        pKey      : Pointer;
        pRecBuf   : Pointer
    ): DBResult; stdcall;

    function GetField(              { Extract field value from record buffer }
        pRecBuf   : Pointer;
        iFieldNo  : LongWord;
        pFldBuf   : Pointer;
    var bBlank    : LongBool            { Returns TRUE/FALSE if blank }
    ): DBResult; stdcall;

    function PutField(              { Put field value into record buffer }
        pRecBuf   : Pointer;
        iFieldNo  : LongWord;
        pFldBuf   : Pointer         { If NULL, adds a blank value }
    ): DBResult; stdcall;

    { Blob functions }

    function GetBlobLen(            { Return length of blob }
        pRecBuf   : Pointer;
        iFieldNo  : LongWord;
    var iLength   : LongWord
    ): DBResult; stdcall;

    function GetBlob(               { Return blob }
        pRecBuf   : Pointer;
        iFieldNo  : LongWord;
        iOffSet   : LongWord;          { Starting position }
        pBuf      : Pointer;
    var iLength   : LongWord          { No of bytes to be read/ returns number read }
    ): DBResult; stdcall;

    function PutBlob(               { Write blob data }
        pRecBuf   : Pointer;
        iFieldNo  : LongWord;
        iOffSet   : LongWord;          { Starting position }
        pBuf      : Pointer;
        iLength   : LongWord
    ): DBResult; stdcall;

    function InitRecord(            { Initialize record buffer (for insertion) }
        pRecBuf  : Pointer
    ): DBResult; stdcall;

    function DeleteRecord: DBResult; stdcall; { Delete current record }

    function ModifyRecord(          { Modify current record }
        pRecBuf  : Pointer
    ): DBResult; stdcall;

    function InsertRecord(          { Insert new record }
        pRecBuf  : Pointer
    ): DBResult; stdcall;

    function UndoLastChange(        { Undo last update }
        bFollowChange  : LongBool
    ): DBResult; stdcall;

    function AddFilter(             { Add a canexpr-filter to this cursor }
        pcanExpr  : Pointer;        { Can expr }
        iLen      : LongWord;          { Length of canexpr }
    var hFilter   : hDSFilter
    ): DBResult; stdcall;

    function DropFilter(            { Drop a filter }
       hFilter  : hDSFilter
    ): DBResult; stdcall;

    function SetRange(              { Set a range on a cursor }
        iFields    : LongWord;
        pKey1      : Pointer;
        bKey1Incl  : LongBool;
        pKey2      : Pointer;
        bKey2Incl  : LongBool
    ): DBResult; stdcall;

    function DropRange: DBResult; stdcall; { Remove current range }

    function SortOnFields(          { Sort on fields }
        iFields    : LongWord;
        piFields   : PLongWord;        { NULL -> all fields }
        pDescending: PLongBool;         { NULL -> all ascending }
        pCaseInsensitive: PLongBool     { NULL -> all case-sensitive }
    ): DBResult; stdcall;

    function UseIndexOrder(         { Switch to index order }
        pszName  : PChar
    ): DBResult; stdcall;

    function SetNotifyCallBack(     { Called when posting changes to dataset }
        iClientData  : LongWord;
        pfCallBack   : pfCHANGECallBack   { Call back fn being registered }
    ): DBResult; stdcall;

    function AddFilterCallBack(     { Add a canexpr-filter to this cursor }
        iClientData  : LongWord;     { Client supplied data }
        pfFilter     : pfDSFilter;  { ptr to filter function }
    var hFilter      : hDSFilter
    ): DBResult; stdcall;

    function VerifyField(           { Verify if field value is valid }
        iFieldNo  : LongWord;
        pFldBuf   : Pointer
    ): DBResult; stdcall;

    function GetProp(               { Get property }
        eProp        : CURProp;
        piPropValue  : Pointer
    ): DBResult; stdcall;

    function RevertRecord: DBResult; stdcall; { Restore current record }

    function LocateWithFilter(
        pCanExpr  : Pointer;        { NULL -> use previous }
        iLen      : LongWord           { Length of canexpr }
    ): DBResult; stdcall;

    function AddAggregate(
        iFlds     : LongWord;          { Defines grouping  (0 if global) }
        iCanLen   : LongWord;          { Length of canexpr (0 if grouping only) }
        pCanExpr  : Pointer;        { Canexpression for aggregate }
    var hAgg      : hDSAggregate    { returns aggregate handle }
    ): DBResult; stdcall;

    function DropAggregate(
        hAgg  : hDSAggregate
    ): DBResult; stdcall;

    function GetAggregateValue(
        hAgg     : hDSAggregate;
        pValue   : Pointer;
    var bBlank   : LongBool
    ): DBResult; stdcall;

    function GetAggregateDesc(
        hAgg   : hDSAggregate;
    var Desc   : DSFLDDesc
    ): DBResult; stdcall;

    function MoveToNextSubGroup(
        iFields  : LongWord
    ): DBResult; stdcall;