DatabaseAccess.h

Go to the documentation of this file.

 
#ifndef __DATABASEACCESS__
#define __DATABASEACCESS__
 
#ifndef __RESOURCES__
#include <Resources.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  enum
  {
    typeNone = FOUR_CHAR_CODE('none'),
    typeDate = FOUR_CHAR_CODE('date'),
    typeTime = FOUR_CHAR_CODE('time'),
    typeTimeStamp = FOUR_CHAR_CODE('tims'),
    typeDecimal = FOUR_CHAR_CODE('deci'),
    typeMoney = FOUR_CHAR_CODE('mone'),
    typeVChar = FOUR_CHAR_CODE('vcha'),
    typeVBin = FOUR_CHAR_CODE('vbin'),
    typeLChar = FOUR_CHAR_CODE('lcha'),
    typeLBin = FOUR_CHAR_CODE('lbin'),
    typeDiscard = FOUR_CHAR_CODE('disc'), 
    typeUnknown = FOUR_CHAR_CODE('unkn'),
    typeColBreak = FOUR_CHAR_CODE('colb'),
    typeRowBreak =
        FOUR_CHAR_CODE('rowb'), 
    typeAnyType = 0
  };
 
  enum
  {
    kDBUpdateWind = 0,
    kDBAboutToInit = 1,
    kDBInitComplete = 2,
    kDBSendComplete = 3,
    kDBExecComplete = 4,
    kDBStartQueryComplete = 5
  };
 
  enum
  {
    kDBGetItemComplete = 6,
    kDBGetQueryResultsComplete = 7,
    kDBWaitForever = -1
  };
 
  enum
  {
    kDBLastColFlag = 0x0001,
    kDBNullFlag = 0x0004
  };
 
  typedef OSType DBType;
  typedef struct DBAsyncParamBlockRec DBAsyncParamBlockRec;
  typedef DBAsyncParamBlockRec *DBAsyncParmBlkPtr;
  typedef CALLBACK_API_REGISTER68K(void, DBCompletionProcPtr,
                                   (DBAsyncParmBlkPtr pb));
  typedef REGISTER_UPP_TYPE(DBCompletionProcPtr) DBCompletionUPP;
  struct DBAsyncParamBlockRec
  {
    DBCompletionUPP completionProc; 
    OSErr result;                   
    long userRef;                   
    long ddevRef;                   
    long reserved;                  
  };
 
  struct ResListElem
  {
    ResType theType; 
    short id;        
  };
  typedef struct ResListElem ResListElem;
  typedef ResListElem *ResListPtr;
  typedef ResListPtr *ResListHandle;
  typedef Handle QueryArray[256];
  typedef Handle *QueryListPtr;
  typedef QueryListPtr *QueryListHandle;
  struct QueryRecord
  {
    short version;             
    short id;                  
    Handle queryProc;          
    Str63 ddevName;            
    Str255 host;               
    Str255 user;               
    Str255 password;           
    Str255 connStr;            
    short currQuery;           
    short numQueries;          
    QueryListHandle queryList; 
    short numRes;              
    ResListHandle resList;     
    Handle dataHandle;         
    long refCon;               
  };
  typedef struct QueryRecord QueryRecord;
  typedef QueryRecord *QueryPtr;
  typedef QueryPtr *QueryHandle;
  typedef DBType ColTypesArray[256];
  typedef Handle ColTypesHandle;
  struct DBColInfoRecord
  {
    short len;
    short places;
    short flags;
  };
  typedef struct DBColInfoRecord DBColInfoRecord;
  typedef DBColInfoRecord ColInfoArray[256];
  typedef Handle ColInfoHandle;
  struct ResultsRecord
  {
    short numRows;           
    short numCols;           
    ColTypesHandle colTypes; 
    Handle colData;          
    ColInfoHandle colInfo;   
  };
  typedef struct ResultsRecord ResultsRecord;
  enum
  {
    kDBInit = 0,
    kDBEnd = 1,
    kDBGetConnInfo = 2,
    kDBGetSessionNum = 3,
    kDBSend = 4,
    kDBSendItem = 5,
    kDBExec = 6,
    kDBState = 7,
    kDBGetErr = 8,
    kDBBreak = 9,
    kDBGetItem = 10,
    kDBUngetItem = 11,
    kDBKill = 12,
    kDBOpen = 100,
    kDBClose = 101,
    kDBIdle = 102
  };
 
  typedef CALLBACK_API(OSErr, DBQueryDefProcPtr)(long *sessID, QueryHandle query);
  typedef CALLBACK_API(Boolean, DBStatusProcPtr)(short message, OSErr result,
                                                 short dataLen, short dataPlaces,
                                                 short dataFlags, DBType dataType,
                                                 Ptr dataPtr);
  typedef CALLBACK_API(OSErr,
                       DBResultHandlerProcPtr)(DBType dataType, short theLen,
                                               short thePlaces, short theFlags,
                                               Ptr theData, Handle theText);
  typedef STACK_UPP_TYPE(DBQueryDefProcPtr) DBQueryDefUPP;
  typedef STACK_UPP_TYPE(DBStatusProcPtr) DBStatusUPP;
  typedef STACK_UPP_TYPE(DBResultHandlerProcPtr) DBResultHandlerUPP;
#if CALL_NOT_IN_CARBON
  DBCompletionUPP
  NewDBCompletionUPP(DBCompletionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDBCompletionProcInfo = 0x0000B802
  }; 
#ifdef __cplusplus
  inline DBCompletionUPP NewDBCompletionUPP(DBCompletionProcPtr userRoutine)
  {
    return (DBCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                 uppDBCompletionProcInfo,
                                                 GetCurrentArchitecture());
  }
#else
#define NewDBCompletionUPP(userRoutine)                                     \
  (DBCompletionUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppDBCompletionProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  DBQueryDefUPP
  NewDBQueryDefUPP(DBQueryDefProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDBQueryDefProcInfo = 0x000003E0
  }; 
#ifdef __cplusplus
  inline DBQueryDefUPP NewDBQueryDefUPP(DBQueryDefProcPtr userRoutine)
  {
    return (DBQueryDefUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDBQueryDefProcInfo, GetCurrentArchitecture());
  }
#else
#define NewDBQueryDefUPP(userRoutine)   \
  (DBQueryDefUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppDBQueryDefProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  DBStatusUPP
  NewDBStatusUPP(DBStatusProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDBStatusProcInfo = 0x000FAA90
  }; 
#ifdef __cplusplus
  inline DBStatusUPP NewDBStatusUPP(DBStatusProcPtr userRoutine)
  {
    return (DBStatusUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDBStatusProcInfo, GetCurrentArchitecture());
  }
#else
#define NewDBStatusUPP(userRoutine)   \
  (DBStatusUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppDBStatusProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  DBResultHandlerUPP
  NewDBResultHandlerUPP(DBResultHandlerProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDBResultHandlerProcInfo = 0x0003EAE0
  }; 
#ifdef __cplusplus
  inline DBResultHandlerUPP
  NewDBResultHandlerUPP(DBResultHandlerProcPtr userRoutine)
  {
    return (DBResultHandlerUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                    uppDBResultHandlerProcInfo,
                                                    GetCurrentArchitecture());
  }
#else
#define NewDBResultHandlerUPP(userRoutine)                                     \
  (DBResultHandlerUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppDBResultHandlerProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeDBCompletionUPP(DBCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDBCompletionUPP(DBCompletionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDBCompletionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeDBQueryDefUPP(DBQueryDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDBQueryDefUPP(DBQueryDefUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDBQueryDefUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeDBStatusUPP(DBStatusUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDBStatusUPP(DBStatusUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDBStatusUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeDBResultHandlerUPP(DBResultHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDBResultHandlerUPP(DBResultHandlerUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDBResultHandlerUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter InvokeDBCompletionUPP(__A1, __A0)
#endif
  void
  InvokeDBCompletionUPP(DBAsyncParmBlkPtr pb, DBCompletionUPP userUPP);
#if !OPAQUE_UPP_TYPES && \
    (!TARGET_OS_MAC || !TARGET_CPU_68K || TARGET_RT_MAC_CFM)
#ifdef __cplusplus
  inline void InvokeDBCompletionUPP(DBAsyncParmBlkPtr pb,
                                    DBCompletionUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppDBCompletionProcInfo, pb);
  }
#else
#define InvokeDBCompletionUPP(pb, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppDBCompletionProcInfo, (pb))
#endif
#endif
 
  OSErr
  InvokeDBQueryDefUPP(long *sessID, QueryHandle query, DBQueryDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeDBQueryDefUPP(long *sessID, QueryHandle query,
                                   DBQueryDefUPP userUPP)
  {
    return (OSErr)CALL_TWO_PARAMETER_UPP(userUPP, uppDBQueryDefProcInfo, sessID,
                                         query);
  }
#else
#define InvokeDBQueryDefUPP(sessID, query, userUPP)                          \
  (OSErr) CALL_TWO_PARAMETER_UPP((userUPP), uppDBQueryDefProcInfo, (sessID), \
                                 (query))
#endif
#endif
 
  Boolean
  InvokeDBStatusUPP(short message, OSErr result, short dataLen, short dataPlaces,
                    short dataFlags, DBType dataType, Ptr dataPtr,
                    DBStatusUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeDBStatusUPP(short message, OSErr result, short dataLen,
                                   short dataPlaces, short dataFlags,
                                   DBType dataType, Ptr dataPtr,
                                   DBStatusUPP userUPP)
  {
    return (Boolean)CALL_SEVEN_PARAMETER_UPP(userUPP, uppDBStatusProcInfo,
                                             message, result, dataLen, dataPlaces,
                                             dataFlags, dataType, dataPtr);
  }
#else
#define InvokeDBStatusUPP(message, result, dataLen, dataPlaces, dataFlags, \
                          dataType, dataPtr, userUPP)                      \
  (Boolean) CALL_SEVEN_PARAMETER_UPP(                                      \
      (userUPP), uppDBStatusProcInfo, (message), (result), (dataLen),      \
      (dataPlaces), (dataFlags), (dataType), (dataPtr))
#endif
#endif
 
  OSErr
  InvokeDBResultHandlerUPP(DBType dataType, short theLen, short thePlaces,
                           short theFlags, Ptr theData, Handle theText,
                           DBResultHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeDBResultHandlerUPP(DBType dataType, short theLen,
                                        short thePlaces, short theFlags,
                                        Ptr theData, Handle theText,
                                        DBResultHandlerUPP userUPP)
  {
    return (OSErr)CALL_SIX_PARAMETER_UPP(userUPP, uppDBResultHandlerProcInfo,
                                         dataType, theLen, thePlaces, theFlags,
                                         theData, theText);
  }
#else
#define InvokeDBResultHandlerUPP(dataType, theLen, thePlaces, theFlags, \
                                 theData, theText, userUPP)             \
  (OSErr) CALL_SIX_PARAMETER_UPP((userUPP), uppDBResultHandlerProcInfo, \
                                 (dataType), (theLen), (thePlaces),     \
                                 (theFlags), (theData), (theText))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewDBCompletionProc(userRoutine) NewDBCompletionUPP(userRoutine)
#define NewDBQueryDefProc(userRoutine) NewDBQueryDefUPP(userRoutine)
#define NewDBStatusProc(userRoutine) NewDBStatusUPP(userRoutine)
#define NewDBResultHandlerProc(userRoutine) NewDBResultHandlerUPP(userRoutine)
#define CallDBCompletionProc(userRoutine, pb) \
  InvokeDBCompletionUPP(pb, userRoutine)
#define CallDBQueryDefProc(userRoutine, sessID, query) \
  InvokeDBQueryDefUPP(sessID, query, userRoutine)
#define CallDBStatusProc(userRoutine, message, result, dataLen, dataPlaces,    \
                         dataFlags, dataType, dataPtr)                         \
  InvokeDBStatusUPP(message, result, dataLen, dataPlaces, dataFlags, dataType, \
                    dataPtr, userRoutine)
#define CallDBResultHandlerProc(userRoutine, dataType, theLen, thePlaces,  \
                                theFlags, theData, theText)                \
  InvokeDBResultHandlerUPP(dataType, theLen, thePlaces, theFlags, theData, \
                           theText, userRoutine)
#endif 
#if CALL_NOT_IN_CARBON
  OSErr
  InitDBPack(void);
 
  OSErr
  DBInit(long *sessID, ConstStr63Param ddevName, ConstStr255Param host,
         ConstStr255Param user, ConstStr255Param passwd, ConstStr255Param connStr,
         DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBEnd(long sessID, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBGetConnInfo(long sessID, short sessNum, long *returnedID, long *version,
                Str63 ddevName, Str255 host, Str255 user, Str255 network,
                Str255 connStr, long *start, OSErr *state,
                DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBGetSessionNum(long sessID, short *sessNum, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBSend(long sessID, Ptr text, short len, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBSendItem(long sessID, DBType dataType, short len, short places, short flags,
             void *buffer, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBExec(long sessID, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBState(long sessID, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBGetErr(long sessID, long *err1, long *err2, Str255 item1, Str255 item2,
           Str255 errorMsg, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBBreak(long sessID, Boolean abort, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBGetItem(long sessID, long timeout, DBType *dataType, short *len,
            short *places, short *flags, void *buffer, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBUnGetItem(long sessID, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBKill(DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBGetNewQuery(short queryID, QueryHandle *query);
 
  OSErr
  DBDisposeQuery(QueryHandle query);
 
  OSErr
  DBStartQuery(long *sessID, QueryHandle query, DBStatusUPP statusProc,
               DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBGetQueryResults(long sessID, ResultsRecord *results, long timeout,
                    DBStatusUPP statusProc, DBAsyncParmBlkPtr asyncPB);
 
  OSErr
  DBResultsToText(ResultsRecord *results, Handle *theText);
 
  OSErr
  DBInstallResultHandler(DBType dataType, DBResultHandlerUPP theHandler,
                         Boolean isSysHandler);
 
  OSErr
  DBRemoveResultHandler(DBType dataType);
 
  OSErr
  DBGetResultHandler(DBType dataType, DBResultHandlerUPP *theHandler,
                     Boolean getSysHandler);
 
  OSErr
  DBIdle(void);
 
#endif 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif