CydandClaude Fable 5
63312e07f9
- BORLAND/: Borland C++ 4.52 (chosen over 4.5 by byte-match: CODE/RP/CW32.LIB
is identical to 4.52's install lib). BCC32/TLINK32/TLIB/MAKE run natively on
Win11; CODE/BT/OPT.MAK is the shipped BTL4OPT.EXE's exact flag recipe
(extender = Borland PowerPack DPMI32, not Phar Lap TNT).
- restoration/source410/: the literal 1995-form reconstruction of the missing
BT game source (never mixed into CODE/). Round 1-3 state:
* 6 of 10 surviving original TUs COMPILE CLEAN under the period toolchain
(BTMSSN, BTCNSL, BTSCNRL, BTTEAM, BTL4MODE, BTL4ARND) - first builds
since 1996.
* BT_L4/BTL4APP.CPP pilot reconstruction: 12/12 functions, Fail() lands on
its binary-recorded line 400 exactly.
* BT/BTCNSL.HPP: console wire IDs recovered from the binary's ctors
(Killed=9, Damaged=10, ScoreUpdate=13, DeathWithoutHonor=15 [T1];
TeamScore=12 flagged [T4]).
* MUNGA/: 8 engine-header backfills back-dated from the BT412 WinTesla tree
(VDATA numbering decomp-verified; AUDREND's OpenAL-era virtual removed -
the period compiler is the drift detector).
* Tooling: backdate.py (WinTesla->1995 header transform), compile410.sh
(per-TU verification sweep under authentic OPT.MAK flags).
* README: corrected roadmap - MECH.HPP is the capstone grown with the mech
TU reconstructions; BTREG.CPP green = the header-family milestone.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
1554 lines
73 KiB
ObjectPascal
1554 lines
73 KiB
ObjectPascal
{*******************************************************}
|
|
{ }
|
|
{ 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.
|