/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: FValue.cxx,v $
 * $Revision: 1.34 $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_connectivity.hxx"

#include <stdio.h>
#include "connectivity/FValue.hxx"
#include "connectivity/CommonTools.hxx"
#include <connectivity/dbconversion.hxx>
#include <com/sun/star/io/XInputStream.hpp>

using namespace connectivity;
using namespace dbtools;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::io;

namespace {
    static sal_Bool isStorageCompatible(sal_Int32 _eType1, sal_Int32 _eType2)
    {
        sal_Bool bIsCompatible = sal_True;

        if (_eType1 != _eType2)
        {
            switch (_eType1)
            {
                case DataType::CHAR:
                case DataType::VARCHAR:
                case DataType::DECIMAL:
                case DataType::NUMERIC:
                case DataType::LONGVARCHAR:
                    bIsCompatible = (DataType::CHAR			== _eType2)
                                ||	(DataType::VARCHAR		== _eType2)
                                ||	(DataType::DECIMAL		== _eType2)
                                ||	(DataType::NUMERIC		== _eType2)
                                ||	(DataType::LONGVARCHAR	== _eType2);
                    break;

                case DataType::DOUBLE:
                case DataType::REAL:
                    bIsCompatible = (DataType::DOUBLE	== _eType2)
                                ||	(DataType::REAL		== _eType2);
                    break;

                case DataType::BINARY:
                case DataType::VARBINARY:
                case DataType::LONGVARBINARY:
                    bIsCompatible = (DataType::BINARY			== _eType2)
                                ||	(DataType::VARBINARY		== _eType2)
                                ||	(DataType::LONGVARBINARY	== _eType2);
                    break;

                case DataType::INTEGER:
                    bIsCompatible = (DataType::SMALLINT	== _eType2)
                                ||	(DataType::TINYINT	== _eType2)
                                ||	(DataType::BIT		== _eType2)
                                ||	(DataType::BOOLEAN	== _eType2);
                    break;
                case DataType::SMALLINT:
                    bIsCompatible = (DataType::TINYINT	== _eType2)
                                ||	(DataType::BIT		== _eType2)
                                ||	(DataType::BOOLEAN	== _eType2);
                    break;
                case DataType::TINYINT:
                    bIsCompatible = (DataType::BIT		== _eType2)
                                ||	(DataType::BOOLEAN	== _eType2);
                    break;

                case DataType::BLOB:
                case DataType::CLOB:
                case DataType::OBJECT:
                    bIsCompatible = (DataType::BLOB		== _eType2)
                                ||	(DataType::CLOB		== _eType2)
                                ||	(DataType::OBJECT	== _eType2);
                    break;

                default:
                    bIsCompatible = sal_False;
            }
        }
        return bIsCompatible;
    }
}

// -----------------------------------------------------------------------------
#ifdef DBG_UTIL

#include <vector>
#include <rtl/string.h>

namespace tracing
{
    struct AllocationType
    {
        const sal_Char*	pName;
        sal_Int32		nAllocatedUnits;

        AllocationType( ) : pName( NULL ), nAllocatedUnits( 0 ) { }
    };

    // =============================================================================
    class AllocationTracer
    {
    public:
        typedef ::std::vector< AllocationType >	AllocationState;
        static AllocationState					s_aAllocated;
        static ::osl::Mutex						s_aMutex;

    public:
        static void registerUnit( const sal_Char* _pName );
        static void revokeUnit( const sal_Char* _pName );

    private:
        static AllocationState::iterator	getLocation( const sal_Char* _pName );
    };

    // =============================================================================
    AllocationTracer::AllocationState::iterator	AllocationTracer::getLocation( const sal_Char* _pName )
    {
        AllocationState::iterator aLookFor = s_aAllocated.begin();
        for	(	;
                aLookFor != s_aAllocated.end();
                ++aLookFor
            )
        {
            if ( 0 == rtl_str_compare( aLookFor->pName, _pName ) )
                // found
                return aLookFor;
        }
        // not found
        s_aAllocated.push_back( AllocationType() );
        aLookFor = s_aAllocated.end(); --aLookFor;
        aLookFor->pName = _pName;	// note that this assumes that _pName is a constant string ....
        return aLookFor;
    }

    // =============================================================================
    AllocationTracer::AllocationState			AllocationTracer::s_aAllocated;
    ::osl::Mutex								AllocationTracer::s_aMutex;

    // =============================================================================
    void AllocationTracer::registerUnit( const sal_Char* _pName )
    {
        ::osl::MutexGuard aGuard( s_aMutex );

        AllocationState::iterator aPos = getLocation( _pName );
        ++aPos->nAllocatedUnits;
    }

    // =============================================================================
    void AllocationTracer::revokeUnit( const sal_Char* _pName )
    {
        ::osl::MutexGuard aGuard( s_aMutex );

        AllocationState::iterator aPos = getLocation( _pName );
        --aPos->nAllocatedUnits;
    }

#define TRACE_ALLOC( type )	tracing::AllocationTracer::registerUnit( #type );
#define TRACE_FREE( type )	tracing::AllocationTracer::revokeUnit( #type );
}
#else
#define TRACE_ALLOC( type )
#define TRACE_FREE( type )
#endif

// -----------------------------------------------------------------------------
void ORowSetValue::setTypeKind(sal_Int32 _eType)
{
    if (!m_bNull)
        if (!isStorageCompatible(_eType, m_eTypeKind))
        {
            switch(_eType)
            {
                case DataType::VARCHAR:
                case DataType::CHAR:
                case DataType::DECIMAL:
                case DataType::NUMERIC:
                case DataType::LONGVARCHAR:
                    (*this) = getString();
                    break;
                case DataType::BIGINT:
                    (*this) = getLong();
                    break;

                case DataType::FLOAT:
                    (*this) = getFloat();
                    break;
                case DataType::DOUBLE:
                case DataType::REAL:
                    (*this) = getDouble();
                    break;
                case DataType::TINYINT:
                    (*this) = getInt8();
                    break;
                case DataType::SMALLINT:
                    (*this) = getInt16();
                    break;
                case DataType::INTEGER:
                    (*this) = getInt32();
                    break;
                case DataType::BIT:
                case DataType::BOOLEAN:
                    (*this) = getBool();
                    break;
                case DataType::DATE:
                    (*this) = getDate();
                    break;
                case DataType::TIME:
                    (*this) = getTime();
                    break;
                case DataType::TIMESTAMP:
                    (*this) = getDateTime();
                    break;
                case DataType::BINARY:
                case DataType::VARBINARY:
                case DataType::LONGVARBINARY:
                    (*this) = getSequence();
                    break;
                case DataType::BLOB:
                case DataType::CLOB:
                case DataType::OBJECT:
                    (*this) = getAny();
                    break;
                default:
                    OSL_ENSURE(0,"ORowSetValue:operator==(): UNSPUPPORTED TYPE!");
            }
        }

    m_eTypeKind = _eType;
}

// -----------------------------------------------------------------------------
void ORowSetValue::free()
{
    if(!m_bNull)
    {
        switch(m_eTypeKind)
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                OSL_ENSURE(m_aValue.m_pString,"String pointer is null!");
                rtl_uString_release(m_aValue.m_pString);
                m_aValue.m_pString = NULL;
                break;
            case DataType::INTEGER:
                if ( !m_bSigned )
                {
                    delete (sal_Int64*)m_aValue.m_pValue;
                    TRACE_FREE( sal_Int64 )
                    m_aValue.m_pValue = NULL;
                }
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                {
                    delete (sal_Int64*)m_aValue.m_pValue;
                    TRACE_FREE( sal_Int64 )
                    m_aValue.m_pValue = NULL;
                }
                else
                {
                    OSL_ENSURE(m_aValue.m_pString,"String pointer is null!");
                    rtl_uString_release(m_aValue.m_pString);
                    m_aValue.m_pString = NULL;
                }
                break;
            case DataType::FLOAT:
                delete (float*)m_aValue.m_pValue;
                TRACE_FREE( float )
                m_aValue.m_pValue = NULL;
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                delete (double*)m_aValue.m_pValue;
                TRACE_FREE( double )
                m_aValue.m_pValue = NULL;
                break;
            case DataType::DATE:
                delete (::com::sun::star::util::Date*)m_aValue.m_pValue;
                TRACE_FREE( Date )
                m_aValue.m_pValue = NULL;
                break;
            case DataType::TIME:
                delete (::com::sun::star::util::Time*)m_aValue.m_pValue;
                TRACE_FREE( Time )
                m_aValue.m_pValue = NULL;
                break;
            case DataType::TIMESTAMP:
                delete (::com::sun::star::util::DateTime*)m_aValue.m_pValue;
                TRACE_FREE( DateTime )
                m_aValue.m_pValue = NULL;
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                delete (Sequence<sal_Int8>*)m_aValue.m_pValue;
                TRACE_FREE( Sequence_sal_Int8 )
                m_aValue.m_pValue = NULL;
                break;
            case DataType::BLOB:
            case DataType::CLOB:
            case DataType::OBJECT:
                delete (Any*)m_aValue.m_pValue;
                TRACE_FREE( Any )
                m_aValue.m_pValue = NULL;
                break;

        }
        m_bNull = sal_True;
    }
}
// -----------------------------------------------------------------------------
ORowSetValue& ORowSetValue::operator=(const ORowSetValue& _rRH)
{
    if(&_rRH == this)
        return *this;

    if ( m_eTypeKind != _rRH.m_eTypeKind || _rRH.m_bNull || m_bSigned != _rRH.m_bSigned)
        free();

    m_bBound	= _rRH.m_bBound;
    m_eTypeKind	= _rRH.m_eTypeKind;
    m_bSigned	= _rRH.m_bSigned;

    if(m_bNull && !_rRH.m_bNull)
    {
        switch(_rRH.m_eTypeKind)
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                rtl_uString_acquire(_rRH.m_aValue.m_pString);
                m_aValue.m_pString = _rRH.m_aValue.m_pString;
                break;
            case DataType::BIGINT:
                if ( _rRH.m_bSigned )
                {
                    m_aValue.m_pValue	= new sal_Int64(*(sal_Int64*)_rRH.m_aValue.m_pValue);
                    TRACE_ALLOC( sal_Int64 )
                }
                else
                {
                    rtl_uString_acquire(_rRH.m_aValue.m_pString);
                    m_aValue.m_pString = _rRH.m_aValue.m_pString;
                }
                break;
            case DataType::FLOAT:
                m_aValue.m_pValue	= new float(*(float*)_rRH.m_aValue.m_pValue);
                TRACE_ALLOC( float )
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                m_aValue.m_pValue	= new double(*(double*)_rRH.m_aValue.m_pValue);
                TRACE_ALLOC( double )
                break;
            case DataType::DATE:
                m_aValue.m_pValue	= new Date(*(Date*)_rRH.m_aValue.m_pValue);
                TRACE_ALLOC( Date )
                break;
            case DataType::TIME:
                m_aValue.m_pValue	= new Time(*(Time*)_rRH.m_aValue.m_pValue);
                TRACE_ALLOC( Time )
                break;
            case DataType::TIMESTAMP:
                m_aValue.m_pValue	= new DateTime(*(DateTime*)_rRH.m_aValue.m_pValue);
                TRACE_ALLOC( DateTime )
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                m_aValue.m_pValue	= new Sequence<sal_Int8>(*(Sequence<sal_Int8>*)_rRH.m_aValue.m_pValue);
                TRACE_ALLOC( Sequence_sal_Int8 )
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                m_aValue.m_bBool	= _rRH.m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( _rRH.m_bSigned )
                    m_aValue.m_nInt8	= _rRH.m_aValue.m_nInt8;
                else
                    m_aValue.m_nInt16	= _rRH.m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( _rRH.m_bSigned )
                    m_aValue.m_nInt16	= _rRH.m_aValue.m_nInt16;
                else
                    m_aValue.m_nInt32	= _rRH.m_aValue.m_nInt32;
                break;
            case DataType::INTEGER:
                if ( _rRH.m_bSigned )
                    m_aValue.m_nInt32	= _rRH.m_aValue.m_nInt32;
                else
                {
                    m_aValue.m_pValue	= new sal_Int64(*(sal_Int64*)_rRH.m_aValue.m_pValue);
                    TRACE_ALLOC( sal_Int64 )
                }
                break;
            default:
                m_aValue.m_pValue	= new Any(*(Any*)_rRH.m_aValue.m_pValue);
                TRACE_ALLOC( Any )
        }
    }
    else if(!_rRH.m_bNull)
    {
        switch(_rRH.m_eTypeKind)
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                (*this) = ::rtl::OUString(_rRH.m_aValue.m_pString);
                break;
            case DataType::BIGINT:
                if ( _rRH.m_bSigned )
                    (*this) = *(sal_Int64*)_rRH.m_aValue.m_pValue;
                else
                    (*this) = ::rtl::OUString(_rRH.m_aValue.m_pString);
                break;
            case DataType::FLOAT:
                (*this) = *(float*)_rRH.m_aValue.m_pValue;
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                (*this) = *(double*)_rRH.m_aValue.m_pValue;
                break;
            case DataType::DATE:
                (*this) = *(Date*)_rRH.m_aValue.m_pValue;
                break;
            case DataType::TIME:
                (*this) = *(Time*)_rRH.m_aValue.m_pValue;
                break;
            case DataType::TIMESTAMP:
                (*this) = *(DateTime*)_rRH.m_aValue.m_pValue;
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                (*this) = *(Sequence<sal_Int8>*)_rRH.m_aValue.m_pValue;
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                m_aValue.m_bBool	= _rRH.m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( _rRH.m_bSigned )
                    m_aValue.m_nInt8	= _rRH.m_aValue.m_nInt8;
                else
                    m_aValue.m_nInt16	= _rRH.m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( _rRH.m_bSigned )
                    m_aValue.m_nInt16	= _rRH.m_aValue.m_nInt16;
                else
                    m_aValue.m_nInt32	= _rRH.m_aValue.m_nInt32;
                break;
            case DataType::INTEGER:
                if ( _rRH.m_bSigned )
                    m_aValue.m_nInt32	= _rRH.m_aValue.m_nInt32;
                else
                    *static_cast<sal_Int64*>(m_aValue.m_pValue) = *(sal_Int64*)_rRH.m_aValue.m_pValue;
                break;
            default:
                (*(Any*)m_aValue.m_pValue)	= (*(Any*)_rRH.m_aValue.m_pValue);
        }
    }

    m_bNull		= _rRH.m_bNull;
    // OJ: BUGID: 96277
    m_eTypeKind	= _rRH.m_eTypeKind;

    return *this;
}
// -------------------------------------------------------------------------

ORowSetValue& ORowSetValue::operator=(const Date& _rRH)
{
    if(m_eTypeKind != DataType::DATE)
        free();

    if(m_bNull)
    {
        m_aValue.m_pValue = new Date(_rRH);
        TRACE_ALLOC( Date )
        m_eTypeKind = DataType::DATE;
        m_bNull = sal_False;
    }
    else
        *(Date*)m_aValue.m_pValue = _rRH;

    return *this;
}
// -------------------------------------------------------------------------
ORowSetValue& ORowSetValue::operator=(const Time& _rRH)
{
    if(m_eTypeKind != DataType::TIME)
        free();

    if(m_bNull)
    {
        m_aValue.m_pValue = new Time(_rRH);
        TRACE_ALLOC( Time )
        m_eTypeKind = DataType::TIME;
        m_bNull = sal_False;
    }
    else
        *(Time*)m_aValue.m_pValue = _rRH;

    return *this;
}
// -------------------------------------------------------------------------
ORowSetValue& ORowSetValue::operator=(const DateTime& _rRH)
{
    if(m_eTypeKind != DataType::TIMESTAMP)
        free();
    if(m_bNull)
    {
        m_aValue.m_pValue = new DateTime(_rRH);
        TRACE_ALLOC( DateTime )
        m_eTypeKind = DataType::TIMESTAMP;
        m_bNull = sal_False;
    }
    else
        *(DateTime*)m_aValue.m_pValue = _rRH;

    return *this;
}
// -------------------------------------------------------------------------

ORowSetValue& ORowSetValue::operator=(const ::rtl::OUString& _rRH)
{
    if(m_eTypeKind != DataType::VARCHAR || m_aValue.m_pString != _rRH.pData)
    {
        free();
        m_bNull = sal_False;

        m_aValue.m_pString = _rRH.pData;
        rtl_uString_acquire(m_aValue.m_pString);
        m_eTypeKind = DataType::VARCHAR;
    }

    return *this;
}
// -------------------------------------------------------------------------

ORowSetValue& ORowSetValue::operator=(const double& _rRH)
{
    if(m_eTypeKind != DataType::DOUBLE)
        free();

    if(m_bNull)
    {
        m_aValue.m_pValue = new double(_rRH);
        TRACE_ALLOC( double )
        m_eTypeKind = DataType::DOUBLE;
        m_bNull = sal_False;
    }
    else
        *(double*)m_aValue.m_pValue = _rRH;

    return *this;
}
// -----------------------------------------------------------------------------
ORowSetValue& ORowSetValue::operator=(const float& _rRH)
{
    if(m_eTypeKind != DataType::FLOAT)
        free();

    if(m_bNull)
    {
        m_aValue.m_pValue = new float(_rRH);
        TRACE_ALLOC( float )
        m_eTypeKind = DataType::FLOAT;
        m_bNull = sal_False;
    }
    else
        *(float*)m_aValue.m_pValue = _rRH;

    return *this;
}
// -------------------------------------------------------------------------

ORowSetValue& ORowSetValue::operator=(const sal_Int8& _rRH)
{
    if(m_eTypeKind != DataType::TINYINT )
        free();

    m_aValue.m_nInt8 = _rRH;
    m_eTypeKind = DataType::TINYINT;
    m_bNull = sal_False;
    return *this;
}
// -------------------------------------------------------------------------

ORowSetValue& ORowSetValue::operator=(const sal_Int16& _rRH)
{
    if(m_eTypeKind != DataType::SMALLINT )
        free();

    m_aValue.m_nInt16 = _rRH;
    m_eTypeKind = DataType::SMALLINT;
    m_bNull = sal_False;

    return *this;
}
// -------------------------------------------------------------------------

ORowSetValue& ORowSetValue::operator=(const sal_Int32& _rRH)
{
    if(m_eTypeKind != DataType::INTEGER )
        free();

    if ( m_bSigned )
        m_aValue.m_nInt32 = _rRH;
    else
    {
        if ( m_bNull )
        {
            m_aValue.m_pValue = new sal_Int64(_rRH);
            TRACE_ALLOC( sal_Int64 )
        }
        else
            *static_cast<sal_Int64*>(m_aValue.m_pValue) = static_cast<sal_Int64>(_rRH);
    }

    m_eTypeKind = DataType::INTEGER;
    m_bNull = sal_False;

    return *this;
}
// -------------------------------------------------------------------------

ORowSetValue& ORowSetValue::operator=(const sal_Bool _rRH)
{
    if(m_eTypeKind != DataType::BIT && DataType::BOOLEAN != m_eTypeKind )
        free();

    m_aValue.m_bBool = _rRH;
    m_eTypeKind = DataType::BIT;
    m_bNull = sal_False;

    return *this;
}
// -------------------------------------------------------------------------
ORowSetValue& ORowSetValue::operator=(const sal_Int64& _rRH)
{
    if ( DataType::BIGINT != m_eTypeKind || !m_bSigned )
        free();

    if ( m_bSigned )
    {
        if(m_bNull)
        {
            m_aValue.m_pValue = new sal_Int64(_rRH);
            TRACE_ALLOC( sal_Int64 )
        }
        else
            *static_cast<sal_Int64*>(m_aValue.m_pValue) = _rRH;
    }
    else
    {
        ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rRH);
        m_aValue.m_pString = aVal.pData;
        rtl_uString_acquire(m_aValue.m_pString);
    }

    m_eTypeKind = DataType::BIGINT;
    m_bNull = sal_False;

    return *this;
}
// -------------------------------------------------------------------------
ORowSetValue& ORowSetValue::operator=(const Sequence<sal_Int8>& _rRH)
{
    if (!isStorageCompatible(DataType::LONGVARBINARY,m_eTypeKind))
        free();

    if (m_bNull)
    {
        m_aValue.m_pValue = new Sequence<sal_Int8>(_rRH);
        TRACE_ALLOC( Sequence_sal_Int8 )
    }
    else
        *static_cast< Sequence< sal_Int8 >* >(m_aValue.m_pValue) = _rRH;

    m_eTypeKind = DataType::LONGVARBINARY;
    m_bNull = sal_False;

    return *this;
}
// -------------------------------------------------------------------------
ORowSetValue& ORowSetValue::operator=(const Any& _rAny)
{
    if (!isStorageCompatible(DataType::OBJECT,m_eTypeKind))
        free();

    if ( m_bNull )
    {
        m_aValue.m_pValue = new Any(_rAny);
        TRACE_ALLOC( Any )
    }
    else
        *static_cast<Any*>(m_aValue.m_pValue) = _rAny;

    m_eTypeKind = DataType::OBJECT;
    m_bNull = sal_False;

    return *this;
}
// -------------------------------------------------------------------------

sal_Bool operator==(const Date& _rLH,const Date& _rRH)
{
    return _rLH.Day == _rRH.Day && _rLH.Month == _rRH.Month && _rLH.Year == _rRH.Year;
}
// -------------------------------------------------------------------------

sal_Bool operator==(const Time& _rLH,const Time& _rRH)
{
    return _rLH.Minutes == _rRH.Minutes && _rLH.Hours == _rRH.Hours && _rLH.Seconds == _rRH.Seconds && _rLH.HundredthSeconds == _rRH.HundredthSeconds;
}
// -------------------------------------------------------------------------

sal_Bool operator==(const DateTime& _rLH,const DateTime& _rRH)
{
    return _rLH.Day == _rRH.Day && _rLH.Month == _rRH.Month && _rLH.Year == _rRH.Year &&
        _rLH.Minutes == _rRH.Minutes && _rLH.Hours == _rRH.Hours && _rLH.Seconds == _rRH.Seconds && _rLH.HundredthSeconds == _rRH.HundredthSeconds;
}
// -------------------------------------------------------------------------

bool ORowSetValue::operator==(const ORowSetValue& _rRH) const
{
    if(m_eTypeKind != _rRH.m_eTypeKind)
        return false;
    if ( m_bSigned != _rRH.m_bSigned )
        return false;
    if(m_bNull != _rRH.isNull())
        return false;
    if(m_bNull && _rRH.isNull())
        return true;

    bool bRet = false;
    OSL_ENSURE(!m_bNull,"SHould not be null!");
    switch(m_eTypeKind)
    {
        case DataType::VARCHAR:
        case DataType::CHAR:
        case DataType::DECIMAL:
        case DataType::NUMERIC:
        case DataType::LONGVARCHAR:
        {
            ::rtl::OUString aVal1(m_aValue.m_pString);
            ::rtl::OUString aVal2(_rRH.m_aValue.m_pString);
            bRet = aVal1 == aVal2;
            break;
        }

        case DataType::FLOAT:
            bRet = *(float*)m_aValue.m_pValue == *(float*)_rRH.m_aValue.m_pValue;
            break;
        case DataType::DOUBLE:
        case DataType::REAL:
            bRet = *(double*)m_aValue.m_pValue == *(double*)_rRH.m_aValue.m_pValue;
            break;
        case DataType::TINYINT:
            bRet = m_bSigned ? ( m_aValue.m_nInt8 == _rRH.m_aValue.m_nInt8 ) : (m_aValue.m_nInt16 == _rRH.m_aValue.m_nInt16);
            break;
        case DataType::SMALLINT:
            bRet = m_bSigned ? ( m_aValue.m_nInt16 == _rRH.m_aValue.m_nInt16 ) : (m_aValue.m_nInt32 == _rRH.m_aValue.m_nInt32);
            break;
        case DataType::INTEGER:
            bRet = m_bSigned ? ( m_aValue.m_nInt32 == _rRH.m_aValue.m_nInt32 ) : (*(sal_Int64*)m_aValue.m_pValue == *(sal_Int64*)_rRH.m_aValue.m_pValue);
            break;
        case DataType::BIGINT:
            if ( m_bSigned )
                bRet = *(sal_Int64*)m_aValue.m_pValue == *(sal_Int64*)_rRH.m_aValue.m_pValue;
            else
            {
                ::rtl::OUString aVal1(m_aValue.m_pString);
                ::rtl::OUString aVal2(_rRH.m_aValue.m_pString);
                bRet = aVal1 == aVal2;
            }
            break;
        case DataType::BIT:
        case DataType::BOOLEAN:
            bRet = m_aValue.m_bBool == _rRH.m_aValue.m_bBool;
            break;
        case DataType::DATE:
            bRet = *(Date*)m_aValue.m_pValue == *(Date*)_rRH.m_aValue.m_pValue;
            break;
        case DataType::TIME:
            bRet = *(Time*)m_aValue.m_pValue == *(Time*)_rRH.m_aValue.m_pValue;
            break;
        case DataType::TIMESTAMP:
            bRet = *(DateTime*)m_aValue.m_pValue == *(DateTime*)_rRH.m_aValue.m_pValue;
            break;
        case DataType::BINARY:
        case DataType::VARBINARY:
        case DataType::LONGVARBINARY:
            bRet = false;
            break;
        case DataType::BLOB:
        case DataType::CLOB:
        case DataType::OBJECT:
            bRet = false;
            break;
        default:
            OSL_ENSURE(0,"ORowSetValue::operator==(): UNSPUPPORTED TYPE!");
    }
    return bRet;
}
// -------------------------------------------------------------------------
Any ORowSetValue::makeAny() const
{
    Any rValue;
    if(isBound() && !isNull())
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                OSL_ENSURE(m_aValue.m_pString,"Value is null!");
                rValue <<= (::rtl::OUString)m_aValue.m_pString;
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                {
                    OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                    rValue <<= *(sal_Int64*)m_aValue.m_pValue;
                }
                else
                {
                    OSL_ENSURE(m_aValue.m_pString,"Value is null!");
                    rValue <<= (::rtl::OUString)m_aValue.m_pString;
                }
                break;
            case DataType::FLOAT:
                OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                rValue <<= *(float*)m_aValue.m_pValue;
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                rValue <<= *(double*)m_aValue.m_pValue;
                break;
            case DataType::DATE:
                OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                rValue <<= *(Date*)m_aValue.m_pValue;
                break;
            case DataType::TIME:
                OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                rValue <<= *(Time*)m_aValue.m_pValue;
                break;
            case DataType::TIMESTAMP:
                OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                rValue <<= *(DateTime*)m_aValue.m_pValue;
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                rValue <<= *(Sequence<sal_Int8>*)m_aValue.m_pValue;
                break;
            case DataType::BLOB:
            case DataType::CLOB:
            case DataType::OBJECT:
                rValue = getAny();
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                rValue.setValue( &m_aValue.m_bBool, ::getCppuBooleanType() );
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    rValue <<= m_aValue.m_nInt8;
                else
                    rValue <<= m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    rValue <<= m_aValue.m_nInt16;
                else
                    rValue <<= m_aValue.m_nInt32;
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    rValue <<= m_aValue.m_nInt32;
                else
                {
                    OSL_ENSURE(m_aValue.m_pValue,"Value is null!");
                    rValue <<= *(sal_Int64*)m_aValue.m_pValue;
                }
                break;
            default:
                OSL_ENSURE(0,"ORowSetValue::makeAny(): UNSPUPPORTED TYPE!");
        }
    }
    return rValue;
}
// -------------------------------------------------------------------------
::rtl::OUString ORowSetValue::getString( ) const
{
    ::rtl::OUString aRet;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                aRet = m_aValue.m_pString;
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    aRet = ::rtl::OUString::valueOf((sal_Int64)*this);
                else
                    aRet = m_aValue.m_pString;
                break;
            case DataType::FLOAT:
                aRet = ::rtl::OUString::valueOf((float)*this);
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                aRet = ::rtl::OUString::valueOf((double)*this);
                break;
            case DataType::DATE:
                aRet = connectivity::toDateString(*this);
                break;
            case DataType::TIME:
                aRet = connectivity::toTimeString(*this);
                break;
            case DataType::TIMESTAMP:
                aRet = connectivity::toDateTimeString(*this);
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                {
                    aRet = ::rtl::OUString::createFromAscii("0x");
                    Sequence<sal_Int8> aSeq(getSequence());
                    const sal_Int8* pBegin	= aSeq.getConstArray();
                    const sal_Int8* pEnd	= pBegin + aSeq.getLength();
                    for(;pBegin != pEnd;++pBegin)
                        aRet += ::rtl::OUString::valueOf((sal_Int32)*pBegin,16);
                }
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Bool)*this);
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int8)*this);
                else
                    aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int16)*this);
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    aRet = ::rtl::OUString::valueOf((sal_Int32)(sal_Int16)*this);
                else
                    aRet = ::rtl::OUString::valueOf((sal_Int32)*this);
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    aRet = ::rtl::OUString::valueOf((sal_Int32)*this);
                else
                    aRet = ::rtl::OUString::valueOf((sal_Int64)*this);
                break;
        }
    }
    return aRet;
}
// -------------------------------------------------------------------------
sal_Bool ORowSetValue::getBool()	const
{
    sal_Bool bRet = sal_False;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::LONGVARCHAR:
                {
                    const ::rtl::OUString sValue(m_aValue.m_pString);
                    const static ::rtl::OUString s_sTrue(RTL_CONSTASCII_USTRINGPARAM("true"));
                    const static ::rtl::OUString s_sFalse(RTL_CONSTASCII_USTRINGPARAM("false"));
                    if ( sValue.equalsIgnoreAsciiCase(s_sTrue) )
                    {
                        bRet = sal_True;
                        break;
                    }
                    else if ( sValue.equalsIgnoreAsciiCase(s_sFalse) )
                    {
                        bRet = sal_False;
                        break;
                    }
                }
                // run through
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            
                bRet = ::rtl::OUString(m_aValue.m_pString).toInt32() != 0;
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    bRet = *(sal_Int64*)m_aValue.m_pValue != 0;
                else
                    bRet = ::rtl::OUString(m_aValue.m_pString).toInt64() != 0;
                break;
            case DataType::FLOAT:
                bRet = *(float*)m_aValue.m_pValue != 0.0;
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                bRet = *(double*)m_aValue.m_pValue != 0.0;
                break;
            case DataType::DATE:
            case DataType::TIME:
            case DataType::TIMESTAMP:
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ASSERT(!"getBool() for this type is not allowed!");
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                bRet = m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                bRet = m_bSigned ? (m_aValue.m_nInt8  != 0) : (m_aValue.m_nInt16 != 0);
                break;
            case DataType::SMALLINT:
                bRet = m_bSigned ? (m_aValue.m_nInt16  != 0) : (m_aValue.m_nInt32 != 0);
                break;
            case DataType::INTEGER:
                bRet = m_bSigned ? (m_aValue.m_nInt32 != 0) : (*static_cast<sal_Int64*>(m_aValue.m_pValue) != sal_Int64(0));
                break;
        }
    }
    return bRet;
}
// -------------------------------------------------------------------------
sal_Int8 ORowSetValue::getInt8()	const
{


    sal_Int8 nRet = 0;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                nRet = sal_Int8(::rtl::OUString(m_aValue.m_pString).toInt32());
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    nRet = sal_Int8(*(sal_Int64*)m_aValue.m_pValue);
                else
                    nRet = sal_Int8(::rtl::OUString(m_aValue.m_pString).toInt32());
                break;
            case DataType::FLOAT:
                nRet = sal_Int8(*(float*)m_aValue.m_pValue);
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                nRet = sal_Int8(*(double*)m_aValue.m_pValue);
                break;
            case DataType::DATE:
            case DataType::TIME:
            case DataType::TIMESTAMP:
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ASSERT(!"getInt8() for this type is not allowed!");
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                nRet = m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt8;
                else
                    nRet = static_cast<sal_Int8>(m_aValue.m_nInt16);
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    nRet = static_cast<sal_Int8>(m_aValue.m_nInt16);
                else
                    nRet = static_cast<sal_Int8>(m_aValue.m_nInt32);
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    nRet = static_cast<sal_Int8>(m_aValue.m_nInt32);
                else
                    nRet = static_cast<sal_Int8>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
                break;
        }
    }
    return nRet;
}
// -------------------------------------------------------------------------
sal_Int16 ORowSetValue::getInt16()	const
{


    sal_Int16 nRet = 0;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                nRet = sal_Int16(::rtl::OUString(m_aValue.m_pString).toInt32());
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    nRet = sal_Int16(*(sal_Int64*)m_aValue.m_pValue);
                else
                    nRet = sal_Int16(::rtl::OUString(m_aValue.m_pString).toInt32());
                break;
            case DataType::FLOAT:
                nRet = sal_Int16(*(float*)m_aValue.m_pValue);
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                nRet = sal_Int16(*(double*)m_aValue.m_pValue);
                break;
            case DataType::DATE:
            case DataType::TIME:
            case DataType::TIMESTAMP:
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ASSERT(!"getInt16() for this type is not allowed!");
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                nRet = m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt8;
                else
                    nRet = m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt16;
                else
                    nRet = static_cast<sal_Int16>(m_aValue.m_nInt32);
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    nRet = static_cast<sal_Int16>(m_aValue.m_nInt32);
                else
                    nRet = static_cast<sal_Int16>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
                break;
        }
    }
    return nRet;
}
// -------------------------------------------------------------------------
sal_Int32 ORowSetValue::getInt32()	const
{
    sal_Int32 nRet = 0;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                nRet = ::rtl::OUString(m_aValue.m_pString).toInt32();
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    nRet = sal_Int32(*(sal_Int64*)m_aValue.m_pValue);
                else
                    nRet = ::rtl::OUString(m_aValue.m_pString).toInt32();
                break;
            case DataType::FLOAT:
                nRet = sal_Int32(*(float*)m_aValue.m_pValue);
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                nRet = sal_Int32(*(double*)m_aValue.m_pValue);
                break;
            case DataType::DATE:
                nRet = dbtools::DBTypeConversion::toDays(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
                break;
            case DataType::TIME:
            case DataType::TIMESTAMP:
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ASSERT(!"getInt32() for this type is not allowed!");
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                nRet = m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt8;
                else
                    nRet = m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt16;
                else
                    nRet = m_aValue.m_nInt32;
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt32;
                else
                    nRet = static_cast<sal_Int32>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
                break;
        }
    }
    return nRet;
}
// -------------------------------------------------------------------------
sal_Int64 ORowSetValue::getLong()	const
{
    sal_Int64 nRet = 0;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                nRet = ::rtl::OUString(m_aValue.m_pString).toInt64();
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    nRet = *(sal_Int64*)m_aValue.m_pValue;
                else
                    nRet = ::rtl::OUString(m_aValue.m_pString).toInt64();
                break;
            case DataType::FLOAT:
                nRet = sal_Int64(*(float*)m_aValue.m_pValue);
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                nRet = sal_Int64(*(double*)m_aValue.m_pValue);
                break;
            case DataType::DATE:
                nRet = dbtools::DBTypeConversion::toDays(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
                break;
            case DataType::TIME:
            case DataType::TIMESTAMP:
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ASSERT(!"getInt32() for this type is not allowed!");
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                nRet = m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt8;
                else
                    nRet = m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt16;
                else
                    nRet = m_aValue.m_nInt32;
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt32;
                else
                    nRet = *(sal_Int64*)m_aValue.m_pValue;
                break;
        }
    }
    return nRet;
}
// -------------------------------------------------------------------------
float ORowSetValue::getFloat()	const
{
    float nRet = 0;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                nRet = ::rtl::OUString(m_aValue.m_pString).toFloat();
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    nRet = float(*(sal_Int64*)m_aValue.m_pValue);
                else
                    nRet = ::rtl::OUString(m_aValue.m_pString).toFloat();
                break;
            case DataType::FLOAT:
                nRet = *(float*)m_aValue.m_pValue;
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                nRet = (float)*(double*)m_aValue.m_pValue;
                break;
            case DataType::DATE:
                nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
                break;
            case DataType::TIME:
                nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Time*)m_aValue.m_pValue);
                break;
            case DataType::TIMESTAMP:
                nRet = (float)dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::DateTime*)m_aValue.m_pValue);
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ASSERT(!"getDouble() for this type is not allowed!");
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                nRet = m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt8;
                else
                    nRet = m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt16;
                else
                    nRet = (float)m_aValue.m_nInt32;
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    nRet = (float)m_aValue.m_nInt32;
                else
                    nRet = float(*(sal_Int64*)m_aValue.m_pValue);
                break;
        }
    }
    return nRet;
}
// -------------------------------------------------------------------------
double ORowSetValue::getDouble()	const
{


    double nRet = 0;
    if(!m_bNull)
    {
        switch(getTypeKind())
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::DECIMAL:
            case DataType::NUMERIC:
            case DataType::LONGVARCHAR:
                nRet = ::rtl::OUString(m_aValue.m_pString).toDouble();
                break;
            case DataType::BIGINT:
                if ( m_bSigned )
                    nRet = double(*(sal_Int64*)m_aValue.m_pValue);
                else
                    nRet = ::rtl::OUString(m_aValue.m_pString).toDouble();
                break;
            case DataType::FLOAT:
                nRet = *(float*)m_aValue.m_pValue;
                break;
            case DataType::DOUBLE:
            case DataType::REAL:
                nRet = *(double*)m_aValue.m_pValue;
                break;
            case DataType::DATE:
                nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Date*)m_aValue.m_pValue);
                break;
            case DataType::TIME:
                nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::Time*)m_aValue.m_pValue);
                break;
            case DataType::TIMESTAMP:
                nRet = dbtools::DBTypeConversion::toDouble(*(::com::sun::star::util::DateTime*)m_aValue.m_pValue);
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                OSL_ASSERT(!"getDouble() for this type is not allowed!");
                break;
            case DataType::BIT:
            case DataType::BOOLEAN:
                nRet = m_aValue.m_bBool;
                break;
            case DataType::TINYINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt8;
                else
                    nRet = m_aValue.m_nInt16;
                break;
            case DataType::SMALLINT:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt16;
                else
                    nRet = m_aValue.m_nInt32;
                break;
            case DataType::INTEGER:
                if ( m_bSigned )
                    nRet = m_aValue.m_nInt32;
                else
                    nRet = double(*(sal_Int64*)m_aValue.m_pValue);
                break;
        }
    }
    return nRet;
}
// -------------------------------------------------------------------------
void ORowSetValue::setFromDouble(const double& _rVal,sal_Int32 _nDatatype)
{
    free();

    m_bNull = sal_False;
    switch(_nDatatype)
    {
        case DataType::CHAR:
        case DataType::VARCHAR:
        case DataType::DECIMAL:
        case DataType::NUMERIC:
        case DataType::LONGVARCHAR:
            {
                ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rVal);
                m_aValue.m_pString = aVal.pData;
                rtl_uString_acquire(m_aValue.m_pString);
            }
            break;
        case DataType::BIGINT:
            if ( m_bSigned )
            {
                m_aValue.m_pValue = new sal_Int64((sal_Int64)_rVal);
                TRACE_ALLOC( sal_Int64 )
            }
            else
            {
                ::rtl::OUString aVal = ::rtl::OUString::valueOf(_rVal);
                m_aValue.m_pString = aVal.pData;
                rtl_uString_acquire(m_aValue.m_pString);
            }
            break;
        case DataType::FLOAT:
            m_aValue.m_pValue = new float((float)_rVal);
            TRACE_ALLOC( float )
            break;
        case DataType::DOUBLE:
        case DataType::REAL:
            m_aValue.m_pValue = new double(_rVal);
            TRACE_ALLOC( double )
            break;
        case DataType::DATE:
            m_aValue.m_pValue = new Date(dbtools::DBTypeConversion::toDate(_rVal));
            TRACE_ALLOC( Date )
            break;
        case DataType::TIME:
            m_aValue.m_pValue = new Time(dbtools::DBTypeConversion::toTime(_rVal));
            TRACE_ALLOC( Time )
            break;
        case DataType::TIMESTAMP:
            m_aValue.m_pValue = new DateTime(dbtools::DBTypeConversion::toDateTime(_rVal));
            TRACE_ALLOC( DateTime )
            break;
        case DataType::BINARY:
        case DataType::VARBINARY:
        case DataType::LONGVARBINARY:
            OSL_ASSERT(!"setFromDouble() for this type is not allowed!");
            break;
        case DataType::BIT:
        case DataType::BOOLEAN:
            m_aValue.m_bBool = _rVal != 0.0;
            break;
        case DataType::TINYINT:
            if ( m_bSigned )
                m_aValue.m_nInt8 = sal_Int8(_rVal);
            else
                m_aValue.m_nInt16 = sal_Int16(_rVal);
            break;
        case DataType::SMALLINT:
            if ( m_bSigned )
                m_aValue.m_nInt16 = sal_Int16(_rVal);
            else
                m_aValue.m_nInt32 = sal_Int32(_rVal);
            break;
        case DataType::INTEGER:
            if ( m_bSigned )
                m_aValue.m_nInt32 = sal_Int32(_rVal);
            else
            {
                m_aValue.m_pValue = new sal_Int64((sal_Int64)_rVal);
                TRACE_ALLOC( sal_Int64 )
            }
            break;
    }
    m_eTypeKind = _nDatatype;
}
// -----------------------------------------------------------------------------
Sequence<sal_Int8>	ORowSetValue::getSequence() const
{
    Sequence<sal_Int8> aSeq;
    if (!m_bNull)
    {
        switch(m_eTypeKind)
        {
            case DataType::OBJECT:
            case DataType::CLOB:
            case DataType::BLOB:
            {
                Reference<XInputStream> xStream;
                Any aValue = getAny();
                if(aValue.hasValue())
                {
                    aValue >>= xStream;
                    if(xStream.is())
                        xStream->readBytes(aSeq,xStream->available());
                }
            }
            break;
            case DataType::VARCHAR:
            case DataType::LONGVARCHAR:
                {
                    ::rtl::OUString sVal(m_aValue.m_pString);
                    aSeq = Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>(sVal.getStr()),sizeof(sal_Unicode)*sVal.getLength());
                }
                break;
            case DataType::BINARY:
            case DataType::VARBINARY:
            case DataType::LONGVARBINARY:
                aSeq = *static_cast< Sequence<sal_Int8>*>(m_aValue.m_pValue);
                break;
            default:
                ;
        }
    }
    return aSeq;

}
// -----------------------------------------------------------------------------
::com::sun::star::util::Date ORowSetValue::getDate()		const
{
    ::com::sun::star::util::Date aValue;
    if(!m_bNull)
    {
        switch(m_eTypeKind)
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::LONGVARCHAR:
                aValue = DBTypeConversion::toDate(getString());
                break;
            case DataType::DECIMAL:
            case DataType::NUMERIC:
                aValue = DBTypeConversion::toDate((double)*this);
                break;
            case DataType::FLOAT:
            case DataType::DOUBLE:
            case DataType::REAL:
                aValue = DBTypeConversion::toDate((double)*this);
                break;

            case DataType::DATE:
                aValue = *static_cast< ::com::sun::star::util::Date*>(m_aValue.m_pValue);
                break;
            case DataType::TIMESTAMP:
                {
                    ::com::sun::star::util::DateTime* pDateTime = static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue);
                    aValue.Day		= pDateTime->Day;
                    aValue.Month	= pDateTime->Month;
                    aValue.Year		= pDateTime->Year;
                }
                break;
        }
    }
    return aValue;
}
// -----------------------------------------------------------------------------
::com::sun::star::util::Time ORowSetValue::getTime()		const
{
    ::com::sun::star::util::Time aValue;
    if(!m_bNull)
    {
        switch(m_eTypeKind)
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::LONGVARCHAR:
                aValue = DBTypeConversion::toTime(getString());
                break;
            case DataType::DECIMAL:
            case DataType::NUMERIC:
                aValue = DBTypeConversion::toTime((double)*this);
                break;
            case DataType::FLOAT:
            case DataType::DOUBLE:
            case DataType::REAL:
                aValue = DBTypeConversion::toTime((double)*this);
                break;
            case DataType::TIMESTAMP:
                {
                    ::com::sun::star::util::DateTime* pDateTime = static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue);
                    aValue.HundredthSeconds	= pDateTime->HundredthSeconds;
                    aValue.Seconds			= pDateTime->Seconds;
                    aValue.Minutes			= pDateTime->Minutes;
                    aValue.Hours			= pDateTime->Hours;
                }
                break;
            case DataType::TIME:
                aValue = *static_cast< ::com::sun::star::util::Time*>(m_aValue.m_pValue);
        }
    }
    return aValue;
}
// -----------------------------------------------------------------------------
::com::sun::star::util::DateTime ORowSetValue::getDateTime()	const
{
    ::com::sun::star::util::DateTime aValue;
    if(!m_bNull)
    {
        switch(m_eTypeKind)
        {
            case DataType::CHAR:
            case DataType::VARCHAR:
            case DataType::LONGVARCHAR:
                aValue = DBTypeConversion::toDateTime(getString());
                break;
            case DataType::DECIMAL:
            case DataType::NUMERIC:
                aValue = DBTypeConversion::toDateTime((double)*this);
                break;
            case DataType::FLOAT:
            case DataType::DOUBLE:
            case DataType::REAL:
                aValue = DBTypeConversion::toDateTime((double)*this);
                break;
            case DataType::DATE:
                {
                    ::com::sun::star::util::Date* pDate = static_cast< ::com::sun::star::util::Date*>(m_aValue.m_pValue);
                    aValue.Day		= pDate->Day;
                    aValue.Month	= pDate->Month;
                    aValue.Year		= pDate->Year;
                }
                break;
            case DataType::TIME:
                {
                    ::com::sun::star::util::Time* pTime = static_cast< ::com::sun::star::util::Time*>(m_aValue.m_pValue);
                    aValue.HundredthSeconds	= pTime->HundredthSeconds;
                    aValue.Seconds			= pTime->Seconds;
                    aValue.Minutes			= pTime->Minutes;
                    aValue.Hours			= pTime->Hours;
                }
                break;
            case DataType::TIMESTAMP:
                aValue = *static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue);
                break;
        }
    }
    return aValue;
}
// -----------------------------------------------------------------------------
void ORowSetValue::setSigned(sal_Bool _bMod)
{
    if ( m_bSigned != _bMod )
    {
        m_bSigned = _bMod;
        if ( !m_bNull )
        {
            sal_Int32 nType = m_eTypeKind;
            switch(m_eTypeKind)
            {
                case DataType::BIGINT:
                    if ( m_bSigned ) // now we are signed, so we were unsigned and need to call getString()
                    {
                        m_bSigned = !m_bSigned;
                        const ::rtl::OUString sValue = getString();
                        free();
                        m_bSigned = !m_bSigned;
                        (*this) = sValue;
                    }
                    else
                    {
                        m_bSigned = !m_bSigned;
                        const sal_Int64 nValue = getLong();
                        free();
                        m_bSigned = !m_bSigned;
                        (*this) = nValue;
                    }
                    break;
                case DataType::TINYINT:
                    if ( m_bSigned )
                        (*this) = getInt8();
                    else
                    {
                        m_bSigned = !m_bSigned;
                        (*this) = getInt16();
                        m_bSigned = !m_bSigned;
                    }
                    break;
                case DataType::SMALLINT:
                    if ( m_bSigned )
                        (*this) = getInt16();
                    else
                    {
                        m_bSigned = !m_bSigned;
                        (*this) = getInt32();
                        m_bSigned = !m_bSigned;
                    }
                    break;
                case DataType::INTEGER:
                    if ( m_bSigned )
                        (*this) = getInt32();
                    else
                    {
                        m_bSigned = !m_bSigned;
                        (*this) = getLong();
                        m_bSigned = !m_bSigned;
                    }
                    break;
            }
            m_eTypeKind = nType;
        }
    }
}
// -----------------------------------------------------------------------------
void ORowSetValue::fill(sal_Int32 _nPos,
                     sal_Int32 _nType,
                     const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XRow>& _xRow)
{
    sal_Bool bReadData = sal_True;
    switch(_nType)
    {
    case DataType::CHAR:
    case DataType::VARCHAR:
    case DataType::DECIMAL:
    case DataType::NUMERIC:
    case DataType::LONGVARCHAR:
        (*this) = _xRow->getString(_nPos);
        break;
    case DataType::BIGINT:
        if ( isSigned() )
            (*this) = _xRow->getLong(_nPos);
        else
            (*this) = _xRow->getString(_nPos);
        break;
    case DataType::FLOAT:
        (*this) = _xRow->getFloat(_nPos);
        break;
    case DataType::DOUBLE:
    case DataType::REAL:
        (*this) = _xRow->getDouble(_nPos);
        break;
    case DataType::DATE:
        (*this) = _xRow->getDate(_nPos);
        break;
    case DataType::TIME:
        (*this) = _xRow->getTime(_nPos);
        break;
    case DataType::TIMESTAMP:
        (*this) = _xRow->getTimestamp(_nPos);
        break;
    case DataType::BINARY:
    case DataType::VARBINARY:
    case DataType::LONGVARBINARY:
        (*this) = _xRow->getBytes(_nPos);
        break;
    case DataType::BIT:
    case DataType::BOOLEAN:
        (*this) = _xRow->getBoolean(_nPos);
        break;
    case DataType::TINYINT:
        if ( isSigned() )
            (*this) = _xRow->getByte(_nPos);
        else
            (*this) = _xRow->getShort(_nPos);
        break;
    case DataType::SMALLINT:
        if ( isSigned() )
            (*this) = _xRow->getShort(_nPos);
        else
            (*this) = _xRow->getInt(_nPos);
        break;
    case DataType::INTEGER:
        if ( isSigned() )
            (*this) = _xRow->getInt(_nPos);
        else
            (*this) = _xRow->getLong(_nPos);
        break;
    case DataType::CLOB:
        (*this) = ::com::sun::star::uno::makeAny(_xRow->getCharacterStream(_nPos));
        setTypeKind(DataType::CLOB);
        break;
    case DataType::BLOB:
        (*this) = ::com::sun::star::uno::makeAny(_xRow->getBinaryStream(_nPos));
        setTypeKind(DataType::BLOB);
        break;
    default:
        bReadData = sal_False;
        break;
    }
    if ( bReadData && _xRow->wasNull() )
        setNull();
    setTypeKind(_nType);
}
// -----------------------------------------------------------------------------
void ORowSetValue::fill(const Any& _rValue)
{
    switch (_rValue.getValueType().getTypeClass())
    {
        case TypeClass_VOID:
            setNull();
            break;
        case TypeClass_BOOLEAN:
        {
            sal_Bool bValue( sal_False );
            _rValue >>= bValue;
            (*this) = bValue;
            break;
        }
        case TypeClass_CHAR:
        {
            sal_Unicode aDummy(0);
            _rValue >>= aDummy;
            (*this) = ::rtl::OUString(aDummy);
            break;
        }
        case TypeClass_STRING:
        {
            ::rtl::OUString sDummy;
            _rValue >>= sDummy;
            (*this) = sDummy;
            break;
        }
        case TypeClass_FLOAT:
        {
            float aDummy;
            _rValue >>= aDummy;
            (*this) = aDummy;
            break;
        }
        case TypeClass_DOUBLE:
        {
            double aDummy;
            _rValue >>= aDummy;
            (*this) = aDummy;
            break;
        }
        case TypeClass_BYTE:
        {
            sal_Int8 aDummy;
            _rValue >>= aDummy;
            (*this) = aDummy;
            break;
        }
        case TypeClass_SHORT:
        {
            sal_Int16 aDummy;
            _rValue >>= aDummy;
            (*this) = aDummy;
            break;
        }
        case TypeClass_LONG:
        {
            sal_Int32 aDummy;
            _rValue >>= aDummy;
            (*this) = aDummy;
            break;
        }
        case TypeClass_UNSIGNED_SHORT:
        {
            sal_uInt16 nValue(0);
            _rValue >>= nValue;
            (*this) = static_cast<sal_Int32>(nValue);
            setSigned(sal_False);
            break;
        }
        case TypeClass_UNSIGNED_LONG:
        {
            sal_uInt32 nValue(0);
            _rValue >>= nValue;
            (*this) = static_cast<sal_Int64>(nValue);
            setSigned(sal_False);
            break;
        }
        case TypeClass_SEQUENCE:
        {
            Sequence<sal_Int8> aDummy;
            if ( _rValue >>= aDummy )
                (*this) = aDummy;
            break;
        }
            
        default:
            OSL_ENSURE(0,"Unknown type");
            break;
    }
}