SQLCore.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>        // for dcl/Thread.h
#endif
 
#include <string.h>
#include <wchar.h>          // wcslen, wcsncpy
#include <dcl/Object.h>
#include <dcl/Thread.h>     // Thread::incrementAndGet, decrementAndGet
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Array.h>           // ByteStringArray
#include <dcl/ListedHashMap.h>   // ListedByteStringToByteStringMap
#include <dcl/SQLCore.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/SQLCore.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
typedef struct __SQL_ERROR
{
    SQL::Error error;
    const wchar_t* message;
} SQL_ERROR;
 
#if __DCL_DEBUG
#define __SQLERROR_MSG(code, msg) {code, L"(" __T(#code) L")"  __T(msg) }
#else
#define __SQLERROR_MSG(code, msg) {code, __T(msg) }
#endif
 
bool SQL::getErrorMessage(
        wchar_t* _buf,      // OUT
        size_t* _buflen,    // IN, OUT
        Error _errorCode   // IN
    )
{
    static const SQL_ERROR errors[] = {
    // Core Error
    __SQLERROR_MSG(eNoError,          "No Error"),
    __SQLERROR_MSG(eServerError,      "서버 혹은 서버 API 호출중에 에러가 발생했습니다."),
    __SQLERROR_MSG(eBadAddress,            "버퍼 혹은 파라메터의 주소가 잘못되었습니다."),
    __SQLERROR_MSG(eOutOfMemory,      "메모리 할당이 불가능합니다."),
    __SQLERROR_MSG(eNotSupportMethod,    "서버 혹은 드라이버에서 지원하지 않는 메소드 입니다."),
 
    // SQL::Connection::execute, SQL::Query::prepare, execute
    __SQLERROR_MSG(eNotSupportStatement, "이 인터페이스를 통해 실행할 수 없는 SQL 입니다"),
 
    // SQL::Connection Errors
    __SQLERROR_MSG(eInvalidConnectionString, "서버 연결을위한 연결문자열의 값이 잘못되었습니다."),
    __SQLERROR_MSG(eConnected,          "서버와 연결되어 있는 상태입니다. 다시 연결할 수 없습니다."),
    __SQLERROR_MSG(eNotConnected,        "서버에 연결되어 있지 않습니다. 연결을 끊을 수 없습니다."),
    __SQLERROR_MSG(eInTransaction,      "트랜잭션 중 입니다. 트랜잭션을 시작할 수 없습니다."),
    __SQLERROR_MSG(eNotInTransaction,    "트랜잭션 상태가 아닙니다. 트랜잭션을 종료할 수 없습니다."),
    __SQLERROR_MSG(eHaveChildQuery,        "이 연결을 사용하는 쿼리 인터페이스가 있습니다."),
    __SQLERROR_MSG(eNoChildQuery,        "이 연결을 사용하는 쿼리 인터페이스가 아닙니다."),
    __SQLERROR_MSG(eNotAvailable,        "서버의 정보를 얻을 수 없습니다."),
 
    // SQL::Query Errors
    __SQLERROR_MSG(eNotPrepared,      "쿼리가 준비되지 있지 않습니다."),
    __SQLERROR_MSG(eNotExecuted,      "쿼리가 실행되어 있지 않습니다."),
    __SQLERROR_MSG(eNotFetched,            "쿼리가 fetch되어 있지 않습니다."),
    __SQLERROR_MSG(eInvalidIndex,        "필드나 파라메터를 참조하는 인덱스가 잘못되었습니다."),
 
    // SQL::Field Errors
    __SQLERROR_MSG(eValueIsNull,      "필드의 값이 null 입니다."),
    __SQLERROR_MSG(eNotSupportDataType,    "서버 혹은 드라이버에서 지원하지 않는 데이터타입입니다."),
    __SQLERROR_MSG(eInvalidDataType,  "필드값을 얻거나 파라메터 값을 설정하기 위한 데이터타입이 잘못되었습니다."),
    __SQLERROR_MSG(eInvalidBufferSize,  "필드 혹은 아웃바인드의 값을 읽고자 하는 버퍼의 크기가 잘못되었습니다."),
    __SQLERROR_MSG(eOutOfRange,            "데이터타입과 사이즈로 Numeric 데이터를 얻는데 범위를 초과했습니다."),
 
    // SQL::Param Errors
    __SQLERROR_MSG(eInvalidData,      "데이터가 잘못되었거나 서버에 적용할수 없는 형식입니다."),
    __SQLERROR_MSG(eInvalidDataSize,  "데이터타입에 적절한 데이터 크기가 아닙니다.")
    };
 
    __DCL_ASSERT(_buf != NULL && _buflen != NULL);
 
    const wchar_t* psz = L"Unknown error code";
    for(size_t i = 0; i < __countof(errors, SQL_ERROR); i++) {
        if (_errorCode == errors[i].error) {
            psz = errors[i].message;
            break;
        }
    }
 
    size_t len = wcslen(psz);
    if (*_buflen >= len) {
        wcsncpy(_buf, psz, len);
        *_buflen = len;
        return true;
    }
 
    *_buflen = len;
    return false;
}
 
#define DATA_TYPE_NAME(type) case type : return __T(#type)
 
const wchar_t* SQL::dataTypeName(
        DataType _dataType
    )
{
    switch(_dataType) {
        DATA_TYPE_NAME(typeUnknown);
        DATA_TYPE_NAME(typeInteger);
        DATA_TYPE_NAME(typeUInteger);
        DATA_TYPE_NAME(typeFloat);
        DATA_TYPE_NAME(typeNumeric);
        DATA_TYPE_NAME(typeDate);
        DATA_TYPE_NAME(typeTime);
        DATA_TYPE_NAME(typeTimeTz);
        DATA_TYPE_NAME(typeTimeStamp);
        DATA_TYPE_NAME(typeTimeStampTz);
        DATA_TYPE_NAME(typeInterval);
        DATA_TYPE_NAME(typeIntervalYm);
        DATA_TYPE_NAME(typeIntervalDs);
        DATA_TYPE_NAME(typeText);
        DATA_TYPE_NAME(typeBinary);
        DATA_TYPE_NAME(typeLongText);
        DATA_TYPE_NAME(typeLongBinary);
        DATA_TYPE_NAME(typeClob);
        DATA_TYPE_NAME(typeBlob);
 
        // additional buffer type
        DATA_TYPE_NAME(typeInputStream);
        DATA_TYPE_NAME(typeOutputStream);
    };
 
    __DCL_ASSERT(false);
    return __T("");
}
 
#define __CHECK_ADDRESS(p) \
{ \
    if (p == NULL) { \
        __SET_ERROR(eBadAddress); \
        return false; \
    } \
}
 

#undef __SET_ERROR
#define __SET_ERROR(_errorCode) \
    __queryHandle->connection()->setErrorStatus(_errorCode, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(SQL::Field, Object)
 
SQL::Field::Field(
        Query* _queryHandle
    )
{
    __queryHandle = _queryHandle;
    __dataType = typeUnknown;
    __precision = -1;
    __scale = 0;
}
 
SQL::Field::~Field()
{
}
 
bool SQL::Field::getDataSize(
        size_t* _pn,
        bool _maxSize
    )
{
    __DCL_ASSERT(__dataType != typeUnknown);
 
    __CHECK_ADDRESS(_pn)
 
    if (_maxSize) {
        if (!__queryHandle->inState(SQL::Query::stPrepared)) {
            __SET_ERROR(eNotPrepared);
            return false;
        }
    }
    else {
        if (!__queryHandle->inState(SQL::Query::stFetched)) {
            __SET_ERROR(eNotFetched);
            return false;
        }
        if (isNull()) {
            __SET_ERROR(eValueIsNull);
            return false;
        }
    }
 
    return __getDataSize(_pn, _maxSize);
}
 
static bool __checkDataType__(
        SQL::DataType _bufferType, // typeof *_pv
        SQL::DataType _dataType        // field or param assign type
    )
{
    switch (_bufferType) {
        case SQL::typeInteger:      // int32_t*, int64_t*
        case SQL::typeUInteger:        // uint32_t*, uint64_t* 
        case SQL::typeFloat:      // float*, double*
        case SQL::typeDate:            // SQL::Date*
            if (_bufferType == _dataType)
                return true;
            break;
        case SQL::typeTime:            // SQL::Time*
            if (_dataType == SQL::typeTime
                || _dataType == SQL::typeTimeTz)
                return true;
            break;
        case SQL::typeTimeStamp:  // SQL::TimeStamp*
            if (_dataType == SQL::typeTimeStamp
                || _dataType == SQL::typeTimeStampTz)
                return true;
            break;
        case SQL::typeInterval:        // SQL::Interval*
            if (_dataType == SQL::typeInterval
                || _dataType == SQL::typeIntervalYm
                || _dataType == SQL::typeIntervalDs)
                return true;
            break;
        case SQL::typeText:
            if (_dataType == SQL::typeNumeric
                || _dataType == SQL::typeText
                || _dataType == SQL::typeLongText
                || _dataType == SQL::typeClob)
                return true;
            break;
        case SQL::typeBinary:
            if (_dataType == SQL::typeBinary
                || _dataType == SQL::typeLongBinary
                || _dataType == SQL::typeBlob)
                return true;
            break;
        case SQL::typeInputStream:
            if (_dataType == SQL::typeText
                || _dataType == SQL::typeBinary
                || _dataType == SQL::typeLongText
                || _dataType == SQL::typeLongBinary
                || _dataType == SQL::typeClob
                || _dataType == SQL::typeBlob)
                return true;
            break;
        case SQL::typeOutputStream:
            if (_dataType == SQL::typeText
                || _dataType == SQL::typeBinary
                || _dataType == SQL::typeLongText
                || _dataType == SQL::typeLongBinary
                || _dataType == SQL::typeClob
                || _dataType == SQL::typeBlob)
                return true;
            break;
        default:
        // case SQL::typeUnknown:
        // case SQL::typeNumeric:
        // case SQL::typeLongText:
        // case SQL::typeLongBinary:
        // case SQL::typeClob:
        // case SQL::typeBlob:
            __DCL_ASSERT(false);
    }
    return false;
}
 
bool SQL::Field::getData(
        void* _pv,              // buffer, OUT
        size_t* _pn,            // sizeof *_pv, IN, OUT
        DataType _dataType      // typeof *_pv
    )
{
    __DCL_ASSERT(__dataType != typeUnknown);
 
    __DCL_ASSERT(_dataType != typeUnknown);
    __DCL_ASSERT(_dataType != typeNumeric);
    __DCL_ASSERT(_dataType != typeTimeTz);
    __DCL_ASSERT(_dataType != typeTimeStampTz);
    __DCL_ASSERT(_dataType != typeIntervalYm);
    __DCL_ASSERT(_dataType != typeIntervalDs);
    __DCL_ASSERT(_dataType != typeLongText);
    __DCL_ASSERT(_dataType != typeLongBinary);
    __DCL_ASSERT(_dataType != typeClob);
    __DCL_ASSERT(_dataType != typeBlob);
    __DCL_ASSERT(_dataType != typeInputStream);
 
    if ((_dataType == typeInputStream) ||
        !__checkDataType__(_dataType, __dataType)) {
        __SET_ERROR(eInvalidDataType);
        return false;
    }
 
    __CHECK_ADDRESS(_pv)
    __CHECK_ADDRESS(_pn)
 
    if (!__queryHandle->inState(SQL::Query::stFetched)) {
        __SET_ERROR(eNotFetched);
        return false;
    }
 
    if (isNull()) {
        __SET_ERROR(eValueIsNull);
        return false;
    }
 
    return __getData(_pv, _pn, _dataType);
}
 
IMPLEMENT_CLASSINFO(SQL::Param, SQL::Field)
 
SQL::Param::Param(
        SQL::Query* _queryHandle
    ) : Field(_queryHandle)
{
}
 
SQL::Param::~Param()
{
}
 
void SQL::Param::setName(
        String _name
    )
{
    __name = _name;
}
 
bool SQL::Param::setData(
        _CONST        void* _pv,  // data, IN
        size_t      _n,         // sizeof *_pv
        DataType    _dataType,  // typeof *_pv
        DataType    _assignType // assign to server type
    )
{
    __DCL_ASSERT(_dataType != typeUnknown);
    __DCL_ASSERT(_dataType != typeNumeric);
    __DCL_ASSERT(_dataType != typeTimeTz);
    __DCL_ASSERT(_dataType != typeTimeStampTz);
    __DCL_ASSERT(_dataType != typeIntervalYm);
    __DCL_ASSERT(_dataType != typeIntervalDs);
    __DCL_ASSERT(_dataType != typeLongText);
    __DCL_ASSERT(_dataType != typeLongBinary);
    __DCL_ASSERT(_dataType != typeClob);
    __DCL_ASSERT(_dataType != typeBlob);
 
    if (!__checkDataType__(_dataType, _assignType)) {
        __SET_ERROR(eInvalidDataType);
        return false;
    }
 
    __CHECK_ADDRESS(_pv)
 
#if __DCL_DEBUG
    switch (_dataType) {
        case typeDate: {
            const Date* p = (const Date*)_pv;
            __DCL_ASSERT(
                (-9999 <= p->year && p->year <= 9999)
                && (1 <= p->month && p->month <= 12)
                && (1 <= p->day && p->day <= 31)
            );
            break;
        }
        case typeTime:
        case typeTimeTz: {            
            const Time* p = (const Time*)_pv;
            __DCL_ASSERT(
                (p->hour <= 23)
                && (p->min <= 59)
                && (p->sec <= 59)
                && (p->frac <= 999999999)
            );
            __DCL_ASSERT(
                (p->tzoff == INT16_MIN)
                || (-720 <= p->tzoff && p->tzoff < 840)
            );
            break;
        }
        case typeTimeStamp:
        case typeTimeStampTz: {
            const TimeStamp* p = (const TimeStamp*)_pv;
            __DCL_ASSERT(
                (-9999 <= p->year && p->year <= 9999)
                && (1 <= p->month && p->month <= 12)
                && (1 <= p->day && p->day <= 31)
                && (p->hour <= 23)
                && (p->min <= 59)
                && (p->sec <= 59)
                && (p->frac <= 999999999)
            );
            __DCL_ASSERT(
                (p->tzoff == INT16_MIN)
                || (-720 <= p->tzoff && p->tzoff < 840)
            );
            break;
        }
        case typeInterval:
        case typeIntervalYm:
        case typeIntervalDs: {
            const Interval* p = (const Interval*)_pv;
            __DCL_ASSERT(
                (-999999999 <= p->years && p->years <= 999999999)
                && (-11 <= p->months && p->months <= 11)
                && (-999999999 <= p->days && p->days <= 999999999)
                && (p->hours <= 23)
                && (p->mins <= 59)
                && (p->secs <= 59)
                && (p->fracs <= 999999999)
            );
            break;
        }
    }
#endif
 
    if (!__queryHandle->inState(SQL::Query::stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    return __setData(_pv, _n, _dataType, _assignType);
}
 
bool SQL::Param::setDataType(
        DataType    _dataType
    )
{
#if __DCL_DEBUG
    __DCL_ASSERT(_dataType != typeUnknown);
    __DCL_ASSERT(_dataType != typeInputStream);
    __DCL_ASSERT(_dataType != typeOutputStream);
#else
    if (_dataType == typeUnknown
        || _dataType == typeInputStream
        || _dataType == typeOutputStream) {
            __SET_ERROR(eInvalidDataType);
            return false;
    }
#endif
 
    if (!__queryHandle->inState(SQL::Query::stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    return __setDataType(_dataType);
}
 
// isNull, __setDataType, __getDataSize, __getData는
// 드라이버에서 구현하지 않을 수도 있다.
 
bool SQL::Param::isNull() const
{
    return true;
}
 
bool SQL::Param::__setDataType(
        DataType    _dataType
    )
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Param::__getDataSize(
        size_t* _pn,
        bool _maxSize
    )
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Param::__getData(
        void* _pv,
        size_t* _pn,            // IN, OUT
        DataType _dataType
    )
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}

#undef __SET_ERROR
#define __SET_ERROR(_errorCode) \
    __connHandle->setErrorStatus(_errorCode, __THIS_FILE__, __LINE__)
 
IMPLEMENT_CLASSINFO(SQL::Query, Object)
 
SQL::Query::Query(
        _CONST SQL::Connection* _connHandle
    )
{
    __connHandle = _connHandle;
    __eof = true;
    __affectedRows = -1;
 
    __fieldCount = 0;
    __paramCount = 0;
    __placeholder = L'?';
 
    __states = stStandBy;
 
    __connHandle->addRef();
}
 
SQL::Query::~Query()
{
    __connHandle->release();
}
 
bool SQL::Query::prepare(
        const char* _sql,
        size_t _sqllen,
        size_t _paramCount
    )
{
    __states = stStandBy;
 
    __CHECK_ADDRESS(_sql)
 
    if (__prepare(_sql, _sqllen, _paramCount)) {
        __SET_STATE(stPrepared);
        return true;
    }
    return false;
}
 
bool SQL::Query::execute()
{
    if (!inState(stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    if (__execute()) {
        __SET_STATE(stExecuted);
        return true;
    }
    return false;
}
 
bool SQL::Query::fetch()
{
    if(!inState(stExecuted)) {
        __SET_ERROR(eNotExecuted);
        return false;
    }
 
    if (__fetch()) {
        __SET_STATE(stFetched);
        return true;
    }
    return false;
}
 
bool SQL::Query::__nextResult()
{
    __SET_ERROR(eNotSupportMethod);
    return false;
}
 
bool SQL::Query::nextResult()
{
    if (!inState(stExecuted)) {
        __SET_ERROR(eNotExecuted);
        return false;
    }
    return __nextResult();
}
 
bool SQL::Query::getField(
        size_t _index,
        SQL::Field** _fieldHandleOut
    )
{
    if (!inState(stExecuted)) {
        __SET_ERROR(eNotExecuted);
        return false;
    }
 
    if (_index >= __fieldCount) {
        __SET_ERROR(eInvalidIndex);
        return false;
    }
    __CHECK_ADDRESS(_fieldHandleOut)
 
    return __getField(_index, _fieldHandleOut);
}
 
bool SQL::Query::getParam(
        size_t _index,
        SQL::Param** _paramHandleOut
    )
{
    if (!inState(stPrepared)) {
        __SET_ERROR(eNotPrepared);
        return false;
    }
 
    if (_index >= __paramCount) {
        __SET_ERROR(eInvalidIndex);
        return false;
    }
    __CHECK_ADDRESS(_paramHandleOut);
 
    return __getParam(_index, _paramHandleOut);
}

#undef __SET_ERROR
#define __SET_ERROR(_errorCode) \
    setErrorStatus(_errorCode, __THIS_FILE__, __LINE__)
 
void SQL::Connection::setErrorStatus(
        SQL::Error _errorCode,
        const wchar_t* _filename,
        int _line
    )
{
    __errorCode = _errorCode;
    __errorFileName = _filename;
    __errorLine = _line;
}
 
IMPLEMENT_CLASSINFO(SQL::Connection, Object)
 
long SQL::Connection::addRef()
{
    return Thread::incrementAndGet(__refCount);
}
 
long SQL::Connection::release()
{
    long n = Thread::decrementAndGet(__refCount);
    __DCL_ASSERT(n >= 0);
    return n;
}
 
SQL::Connection::Connection(
        const wchar_t* _serverTitle
    )
{
    __refCount = 0;
 
    __canTransact = false;
    __serverTitle = _serverTitle;
 
    __errorCode = eNoError;
    __errorFileName = NULL;
    __errorLine = 0;
 
    __states = stClosed;
}
 
SQL::Connection::~Connection()
{
    __DCL_ASSERT(refCount() == 0);
}
 
bool SQL::Connection::open(
        const char* _connString,
        size_t _connlen
    )
{
    if (inState(stOpenned)) {
        __SET_ERROR(eConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_connString)
 
    if (__open(_connString, _connlen)) {
        __SET_STATE(stOpenned);
        return true;
    }
    return false;
}
 
bool SQL::Connection::close()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (refCount()) {
        __SET_ERROR(eHaveChildQuery);
        return false;
    }
 
    if (__close()) {
        __SET_STATE(stClosed);
        return true;
    }
    return false;
}
 
bool SQL::Connection::execute(
        const char* _sql,
        size_t _sqllen
    )
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_sql)
 
    return __execute(_sql, _sqllen);
}
 
bool SQL::Connection::startTrans()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (inState(stInTransaction)) {
        __SET_ERROR(eInTransaction);
        return false;
    }
 
    if (__startTrans()) {
        __SET_STATE(stInTransaction);
        return true;
    }
    return false;
}
 
bool SQL::Connection::commitTrans()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (!inState(stInTransaction)) {
        __SET_ERROR(eNotInTransaction);
        return false;
    }
 
    if (__commitTrans()) {
        __UNSET_STATE(stInTransaction);
        return true;
    }
    return false;
}
 
bool SQL::Connection::rollbackTrans()
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (!inState(stInTransaction)) {
        __SET_ERROR(eNotInTransaction);
        return false;
    }
 
    if (__rollbackTrans()) {
        __UNSET_STATE(stInTransaction);
        return true;
    }
    return false;
}
 
bool SQL::Connection::getErrorMessage(
        char* _buf,
        size_t* _buflen
    )
{
    if ((_buf == NULL) || (_buflen == NULL) || (*_buflen <= 0))
        return false;
 
    return __getErrorMessage(_buf, _buflen);
}
 
bool SQL::Connection::getServerInfo(
        char* _buf,
        size_t* _buflen
    )
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_buf)
    __CHECK_ADDRESS(_buflen)
 
    return __getServerInfo(_buf, _buflen);
}
 
bool SQL::Connection::createQueryInstance(
        SQL::Query** _queryHandleOut
    )
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    __CHECK_ADDRESS(_queryHandleOut);
 
    if (__createQueryInstance(_queryHandleOut)) {
        addRef();
        return true;
    }
    return false;
}
 
bool SQL::Connection::destroyQueryInstance(
        SQL::Query* _queryHandle
    )
{
    if (!inState(stOpenned)) {
        __SET_ERROR(eNotConnected);
        return false;
    }
 
    if (_queryHandle->__connHandle != this) {
        __SET_ERROR(eNoChildQuery);
        return false;
    }
 
    release();
    _queryHandle->__destroy();
    return true;
}
 
// static members
// for driver implemtation
size_t SQL::Connection::splitConnectionString(
        const char* _pszConnectionString,
        size_t _n,
        ListedByteStringToByteStringMap& _map
    )
{
    __DCL_ASSERT(_pszConnectionString != NULL);
    ByteStringArray elts;
    ByteString::split(
        _pszConnectionString, _pszConnectionString + _n,
        ';', elts
        );
 
    for(ByteStringArray::Iterator it = elts.begin();
            it != elts.end(); it++) {
        ByteStringArray pair;
        (*it).split('=', pair);
        if (pair.size() > 0) {
            ByteStringArray::Iterator itPair = pair.begin();
            ByteString name = *itPair++;
            ByteString value;
            if (pair.size() > 1) {
                value = *itPair;
            }
            _map[name.trim().toUpperCase()] = value.trim();
        }
    }
    return _map.size();
}
 
__DCL_END_NAMESPACE