sqlapi.h

SQLAPI C/C++ 连接Oracle 数据库！

#if !defined(__SQLAPI_H__)
#define __SQLAPI_H__

#ifdef SQLAPI_EXPORTS
	#define SQLAPI_API __declspec(dllexport)
#else
	#define SQLAPI_API
#endif

#ifdef SQLAPI_DECL_THROW
	#define SQLAPI_THROW(x) throw(x)
#else
	#define SQLAPI_THROW(x)
#endif

#if defined(_WIN32) || defined(_WINDOWS) || defined(WIN32) || defined(_WINDOWS_)
#define SQLAPI_WIN32
#endif

#if !defined(SQLAPI_WIN32) || defined (CYGWIN)
#include <wchar.h>
#include <wctype.h>
#endif

#include <sys/types.h>
#ifndef SQLAPI_WIN32
#include <sys/time.h>
#endif
#include <sys/timeb.h>
#include <time.h>
#include <stdarg.h>

#ifdef SQLAPI_WIN32
// 64-bit integer
typedef __int64 sa_int64_t;
typedef unsigned __int64 sa_uint64_t;
// SQLAPI callback naming
#define SQLAPI_CALLBACK __cdecl
#else
// 64-bit integer
#include <inttypes.h>
typedef int64_t sa_int64_t;
typedef uint64_t sa_uint64_t;
// SQLAPI callback naming
#define SQLAPI_CALLBACK
#endif // ! SQLAPI_WIN32

class ISAClient;
class ISAConnection;
class ISACursor;

class SAMutex;

class SAConnection;
class SACommand;
struct sa_Commands;
class saOptions;
class SAParam;
class SAField;

class SAException;

class saPlaceHolder;

class SABytes;
class SALongBinary;
class SALongChar;
class SABLob;
class SACLob;
class SAValueRead;

//! \addtogroup enums SQLAPI++ defined enums
//! \{

typedef
enum
{
	//! DBMS client is not specified
	SA_Client_NotSpecified,
	//! ODBC
	SA_ODBC_Client,
	//! Oracle
	SA_Oracle_Client,
	//! Microsoft SQL Server
	SA_SQLServer_Client,
	//! InterBase or Firebird
	SA_InterBase_Client,
	//! SQLBase
	SA_SQLBase_Client,
	//! IBM DB2
	SA_DB2_Client,
	//! Informix
	SA_Informix_Client,
	//! Sybase ASE 
	SA_Sybase_Client,
	//! MySQL
	SA_MySQL_Client,
	//! PostgreSQL
	SA_PostgreSQL_Client,
	//! SQLite
	SA_SQLite_Client,
	_SA_Client_Reserverd = (int)(((unsigned int)(-1))/2)
} SAClient_t;

typedef
enum
{
	//! no error occurred
	SA_No_Error,
	//! user-generated error
	SA_UserGenerated_Error,
	//! the Library-generated error
	SA_Library_Error,
	//! DBMS API error occured
	SA_DBMS_API_Error,
	_SA_ErrorClass_Reserved = (int)(((unsigned int)(-1))/2)
} SAErrorClass_t;

typedef
enum
{
	//! the default(unknown) isolation level
	SA_LevelUnknown = -1,
	//! standard ANSI isolation level 0
	SA_ANSILevel0,
	//! standard ANSI isolation level 1
	SA_ANSILevel1,
	//! standard ANSI isolation level 2
	SA_ANSILevel2,
	//! standard ANSI isolation level 3
	SA_ANSILevel3,
	//! isolation level 'Read Uncommitted'
	SA_ReadUncommitted = SA_ANSILevel0,
	//! isolation level 'Read Committed'
	SA_ReadCommitted = SA_ANSILevel1,
	//! isolation level 'Repeatable Read'
	SA_RepeatableRead = SA_ANSILevel2,
	//! isolation level 'Serializable'
	SA_Serializable = SA_ANSILevel3,
	_SA_IsolationLevel_Reserved = (int)(((unsigned int)(-1))/2)
} SAIsolationLevel_t;

typedef
enum
{
	//! the default(unknown) auto-commit mode
	SA_AutoCommitUnknown = -1,
	//! auto-commit mode is off
	SA_AutoCommitOff,
	//! auto-commit mode is on
	SA_AutoCommitOn,
	_SA_AutoCommit_Reserved = (int)(((unsigned int)(-1))/2)
} SAAutoCommit_t;

typedef
enum
{
	SA_dtUnknown,
	SA_dtBool,
	SA_dtShort,
	SA_dtUShort,
	SA_dtLong,
	SA_dtULong,
	SA_dtDouble,
	SA_dtNumeric,
	SA_dtDateTime,
	SA_dtInterval,
	SA_dtString,
	SA_dtBytes,
	SA_dtLongBinary,
	SA_dtLongChar,
	SA_dtBLob,
	SA_dtCLob,
	SA_dtCursor,
	SA_dtSpecificToDBMS,
	_SA_DataType_Reserved = (int)(((unsigned int)(-1))/2)
} SADataType_t;

typedef
enum
{
	//! command type is not defined
	SA_CmdUnknown,
	//! command is an SQL statement (with or without parameters)
	SA_CmdSQLStmt,
	//! command is a raw SQL statement and not interpreted by SQLAPI++
	SA_CmdSQLStmtRaw,
	//! command is a stored procedure or a function
	SA_CmdStoredProc,
	_SA_Cmd_Reserved = (int)(((unsigned int)(-1))/2)
} SACommandType_t;

typedef
enum
{
	SA_ParamInput,
	SA_ParamInputOutput,
	SA_ParamOutput,
	SA_ParamReturn,
	_SA_ParamDirType_Reserved = (int)(((unsigned int)(-1))/2)
} SAParamDirType_t;

typedef
enum
{
	SA_LongOrLobReaderDefault,
	SA_LongOrLobReaderManual,
	_SA_LongOrLobReaderModes_Reserved = (int)(((unsigned int)(-1))/2)
} SALongOrLobReaderModes_t;

typedef
enum {
	SA_FirstPiece = 1,
	SA_NextPiece = 2,
	SA_LastPiece = 3,
    SA_OnePiece = 4,
	_SA_Reserved_PieceType = (int)(((unsigned int)(-1))/2)
} SAPieceType_t;

typedef
enum {
	//! The handles is called after DBMS connection structures is allocated
	SA_PreConnectHandler,
	//! The handles is called after DBMS connection is esteblished
	SA_PostConnectHandler
} SAConnectionHandlerType_t;

//! \}

//! \addtogroup typedefs SQLAPI++ defined types
//! \{

//! Callback for exception pre-handling
typedef bool (SQLAPI_CALLBACK *PreHandleException_t)(SAException &x);

//! Long or LOB writer callback, use for parameter binding
typedef unsigned int (SQLAPI_CALLBACK *saLongOrLobWriter_t)(SAPieceType_t &ePieceType, void *pBuf, unsigned int nLen, void *pAddlData);

//! Long or LOB reader callback, use for field fetching
typedef void (SQLAPI_CALLBACK *saLongOrLobReader_t)(SAPieceType_t ePieceType, void *pBuf, unsigned int nLen, unsigned int nBlobSize, void *pAddlData);

//! DBMS connection handling callback
typedef void (SQLAPI_CALLBACK *saConnectionHandler_t)(SAConnection &con, SAConnectionHandlerType_t eHandlerType);

//! \}

typedef void (SQLAPI_CALLBACK *EnumCursors_t)(ISACursor *, void *);

class SQLAPI_API saAPI
{
public:
	virtual ~saAPI() {};
};

class SQLAPI_API saConnectionHandles
{
public:
	virtual ~saConnectionHandles() {};
};

class SQLAPI_API saCommandHandles
{
public:
	virtual ~saCommandHandles() {};
};

#if defined(SA_UNICODE)
#define _TSA(x)      L ## x
typedef wchar_t SAChar;
#else
typedef char SAChar;
#define _TSA(x)      x
#endif

struct SAStringConvertedData
{
	int nDataLength;        // length of converted data (including terminator)
	// !SAChar ConvertedData[nDataLength+1]

#ifdef SA_UNICODE
	char *data()		// char * to converted data
		{ return (char *)(this+1); }
#else	// !SA_UNICODE
	wchar_t *data()	// wchar_t * to converted data
		{ return (wchar_t *)(this+1); }
#endif	//!SA_UNICODE
};

struct SAStringData
{
	SAStringConvertedData	*pConvertedData;	// pointer to converted data, if any

#ifdef SA_UNICODE
	SAStringConvertedData	*pUTF8Data;
	// nDataLength*sizeof(SAChar) - real length of binary data
	// also true: nLengthInBytes % sizeof(SAChar)
	// In bytes [0..sizeof(SAChar)-1]
	int nBinaryDataLengthDiff;
#endif	// SA_UNICODE

	long nRefs;				// reference count
	int nDataLength;		// length of data (including terminator)
	int nAllocLength;		// length of allocation
	// SAChar data[nAllocLength]

	SAChar *data()           // SAChar * to managed data
		{ return (SAChar *)(this+1); }
};

//! Provides support for manipulating character values
class SQLAPI_API SAString
{
public:
// Constructors
	//! Constructs an empty SAString
	SAString();
	//! Copy constructor
	SAString(const SAString &stringSrc);
	//! Initializes SAString from a single character
	SAString(SAChar ch, int nRepeat = 1);
	//! Initializes SAString from an ANSI (multibyte) string (converts to SAChar)
	SAString(const char *lpsz);
	//! Initializes SAString from a UNICODE string (converts to SAChar)
	SAString(const wchar_t *lpsz);
	//! Initializes SAString from subset of characters from an ANSI (multibyte) string (converts to SAChar)
	SAString(const char *lpch, int nLength);
	//! Initializes SAString from subset of characters from a UNICODE string (converts to SAChar)
	SAString(const wchar_t *lpch, int nLength);
	//! Initializes SAString from unsigned characters (converts to SAChar)
	SAString(const unsigned char *psz);
	//! Special constructor for binary data (no converion to SAChar)
	SAString(const void *pBuffer, int nLengthInBytes);

// Attributes & Operations

	//! Get the data length (in characters).
	int GetLength() const;
	//! True if zero length
	bool IsEmpty() const;
	//! Clear contents to empty
	void Empty();

	//! Return pointer to const string
	operator const SAChar *() const;

	// overloaded assignment

	//! Ref-counted copy from another SAString
	const SAString &operator =(const SAString &sSrc);
	//! Set string content to single character
	const SAString &operator=(SAChar ch);
#ifdef SA_UNICODE
	const SAString &operator=(char ch);
#endif
	//! Copy string content from ANSI (multibyte) string (converts to SAChar)
	const SAString &operator=(const char *lpsz);
	//! Copy string content from UNICODE string (converts to SAChar)
	const SAString &operator=(const wchar_t *lpsz);
	//! Copy string content from unsigned chars
	const SAString &operator=(const unsigned char *psz);

	// string concatenation

	//! Concatenate from another SAString
	const SAString &operator+=(const SAString &string);
	//! Concatenate a single character
	const SAString &operator+=(SAChar ch);
#ifdef SA_UNICODE
	// concatenate an ANSI character after converting it to SAChar
	const SAString &operator+=(char ch);
#endif
	//! Concatenate from a SAChar string
	const SAString &operator+=(const SAChar *lpsz);

	friend SAString SQLAPI_API operator+(const SAString &string1, const SAString &string2);
	friend SAString SQLAPI_API operator+(const SAString &string, SAChar ch);
	friend SAString SQLAPI_API operator+(SAChar ch, const SAString &string);
#ifdef SA_UNICODE
	friend SAString SQLAPI_API operator+(const SAString &string, char ch);
	friend SAString SQLAPI_API operator+(char ch, const SAString &string);
#endif
	friend SAString SQLAPI_API operator+(const SAString &string, const SAChar *lpsz);
	friend SAString SQLAPI_API operator+(const SAChar *lpsz, const SAString &string);

	// string comparison

	//! Straight character comparison
	int Compare(const SAChar *lpsz) const;
	//! Compare ignoring case
	int CompareNoCase(const SAChar *lpsz) const;
	//! NLS aware comparison, case sensitive
	int Collate(const SAChar *lpsz) const;

	//! Convert the object to an uppercase
	void MakeUpper();
	//! Convert the object to an lowercase
	void MakeLower();

	// simple sub-string extraction

	//! Return all characters starting at zero-based nFirst
	SAString Mid(int nFirst) const;
	//! Return nCount characters starting at zero-based nFirst
	SAString Mid(int nFirst, int nCount) const;
	//! Return first nCount characters in string
	SAString Left(int nCount) const;
	//! Return nCount characters from end of string
	SAString Right(int nCount) const;

	// trimming whitespace (either side)

	//! Remove whitespace starting from right edge
	void TrimRight();
	//! Remove whitespace starting from left side
	void TrimLeft();

	// trimming anything (either side)

	//! Remove continuous occurrences of chTarget starting from right
	void TrimRight(SAChar chTarget);
	//! Remove continuous occcurrences of characters in passed string,
	// starting from right
	void TrimRight(const SAChar *lpszTargets);
	//! Remove continuous occurrences of chTarget starting from left
	void TrimLeft(SAChar chTarget);
	//! Remove continuous occcurrences of characters in
	// passed string, starting from left
	void TrimLeft(const SAChar *lpszTargets);

	// advanced manipulation

	// replace occurrences of substring lpszOld with lpszNew;
	// empty lpszNew removes instances of lpszOld
	int Replace(const SAChar *lpszOld, const SAChar *lpszNew);
	// insert character at zero-based index; concatenates
	// if index is past end of string
	int Insert(int nIndex, SAChar ch);
	// insert substring at zero-based index; concatenates
	// if index is past end of string
	int Insert(int nIndex, const SAChar *pstr);
	// delete nCount characters starting at zero-based index
	int Delete(int nIndex, int nCount = 1);

	// searching

	// find character starting at left, -1 if not found
	int Find(SAChar ch) const;
	// find character starting at right
	int ReverseFind(SAChar ch) const;
	// find character starting at zero-based index and going right
	int Find(SAChar ch, int nStart) const;
	// find first instance of any character in passed string
	int FindOneOf(const SAChar *lpszCharSet) const;
	// find first instance of substring
	int Find(const SAChar *lpszSub) const;
	// find first instance of substring starting at zero-based index
	int Find(const SAChar *lpszSub, int nStart) const;

	// simple formatting

	// printf-like formatting using passed string
	void Format(const SAChar *lpszFormat, ...);
	// printf-like formatting using variable arguments parameter
	void FormatV(const SAChar *, va_list argList);

	// Access to string implementation buffer as "C" character array

	// get pointer to modifiable buffer at least as long as nMinBufLength
	SAChar *GetBuffer(int nMinBufLength);
	// release buffer, setting length to nNewLength (or to first nul if -1)
	void ReleaseBuffer(int nNewLength = -1);

	// Use LockBuffer/UnlockBuffer to turn refcounting off

	// turn refcounting off
	SAChar *LockBuffer();
	// turn refcounting back on
	void UnlockBuffer();

// Special buffer access routines to manipulate binary data

	// get binary data length (in bytes)
	int GetBinaryLength() const;
	// return pointer to const binary data buffer
	operator const void *() const;
	// get pointer to modifiable binary data buffer at least as long as nMinBufLengthInBytes
	void *GetBinaryBuffer(int nMinBufLengthInBytes);
	// release buffer, setting length to nNewLength (or to first nul if -1)
	void ReleaseBinaryBuffer(int nNewLengthInBytes);

// Special conversion functions (multibyte <-> Unicode)
#ifdef SA_UNICODE
	// return pointer to const multibyte string, convert if needed
	const char *GetMultiByteChars() const;
	// get string length (in multibyte characters)
	int GetMultiByteCharsLength() const;
#define GetWideChars operator const SAChar *
#define GetWideCharsLength GetLength
	// return pointer to const UTF8 string
	const char *GetUTF8Chars() const;
	// get string length (in UTF8 characters)
	int GetUTF8CharsLength() const;
	// assing UTF8 data
	void SetUTF8Chars(const char* szSrc, int nSrcLen = -1);