bde.int

Delphi7官方文档-英文 对于英文好的delphi程序员来说 这个是你的至宝！

    opFILLER1,                          { Filler to make first one 3 }
    opFILLER2,                          { Filler to make first one 3 }
    opDBCREATE,
    opDBOPEN,
    opTBLCREATE,
    opTBLOPEN
  );

type
  pDRVType = ^DRVType;
  DRVType = packed record               { Driver Description/Capabilities }
    szType          : DBINAME;          { Symbolic name to identify }
    szText          : DBINAME;          { Descriptive text }
    edrvCat         : DRVCat;           { Driver category }
    bTrueDb         : WordBool;         { Supports True Db concept }
    szDbType        : DBINAME;          { Db Type to be used }
    bMultiUser      : WordBool;         { Supports Multi-user access }
    bReadWrite      : WordBool;         { Read Write or Read-only }
    bTrans          : WordBool;         { Supports Transactions }
    bPassThruSQL    : WordBool;         { Supports Pass-thru SQL }
    bLogIn          : WordBool;         { Requires explicit login }
    bCreateDb       : WordBool;         { Can reate a Database }
    bDeleteDb       : WordBool;         { Can drop database }
    bCreateTable    : WordBool;         { Can create a Table }
    bDeleteTable    : WordBool;         { Can delete a Table }
    bMultiplePWs    : WordBool;         { Multiple passwords }
    iDriverVersion  : Word;             { Driver version 1..n }
    bSQLRowid       : WordBool;         { Supports SQL rowid }
    iUnUsed         : packed array [0..14] of Word;
  end;


  pTBLType = ^TBLType;
  TBLType = packed record               { Table Capabilities }
    iId             : Word;             { Id of Table Type }
    szName          : DBINAME;          { Symbolic name; eg "dBASE" }
    szText          : DBINAME;          { Descriptive text }
    szFormat        : DBINAME;          { Format; eg "HEAP" }
    bReadWrite      : WordBool;         { User can Read/Write }
    bCreate         : WordBool;         { Can create new tables }
    bRestructure    : WordBool;         { Can restructure this table }
    bValChecks      : WordBool;         { Val Checks can be specified }
    bSecurity       : WordBool;         { Can be protected }
    bRefIntegrity   : WordBool;         { Can participate in ref integrity }
    bPrimaryKey     : WordBool;         { Supports primary key concept }
    bIndexing       : WordBool;         { Can have other indexes }
    iFldTypes       : Word;             { Number of Phy Field types supported }
    iMaxRecSize     : Word;             { Max record size }
    iMaxFldsInTable : Word;             { Max fields in a table }
    iMaxFldNameLen  : Word;             { Maximum field name length }
    iTblLevel       : Word;             { Driver dependent table level (version) }
    iUnUsed         : packed array [0..15] of Word;
  end;


  pIDXType = ^IDXType;
  IDXType = packed record
    iId             : Word;             { Id of Index Type }
    szName          : DBINAME;          { Symbolic name }
    szText          : DBINAME;          { Descriptive text }
    szFormat        : DBINAME;          { Optional format(BTREE, HASH etc) }
    bComposite      : WordBool;         { Supports composite keys }
    bPrimary        : WordBool;         { True, if primary index }
    bUnique         : WordBool;         { True, No duplicates supported }
    bKeyDescending  : WordBool;         { If whole key can be descending }
    bFldDescending  : WordBool;         { Field level descending }
    bMaintained     : WordBool;         { Supports maintained option }
    bSubset         : WordBool;         { Supports Subset expression }
    bKeyExpr        : WordBool;         { If Key can be expres }
    bCaseInsensitive : WordBool;        { Supports Caseinsensitive indexes }
    iUnUsed         : packed array [0..15] of Word;
  end;

  pFLDType = ^FLDType;
  FLDType = packed record
    iId             : Word;             { Id of Field Type }
    szName          : DBINAME;          { Symbolic name; eg "ALPHA" }
    szText          : DBINAME;          { Descriptive text }
    iPhyType        : Word;             { Physical/Native type }
    iXltType        : Word;             { Default xlated type }
    iXltSubType     : Word;             { Default xlated sub type }
    iMaxUnits1      : Word;             { Max units allowed (1) }
    iMaxUnits2      : Word;             { Max units allowed (2) }
    iPhySize        : Word;             { Physical size in bytes (per unit) }
    bRequired       : WordBool;         { Supports 'required' option }
    bDefaultVal     : WordBool;         { Supports user specified 'default' }
    bMinVal         : WordBool;         { Supports MIN Val constraint }
    bMaxVal         : WordBool;         { Supports MAX Val constraint }
    bRefIntegrity   : WordBool;         { Can participate in ref integrity }
    bOtherChecks    : WordBool;         { Supports other kinds of checks }
    bKeyed          : WordBool;         { The field type can be keyed }
    bMultiplePerTable : WordBool;       { Table can have more than 1 of this type }
    iMinUnits1      : Word;             { Min units required (1) }
    iMinUnits2      : Word;             { Min units required (2) }
    bCreateable     : WordBool;         { Type can be created }
    szNativeName    : DBINAME;          { Native (SQL) name used in DDL }
    iUnUsed         : packed array [0..15] of Word;
  end;

  PROPValid = (                         { PROP Validity }
    epropINVALID,                       { Property is INVALID (not supported) }
    epropCANGET,                        { You can GET value of the property }
    epropCANSET                         { You can GET and SET value of the property }
  );

{============================================================================}
{                                Call Backs                                  }
{============================================================================}

type
  pCBType            = ^CBType;
  CBType = (                            { Call back type }
    cbGENERAL,                          { General purpose }
    cbRESERVED1,
    cbRESERVED2,
    cbINPUTREQ,                         { Input requested }
    cbRESERVED4,
    cbRESERVED5,
    cbBATCHRESULT,                      { Batch processing rslts }
    cbRESERVED7,
    cbRESTRUCTURE,                      { Restructure }
    cbRESERVED9,
    cbRESERVED10,
    cbRESERVED11,
    cbRESERVED12,
    cbRESERVED13,
    cbRESERVED14,
    cbRESERVED15,
    cbRESERVED16,
    cbRESERVED17,
    cbTABLECHANGED,                     { Table changed notification }
    cbRESERVED19,
    cbCANCELQRY,                        { Allow user to cancel Query }
    cbSERVERCALL,                       { Server Call }
    cbRESERVED22,
    cbGENPROGRESS,                      { Generic Progress report. }
    cbDBASELOGIN,                       { dBASE Login }
    cbDELAYEDUPD,                       { Delayed Updates }
    cbFIELDRECALC,                      { Field(s) recalculation }
    cbTRACE,                            { Trace }
    cbDBLOGIN,                          { Database login }
    cbDETACHNOTIFY,                     { DLL Detach Notification }
    cbNBROFCBS                          { Number of cbs }
  );

const
  cbYIELDCLIENT = cbCANCELQRY;

type
  pCBRType           = ^CBRType;
  CBRType = (                           { Call-back return type }
    cbrUSEDEF,                          { Take default action }
    cbrCONTINUE,                        { Continue }
    cbrABORT,                           { Abort the operation }
    cbrCHKINPUT,                        { Input given }
    cbrYES,                             { Take requested action }
    cbrNO,                              { Do not take requested action }
    cbrPARTIALASSIST,                   { Assist in completing the job }
    cbrSKIP,                            { Skip this operation }
    cbrRETRY                            { Retry this operation }
  );

  ppfDBICallBack = ^pfDBICallBack;
  pfDBICallBack  = function (           { Call-back funtion pntr type }
      ecbType       : CBType;           { Callback type }
      iClientData   : Longint;          { Client callback data }
      CbInfo        : Pointer           { Call back info/Client Input }
   ): CBRType stdcall;

{ Progress callback structure }

  pCBPROGRESSDesc = ^CBPROGRESSDesc;
  CBPROGRESSDesc  = packed record
    iPercentDone    : SmallInt;         { Percentage done. }
    szMsg           : DBIMSG;           { Message to display }
  end;

  DelayUpdErrOpType = (                 { type of delayed update object (delayed updates callback) }
    delayupdNONE,
    delayupdMODIFY,
    delayupdINSERT,
    delayupdDELETE
  );

  PDELAYUPDCbDesc = ^DELAYUPDCbDesc;
  DELAYUPDCbDesc = packed record        { delayed updates callback info }
    iErrCode        : DBIResult;
    eDelayUpdOpType : DelayUpdErrOpType;
    iRecBufSize     : Word;             { Record size (physical record) }
    pNewRecBuf      : Pointer;
    pOldRecBuf      : Pointer;
  end;

  RESTErrObjType = (                    { type of restructure object (restructure callback) }
    restrNONE,
    restrNEWFLD,
    restrOLDFLD,
    restrNEWINDEX,
    restrOLDINDEX,
    restrNEWVCHK,
    restrOLDVCHK,
    restrNEWRINT,
    restrOLDRINT,
    restrNEWSEC,
    restrOLDSEC,
    restrNEWTABLE
  );

  pCBDBLogin = ^TCBDBLogin;
  TCBDBLogin = packed record            { Database login }
    szDbName        : DBINAME;          { Database name }
    eOpenMode       : DBIOpenMode;      { Open type desired }
    eShareMode      : DBIShareMode;     { Share type desired }
    szPassword      : DBINAME;          { Password }
    bCallbackToClose : Bool;            { Returned flag }
    hDb             : hDBIDb;           { db handle }
  end;

type
  pTRACECat = ^TRACECat;                { trace categories }
  TRACECat = TypedEnum;
const
    traceUNKNOWN   = $0000;
    traceQPREPARE  = $0001;             { prepared query statements }
    traceQEXECUTE  = $0002;             { executed query statements }
    traceERROR     = $0004;             { vendor errors }
    traceSTMT      = $0008;             { statement ops (i.e. allocate, free) }
    traceCONNECT   = $0010;             { connect / disconnect }
    traceTRANSACT  = $0020;             { transaction }
    traceBLOB      = $0040;             { blob i/o }
    traceMISC      = $0080;             { misc. }
    traceVENDOR    = $0100;             { vendor calls }
    traceDATAIN    = $0200;             { parameter bound data }
    traceDATAOUT   = $0400;             { trace fetched data }

type
  pTRACEDesc = ^TRACEDesc;
  TRACEDesc = packed record             { trace callback info }
    eTraceCat       : TRACECat;
    uTotalMsgLen    : Word;
    pszTrace        : array [0..0] of Char;
  end;

type
  TuObjDesc = packed record
    case Integer of
      1: (fldDesc:  FLDDesc);
      2: (idxDesc:  IDXDesc);
      3: (vchkDesc: VCHKDesc);
      4: (rintDesc: RINTDesc);
      5: (secDesc:  SECDesc);
  end;

  RESTCbDesc = packed record            { restructure callback info }
    iErrCode        : DBIResult;
    iTblNum         : Word;
    iObjNum         : Word;
    eRestrObjType   : RESTErrObjType;
    uObjDesc        : TuObjDesc;
  end;

  CBEntry = packed record
    szKeyWord       : DBINAME;