{*******************************************************}
{                                                       }
{       BDE Procedure Interface Unit                    }
{                                                       }
{       Copyright (c) 1995 Borland International        }
{                                                       }
{*******************************************************}

unit DbiProcs;

interface

uses
{$IFNDEF VER80}
  Win31,
{$ENDIF}
  Wintypes, WinProcs, DbiTypes;

type
  DbiDate = Date;  

const
  DBIINTFVER         = 119;             { Version of the interface }
  DBIENGVERSION      = 120;             { Version of the engine (1.20) }

{============================================================================}
{                          DBI prototypes                                    }
{============================================================================}
{                          Environmental                                     }
{----------------------------------------------------------------------------}

function DbiInitFn (                    { Initialize the Engine }
      iVer          : Word;             { Interface Version }
      pEnv          : pDBIEnv           { Environment Structure/NULL }
   ): DBIResult;
 { DO NOT CALL THIS DIRECTLY. Use the 'DbiInit' define below. }

 { Initializes the engine environment. Default settings can be overwritten  }
 { by supplying the appropriate settings. Defaults are read from the system }
 { configuration file. pEnv can be NULLP to get the system defautls.        }

function DbiInit (pEnv: PDbiEnv): DBIResult;

function DbiExit: DBIResult;            { Exit engine }


{============================================================================}
{                         System Level Info                                  }
{============================================================================}

function DbiGetSysVersion (             { Get system version info }
var   sysVersion    : SYSVersion
   ): DBIResult;

function DbiGetSysConfig (              { System configuration }
var   sysConfig     : SYSConfig
   ): DBIResult;

function DbiGetClientInfo (             { Get Client info }
var   clientInfo    : CLIENTInfo
   ): DBIResult;

function DbiGetSysInfo (                { Get system status/info }
var   sysInfo       : SYSInfo
   ): DBIResult;

function DbiLoadDriver (                { Load a given driver }
      pszDriverType : PChar             { Driver name }
   ): DBIResult;

{============================================================================}
{                            Sessions                                        }
{============================================================================}

function DbiStartSession (              { Start a new session }
      pszName       : PChar;            { Name (Optional) }
var   hSes          : hDBISes;          { Session }
      pNetDir       : PChar             { Netfile directory for session (opt) }
   ): DbiResult;

function DbiGetCurrSession (            { Get the current session }
var   hSes          : hDBISes           { Session }
   ): DbiResult;

function DbiSetCurrSession (            { Set the current session }
      hSes          : hDBISes           { Session/NULL }
   ): DbiResult;

function DbiCloseSession (              { Close the current session }
      hSes          : hDBISes           { Session }
   ): DbiResult;

function DbiGetSesInfo (                { Get current session info }
var   sesInfo       : SESInfo
   ): DbiResult;

function DbiSetPrivateDir (             { Set Private Directory for session }
      pszDir        : PChar             { Directory name/NULL }
   ): DbiResult;


{============================================================================}
{                     Datababase, Schema and File inquiry                    }
{============================================================================}

function DbiOpenDatabase (              { Open a database }
      pszDbName     : PChar;            { Database name }
      pszDbType     : PChar;            { Database type (NULL: Universal) }
      eOpenMode     : DBIOpenMode;      { Open type }
      eShareMode    : DBIShareMode;     { Share type }
      pszPassword   : PChar;            { Password }
      iOptFlds      : Word;             { Number of optional Params }
      pOptFldDesc   : pFLDDesc;         { Optional Field Descriptors }
      pOptParams    : Pointer;          { Optional Params }
var   hDb           : hDBIDb            { Returnd database handle }
   ): DBIResult;

function DbiSetDirectory (              { Set the current directory }
      hDb           : hDBIDb;           { Universal database handle }
      pszDir        : PChar             { Directory/NULL }
   ): DBIResult;

function DbiGetDirectory (              { Get the current/default directory }
      hDb           : hDBIDb;           { Universal database handle }
      bDefault      : Bool;             { True for default }
      pszDir        : PChar             { Returned directory }
   ): DBIResult;

function DbiOpenTableList (             { Open a cursor on "Tables" }
      hDb           : hDBIDb;           { Database handle }
      bExtended     : Bool;             { True for extended info }
      bSystem       : Bool;             { True to include system tables }
      pszWild       : PChar;            { Wild card name }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiOpenFileList (              { Open a cursor on "Files" }
      hDb           : hDBIDb;           { Universal database handle }
      pszWild       : PChar;            { Wild card name }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiOpenIndexList (             { Return "Indexes" for a table }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type }
var   hCur          : hDBICur           { Returned cursor on "Indexes" }
   ): DBIResult;

function DbiOpenFieldList (             { Return "Fields" for a table }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type }
      bPhyTypes     : Bool;             { True, for physical types }
var   hCur          : hDBICur           { Returned cursor on "Fields" }
   ): DBIResult;

function DbiOpenVchkList (              { Return "Checks" for a table }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver Type }
var   hChkCur       : hDBICur           { Returned cursor on "Checks" }
   ): DBIResult;

function DbiOpenRintList (              { Return Integrity checks }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type }
var   hChkCur       : hDBICur           { Returned cursor on "Ref Int". }
   ): DBIResult;

function DbiOpenSecurityList (          { Return security descriptions }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type }
var   hSecCur       : hDBICur           { Returned cursor on sec list }
   ): DBIResult;

function DbiOpenFamilyList (            { Return family members }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type }
var   hFmlCur       : hDBICur           { Returned cursor on "Family" }
   ): DBIResult;

function DbiOpenSPList (                { Open a cursor on "Stored Procedures" }
      hDb           : hDBIDb;           { Universal database handle }
      bExtended     : Bool;             { True for extended info (N/A) }
      bSystem       : Bool;             { True to include system procedures }
      pszQual       : PChar;            { Qualifier (N/A) }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiOpenSPParamList (           { Return "Parameters" for a stored procedure }
      hDb           : hDBIDb;           { Database handle }
      pszSPName     : PChar;            { Stored procedure name }
      bPhyTypes     : Bool;             { True, for physical types }
      uOverload     : Word;             { Overload number }
var   hCur          : hDBICur           { Returned cursor on "Parameters" }
   ): DBIResult;

function DbiCloseDatabase (             { Close a database }
var   hDb           : hDBIDb            { Pointer to database handle }
   ): DBIResult;

{============================================================================}
{                                  Capabilities                              }
{============================================================================}

function DbiOpenDriverList (            { Get a list of driver names }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiGetDriverDesc (             { Get description for a given type }
      pszDriverType : PChar;            { Symbolic name for driver type }
var   drvType       : DRVType           { Driver type description }
   ): DBIResult;

function DbiOpenDatabaseList (          { Get a list of registered databases }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiGetDatabaseDesc (           { Get a description of a logical db }
      pszName       : PChar;            { Name of logical database }
      pdbDesc       : pDBDesc           { Database description }
   ): DBIResult;

function DbiOpenTableTypesList (        { Get a list of table types }
      pszDriverType : PChar;            { Driver type }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiGetTableTypeDesc (          { Get Table capabilities }
      pszDriverType : PChar;            { Driver type }
      pszTableType  : PChar;            { Table type }
var   tblType       : TBLType           { Table Capabilities }
   ): DBIResult;


function DbiOpenFieldTypesList (        { Get a list of field types }
      pszDriverType : PChar;            { Driver type }
      pszTblType    : PChar;            { Table type (Optional) }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiGetFieldTypeDesc (          { Get list of field types }
      pszDriverType : PChar;            { Driver type }
      pszTableType  : PChar;            { Table type }
      pszFieldType  : PChar;            { Field type  (Physical only) }
var   fldType       : FLDType           { Field type description }
   ): DBIResult;

function DbiOpenIndexTypesList (        { Get list of index types }
      pszDriverType : PChar;            { Driver type }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiGetIndexTypeDesc (          { Get description of given idx type }
      pszDriverType : PChar;            { Driver type }
      pszIndexType  : PChar;            { Index type }
var   idxType       : IDXType           { Index description }
   ): DBIResult;

function DbiOpenLdList (                { Get a list of Lang Drivers }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

{===========================================================================}
{                      Table Open, Properties & Structure                   }
{===========================================================================}

function DbiOpenTable (                 { Open a table }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name or file name }
      pszDriverType : PChar;            { Driver type                 /NULL }
      pszIndexName  : PChar;            { Index to be used for access /NULL }
      pszIndexTagName : PChar;          { Index tag name              /NULL }
      iIndexId      : Word;             { Index number                /0 }
      eOpenMode     : DBIOpenMode;      { Read or RW }
      eShareMode    : DBIShareMode;     { Excl or Share }
      exltMode      : XLTMode;          { Xlate mode }
      bUniDirectional : Bool;           { Uni or Bi directional }
      pOptParams    : Pointer;          { Optional params /NULL }
var   hCursor       : hDBICur           { Returns Cursor handle }
   ): DBIResult;


function DbiGetCursorProps (            { Get Cursor properties }
      hCursor       : hDBICur;          { Cursor handle }
var   curProps      : CURProps          { Cursor properties }
   ): DBIResult;

function DbiGetObjFromName (            { Get object from name }
      eObjType      : DBIOBJType;       { Object handle }
      pszObjName    : PChar;            { Name of object /NULL }
var   hObj          : hDBIObj           { Returned object handle }
   ): DBIResult;

function DbiGetObjFromObj (             { Get associated object }
      hObj          : hDBIObj;          { Object handle }
      eObjType      : DBIOBJType;       { Type of associated object }
var   hObj          : hDBIObj           { Returns object of eObjType }
   ): DBIResult;

function DbiGetProp (                   { Get property }
      hObj          : hDBIObj;          { Object handle }
      iProp         : Longint;          { Property to retrieve }
      PropValue     : Pointer;          { == NULL, validate iProp for getting }
      iMaxLen       : Word;             { Length of buffer pPropValue }
var   iLen          : Word              { Returns required length }
   ): DBIResult;

function DbiSetProp (                   { Set property }
      hObj          : hDBIObj;          { Object handle }
      iProp         : Longint;          { Property to set }
      iPropValue    : Longint           { Property value }
   ): DBIResult;

function DbiValidateProp (              { Validate a property }
      hObj          : hDBIObj;          { Object handle }
      iProp         : Longint;          { property to validate }
      bSetting      : Bool              { TRUE:setting, FALSE:getting }
   ): DBIResult;

function DbiGetFieldDescs (             { Get field descriptions }
      hCursor       : hDBICur;          { Cursor handle }
      pfldDesc      : pFLDDesc          { Array of field descriptors }
   ): DBIResult;

function DbiGetCursorForTable (         { Find cursor for a given table }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type / NULL }
var   hCursor       : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiCloneCursor (               { Return a duplicate cursor }
      hCurSrc       : hDBICur;          { Source cursor }
      bReadOnly     : Bool;             { If TRUE, read only mode }
      bUniDirectional : Bool;           { If TRUE, Uni directional }
var   hCurNew       : hDBICur           { Destination cursor address }
   ): DBIResult;

function DbiCloseCursor (               { Closes cursor }
var   hCursor       : hDBICur           { Pntr to Cursor handle }
   ): DBIResult;


{============================================================================}
{                      Index Manipulation & Usage                            }
{============================================================================}

function DbiOpenIndex (                 { Open an index }
      hCursor       : hDBICur;          { Cursor handle }
      pszIndexName  : PChar;            { Index Name }
      iIndexId      : Word              { Index number (if applicable) }
   ): DBIResult;

function DbiCloseIndex (                { Close an index }
      hCursor       : hDBICur;          { Cursor handle }
      pszIndexName  : PChar;            { Index Name }
      iIndexId      : Word              { Index number }
   ): DBIResult;

function DbiSwitchToIndex (             { Change index order of access }
var   hCursor       : hDBICur;          { Cursor handle (In/Out) }
      pszIndexName  : PChar;            { Index name }
      pszTagName    : PChar;            { Tag name (if applicable) }
      iIndexId      : Word;             { Index number }
      bCurrRec      : Bool              { Position at current rec }
   ): DBIResult;

function DbiGetIndexDesc (              { Get index properties }
      hCursor       : hDBICur;          { Cursor handle }
      iIndexSeqNo   : Word;             { Index number }
var   idxDesc       : IDXDesc           { Returned index description }
   ): DBIResult;

function DbiGetIndexDescs (             { Get index properties }
      hCursor       : hDBICur;          { Cursor handle }
var   idxDesc       : IDXDesc           { Returned index descriptors }
   ): DBIResult;

function DbiGetIndexForField (          { Get index desc for given field }
      hCursor       : hDBICur;          { Cursor handle }
      iFld          : Word;             { Field Number (1..N) }
      bProdTagOnly  : Bool;             { If TRUE, only xBASE prod tags will be returned }
var   idxDesc       : IDXDesc           { (Optional) }
   ): DBIResult;

function DbiGetIndexSeqNo (             { Get index sequence number }
      hCursor       : hDBICur;          { Cursor handle }
      pszIndexName  : PChar;            { Index name }
      pszTagName    : PChar;            { Tag name (if applicable) }
      iIndexId      : Word;             { Index number }
var   iIndexSeqNo   : Word              { Index number }
   ): DBIResult;

function DbiSetToKey (                  { Set key condition }
      hCursor       : hDBICur;          { Cursor handle }
      eSearchCond   : DBISearchCond;    { Search condition (default is =) }
      bDirectKey    : Bool;             { Key is supplied directly }
      iFields       : Word;             { No of full fields to match }
      iLen          : Word;             { Partial key len of last field }
      pBuff         : Pointer           { Either Record buffer or Key itself }
   ): DBIResult;

function DbiExtractKey (                { Get the key value of current record }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Record buffer (optional) }
      pKeyBuf       : Pointer           { Returned. Key bytes. }
   ): DBIResult;

function DbiSetRange (                  { Set cursor to a range }
      hCursor       : hDBICur;          { Cursor }
      bKeyItself    : Bool;             { Whether Key or Record buffer }
      iFields1      : Word;             { Key fields to be mathced in full }
      iLen1         : Word;             { Key length to compare }
      pKey1         : Pointer;          { Top/Left key in Range }
      bKey1Incl     : Bool;             { If Inclusive of Key1 }
      iFields2      : Word;             { Key fields to be mathced in full }
      iLen2         : Word;             { Key length to compare }
      pKey2         : Pointer;          { Bottom/Right key in Range }
      bKey2Incl     : Bool              { If Inclusive of Key2 }
   ): DBIResult;

function DbiResetRange (                { Reset range }
      hCursor       : hDBICur           { cursor handle }
   ): DBIResult;

function DbiCompareKeys (               { Compare two keys }
      hCursor       : hDBICur;          { Cursor handle }
      pKey1         : Pointer;          { Key buffer 1 to compare }
      pKey2         : Pointer;          { Key buffer 2 (Or NULL) }
      iFields       : Word;             { Fields to compare in full }
      iLen          : Word;             { Partial key to compare }
var   iResult       : Integer           { Compare result }
   ): DBIResult;

function DbiGetRecordForKey (           { Find a record matching key }
      hCursor       : hDBICur;          { Cursor handle }
      bDirectKey    : Bool;             { Key is supplied directly }
      iFields       : Word;             { No of full fields to match }
      iLen          : Word;             { Partial key len of last field }
      pKey          : Pointer;          { Either Record buffer or Key itself }
      pRecBuff      : Pointer           { (Optional) Record buffer }
   ): DBIResult;

{=============================================================================}
{                          Validity check and referential integrity           }
{=============================================================================}

function DbiGetVchkDesc (               { Get valcheck descriptor }
      hCursor       : hDBICur;          { Cursor handle }
      iValSeqNo     : Word;             { Valcheck sequence number }
      pvalDesc      : pVCHKDesc         { Returned valcheck description }
   ): DBIResult;

function DbiGetRintDesc (               { Get referential integrity descriptor }
      hCursor       : hDBICur;          { Cursor handle }
      iRintSeqNo    : Word;             { Rint sequence number }
      printDesc     : pRINTDesc         { Returned rint description }
   ): DBIResult;

{=============================================================================}
{                              Cursor Maintenance                             }
{=============================================================================}


function DbiSetToBegin (                { Reset cursor to beginning }
      hCursor       : hDBICur           { Cursor handle }
   ): DBIResult;

function DbiSetToEnd (                  { Reset cursor to ending }
      hCursor       : hDBICur           { Cursor handle }
   ): DBIResult;

function DbiSetToCursor (               { Set cursor to another cursor position }
      hDest         : hDBICur;          { Destination cursor }
      hSrc          : hDBICur           { Source cursor }
   ): DBIResult;

function DbiGetBookMark (               { Get a book-mark }
      hCur          : hDBICur;          { Cursor }
      pBookMark     : Pointer           { Pointer to Book-Mark }
   ): DBIResult;

function DbiSetToBookMark (             { Position to a Book-Mark }
      hCur          : hDBICur;          { Cursor }
      pBookMark     : Pointer           { Pointer to Book-Mark }
   ): DBIResult;

function DbiCompareBookMarks (          { Compare two Book-marks }
      hCur          : hDBICur;          { Cursor }
      pBookMark1    : Pointer;          { Book mark 1 }
      pBookMark2    : Pointer;          { Book mark 2 }
var   CmpBkmkResult : Word              { Compare result }
   ): DBIResult;

{============================================================================}
{                      Data Access: Logical Record Level                     }
{============================================================================}


function DbiGetNextRecord (             { Find/Get the next record }
      hCursor       : hDBICur;          { Cursor handle }
      eLock         : DBILockType;      { Optional lock request }
      pRecBuff      : Pointer;          { Record buffer(client) }
      precProps     : pRECProps         { Optional record properties }
   ): DBIResult;

function DbiGetPriorRecord (            { Find/Get the prior record }
      hCursor       : hDBICur;          { Cursor handle }
      eLock         : DBILockType;      { Optional lock request }
      pRecBuff      : Pointer;          { Record buffer (client) }
      precProps     : pRECProps         { Optional record properties }
   ): DBIResult;

function DbiGetRecord (                 { Gets the current record }
      hCursor       : hDBICur;          { Cursor handle }
      eLock         : DBILockType;      { Optional lock request }
      pRecBuff      : Pointer;          { Record buffer(client) }
      precProps     : pRECProps         { Optional record properties }
   ): DBIResult;

function DbiGetRelativeRecord (         { Find/Get a record by record number }
      hCursor       : hDBICur;          { Cursor handle }
      iPosOffset    : Longint;          { offset from current position }
      eLock         : DBILockType;      { Optional lock request }
      pRecBuff      : Pointer;          { Record buffer(client) }
      precProps     : pRECProps         { Optional record properties }
   ): DBIResult;

function DbiInitRecord (                { Initialize record area }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuff      : Pointer           { Record buffer }
   ): DBIResult;

function DbiInsertRecord (              { Inserts a new record }
      hCursor       : hDBICur;          { Cursor handle }
      eLock         : DBILockType;      { Optional lock on this rec }
      pRecBuff      : Pointer           { New Record (client) }
   ): DBIResult;

function DbiModifyRecord (              { Updates the current record }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Modified record }
      bFreeLock     : Bool              { Free record lock }
   ): DBIResult;

function DbiDeleteRecord (              { Deletes the current record }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer           { Copy of deleted record }
   ): DBIResult;

function DbiReadBlock (                 { Read a block of records }
      hCursor       : hDBICur;          { Cursor handle }
var   iRecords      : Longint;          { Number of records to read }
      pBuf          : Pointer           { Buffer }
   ): DBIResult;

function DbiWriteBlock (                { Write a block of records }
      hCursor       : hDBICur;          { Cursor handle }
var   iRecords      : Longint;          { Number of records to write/written }
      pBuf          : Pointer           { Buffer }
   ): DBIResult;

function DbiAppendRecord (              { Inserts a new record }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuff      : Pointer           { New Record (client) }
   ): DBIResult;

function DbiUndeleteRecord (            { Undeletes the current record }
      hCursor       : hDBICur           { Cursor handle }
   ): DBIResult;

function DbiGetSeqNo (                  { Get logical record number }
      hCursor       : hDBICur;          { Cursor handle }
var   iSeqNo        : Longint           { Pointer to sequence number }
   ): DBIResult;

function DbiSetToSeqNo (                { Position to a logical record number }
      hCursor       : hDBICur;          { Cursor handle }
      iSeqNo        : Longint           { Sequence number }
   ): DBIResult;

function DbiGetRecordCount (            { Get the current number of records }
      hCursor       : hDBICur;          { Cursor handle }
var   iRecCount     : Longint           { Number of records }
   ): DBIResult;


function DbiSetToRecordNo (             { Position to Physical Rec# }
      hCursor       : hDBICur;          { Cursor handle }
      iRecNo        : Longint           { Physical record number }
   ): DBIResult;

function DbiSaveChanges (               { Flush all buffered changes }
      hCursor       : hDBICur           { Cursor handle }
   ): DBIResult;

function DbiForceReread (               { Force Reread of buffers from Disk }
      hCursor       : hDBICur           { Cursor }
   ): DBIResult;

function DbiCheckRefresh: DBIResult;    { Check refresh for session }

function DbiMakePermanent (             { Make temporary table permanent }
      hCursor       : hDBICur;          { Cursor handle }
      pszName       : PChar;            { Rename temporary table }
      bOverWrite    : Bool              { Overwrite existing file }
   ): DBIResult;

{============================================================================}
{                            Field Level Access                              }
{============================================================================}

function DbiGetField (                  { Get Field value }
      hCursor       : hDBICur;          { Cursor }
      iField        : Word;             { Field # (1..n) }
      pRecBuff      : Pointer;          { Record buffer }
      pDest         : Pointer;          { Destination field buffer }
var   bBlank        : Bool              { Returned : is field blank }
   ): DBIResult;

function DbiPutField (                  { Put a value in the record buffer }
      hCursor       : hDBICur;          { Cursor }
      iField        : Word;             { Field # (1..n) }
      pRecBuff      : Pointer;          { Record buffer }
      pSrc          : Pointer           { Source field buffer }
   ): DBIResult;

function DbiVerifyField (               { Verifies the field value }
      hCursor       : hDBICur;          { Cursor }
      iField        : Word;             { Field # (1..n) }
      pSrc          : Pointer;          { Field Value }
var   bBlank        : Bool              { Field is Blank (Returned) }
   ): DBIResult;

function DbiOpenBlob (                  { Open a blob for access }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Record Buffer }
      iField        : Word;             { Field number (1..n) }
      eOpenMode     : DBIOpenMode       { Open for Read or RW }
   ): DBIResult;

function DbiGetBlobSize (               { Gets the size of a blob }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Record Buffer }
      iField        : Word;             { Field number of blob (1..n) }
var   iSize         : Longint           { Blob size in bytes }
   ): DBIResult;

function DbiGetBlob (                   { Read bytes from blob }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Record Buffer }
      iField        : Word;             { Field number of blob (1..n) }
      iOffSet       : Longint;          { Starting position   }
      iLen          : Longint;          { No of bytes to be read   }
      pDest         : Pointer;          { Destination }
var   iRead         : Longint           { Actual no of bytes read }
   ): DBIResult;

function DbiPutBlob (                   { Write bytes to blob }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Record Buffer }
      iField        : Word;             { Field number of blob (1..n) }
      iOffSet       : Longint;          { Starting position   }
      iLen          : Longint;          { No of bytes to put   }
      pSrc          : Pointer           { pntr to Source }
   ): DBIResult;

function DbiTruncateBlob (              { Reduces the blob size }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Record Buffer }
      iField        : Word;             { Field number of blob (1..n) }
      iLen          : Longint           { New blob length }
   ): DBIResult;

function DbiFreeBlob (                  { Closes the blob }
      hCursor       : hDBICur;          { Cursor handle }
      pRecBuf       : Pointer;          { Record Buffer }
      iField        : Word              { Field number of blob (0..n) }
   ): DBIResult;

function DbiGetBlobHeading (            { Get Blob Heading }
      hCursor       : hDBICur;          { Cursor handle }
      iField        : Word;             { Field number of blob (1..n) }
      pRecBuf       : Pointer;          { Record buffer of owner record }
      pDest         : Pointer           { Destination buffer }
   ): DBIResult;

function DbiSetFieldMap (               { Set a fieldmap }
      hCur          : hDBICur;          { Cursor handle }
      iFields       : Word;             { Number of fields }
      pFldDesc      : pFLDDesc          { Array of field descriptions }
   ): DBIResult;


{=============================================================================}
{                                TRANSACTIONS                                 }
{=============================================================================}

function DbiBeginTran (                 { Begin a transaction }
      hDb           : hDBIDb;           { Database handle }
      eXIL          : eXILType;         { Transaction isolation level }
var   hXact         : hDBIXact          { Returned Xact handle }
   ): DBIResult;

function DbiEndTran (                   { End a transaction }
      hDb           : hDBIDb;           { Database handle }
      hXact         : hDBIXact;         { Xact handle }
      eEnd          : eXEnd             { Xact end type }
   ): DBIResult;

function DbiGetTranInfo (               { Get transaction info }
      hDb           : hDBIDb;           { Database handle }
      hXact         : hDBIXact;         { Xact handle }
      pxInfo        : pXInfo            { Xact info }
   ): DBIResult;

{=============================================================================}
{                                  LOCKING                                    }
{=============================================================================}

function DbiAcqTableLock (              { Lock a table }
      hCursor       : hDBICur;          { Cursor handle }
      eLockType     : DBILockType       { Lock type }
   ): DBIResult;

function DbiAcqPersistTableLock (       { Get a persistent lock }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar             { Driver type / NULL }
   ): DBIResult;

function DbiRelPersistTableLock (       { Releases a persistent lock }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar             { Driver type / NULL }
   ): DBIResult;

function DbiRelTableLock (              { Unlocks Table level locks }
      hCursor       : hDBICur;          { Cursor handle }
      bAll          : Bool;             { True for all table level locks }
      eLockType     : DBILockType       { Specific lock type }
   ): DBIResult;

function DbiRelRecordLock (             { Releases record level locks }
      hCursor       : hDBICur;          { Cursor handle }
      bAll          : Bool              { True for all. Default Current. }
   ): DBIResult;

function DbiIsRecordLocked (            { Check if current record is locked }
      hCursor       : hDBICur;          { Cursor handle }
var   bLocked       : Bool              { Rec lock status }
   ): DBIResult;

function DbiIsTableLocked (             { Verify if Table is locked }
      hCursor       : hDBICur;          { Cursor handle }
      epdxLock      : DBILockType;      { Lock type to verify }
var   iLocks        : Word              { Nbr of locks of the given type }
   ): DBIResult;

function DbiIsTableShared (             { Verify if this is a shared table }
      hCursor       : hDBICur;          { Cursor handle }
var   bShared       : Bool              { Shared status }
   ): DBIResult;

function DbiOpenLockList (              { Get a list of locks }
      hCursor       : hDBICur;          { Cursor handle }
      bAllUsers     : Bool;             { True, for all Users locks }
      bAllLockTypes : Bool;             { True, for all lock types }
var   hLocks        : hDBICur           { Returned cursor on Lock list }
   ): DBIResult;

function DbiOpenUserList (              { Get a list of users loggedin }
var   hUsers        : hDBICur           { Returned cursor on user list }
   ): DBIResult;

function DbiSetLockRetry (              { Set Lock wait time }
      iWait         : Integer           { Time in seconds }
   ): DBIResult;


{============================================================================}
{                              Batch Operations                              }
{============================================================================}


function DbiBatchMove (                 { Copy records to destination table }
      pSrcTblDesc   : pBATTblDesc;      { Source table identification, }
      hSrcCur       : hDBICur;          {  OR source cursor  ( one must be NULL ) }
      pDstTblDesc   : pBATTblDesc;      { Destination table identification, }
      hDstCur       : hDBICur;          {  OR destination cursor ( one must be NULL ) }
      ebatMode      : eBATMode;         { Batch mode }
      iFldCount     : Word;             { size of field maps }
      pSrcFldMap    : PWord;            { Array of source field numbers }
      pszIndexName  : PChar;            { If update mode, used to match records }
      pszIndexTagName : PChar;          { Index tag name }
      iIndexId      : Word;             { Index  id }
      pszKeyviolName : PChar;           { Keyviol table name  (optional) }
      pszProblemsName : PChar;          { Problems table name (optional) }
      pszChangedName : PChar;           { Changed table name (optional) }
      lProbRecs     : PLongint;         { Number of records to read from source }
      lKeyvRecs     : PLongint;         { Number of records to read from source }
      lChangedRecs  : PLongint;         { Number of records to read from source }
      bAbortOnFirstProb : Bool;         { If TRUE, abort on first problem rec }
      bAbortOnFirstKeyviol : Bool;      { If TRUE, abort on first keyviol rec }
var   lRecsToMove   : Longint;          { Number of records to read from source }
      bTransliterate : Bool             { If TRUE, transliterate character data }
   ): DBIResult;

function DbiCopyTable (                 { Copy one table to another }
      hDb           : hDBIDb;           { Database handle }
      bOverWrite    : Bool;             { True, to overwrite existing file }
      pszSrcTableName : PChar;          { Source table name }
      pszSrcDriverType : PChar;         { Source driver type }
      pszDestTableName : PChar          { Destination table name }
   ): DBIResult;

function DbiEmptyTable (                { Deletes all records }
      hDb           : hDBIDb;           { Database handle }
      hCursor       : hDBICur;          { Cursor (OR) }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar             { Driver type /NULL }
   ): DBIResult;

function DbiPackTable (                 { Pack a table }
      hDb           : hDBIDb;           { Database handle }
      hCursor       : hDBICur;          { Cursor (OR) }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type /NULL }
      bRegenIdxs    : Bool              { Regenerate indexes }
   ): DBIResult;

function DbiRegenIndex (                { Regenerate an index }
      hDb           : hDBIDb;           { Database handle }
      hCursor       : hDBICur;          { Cursor (OR) }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type /NULL }
      pszIndexName  : PChar;            { Index name }
      pszIndexTagName : PChar;          { Index tagname (xbase MDX) }
      iIndexId      : Word              { Index number }
   ): DBIResult;

function DbiRegenIndexes (              { Regenerate all indexes }
      hCursor       : hDBICur           { Cursor }
   ): DBIResult;

function DbiSortTable (                 { Sort table }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name of source }
      pszDriverType : PChar;            { Driver type /NULL }
      hSrcCur       : hDBICur;          { OR cursor of table to sort }
      pszSortedName : PChar;            { Destination table (NULL if sort to self) }
      phSortedCur   : phDBICur;         { If non-null, return cursor on destination }
      hDstCur       : hDBICur;          { OR cursor of destination }
      iSortFields   : Word;             { Number of sort fields }
      piFieldNum    : PWord;            { Array of field numbers }
      pbCaseInsensitive : PBool;        { Which fields should sort c-i (Opt) }
      pSortOrder    : pSORTOrder;       { Array of Sort orders (Opt) }
      ppfSortFn     : ppfSORTCompFn;    { Array of compare fn pntrs (Opt) }
      bRemoveDups   : Bool;             { TRUE : Remove duplicates }
      hDuplicatesCur : hDBICur;         { Cursor to duplicates table (Opt) }
var   lRecsSort     : Longint           { in/out param. - sort this number }
   ): DBIResult;


{============================================================================}
{                           Create & Restructure                             }
{============================================================================}

function DbiCreateTable (               { Create a new table }
      hDb           : hDBIDb;           { Database handle }
      bOverWrite    : Bool;             { True, to overwrite existing file. }
var   crTblDsc      : CRTblDesc         { Table description }
   ): DBIResult;

function DbiCreateInMemTable (          { Create a temporary table (Logical) }
      hDb           : hDBIDb;           { Database handle }
      pszName       : PChar;            { Logical Name }
      iFields       : Word;             { No of fields }
      pfldDesc      : pFLDDesc;         { Array of field descriptors }
var   hCursor       : hDBICur           { Returned cursor handle }
   ): DBIResult;

function DbiCreateTempTable (           { Create temporary table (Physical) }
      hDb           : hDBIDb;           { Database handle }
var   crTblDsc      : CRTblDesc;        { Table description }
var   hCursor       : hDBICur           { Returned cursor on table }
   ): DBIResult;

function DbiDoRestructure (             { Restructure a table }
      hDb           : hDBIDb;           { Database handle }
      iTblDescCount : Word;             { Number of table descriptors (1) }
      pTblDesc      : pCRTblDesc;       { Array of table descs }
      pszSaveAs     : PChar;            { Restructure to this table }
      pszKeyviolName : PChar;           { Keyviol table name  (optional) }
      pszProblemsName : PChar;          { Problems table name (optional) }
      bAnalyzeOnly  : Bool              { Analyze restructure }
   ): DBIResult;

function DbiRenameTable (               { Rename table & family }
      hDb           : hDBIDb;           { Database handle }
      pszOldName    : PChar;            { Old name }
      pszDriverType : PChar;            { Driver type /NULL }
      pszNewName    : PChar             { New name }
   ): DBIResult;

function DbiDeleteTable (               { Delete a table }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Name including any path }
      pszDriverType : PChar             { Driver type /NULL }
   ): DBIResult;

function DbiAddIndex (                  { Add a new index }
      hDb           : hDBIDb;           { Database handle }
      hCursor       : hDBICur;          { Cursor (OR) }
      pszTableName  : PChar;            { Table name including any path }
      pszDriverType : PChar;            { Driver type /NULL }
var   IdxDesc       : IDXDesc;          { Description of the index }
      pszKeyviolName : PChar            { Keyviol table name (optional) }
   ): DBIResult;

function DbiDeleteIndex (               { Delete index }
      hDb           : hDBIDb;           { Database handle }
      hCursor       : hDBICur;          { Cursor (OR) }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type /NULL }
      pszIndexName  : PChar;            { Index name }
      pszIndexTagName : PChar;          { Index tagname (xbase MDX) }
      iIndexId      : Word              { Index number }
   ): DBIResult;

{===========================================================================}
{                            Error Info                                     }
{===========================================================================}

function DbiGetErrorEntry (             { Get error entry }
      uEntry        : Word;             { Error stack entry }
var   ulNativeError : Longint;          { Returned. Native error code, if any }
      pszError      : PChar             { Returned. Error string, if any }
   ): DBIResult;

function DbiGetErrorInfo (              { Return info on last error }
      bFull         : Bool;             { If Full details }
var   ErrInfo       : DBIErrInfo        { Error Info }
   ): DBIResult;

function DbiGetErrorString (            { Get message for error code }
      rslt          : DBIResult;        { Engine error code }
      pszError      : PChar             { Error string for the error }
   ): DBIResult;

function DbiGetErrorContext (           { Get specific Context if available }
      eContext      : Integer;          { Context type }
      pszContext    : PChar             { Context string (MAXMSGLEN +1) }
   ): DBIResult;

{============================================================================}
{                              Dbi Services                                  }
{============================================================================}

function DbiDateEncode (                { Encode Date components into Date }
      iMon          : Word;             { Month    (1..12) }
      iDay          : Word;             { Day      (1..31) }
      iYear         : Integer;         { Year     (0..2**16-1) }
var   dateD         : DbiDate           { Encoded date }
   ): DBIResult;

function DbiDateDecode (                { Decode Date into components }
      dateD         : DbiDate;          { Encoded Date }
var   iMon          : Word;             { Month }
var   iDay          : Word;             { Day }
var   iYear         : Integer          { Year }
   ): DBIResult;

function DbiTimeEncode (                { Encode Time components into TIME }
      iHour         : Word;             { Hours (0..23) }
      iMin          : Word;             { Minutes (0..59) }
      iMilSec       : Word;             { Milli Seconds (0..59999) }
var   timeT         : Time              { Encoded Time }
   ): DBIResult;

function DbiTimeDecode (                { Decode TIME into components }
      timeT         : Time;             { Encoded Time }
var   iHour         : Word;             { Hours (0..23) }
var   iMin          : Word;             { Minutes (0..59) }
var   iMilSec       : Word              { Milli Seconds (0..59999) }
   ): DBIResult;

function DbiTimeStampEncode (           { Encode Date & TIme into Date+Time }
      dateD         : DbiDate;          { Encoded Date }
      timeT         : Time;             { Encoded Time }
var   tsTS          : TimeStamp         { Encoded Date+Time }
   ): DBIResult;

function DbiTimeStampDecode (           { Decode Date & Time from Date+Time }
      tsTS          : TIMESTAMP;        { Encoded Date+Time }
var   dateD         : DbiDate;          { Encoded Date }
var   timeT         : Time              { Encoded Time }
   ): DBIResult;


function DbiBcdFromFloat (              { Converts FLOAT number into FMTBcd format }
var   iVal          : Double;           { Float to convert }
      iPrecision    : Word;             { Precision of BCD }
      iPlaces       : Word;             { Number of decimals }
var   Bcd           : FMTBcd            { returns Bcd number (length = iPrecision +2) }
   ): DBIResult;

function DbiBcdToFloat (                { Converts FMTBcd number to FLOAT }
var   Bcd           : FMTBcd;           { Bcd number to convert }
var   iVal          : Double            { Returns converted float }
   ): DBIResult;

{===========================================================================}
{                           CallBacks                                       }
{===========================================================================}

function DbiRegisterCallBack (          { Register a call back fn }
      hCursor       : hDBICur;          { Cursor (Optional) }
      ecbType       : CBType;           { Type of call back }
      iClientData   : Longint;          { Pass-thru client data }
      iCbBufLen     : Word;             { Callback buffer len }
      CbBuf         : Pointer;          { Pointer to callback buffer }
      pfCb          : pfDBICallBack     { Call back fn being registered }
   ): DBIResult;

function DbiGetCallBack (               { Register a call back fn }
      hCursor       : hDBICur;          { Cursor (Optional) }
      ecbType       : CBType;           { Type of call back }
var   iClientData   : Longint;          { Pass-thru client data }
var   iCbBufLen     : Word;             { Callback buffer len }
var   pCbBuf        : Pointer;          { Pointer to callback buffer }
      ppfCb         : ppfDBICallBack    { Call back fn being registered }
   ): DBIResult;

{============================================================================}
{                           Date, time formats                                 }
{============================================================================}


function DbiGetDateFormat (             { Get current date format }
var   fmtDate       : FMTDate
   ): DBIResult;

function DbiSetDateFormat (             { Set current date format }
var   fmtDate       : FMTDate
   ): DBIResult;

function DbiGetTimeFormat (             { Get current time format }
var   fmtTime       : FMTTime
   ): DBIResult;

function DbiSetTimeFormat (             { Set current time format }
var   fmtTime       : FMTTime
   ): DBIResult;

function DbiGetNumberFormat (           { Get current number format }
var   fmtNumber     : FMTNumber
   ): DBIResult;

function DbiSetNumberFormat (           { Set current number format }
var   fmtNumber     : FMTNumber
   ): DBIResult;

{============================================================================}
{                      Conversions                                           }
{============================================================================}

function DbiNativeToAnsi (              { Convert from native to Ansi }
      LdObj         : Pointer;          { Language driver }
      pAnsiStr      : PChar;            { Destination buffer (opt) }
      pNativeStr    : PChar;            { Source buffer }
      iLen          : Word;             { Length of buffer (opt) }
var   bDataLoss     : Bool              { Returns TRUE if conversion will loose data (opt) }
   ): DBIResult;

function DbiAnsiToNative (              { Convert from Ansi to native }
      LdObj         : Pointer;          { Language driver }
      pNativeStr    : PChar;            { Destination buffer (opt) }
      pAnsiStr      : PChar;            { Source buffer }
      iLen          : Word;             { Length of buffer (opt) }
var   bDataLoss     : Bool              { Returns TRUE if conversion will loose data (opt) }
   ): DBIResult;

{============================================================================}
{                            Filters                                         }
{============================================================================}

function DbiAddFilter (                 { Add a filter to the cursor }
      hCursor       : hDBICur;          { Cursor handle }
      iClientData   : Longint;          { Client supplied data      (opt) }
      iPriority     : Word;             { 1..N with 1 being highest (opt) }
      bCanAbort     : Bool;             { TRUE if pfFiltercan return ABORT (opt) }
      pcanExpr      : pCANExpr;         { Expression tree        (opt) }
      pfFilter      : pfGENFilter;      { ptr to filter function (opt) }
var   hFilter       : hDBIFilter        { Returns filter handle }
   ): DBIResult;

function DbiDropFilter (                { Drop a filter }
      hCursor       : hDBICur;          { Cursor handle }
      hFilter       : hDBIFilter        { Filter handle }
   ): DBIResult;

function DbiActivateFilter (            { Activate a Filter }
      hCursor       : hDBICur;          { Cursor handle }
      hFilter       : hDBIFilter        { Filter handle }
   ): DBIResult;

function DbiDeactivateFilter (          { Deactivate Filter }
      hCursor       : hDBICur;          { Cursor handle }
      hFilter       : hDBIFilter        { Filter handle }
   ): DBIResult;

function DbiGetFilterInfo (             { Get filter information }
      hCur          : hDBICur;          { Cursor handle }
      hFilter       : hDBIFilter;       { Filter handle          /NULL }
      iFilterId     : Word;             { Filter id              /0 }
      iFilterSeqNo  : Word;             { Filter sequence number /0 }
var   Filterinfo    : FilterInfo        { Returns filter info }
   ): DBIResult;

{============================================================================}
{                            Linked Cursors                                  }
{============================================================================}

function DbiBeginLinkMode (             { Convert cursor to a link cursor }
var   hCursor       : hDBICur           { In/Out : returns new cursor }
   ): DBIResult;

function DbiEndLinkMode (               { Convert cursor back to normal cursor }
var   hCursor       : hDBICur           { In/Out : returns original cursor }
   ): DBIResult;

function DbiLinkDetail (                { Link detail to master }
      hMstrCursor   : hDBICur;          { Master cursor }
      hDetlCursor   : hDBICur;          { Detail cursor }
      iLnkFields    : Word;             { Number of link fields }
      piMstrFields  : PWord;            { Array of fields in master }
      piDetlFields  : PWord             { Array of fields in detail }
   ): DBIResult;

function DbiLinkDetailToExp (           { Link detail to a master using exp }
      hCursorMstr   : hDBICur;          { Master cursor }
      hCursorDetl   : hDBICur;          { Detail cursor }
      iKeyLen       : Word;             { Key length to match }
      pszMstrExp    : PChar             { Expression string }
   ): DBIResult;

function DbiUnlinkDetail (              { Unlink detail from master }
      hDetlCursor   : hDBICur           { Detail cursor to unlink }
   ): DBIResult;

function DbiGetLinkStatus (             { Query linkage info for table }
      hCursor       : hDBICur;          { Cursor handle }
var   hCursorMstr   : hDBICur;          { Returns master cursor, if any   (opt) }
var   hCursorDet    : hDBICur;          { Returns first detail cursor, if any (opt) }
var   hCursorSib    : hDBICur           { Returns next sibling detail cursor, if any (opt) }
   ): DBIResult;


{===========================================================================}
{                            Translation                                    }
{===========================================================================}


function DbiTranslateRecordStructure (  { Translate a record }
      pszSrcDriverType : PChar;         { Source driver type }
      iFlds         : Word;             { Number of fields }
      pfldsSrc      : pFLDDesc;         { Array of source fields: logical or physical types }
      pszDstDriverType : PChar;         { Destination driver type }
      pszLangDriver : PChar;            { Language driver for destination }
      pfldsDst      : pFLDDesc          { Array of dest. fields returned }
   ): DBIResult;

function DbiOpenFieldXlt (              { Open translation object }
      pszSrcTblType : PChar;            { NULL for Logical }
      pszSrcLangDrv : PChar;            { NULL if no tranliteration }
      pfldSrc       : pFLDDesc;         { source field descriptor }
      pszDestTblType : PChar;           { NULL for Logical }
      pszDstLangDrv : PChar;            { NULL if no tranliteration }
      pfldDest      : pFLDDesc;         { Source field descriptor }
var   bDataLoss     : Bool;             { Set to TRUE, for data loss }
var   hXlt          : hDBIXlt           { Returned translate handle }
   ): DBIResult;

function DbiTranslateField (            { Translate a field }
      hXlt          : hDBIXlt;          { Translation handle }
      pSrc          : Pointer;          { Source field }
      pDest         : Pointer           { Destination field }
   ): DBIResult;

function DbiCloseFieldXlt (             { Close translation object }
      hXlt          : hDBIXlt           { Translation handle }
   ): DBIResult;


{===========================================================================}
{                                 MISC.                                     }
{===========================================================================}


function DbiGetTableOpenCount (         {  Get local cursor count }
      hDb           : hDBIDb;           { Database }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type /NULL }
var   iOpenCount    : Word              { returned number of cursors }
   ): DBIResult;

function DbiUseIdleTime: DBIResult;

function DbiGetLdObj (                  { Get language driver }
      hCursor       : hDBICur;          { Cursor handle }
var   pLdObj        : Pointer           { Returned language driver object }
   ): DBIResult;

function DbiGetLdName (                 { Get language driver name from table }
      pszDriver     : PChar;            { Driver name }
      pObjName      : PChar;            { Name of object, i.e. table name }
      pLdName       : PChar             { Returned language driver name }
   ): DBIResult;

function DbiFormFullName (              { Form Full Name }
      hDb           : hDBIDb;           { Database handle }
      pszTableName  : PChar;            { Table name }
      pszDriverType : PChar;            { Driver type /NULL }
      pszFullName   : PChar             { Returns full name }
   ): DBIResult;

function DbiAddPassword (               { Add a password to current session }
      pszPassword   : PChar             { Password }
   ): DBIResult;

function DbiDropPassword (              { Drop a password from current session }
      pszPassword   : PChar             { password/NULL }
   ): DBIResult;

function DbiGetNetUserName (            { Get network username }
      pszNetUserName : PChar            { Returns username }
   ): DBIResult;


function DbiDebugLayerOptions (         { Get SDK debug layer options }
      iOption       : Word;             { Option }
      pDebugFile    : PChar
   ): DBIResult;

function DbiOpenCfgInfoList (           { Open a cursor on "Config" }
      hCfg          : hDBICfg;          { NULL }
      eOpenMode     : DBIOpenMode;      { ReadWrite or readonly }
      eConfigMode   : CFGMode;          { Config mode }
      pszCfgPath    : PChar;            { Path }
var   hCur          : hDBICur           { Returned cursor }
   ): DBIResult;

function DbiAddAlias (                  { Add a new alias }
      hCfg          : hDBICfg;          { Config Handle/NULL }
      pszAliasName  : PChar;            { Alias name }
      pszDriverType : PChar;            { Driver type for alias }
      pszParams     : PChar;            { Optional parameters }
      bPersist      : Bool              { Persistent or session relative }
   ): DBIResult;

function DbiDeleteAlias (               { Delete an alias }
      hCfg          : hDBICfg;          { Config Handle/NULL }
      pszAliasName  : PChar             { Alias name }
   ): DBIResult;




{===========================================================================}
{                      Query Management                                     }
{===========================================================================}

function DbiQExecDirect (               { Execute query }
      hDb           : hDBIDb;           { Database handle }
      eQryLang      : DBIQryLang;       { Query language }
      pszQuery      : PChar;            { Query }
      phCur         : phDBICur          { Returned cursor on result set }
   ): DBIResult;

function DbiQPrepare (                  { Prepare a query }
      hDb           : hDBIDb;           { Database handle }
      eQryLang      : DBIQryLang;       { Query language }
      pszQuery      : PChar;            { Query }
var   hStmt         : hDBIStmt          { Returned statment handle }
   ): DBIResult;

function DbiQPrepareExt (               { Prepare a query }
      hDb           : hDBIDb;           { Database handle }
      eQryLang      : DBIQryLang;       { Query language }
      pszQuery      : PChar;            { Query }
      propBits      : Word;             { properties for Prepare, e.g. qprepFORUPDATE }
var   hStmt         : hDBIStmt          { Returned statment handle }
   ): DBIResult;

function DbiQExec (                     { Execute prepared query }
      hStmt         : hDBIStmt;         { Statement handle }
      phCur         : phDBICur          { Returned handle on result set }
   ): DBIResult;

function DbiQFree (                     { Free statement handle }
var   hStmt         : hDBIStmt          { Statement handle }
   ): DBIResult;

function DbiQSetParams (                { Set query options }
      hStmt         : hDBIStmt;         { Statement handle }
      uFldDescs     : Word;             { Number of parameter field descriptors }
      paFldDescs    : pFLDDesc;         { Array of parameter field descriptors }
      pRecBuff      : Pointer           { Record buffer }
   ): DBIResult;

function DbiQInstantiateAnswer (        { Create answer table }
      hStmt         : hDBIStmt;         { Statement Handle }
      hCur          : hDBICur;          { Cursor Handle }
      pszAnswerName : PChar;            { Answer Table Name/NULL }
      pszAnswerType : PChar;            { Answer Table Type/NULL }
      bOverWrite    : Bool;             { Overwrite Flag }
var   hCur          : hDBICur           { cursor to instantiated table (output)(optional) }
   ): DBIResult;

function DbiQExecProcDirect (           { Direct execution of stored procedure }
      hDb           : hDBIDb;           { Database handle }
      pszProc       : PChar;            { Stored procedure name }
      uParamDescs   : Word;             { Number of parameter descriptors }
      paParamDescs  : pSPParamDesc;     { Array of parameter descriptors }
      pRecBuff      : Pointer;          { Record buffer }
var   hCur          : hDBICur           { Returned handle on result set }
   ): DBIResult;

function DbiQPrepareProc (              { Prepare a stored procedure }
      hDb           : hDBIDb;           { Database handle }
      pszProc       : PChar;            { Stored procedure name }
      uParamDescs   : Word;             { Number of parameter descriptors }
      paParamDescs  : pSPParamDesc;     { Array of parameter descriptors }
      pRecBuff      : Pointer;          { Record buffer }
var   hStmt         : hDBIStmt          { Returned statment handle }
   ): DBIResult;

function DbiQSetProcParams (            { Set procedure params }
      hStmt         : hDBIStmt;         { Statement handle }
      uParamDescs   : Word;             { Number of parameter descriptors }
      paParamDescs  : pSPParamDesc;     { Array of parameter descriptors }
      pRecBuff      : Pointer           { Record buffer }
   ): DBIResult;


implementation

function DbiInit(pEnv: PDBIEnv): DbiResult;
begin
  DbiInit := DbiInitFn(DbiINTFVER, pEnv);
end;

{$L IDPAS01.OBJ}
{$L INTFPAS.OBJ}
{$L DBI.OBJ}
function DBIINITFN;                     external;
function DBIEXIT;                       external;
function DBIGETSYSVERSION;              external;
function DBIGETSYSCONFIG;               external;
function DBIGETCLIENTINFO;              external;
function DBIGETSYSINFO;                 external;
function DBILOADDRIVER;                 external;
function DBISTARTSESSION;               external;
function DBIGETCURRSESSION;             external;
function DBISETCURRSESSION;             external;
function DBICLOSESESSION;               external;
function DBIGETSESINFO;                 external;
function DBISETPRIVATEDIR;              external;
function DBIOPENDATABASE;               external;
function DBISETDIRECTORY;               external;
function DBIGETDIRECTORY;               external;
function DBIOPENTABLELIST;              external;
function DBIOPENFILELIST;               external;
function DBIOPENINDEXLIST;              external;
function DBIOPENFIELDLIST;              external;
function DBIOPENVCHKLIST;               external;
function DBIOPENRINTLIST;               external;
function DBIOPENSECURITYLIST;           external;
function DBIOPENFAMILYLIST;             external;
function DBIOPENSPLIST;                 external;
function DBIOPENSPPARAMLIST;            external;
function DBICLOSEDATABASE;              external;
function DBIOPENDRIVERLIST;             external;
function DBIGETDRIVERDESC;              external;
function DBIOPENDATABASELIST;           external;
function DBIGETDATABASEDESC;            external;
function DBIOPENTABLETYPESLIST;         external;
function DBIGETTABLETYPEDESC;           external;
function DBIOPENFIELDTYPESLIST;         external;
function DBIGETFIELDTYPEDESC;           external;
function DBIOPENINDEXTYPESLIST;         external;
function DBIGETINDEXTYPEDESC;           external;
function DBIOPENLDLIST;                 external;
function DBIOPENTABLE;                  external;
function DBIGETCURSORPROPS;             external;
function DBIGETOBJFROMNAME;             external;
function DBIGETOBJFROMOBJ;              external;
function DBIGETPROP;                    external;
function DBISETPROP;                    external;
function DBIVALIDATEPROP;               external;
function DBIGETFIELDDESCS;              external;
function DBIGETCURSORFORTABLE;          external;
function DBICLONECURSOR;                external;
function DBICLOSECURSOR;                external;
function DBIOPENINDEX;                  external;
function DBICLOSEINDEX;                 external;
function DBISWITCHTOINDEX;              external;
function DBIGETINDEXDESC;               external;
function DBIGETINDEXDESCS;              external;
function DBIGETINDEXFORFIELD;           external;
function DBIGETINDEXSEQNO;              external;
function DBISETTOKEY;                   external;
function DBIEXTRACTKEY;                 external;
function DBISETRANGE;                   external;
function DBIRESETRANGE;                 external;
function DBICOMPAREKEYS;                external;
function DBIGETRECORDFORKEY;            external;
function DBIGETVCHKDESC;                external;
function DBIGETRINTDESC;                external;
function DBISETTOBEGIN;                 external;
function DBISETTOEND;                   external;
function DBISETTOCURSOR;                external;
function DBIGETBOOKMARK;                external;
function DBISETTOBOOKMARK;              external;
function DBICOMPAREBOOKMARKS;           external;
function DBIGETNEXTRECORD;              external;
function DBIGETPRIORRECORD;             external;
function DBIGETRECORD;                  external;
function DBIGETRELATIVERECORD;          external;
function DBIINITRECORD;                 external;
function DBIINSERTRECORD;               external;
function DBIMODIFYRECORD;               external;
function DBIDELETERECORD;               external;
function DBIREADBLOCK;                  external;
function DBIWRITEBLOCK;                 external;
function DBIAPPENDRECORD;               external;
function DBIUNDELETERECORD;             external;
function DBIGETSEQNO;                   external;
function DBISETTOSEQNO;                 external;
function DBIGETRECORDCOUNT;             external;
function DBISETTORECORDNO;              external;
function DBISAVECHANGES;                external;
function DBIFORCEREREAD;                external;
function DBICHECKREFRESH;               external;
function DBIMAKEPERMANENT;              external;
function DBIGETFIELD;                   external;
function DBIPUTFIELD;                   external;
function DBIVERIFYFIELD;                external;
function DBIOPENBLOB;                   external;
function DBIGETBLOBSIZE;                external;
function DBIGETBLOB;                    external;
function DBIPUTBLOB;                    external;
function DBITRUNCATEBLOB;               external;
function DBIFREEBLOB;                   external;
function DBIGETBLOBHEADING;             external;
function DBISETFIELDMAP;                external;
function DBIBEGINTRAN;                  external;
function DBIENDTRAN;                    external;
function DBIGETTRANINFO;                external;
function DBIACQTABLELOCK;               external;
function DBIACQPERSISTTABLELOCK;        external;
function DBIRELPERSISTTABLELOCK;        external;
function DBIRELTABLELOCK;               external;
function DBIRELRECORDLOCK;              external;
function DBIISRECORDLOCKED;             external;
function DBIISTABLELOCKED;              external;
function DBIISTABLESHARED;              external;
function DBIOPENLOCKLIST;               external;
function DBIOPENUSERLIST;               external;
function DBISETLOCKRETRY;               external;
function DBIBATCHMOVE;                  external;
function DBICOPYTABLE;                  external;
function DBIEMPTYTABLE;                 external;
function DBIPACKTABLE;                  external;
function DBIREGENINDEX;                 external;
function DBIREGENINDEXES;               external;
function DBISORTTABLE;                  external;
function DBICREATETABLE;                external;
function DBICREATEINMEMTABLE;           external;
function DBICREATETEMPTABLE;            external;
function DBIDORESTRUCTURE;              external;
function DBIRENAMETABLE;                external;
function DBIDELETETABLE;                external;
function DBIADDINDEX;                   external;
function DBIDELETEINDEX;                external;
function DBIGETERRORENTRY;              external;
function DBIGETERRORINFO;               external;
function DBIGETERRORSTRING;             external;
function DBIGETERRORCONTEXT;            external;
function DBIDATEENCODE;                 external;
function DBIDATEDECODE;                 external;
function DBITIMEENCODE;                 external;
function DBITIMEDECODE;                 external;
function DBITIMESTAMPENCODE;            external;
function DBITIMESTAMPDECODE;            external;
function DBIBCDFROMFLOAT;               external;
function DBIBCDTOFLOAT;                 external;
function DBIREGISTERCALLBACK;           external;
function DBIGETCALLBACK;                external;
function DBIGETDATEFORMAT;              external;
function DBISETDATEFORMAT;              external;
function DBIGETTIMEFORMAT;              external;
function DBISETTIMEFORMAT;              external;
function DBIGETNUMBERFORMAT;            external;
function DBISETNUMBERFORMAT;            external;
function DBINATIVETOANSI;               external;
function DBIANSITONATIVE;               external;
function DBIADDFILTER;                  external;
function DBIDROPFILTER;                 external;
function DBIACTIVATEFILTER;             external;
function DBIDEACTIVATEFILTER;           external;
function DBIGETFILTERINFO;              external;
function DBIBEGINLINKMODE;              external;
function DBIENDLINKMODE;                external;
function DBILINKDETAIL;                 external;
function DBILINKDETAILTOEXP;            external;
function DBIUNLINKDETAIL;               external;
function DBIGETLINKSTATUS;              external;
function DBITRANSLATERECORDSTRUCTURE;   external;
function DBIOPENFIELDXLT;               external;
function DBITRANSLATEFIELD;             external;
function DBICLOSEFIELDXLT;              external;
function DBIGETTABLEOPENCOUNT;          external;
function DBIUSEIDLETIME;                external;
function DBIGETLDOBJ;                   external;
function DBIGETLDNAME;                  external;
function DBIFORMFULLNAME;               external;
function DBIADDPASSWORD;                external;
function DBIDROPPASSWORD;               external;
function DBIGETNETUSERNAME;             external;
function DBIDEBUGLAYEROPTIONS;          external;
function DBIOPENCFGINFOLIST;            external;
function DBIQEXECDIRECT;                external;
function DBIQPREPARE;                   external;
function DBIQEXEC;                      external;
function DBIQFREE;                      external;
function DBIQSETPARAMS;                 external;
function DBIQPREPAREEXT;                external;
function DbiQInstantiateAnswer;         external;
function DbiQExecProcDirect;            external;
function DbiQPrepareProc;               external;
function DbiQSetProcParams;             external;
function DbiAddAlias;                   external;
function DbiDeleteAlias;                external;


end.