oracl.h

这是书上的代码

#define OAQ_DQ_NEXT_MSG	3

#define OAQ_DQ_WAIT_FOREVER	-1
#define OAQ_DQ_NOWAIT 0

#define OAQ_MSG_NO_DELAY 0

#define OAQ_MSG_PRIORITY_NORMAL	0
#define OAQ_MSG_PRIORITY_HIGH -10
#define OAQ_MSG_PRIORITY_LOW 10

#define OAQ_MSG_NO_EXPIRE 0
#define OAQ_MAX_AGENTS 10

//Ref
#define OREF_NO_LOCK 1
#define OREF_EXCLUSIVE_LOCK 2
#define OREF_NOWAIT_LOCK 3

#define OREF_READ_ANY 3
#define OREF_READ_RECENT 4
#define OREF_READ_LATEST 5

//MetaData
#define OMD_TABLE 1
#define OMD_VIEW 2
#define OMD_COLUMN 3
#define OMD_COLUMN_LIST	4
#define OMD_TYPE 5
#define OMD_TYPE_ATTR 6
#define OMD_TYPE_ATTR_LIST 7
#define OMD_TYPE_METHOD	8
#define OMD_TYPE_METHOD_LIST 9
#define OMD_TYPE_ARG 10
#define OMD_TYPE_RESULT	11
#define OMD_PROC 12
#define OMD_FUNC 13
#define OMD_ARG	14
#define OMD_ARG_LIST 15	
#define OMD_PACKAGE	16
#define OMD_SUBPROG_LIST 17
#define OMD_COLLECTION 18
#define OMD_SYNONYM	19
#define OMD_SEQENCE	20
#define OMD_SCHEMA 21
#define OMD_OBJECT_LIST	22
#define OMD_SCHEMA_LIST	23
#define OMD_DATABASE 24

// definitions for UpdateSource sources
enum	updsrcs {SYSDATE, TIMESTAMP, DATESTAMP, FUNCTION, OTHFIELD, STRLITERAL};

// forward references
class OEXPORT OSession;
class OEXPORT OSessionCollection;
class OEXPORT OClient;
class OEXPORT OConnection;
class OEXPORT OConnectionCollection;
class OEXPORT ODatabase;
class OEXPORT ODynaset;
class OEXPORT ODynasetMark;
class OEXPORT OField;
class OEXPORT OFieldCollection;
class OEXPORT OAdvise;
class OEXPORT OParameter;
class OEXPORT OParamArray;
class OEXPORT OParameterCollection;
class OEXPORT OSqlStmt;
class OEXPORT OMDAttribute;
class OEXPORT OMetaData;
class OOLEvar;
class OEXPORT OObject;
class OEXPORT ORef;
class OEXPORT OCollection;
class OEXPORT OBlob;
class OEXPORT OClob;
class OEXPORT OBfile;
class OEXPORT OServer;
class OEXPORT OSnapshotID;
class OEXPORT OValue;
class OEXPORT OAQ;
class OEXPORT OAQMsg;
class OEXPORT OAQAgent;
class OEXPORT OAQCallback;
class OEXPORT OException;

// exception specification not supported by MSVC yet
#pragma warning( disable : 4290 ) 

// ------------------------------------------------------------
// functions that are not class methods

// routine to initialize library.  Should be called once at startup 
// returns TRUE if successful, FALSE if not
oboolean OEXPORT OStartup(int ThreadingModel = OSTARTUP_APARTMENTTHREADED); // Threading Model Options


// routine to close down the library.  Should be called once
// at application shutdown
void OEXPORT OShutdown(void);

class COraCriticalSection 
{
public:
	COraCriticalSection()
	{
		InitializeCriticalSection (&m_CritSect);
	}

	~COraCriticalSection()
	{
		DeleteCriticalSection (&m_CritSect);
	}
	
	void Lock()
	{
		EnterCriticalSection(&m_CritSect);
	}

	void Unlock()
	{		
		LeaveCriticalSection(&m_CritSect);
	}

private:
	CRITICAL_SECTION m_CritSect;
};

// ----- OOracleObject -----------------------------------------------
// base object class
//   This class is the base for the OO4W classes.  By itself
//   it provides the error reporting interface and helps with
//   the various copying mechanisms

class OEXPORT OOracleObject
{
friend ORef;
public:
    // constructors & destructors
    OOracleObject(void);
    OOracleObject(const OOracleObject &other);

    virtual ~OOracleObject(void);
    
    // overloaded operators
    OOracleObject &operator=(const OOracleObject &other);
    int operator==(const OOracleObject &other) const;
    int operator!=(const OOracleObject &other) const;
    
    // properties
    virtual oboolean IsOpen(void) const;
    
    // Error handling methods
    long  ErrorNumber(void) const; // return error "number"
    
    const char *LookupErrorText(long errnum) const;  // get error text for given error number
    const char *GetErrorText(void) const;  // get description of last error

    // set error information
    void  ErrorReset(void) const;  // reset error state to "no error"
    // SetOtherError and SetInternalError are for internal use only
    void  SetOtherError(void *otheri) const;
    void  SetInternalError(long errnum) const;
    
    void *Internal(void) const;
	void *DInternal() const;
    
protected:
    // copy and cleanup routines (used to implement destructor, constructor, =)
    virtual oresult Copy(const OOracleObject &other);
    virtual oresult Cleanup(void);
    
    // access to object interface
	oresult SetObjectInterface(void *obji, oboolean geterror = TRUE);
	oresult SetObjectInterface(void *dp, void *id);

    oresult ActionStart(void) const;  // start of most of the methods
    oresult ActionGetStart(const OOracleObject *nobj) const;

	OOracleObject(void *dp, void *id);
	OOracleObject(void *pImpl);

private:
    void   *m_obji;   // pointer to object interface
    void   *m_erri;   // pointer to error interface of object
    void   *m_errotheri;  // pointer to error interface on other object
    char   *m_lasterrstring;  // last error string we've handled
    
    int     m_errstate;   // where did the error come from (values in implementation)
	long    m_errno;  // error number (see below, or negative for internal values)
};


// ----- OOracleCollection -----------------------------------------------
// general set class
// This is a base class used for collections of sessions, connections and fields
// It has no utility on its own.  Routines to get items from the collection are
// in the subclasses

class OEXPORT OOracleCollection : public OOracleObject
{
public:

    // constructors & destructors
    OOracleCollection(void);
    OOracleCollection(const OOracleCollection &other);
    ~OOracleCollection(void);
    
    // Open & Close
    oresult Close(void);   // close the set
    
    // overloaded operators
    OOracleCollection &operator=(const OOracleCollection &other);
    
	 // # of items in the set
    long   GetCount(void) const;

protected:
    oresult OpenSetHelper(void *idisp, void *otheri, unsigned char stype);  // finish the work of opening the set
    void  *GetItem(unsigned char stype, int index) const;
    void  *GetItem(oboolean oflag, const char *name) const;

private:
    unsigned char m_settype;
    
	 // internal helper routines
    oresult Cleanup(void);
	oresult Copy(const OOracleCollection &other);
}                                                       ;

// ----- OSession -----------------------------------------------

class OEXPORT OSession : public OOracleObject
{
public:
    // construction & destruction
    OSession(void);
    OSession(const OSession &other); // copy constructor
    OSession(const char *sname);     // construct & open (NULL sname means open default session)
	~OSession(void);
    
    // open the session
    oresult Open(void);               // open the default session
    oresult Open(const char *sname);  // open a new session with specific name
    oresult Close(void);
    
    // Getting other objects
    OConnectionCollection GetConnections(void) const;
    OClient GetClient(void) const; 
    static OSession GetNamedSession(const char *sname);

    // overloaded operators
    OSession &operator=(const OSession &other);
	
	oresult CreateDatabasePool
	    (long initSize, long maxSize, long timeOut, 
		 const char *dbname, const char *username, 
		 const char *pwd,long options = ODATABASE_DEFAULT);
	
	ODatabase OSession::GetDatabaseFromPool(long waitTime);

	oresult OSession::GetUserPwd(const char *username, const char *pwd, char **retname);

	oresult OSession::DestroyDatabasePool();

	long OSession::GetDbPoolMaxSize() const;

	long OSession::GetDbPoolCurrentSize() const; 

	long OSession::GetDbPoolInitialSize() const;

	long OSession::GetDbPoolUsedCount() const;

    // error handling
    long ServerErrorNumber(void) const;
    const char *GetServerErrorText(void) const;
    oresult ServerErrorReset(void);
    
    // get properties
    const char       *GetName(void) const;   // returns session name 
    const char       *GetVersion(void) const;  // returns version of Oracle Objects
    
    // transaction operations
    oresult  BeginTransaction(void);  // start a transaction
    oresult  Commit(oboolean startnew = FALSE);   // commit (may start new transaction)
    oresult  Rollback(oboolean startnew = FALSE); // rolls back transaction (may start new transaction)
    oresult  ResetTransaction(void);  // unconditionally rollback (no advisories)
   
	//new to 8.1.6
	oresult OSession::ChangePassword(const char *dbalias, const char *username, const char *current_pass, const char *new_pass) const;
    
	// function used by other classes to construct OSession objects (don't call this!)
    oresult OpenHelper(void *idisp, void *otheri);

    // Memory Management Routines
    oresult  MemoryManager (int flags = -1);
    oresult  MemoryLog (int flags = -1);

private:
	char      *m_name;
	char      *m_errtext;
    char      *m_version;
    
    // internal helper routines
    oresult Cleanup(void);
    oresult Copy(const OSession &other);
    
};

// ----- OSessionCollection -----------------------------------------------

class OEXPORT OSessionCollection : public OOracleCollection
{
public:
    OSession GetSession(int index) const;

    // function used by other classes to construct OSessionCollection objects (don't call this!)
    oresult OpenHelper(void *idisp, void *otheri);  // finish the work of opening the set
};

// ----- ODatabase -----------------------------------------------

class OEXPORT ODatabase : public OOracleObject
{
public:
    // construction & destruction
    ODatabase(void);
    ODatabase(const ODatabase &other);
    ~ODatabase(void); 
    
    // construct & open
	 ODatabase(const OSession &dbsess, const char *dbname, const char *username,
					const char *pwd, long options = ODATABASE_DEFAULT);
	 ODatabase(const char *dbname, const char *username, const char *pwd,
					long options = ODATABASE_DEFAULT);

	 ODatabase(const OServer &server, const char *username, const char *pwd,
					long options = ODATABASE_DEFAULT);

	 // for the Open calls, if pwd is NULL it is assumed that username contains username/password

	 // open a database on a new session (implicitly creates a session)
	 oresult Open(const char *dbname, const char *username, const char *pwd,
						long options = ODATABASE_DEFAULT);
	 // open a database on an existing session
	 oresult Open(const OSession &dbsess, const char *dbname,
						const char *username, const char *pwd,
						long options = ODATABASE_DEFAULT);

	 oresult Open(const OServer &server, const char *username, const char *pwd,
						long options = ODATABASE_DEFAULT);

	 oresult Close(void);

	 // getting other objects
	 OSession GetSession(void) const;
	 OConnection GetConnection(void) const;