|
|
|
|
procedure CloseAllSystems; stdcall; exports CloseAllSystems name 'MultSage_CloseAllSystems';
procedure CloseSystem; stdcall; exports CloseSystem name 'MultSage_CloseSystem';
procedure CloseSystemNumber
(const systemNumber : ModSys.INT32); stdcall;
exports CloseSystemNumber name 'MultSage_CloseSystemNumber';
procedure CloseRelation
(const Relation : array of char); overload; stdcall;
exports MultSage.CloseRelation (const Relation : array of char) name 'MultSage_CloseRelation';
procedure CloseRelation
(const Relation : string); overload; stdcall;
exports MultSage.CloseRelation (const Relation : string) name 'MultSage_STRCloseRelation';
function CurrentSystemNumber
() : ModSys.INT32; stdcall;
exports CurrentSystemNumber name 'MultSage_CurrentSystemNumber';
procedure DeleteRecord
(const Relation : array of char); overload; stdcall;
exports MultSage.DeleteRecord (const Relation : array of char) name 'MultSage_DeleteRecord';
procedure DeleteRecord
(const Relation : string); overload; stdcall;
exports MultSage.DeleteRecord (const Relation : string) name 'MultSage_STRDeleteRecord';
procedure DuplicateBlock
(const Relation : array of char;
const Field : array of char); stdcall;
exports DuplicateBlock name 'MultSage_DuplicateBlock';
procedure EnableRecordLocking
(const state : boolean); stdcall;
exports EnableRecordLocking name 'MultSage_EnableRecordLocking';
//*
// EnableRecordLocking - Set the record locking state.
//
//
// If 'State' is True then all record locking procedures are
// enabled, otherwise they are disabled.
//
// Setting 'State' to True provides the maximum protection in
// a multi-user environment. The performance of the system is
// degraded in this mode.
//
// Setting 'State' to False provides the minimum protection in
// a multi-user environment. The performance of the system is
// at its maximum in this mode. In most cases, this mode is used
// where the programmer will control the multi-user aspects of
// the system using the semaphore mechanisms provided herein.
//
// By default the system is set with 'State' as True;
//
// CALLING SEQUENCE -
//
// EnableRecordLocking (State);
//
// ENTRY -
//
// State : boolean
// The desired state for system record locking.
//
procedure ExclusiveReadLockRelation
(const RelationName : array of char;
const LockTimeOut : cardinal); overload; stdcall;
exports ExclusiveReadLockRelation (const RelationName : array of char;
const LockTimeOut : cardinal) name 'MultSage_ExclusiveReadLockRelation';
//*
// ExclusiveReadLockRelation - Read lock an entire relation.
//
//
// The relation 'RelationName' is read locked. This will prohibit
// any other user from reading, rewriting or writing any records in
// the relation.
//
// The procedure will try for 'LockTimeOut' seconds to lock the
// relation. If it times out a sage error will be set. If 'LockTimeOut'
// is 0 it will wait forever.
//
// The difference between this procedure and 'ReadLockRelation' is
// that this procedure cannot be preempted and hence runs faster.
//
// CALLING SEQUENCE -
//
// ExclusiveReadLockRelation (RelationName, LockTimeOut,
// PreemptTimeOut);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation to be locked.
//
// LockTimeOut : cardinal
// The time in seconds to try to lock.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid or the relation
// 'RelationName' is already locked.
//
procedure ExclusiveReadLockRelation
(const RelationName : string;
const LockTimeOut : cardinal); overload; stdcall;
exports ExclusiveReadLockRelation (const RelationName : string;
const LockTimeOut : cardinal) name 'MultSage_STRExclusiveReadLockRelation';
//*
// STRExclusiveReadLockRelation - See documentation of ExclusiveReadLockRelation.
//
procedure ExclusiveUnlockRelation
(const RelationName : array of char); overload; stdcall;
exports ExclusiveUnlockRelation (const RelationName : array of char) name 'MultSage_ExclusiveUnlockRelation';
//*
// ExclusiveUnlockRelation - Unlock an entire relation.
//
//
// The relation 'RelationName' is unlocked.
//
// CALLING SEQUENCE -
//
// ExclusiveUnlockRelation (RelationName);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation to lock.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid, the relation
// 'RelationName' is not locked, or the lock timed out.
//
procedure ExclusiveUnlockRelation
(const RelationName : string); overload; stdcall;
exports ExclusiveUnlockRelation (const RelationName : string) name 'MultSage_STRExclusiveUnlockRelation';
//*
// STRExclusiveUnlockRelation - See documentation of ExclusiveUnlockRelation.
//
procedure ExclusiveWriteLockRelation
(const RelationName : array of char;
const LockTimeOut : cardinal); stdcall;
exports ExclusiveWriteLockRelation name 'MultSage_ExclusiveWriteLockRelation';
//*
// ExclusiveWriteLockRelation - Write lock an entire relation.
//
//
// The relation 'RelationName' is write locked. This will prohibit
// any other user from rewriting or writing any records in the relation.
//
// The procedure will try for 'LockTimeOut' seconds to lock the
// relation. If it times out a sage error will be set. If 'LockTimeOut'
// is 0 it will wait forever.
//
// The difference between this procedure and 'WriteLockRelation' is
// that this procedure cannot be preempted and hence runs faster.
//
// CALLING SEQUENCE -
//
// ExclusiveWriteLockRelation (RelationName,
// LockTimeOut, PreemptTimeOut);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation to be locked.
//
// LockTimeOut : cardinal
// The time in seconds to try to lock.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid or the relation
// 'RelationName' is already locked.
//
function RecordLockPending
(const RelationName : array of char) : boolean; stdcall;
exports RecordLockPending name 'MultSage_RecordLockPending';
//*
// RecordLockPending - A record lock has been requested for next Read.
//
function ExclusiveLocked
(const RelationName : array of char) : boolean; stdcall;
exports ExclusiveLocked name 'MultSage_ExclusiveLocked';
//*
// ExclusiveLocked - Determine if you have an exclusive rel. lock.
//
procedure FindRecord
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations); overload; stdcall;
exports MultSage.FindRecord (const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations) name 'MultSage_FindRecord';
procedure FindRecord
(const Relation : string;
const Field : string;
const Operation : Sage.SageOperations); overload; stdcall;
exports MultSage.FindRecord (const Relation : string;
const Field : string;
const Operation : Sage.SageOperations) name 'MultSage_STRFindRecord';
procedure FindRecordA
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const Alpha : array of char); stdcall;
exports FindRecordA name 'MultSage_FindRecordA';
procedure FindRecordC
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const CardVal : cardinal); stdcall;
exports FindRecordC name 'MultSage_FindRecordC';
procedure FindRecordF
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const RealVal : ModSys.FLOAT32); stdcall;
exports FindRecordF name 'MultSage_FindRecordF';
procedure FindRecordI
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const IntVal : integer); stdcall;
exports FindRecordI name 'MultSage_FindRecordI';
procedure FindRecordN
(const Relation : array of char;
const Field : array of char;
const Number : ModSys.INT32); stdcall;
exports FindRecordN name 'MultSage_FindRecordN';
procedure FindRecordR
(const Relation1 : array of char;
const Field1 : array of char;
const Operation : Sage.SageOperations;
const Relation2 : array of char;
const Field2 : array of char); stdcall;
exports FindRecordR name 'MultSage_FindRecordR';
procedure FindRecordU
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const Value : array of WideChar); stdcall;
exports FindRecordU name 'MultSage_FindRecordU';
procedure GenerateUniqueKey
(const Relation : array of char;
const Field : array of char;
var keyNum : ModSys.INT32); stdcall;
exports GenerateUniqueKey name 'MultSage_GenerateUniqueKey';
procedure GetBlock
(const Relation : array of char;
const Field : array of char;
const Buff : pointer;
var nBytes : cardinal;
var firstByte : ModSys.INT32); overload; stdcall;
exports MultSage.GetBlock (const Relation : array of char;
const Field : array of char;
const Buff : pointer;
var nBytes : cardinal;
var firstByte : ModSys.INT32) name 'MultSage_GetBlock';
procedure GetBlock
(const Relation : string;
const Field : string;
const Buff : pointer;
var nBytes : cardinal;
var firstByte : ModSys.INT32); overload; stdcall;
exports MultSage.GetBlock (const Relation : string;
const Field : string;
const Buff : pointer;
var nBytes : cardinal;
var firstByte : ModSys.INT32) name 'MultSage_STRGetBlock';
procedure GetBlockSize
(const Relation : array of char;
const Field : array of char;
var size : ModSys.INT32); overload; stdcall;
exports MultSage.GetBlockSize (const Relation : array of char;
const Field : array of char;
var size : ModSys.INT32) name 'MultSage_GetBlockSize';
procedure GetBlockSize
(const Relation : string;
const Field : string;
var size : ModSys.INT32); overload; stdcall;
exports MultSage.GetBlockSize (const Relation : string;
const Field : string;
var size : ModSys.INT32) name 'MultSage_STRGetBlockSize';
procedure GetKeyPosition
(const Relation : array of char;
const Field : array of char;
var Position : ModSys.INT32); overload; stdcall;
exports MultSage.GetKeyPosition (const Relation : array of char;
const Field : array of char;
var Position : ModSys.INT32) name 'MultSage_GetKeyPosition';
procedure GetKeyPosition
(const Relation : string;
const Field : string;
var Position : ModSys.INT32); overload; stdcall;
exports MultSage.GetKeyPosition (const Relation : string;
const Field : string;
var Position : ModSys.INT32) name 'MultSage_STRGetKeyPosition';
function GetRecordPreemptTime
() : cardinal; stdcall;
exports GetRecordPreemptTime name 'MultSage_GetRecordPreemptTime';
//*
// GetRecordPreemptTime - Get default record preempt time.
//
//
// The current value of the system default record preempt time
// is returned.
//
// CALLING SEQUENCE -
//
// Seconds := GetRecordPreemptTime ();
//
// ENTRY -
//
// None
// N/A
//
// EXIT -
//
// Seconds : cardinal
// The current value of the system record preempt time.
//
function GetRelationPreemptTime
() : cardinal; stdcall;
exports GetRelationPreemptTime name 'MultSage_GetRelationPreemptTime';
//*
// GetRelationPreemptTime - Get default relation preempt time.
//
//
// The current value of the system default relation preempt time
// is returned.
//
// CALLING SEQUENCE -
//
// Seconds := GetRelationPreemptTime ();
//
// ENTRY -
//
// None
// N/A
//
// EXIT -
//
// Seconds : cardinal
// The current value of the system relation preempt time.
//
procedure GetUserID
(var CurrentUserID : array of char); stdcall;
exports GetUserID name 'MultSage_GetUserID';
//*
// GetUserID - Get the User ID.
//
//
// The current value of the UserID is gotten.
//
// CALLING SEQUENCE -
//
// GetUserID (CurrentUserID);
//
// ENTRY -
//
// None
// N/A
//
// EXIT -
//
// CurrentUserID : array of char
// A three character array.
//
function SystemIsOpen
(const Dictionary : array of char) : boolean; overload; stdcall;
exports MultSage.SystemIsOpen (const Dictionary : array of char) name 'Sage_SystemIsOpen';
//*
// SystemIsOpen - Check if the system is already opened.
//
//
// This routine checks the system name and returns a boolean
// value indicating if that system has already been opened.
//
// CALLING SEQUENCE -
//
// AlreadyOpen := SystemIsOpen (Dictionary)
//
// ENTRY -
//
// Dictionary : array of char
// The name of the dictionary file for the database.
//
// EXIT -
//
// boolean
// TRUE - This system is already open.
// FALSE - This system is currently not open.
//
function SystemIsOpen
(const Dictionary : string) : boolean; overload; stdcall;
exports MultSage.SystemIsOpen (const Dictionary : string) name 'Sage_STRSystemIsOpen';
//*
// STRSystemIsOpen - See documentation of SystemIsOpen.
//
procedure OpenSystem
(const Dictionary : array of char;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal); overload; stdcall;
exports MultSage.OpenSystem (const Dictionary : array of char;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal) name 'MultSage_OpenSystem';
procedure OpenSystem
(const Dictionary : string;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal); overload; stdcall;
exports MultSage.OpenSystem (const Dictionary : string;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal) name 'MultSage_STROpenSystem';
procedure OpenRelation
(const Relation : array of char;
const Modify : boolean); overload; stdcall;
exports MultSage.OpenRelation (const Relation : array of char;
const Modify : boolean) name 'MultSage_OpenRelation';
procedure OpenRelation
(const Relation : string;
const Modify : boolean); overload; stdcall;
exports MultSage.OpenRelation (const Relation : string;
const Modify : boolean) name 'MultSage_STROpenRelation';
procedure PutBlock
(const Relation : array of char;
const Field : array of char;
const Buff : pointer;
const nBytes : cardinal;
var firstByte : ModSys.INT32); overload; stdcall;
exports MultSage.PutBlock (const Relation : array of char;
const Field : array of char;
const Buff : pointer;
const nBytes : cardinal;
var firstByte : ModSys.INT32) name 'MultSage_PutBlock';
procedure PutBlock
(const Relation : string;
const Field : string;
const Buff : pointer;
const nBytes : cardinal;
var firstByte : ModSys.INT32); overload; stdcall;
exports MultSage.PutBlock (const Relation : string;
const Field : string;
const Buff : pointer;
const nBytes : cardinal;
var firstByte : ModSys.INT32) name 'MultSage_STRPutBlock';
procedure ReadLockRecord
(const RelationName : array of char;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal); overload; stdcall;
exports ReadLockRecord (const RelationName : array of char;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal) name 'MultSage_ReadLockRecord';
//*
// ReadLockRecord - Cause next record read to be read locked.
//
//
// The next record read from relation 'RelationName', in any form
// (i.e. ReadRecord, ReadRecordP, etc.), will be read locked.
// This will prohibit any other user from reading or rewriting the
// next record read. To unlock the record either 'ReWrite', 'Delete'
// or 'UnlockRecord' the record.
//
// When the read operation is attempted it will try for 'LockTimeOut'
// seconds to read with lock. If it times out a sage error will be
// set. If 'LockTimeOut' is 0 it will wait forever.
//
// The record lock that occurs as a result of the next read will be
// un-preemptable for either 'PreemptTimeOut' seconds or
// 'SysRecordPreemptTimeOut' seconds, whichever is shorter.
//
// CALLING SEQUENCE -
//
// ReadLockRecord (RelationName, LockTimeOut, PreemptTimeOut);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation whose record is to be locked.
//
// LockTimeOut : cardinal
// The time in seconds to try to read with lock.
//
// PreemptTimeOut : cardinal
// The time in seconds to not allow lock preempting.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid or the relation
// 'RelationName' has a record locked.
//
procedure ReadLockRecord
(const RelationName : string;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal); overload; stdcall;
exports ReadLockRecord (const RelationName : string;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal) name 'MultSage_STRReadLockRecord';
//*
// STRReadLockRecord - See documentation of ReadLockRecord.
//
procedure ReadLockRelation
(const RelationName : array of char;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal); stdcall;
exports ReadLockRelation name 'MultSage_ReadLockRelation';
//*
// ReadLockRelation - Read lock an entire relation.
//
//
// The relation 'RelationName' is read locked. This will prohibit
// any other user from reading, rewriting or writing any records in
// the relation.
//
// The procedure will try for 'LockTimeOut' seconds to lock the
// relation. If it times out a sage error will be set. If 'LockTimeOut'
// is 0 it will wait forever.
//
// The relation lock will be un-preemptable for either 'PreemptTimeOut'
// seconds or 'SysRelationPreemptTimeOut' seconds, whichever
// is shorter.
//
// CALLING SEQUENCE -
//
// ReadLockRelation (RelationName, LockTimeOut, PreemptTimeOut);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation to be locked.
//
// LockTimeOut : cardinal
// The time in seconds to try to lock.
//
// PreemptTimeOut : cardinal
// The time in seconds to not allow lock preempting.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid or the relation
// 'RelationName' is already locked.
//
procedure ReadRecord
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations); overload; stdcall;
exports MultSage.ReadRecord (const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations) name 'MultSage_ReadRecord';
procedure ReadRecord
(const Relation : string;
const Field : string;
const Operation : Sage.SageOperations); overload; stdcall;
exports MultSage.ReadRecord (const Relation : string;
const Field : string;
const Operation : Sage.SageOperations) name 'MultSage_STRReadRecord';
procedure ReadRecordA
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const Alpha : array of char); stdcall;
exports ReadRecordA name 'MultSage_ReadRecordA';
procedure ReadRecordC
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const CardVal : cardinal); stdcall;
exports ReadRecordC name 'MultSage_ReadRecordC';
procedure ReadRecordF
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const RealVal : ModSys.FLOAT32); stdcall;
exports ReadRecordF name 'MultSage_ReadRecordF';
procedure ReadRecordI
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const IntVal : integer); stdcall;
exports ReadRecordI name 'MultSage_ReadRecordI';
procedure ReadRecordN
(const Relation : array of char;
const Field : array of char;
const Number : ModSys.INT32); overload; stdcall;
exports MultSage.ReadRecordN (const Relation : array of char;
const Field : array of char;
const Number : ModSys.INT32) name 'MultSage_ReadRecordN';
procedure ReadRecordN
(const Relation : string;
const Field : string;
const Number : ModSys.INT32); overload; stdcall;
exports MultSage.ReadRecordN (const Relation : string;
const Field : string;
const Number : ModSys.INT32) name 'MultSage_STRReadRecordN';
procedure ReadRecordP
(const Relation : array of char;
const Field : array of char;
const Number : ModSys.INT32); overload; stdcall;
exports MultSage.ReadRecordP (const Relation : array of char;
const Field : array of char;
const Number : ModSys.INT32) name 'MultSage_ReadRecordP';
procedure ReadRecordP
(const Relation : string;
const Field : string;
const Number : ModSys.INT32); overload; stdcall;
exports MultSage.ReadRecordP (const Relation : string;
const Field : string;
const Number : ModSys.INT32) name 'MultSage_STRReadRecordP';
procedure ReadRecordR
(const Relation1 : array of char;
const Field1 : array of char;
const Operation : Sage.SageOperations;
const Relation2 : array of char;
const Field2 : array of char); stdcall;
exports ReadRecordR name 'MultSage_ReadRecordR';
procedure ReadRecordU
(const Relation : array of char;
const Field : array of char;
const Operation : Sage.SageOperations;
const Value : array of WideChar); stdcall;
exports ReadRecordU name 'MultSage_ReadRecordU';
function RelationIsOpen
(const Relation : array of char) : boolean; overload; stdcall;
exports MultSage.RelationIsOpen (const Relation : array of char) name 'MultSage_RelationIsOpen';
//*
// RelationIsOpen - Check to see if relation is open.
//
// (Refer to the documentation for the same procedure in the Sage package).
//
function RelationIsOpen
(const Relation : string) : boolean; overload; stdcall;
exports MultSage.RelationIsOpen (const Relation : string) name 'MultSage_STRRelationIsOpen';
//*
// STRRelationIsOpen - See documentation of RelationIsOpen.
//
function RelationOpenForModify
(const Relation : array of char) : boolean; stdcall;
exports RelationOpenForModify name 'MultSage_RelationOpenForModify';
//*
// RelationOpenForModify - Check to see if relation is opened for modify.
//
// (Refer to the documentation for the same procedure in the Sage package).
//
procedure ReWriteRecord
(const Relation : array of char); overload; stdcall;
exports MultSage.ReWriteRecord (const Relation : array of char) name 'MultSage_ReWriteRecord';
procedure ReWriteRecord
(const Relation : string); overload; stdcall;
exports MultSage.ReWriteRecord (const Relation : string) name 'MultSage_STRReWriteRecord';
function RecordIsWriteLocked
(const Relation : array of char) : boolean; stdcall;
exports RecordIsWriteLocked name 'MultSage_RecordIsWriteLocked';
//*
// RecordIsWriteLocked - The record has a write lock.
//
// This function returns a true if a write permission lock is
// currently in place. This could be if :
// 1. A record write lock was requested on a record and has not
// been preempted.
// 2. An exclusive read or write lock is in force for the relation.
// 3. Locking has been turned off
//
procedure SetRecordPreemptTime
(const Seconds : cardinal); stdcall;
exports SetRecordPreemptTime name 'MultSage_SetRecordPreemptTime';
//*
// SetRecordPreemptTime - Set default record preempt time.
//
//
// The system default record preempt time is set to 'Seconds'.
//
// This value sets the upper limit on the preempt time for
// record locks.
//
// CALLING SEQUENCE -
//
// SetRecordPreemptTime (Seconds);
//
// ENTRY -
//
// Seconds : cardinal
// The number of seconds to set the record preempt time
// limit to.
//
// EXIT -
//
// None
// N/A
//
procedure SetRelationPreemptTime
(const Seconds : cardinal); stdcall;
exports SetRelationPreemptTime name 'MultSage_SetRelationPreemptTime';
//*
// SetRelationPreemptTime - Set default relation preempt time.
//
//
// The system default relation preempt time is set to 'Seconds'.
//
// This value sets the upper limit on the preempt time for
// relation locks.
//
// CALLING SEQUENCE -
//
// SetRelationPreemptTime (Seconds);
//
// ENTRY -
//
// Seconds : cardinal
// The number of seconds to set the relation preempt time
// limit to.
//
procedure SetToSystemNumber
(const systemNumber : ModSys.INT32); stdcall;
exports SetToSystemNumber name 'MultSage_SetToSystemNumber';
procedure SetUserID
(const NewUserID : array of char); overload; stdcall;
exports SetUserID (const NewUserID : array of char) name 'MultSage_SetUserID';
//*
// SetUserID - Set the User ID.
//
//
// The current value of the UserID is set.
//
// CALLING SEQUENCE -
//
// SetUserID (NewUserID);
//
// ENTRY -
//
// NewUserID : array of char
// A three character array.
//
procedure SetUserID
(const NewUserID : string); overload; stdcall;
exports SetUserID (const NewUserID : string) name 'MultSage_STRSetUserID';
//*
// STRSetUserID - See documentation of SetUserID.
//
function TotalRecords
(const relName : array of char) : ModSys.INT32; overload; stdcall;
exports MultSage.TotalRecords (const relName : array of char) name 'MultSage_TotalRecords';
function TotalRecords
(const relName : string) : ModSys.INT32; overload; stdcall;
exports MultSage.TotalRecords (const relName : string) name 'MultSage_STRTotalRecords';
procedure TruncateBlock
(const Relation : array of char;
const Field : array of char;
var firstByte : ModSys.INT32); overload; stdcall;
exports MultSage.TruncateBlock (const Relation : array of char;
const Field : array of char;
var firstByte : ModSys.INT32) name 'MultSage_TruncateBlock';
procedure TruncateBlock
(const Relation : string;
const Field : string;
var firstByte : ModSys.INT32); overload; stdcall;
exports MultSage.TruncateBlock (const Relation : string;
const Field : string;
var firstByte : ModSys.INT32) name 'MultSage_STRTruncateBlock';
procedure UnlockRecord
(const RelationName : array of char); overload; stdcall;
exports UnlockRecord (const RelationName : array of char) name 'MultSage_UnlockRecord';
//*
// UnlockRecord - Unlock a pending record lock.
//
//
// If the relation 'RelationName' has a record locked then the record is
// unlocked. No data base update is associated with this operation.
//
// CALLING SEQUENCE -
//
// UnlockRecord (RelationName);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation whose record is to be unlocked.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid, the relation
// 'RelationName' has no record locked, or the record lock timed
// out.
//
procedure UnlockRecord
(const RelationName : string); overload; stdcall;
exports UnlockRecord (const RelationName : string) name 'MultSage_STRUnlockRecord';
//*
// STRUnlockRecord - See documentation of UnlockRecord.
//
procedure UnlockRelation
(const RelationName : array of char); stdcall;
exports UnlockRelation name 'MultSage_UnlockRelation';
//*
// UnlockRelation - Unlock an entire relation.
//
//
// The relation 'RelationName' is unlocked.
//
// CALLING SEQUENCE -
//
// UnlockRelation (RelationName);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation to lock.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid, the relation
// 'RelationName' is not locked, or the lock timed out.
//
procedure WriteLockRecord
(const RelationName : array of char;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal); overload; stdcall;
exports WriteLockRecord (const RelationName : array of char;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal) name 'MultSage_WriteLockRecord';
//*
// WriteLockRecord - Cause next record read to be write locked.
//
//
// The next record read from relation 'RelationName', in any form
// (i.e. ReadRecord, ReadRecordP, etc.), will be write locked.
// This will prohibit any other user from rewriting the
// next record read. To unlock the record either 'ReWrite', 'Delete'
// or 'UnlockRecord' the record.
//
// When the read operation is attempted it will try for 'LockTimeOut'
// seconds to read with lock. If it times out a sage error will
// be set. If 'LockTimeOut' is 0 it will wait forever.
//
// The record lock that occurs as a result of the next read will be
// un-preemptable for either 'PreemptTimeOut' seconds or
// 'SysRecordPreemptTimeOut' seconds, whichever is shorter.
//
// CALLING SEQUENCE -
//
// WriteLockRecord (RelationName, LockTimeOut, PreemptTimeOut);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation whose record is to be locked.
//
// LockTimeOut : cardinal
// The time in seconds to try to read with lock.
//
// PreemptTimeOut : cardinal
// The time in seconds to not allow lock preempting.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid or the relation
// 'RelationName' has a record locked.
//
procedure WriteLockRecord
(const RelationName : string;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal); overload; stdcall;
exports WriteLockRecord (const RelationName : string;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal) name 'MultSage_STRWriteLockRecord';
//*
// STRWriteLockRecord - See documentation of WriteLockRecord.
//
procedure WriteLockRelation
(const RelationName : array of char;
const LockTimeOut : cardinal;
const PreemptTimeOut : cardinal); stdcall;
exports WriteLockRelation name 'MultSage_WriteLockRelation';
//*
// WriteLockRelation - Write lock an entire relation.
//
//
// The relation 'RelationName' is write locked. This will prohibit
// any other user from rewriting or writing any records in the relation.
//
// The procedure will try for 'LockTimeOut' seconds to lock the
// relation. If it times out a sage error will be set. If 'LockTimeOut'
// is 0 it will wait forever.
//
// The relation lock will be un-preemptable for either 'PreemptTimeOut'
// seconds or 'SysRelationPreemptTimeOut' seconds, whichever
// is shorter.
//
// CALLING SEQUENCE -
//
// WriteLockRelation (RelationName, LockTimeOut, PreemptTimeOut);
//
// ENTRY -
//
// RelationName : array of char
// The name of the relation to be locked.
//
// LockTimeOut : cardinal
// The time in seconds to try to lock.
//
// PreemptTimeOut : cardinal
// The time in seconds to not allow lock preempting.
//
// EXIT -
//
// Sage error is set if 'RelationName' is invalid or the relation
// 'RelationName' is already locked.
//
procedure WriteRecord
(const Relation : array of char); overload; stdcall;
exports MultSage.WriteRecord (const Relation : array of char) name 'MultSage_WriteRecord';
procedure WriteRecord
(const Relation : string); overload; stdcall;
exports MultSage.WriteRecord (const Relation : string) name 'MultSage_STRWriteRecord';
procedure GetRecordLocking
(var lockingEnabled : boolean); stdcall;
exports GetRecordLocking name 'MultSage_GetRecordLocking';
procedure ReduceLongUserID
(const longUserID : array of char;
var acceptedUserID : array of char); overload; stdcall;
exports ReduceLongUserID (const longUserID : array of char;
var acceptedUserID : array of char) name 'MultSage_ReduceLongUserID';
//*
// ReduceLongUserID - Reduce a long user ID to an acceptable unique 3 char. one.
//
procedure ReduceLongUserID
(const longUserID : string;
var acceptedUserID : array of char); overload; stdcall;
exports ReduceLongUserID (const longUserID : string;
var acceptedUserID : array of char) name 'MultSage_STRReduceLongUserID';
//*
// STRReduceLongUserID - See documentation of ReduceLongUserID.
//
procedure GetMaxUsers
(var maximumUsers : cardinal); stdcall;
exports GetMaxUsers name 'MultSage_GetMaxUsers';
procedure SetMaxUsers
(const maximumUsers : cardinal); stdcall;
exports SetMaxUsers name 'MultSage_SetMaxUsers';
function OpenSystemDirect
(const Dictionary : array of char;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal) : ModSys.INT32; overload; stdcall;
exports MultSage.OpenSystemDirect (const Dictionary : array of char;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal) name 'MultSage_MultOpenSystemDirect';
function OpenSystemDirect
(const Dictionary : string;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal) : ModSys.INT32; overload; stdcall;
exports MultSage.OpenSystemDirect (const Dictionary : string;
const MaxForms : cardinal;
const MaxScreens : cardinal;
const BufferSize : cardinal) name 'MultSage_STRMultOpenSystemDirect';
procedure CloseSystemDirect
(const systemNumber : ModSys.INT32); stdcall;
exports CloseSystemDirect name 'MultSage_CloseSystemDirect';
procedure OpenRelationDirect
(const systemNumber : cardinal;
const relationNumber : cardinal;
const Modify : boolean); stdcall;
exports OpenRelationDirect name 'MultSage_OpenRelationDirect';
procedure CloseRelationDirect
(const systemNumber : cardinal;
const relationNumber : cardinal); stdcall;
exports CloseRelationDirect name 'MultSage_CloseRelationDirect';
function TotalRecordsDirect
(const systemNumber : cardinal;
const relationNumber : cardinal) : ModSys.INT32; stdcall;
exports TotalRecordsDirect name 'MultSage_TotalRecordsDirect';
function RelationIsOpenDirect
(const systemNumber : cardinal;
const relationNumber : cardinal) : boolean; stdcall;
exports RelationIsOpenDirect name 'MultSage_RelationIsOpenDirect';
Send mail to
warren.merrill@inl.gov
with questions or comments about this web site.
Copyright © 1989-2006 Battelle Energy Alliance