SQL.h

Go to the documentation of this file.

#ifndef __DCL_SQL_H__
#define __DCL_SQL_H__   20050322
 
#ifndef __DCL_OBJECT_H__
#include <dcl/Object.h>
#endif
 
#include <dcl/SQLCore.h>
#include <dcl/SQLDriver.h>
 
#ifndef __DCL_NUMERIC_H__
#include <dcl/Numeric.h>
#endif
#ifndef __DCL_DATE_TIME_H__
#include <dcl/DateTime.h>
#endif
#ifndef __DCL_INPUT_STREAM_H__
#include <dcl/InputStream.h>
#endif
#ifndef __DCL_OUTPUT_STREAM_H__
#include <dcl/OutputStream.h>
#endif
 
#ifndef __DCL_THREAD_H__
#include <dcl/Thread.h>
#endif
#ifndef __DCL_ARRAY_H__
#include <dcl/Array.h>
#endif
#ifndef __DCL_LIST_H__
#include <dcl/List.h>
#endif
#ifndef __DCL_HASH_MAP_H__
#include <dcl/HashMap.h>
#endif
 
__DCL_BEGIN_NAMESPACE
 
class SQLField;
class SQLFields;
class SQLParam;
class SQLParams;
class SQLQuery;
class SQLConnection;
class SQLConnectionPool;
 
class DCLCAPI SQLField : public Object
{
    DECLARE_CLASSINFO(SQLField)
public:
    SQL::Field* handle() const;
    const String& name() const ;
 
    SQL::DataType dataType() const;
    const wchar_t* dataTypeName() const;
    const wchar_t* serverDataTypeName() const;
 
    short precision() const;
    short scale() const;
 
    bool isNull() __DCL_THROWS1(SQLException*);
 
    size_t getDataSize(
        bool _maxsize = false
    ) __DCL_THROWS1(SQLException*);
 
    void getData(
        void*           _buf,       // buffer
        size_t*         _size,      // sizeof *_buf
        SQL::DataType  _bufType    // buffer data type
    ) __DCL_THROWS1(SQLException*);
 
    // helper functions
    size_t dataSize() __DCL_THROWS1(SQLException*);
    size_t dataSizeMax() __DCL_THROWS1(SQLException*);
 
    void getValue(int8_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(uint8_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(int16_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(uint16_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(int32_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(uint32_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(int64_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(uint64_t& _val) __DCL_THROWS1(SQLException*);
    void getValue(float& _val) __DCL_THROWS1(SQLException*);
    void getValue(double& _val) __DCL_THROWS1(SQLException*);
    void getValue(SQL::Date& _val) __DCL_THROWS1(SQLException*);
    void getValue(SQL::Time& _val) __DCL_THROWS1(SQLException*);
    void getValue(SQL::TimeStamp& _val) __DCL_THROWS1(SQLException*);
    void getValue(SQL::Interval& _val) __DCL_THROWS1(SQLException*);
    void getValue(String& _val) __DCL_THROWS1(SQLException*);
 
    void getValue(
        ByteString& _val,
        SQL::DataType _bufType = SQL::typeBinary
    ) __DCL_THROWS1(SQLException*);
 
    void getValue(
        OutputStream&   _output,
        size_t          _size = (size_t)-1
    ) __DCL_THROWS1(SQLException*);
 
    bool asBoolean() __DCL_THROWS1(SQLException*);
    int asInteger() __DCL_THROWS1(SQLException*);
    int32_t asInt32() __DCL_THROWS1(SQLException*);
    int64_t asInt64() __DCL_THROWS1(SQLException*);
    float asSingle() __DCL_THROWS1(SQLException*);
    double asDouble() __DCL_THROWS1(SQLException*);
 
    Date asDate() __DCL_THROWS1(SQLException*);
    Time asTime() __DCL_THROWS1(SQLException*);
    DateTime asDateTime() __DCL_THROWS1(SQLException*);
    Interval asInterval() __DCL_THROWS1(SQLException*);
 
    String asString() __DCL_THROWS1(SQLException*);
    // Formatted String
    String asStringF(
        const wchar_t* _format = NULL
    ) __DCL_THROWS1(SQLException*);
 
protected:
    SQL::Field*   __handle;
    SQLQuery*   __query;
protected:
//  SQLField(SQL::Field* hField);
    SQLField();
    virtual ~SQLField();
 
    friend class SQLFields;
};
 
class DCLCAPI SQLParam : public SQLField
{
    DECLARE_CLASSINFO(SQLParam)
public:
    void setNull();
 
    void setData(
        _CONST void*  _val,       // data, IN
        size_t          _size,      // sizeof *_val
        SQL::DataType  _valType,   // typeof *_val
        SQL::DataType  _sqlType    // assign to server type
    ) __DCL_THROWS1(SQLException*);
 
    // output parameter support
    void setOutputType(
        SQL::DataType  _sqlType
    ) __DCL_THROWS1(SQLException*);
 
    // helper functions
    void setValue(int8_t _val) __DCL_THROWS1(SQLException*);
    void setValue(uint8_t _val) __DCL_THROWS1(SQLException*);
    void setValue(int16_t _val) __DCL_THROWS1(SQLException*);
    void setValue(uint16_t _val) __DCL_THROWS1(SQLException*);
    void setValue(int32_t _val) __DCL_THROWS1(SQLException*);
    void setValue(uint32_t _val) __DCL_THROWS1(SQLException*);
    void setValue(int64_t _val) __DCL_THROWS1(SQLException*);
    void setValue(uint64_t _val) __DCL_THROWS1(SQLException*);
    void setValue(float _val) __DCL_THROWS1(SQLException*);
    void setValue(double _val) __DCL_THROWS1(SQLException*);
 
    void setValue(
        const Decimal& _val
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(Date _val) __DCL_THROWS1(SQLException*);
 
    void setValue(
        Time _val,
        int16_t _tzMinute = INT16_MIN
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(
        DateTime _val,
        int16_t _tzMinute = INT16_MIN
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(
        Interval _val,
        SQL::DataType _sqlType = SQL::typeIntervalDs
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(
        const String& _val,
        SQL::DataType _sqlType = SQL::typeText
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(
        const wchar_t* _val, size_t _size,      // count of chars
        SQL::DataType _sqlType = SQL::typeText
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(
        const ByteString& _val,
        SQL::DataType _sqlType = SQL::typeBinary
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(
        const char* _val, size_t _size,     // count of bytes
        SQL::DataType _sqlType = SQL::typeBinary
    ) __DCL_THROWS1(SQLException*);
 
    void setValue(
        _CONST InputStream& _input, size_t _size = (size_t)-1,
        SQL::DataType _sqlType = SQL::typeLongBinary
    ) __DCL_THROWS1(SQLException*);
 
protected:
    ByteString      __bytesValue;       // for String, Decimal
 
protected:
//  SQLParam(SQL::Param* hParam);
    SQLParam();
    virtual ~SQLParam();
 
    friend class SQLParams;
};
 
class DCLCAPI SQLFields : public Object
{
    DECLARE_CLASSINFO(SQLFields)
protected:
    SQLField*           __fields;
    size_t              __count;
    StringToPointerMap  __fieldMap; 
 
protected:
    SQLFields();
    virtual ~SQLFields();
 
    void clear();
    void initialize(SQLQuery* _query);
    friend class SQLQuery;
 
public:
    _CONST SQLField& at(size_t _index) const;
 
    _CONST SQLField& byName(
        const wchar_t* _name
    ) _CONST __DCL_THROWS1(InvalidIndexException*);
 
    _CONST SQLField& operator[](size_t _index) const ;
    size_t count() const;
    bool isEmpty() const;
};
 
class DCLCAPI SQLParams : public Object
{
    DECLARE_CLASSINFO(SQLParams)
protected:
    SQLParam*           __params;
    size_t              __count;
    StringToPointerMap  __paramMap;
 
protected:
    SQLParams();
    virtual ~SQLParams();
 
    void clear();
    void initialize(SQLQuery* _query, const StringArray _names);
    friend class SQLQuery;
 
public:
    SQLParam& at(size_t _index) const;
 
    SQLParam& byName(
        const wchar_t* _name
    ) _CONST __DCL_THROWS1(InvalidIndexException*);
 
    SQLParam& operator[](size_t _index) const;
    size_t count() const;
    bool isEmpty() const;
};
 
class DCLCAPI SQLQuery : public Object
{
    DECLARE_CLASSINFO(SQLQuery)
protected:
    void initialize(SQLConnection* _conn) __DCL_THROWS1(SQLException*);
 
public:
    SQLQuery(SQLConnection* _conn) __DCL_THROWS1(SQLException*);
    SQLQuery(SQLConnection& _conn) __DCL_THROWS1(SQLException*);
    virtual ~SQLQuery();
 
    void prepare(const String& _sql) __DCL_THROWS1(SQLException*);
    void execute() __DCL_THROWS1(SQLException*);
    void execute(const String& _sql) __DCL_THROWS1(SQLException*);
 
    void fetch() __DCL_THROWS1(SQLException*);
    bool moreResults() __DCL_THROWS1(SQLException*);
    bool eof() const;
    int64_t affectedRows() const;
    _CONST SQLFields& fields() _CONST;
    _CONST SQLParams& params() _CONST;
 
    SQL::Query* handle() const;
    SQLConnection* connection() const;
 
protected:
    SQL::Query*       __handle;
    SQLConnection* __connection;
    SQLFields      __fields;
    SQLParams      __params;
 
#ifdef __DCL_DEBUG
    String          __sql;
#endif
};
 
class DCLCAPI SQLConnection : public Object
{
    DECLARE_CLASSINFO(SQLConnection)
protected:
    void initialize(SQLDriver* _driver);
 
public:
    SQLConnection(SQLDriver* _driver);
    SQLConnection(const String& _driverName)
        __DCL_THROWS1(SQLDriverException*);
    virtual ~SQLConnection();
 
    // Operations
    // "USER=aUser; PASSWORD=aPW; DATABASE=aDB; SERVER=aHost"
    void open(const String& _connstr) __DCL_THROWS1(SQLException*);
    void close() __DCL_THROWS1(SQLException*);
    void execute(const String& _sql) __DCL_THROWS1(SQLException*);
    void startTrans() __DCL_THROWS1(SQLException*);
    void commitTrans() __DCL_THROWS1(SQLException*);
    void rollbackTrans() __DCL_THROWS1(SQLException*);
 
    String getServerInfo() __DCL_THROWS1(SQLException*);
 
    bool canTransact() const;
 
    // Properties
    SQL::Connection* handle() const;
    SQLDriver* driver() const;
    bool connected() const;
    bool inTransaction() const;
 
protected:
    SQL::Connection* __handle;
    SQLDriver*     __driver;
    bool            __connected;
};
 
class DCLCAPI SQLConnectionPool : public Object
{
    DECLARE_CLASSINFO(SQLConnectionPool)
public:
    SQLConnectionPool(
        const String& _connString, 
        const String& _driverName
    ) __DCL_THROWS1(SQLDriverException*);
 
    virtual ~SQLConnectionPool();
 
    // NULL reach __allMax
    SQLConnection* getConnection() __DCL_THROWS1(SQLException*);
    void release(SQLConnection* _conn);
 
    bool setMaxCount(size_t _idleMax, size_t _allMax);
 
    size_t count() const;
 
    size_t idleCount() const;
 
    void clear(unsigned _waitSeconds);
 
protected:
    SQLDriver*     __sqlDriver;
    String          __connString;
 
    PointerList     __idleConns;
    PointerArray    __allConns;
 
    Thread::Mutex  __lock;
 
    size_t          __idleMax;
    size_t          __allMax;
};
 
// exception support for addtional members
class DCLCAPI SQLException : public Exception
{
    DECLARE_CLASSINFO(SQLException)
public:
    enum AsErrorCode
    {
        // asInt32, asInt64, asSingle, ... 변환 에러
        eInvalidCast,
        eOutOfRange
    };
    String      __message;
 
protected:
    String getServerMessage(SQL::Connection* _connHandle);
 
public:
    SQLException(SQLConnection* _conn, Exception* _cause);
    SQLException(SQLConnection* _conn, const String& _message);
    SQLException(SQLQuery* _query, Exception* _cause);
    SQLException(SQLQuery* _query, const String& _message);
    SQLException(SQLField* _field, Exception* _cause);
 
    SQLException(
        SQLField* _field,
        const wchar_t* _cast,
        AsErrorCode errorCode
    );
 
    SQLException(
        SQLField* _field,
        const wchar_t* _cast,
        Exception* _cause
    );
 
    virtual String toString() const;
};
 
#include <dcl/SQL.inl>
 
__DCL_END_NAMESPACE
 
#endif  // __DCL_SQL_H__