Automated merge with file:///z:\so-cwsserv02\dba33b\DEV300\ooo

27 files changed, 424 insertions, 131 deletions

diff --git a/connectivity/inc/connectivity/dbtools.hxx b/connectivity/inc/connectivity/dbtools.hxx
index 493dc2a3802f..32ef3bcb7da1 100644
--- a/connectivity/inc/connectivity/dbtools.hxx
+++ b/connectivity/inc/connectivity/dbtools.hxx
@@ -37,6 +37,7 @@
 #include <comphelper/stl_types.hxx>
 #include <unotools/sharedunocomponent.hxx>
 #include "connectivity/dbtoolsdllapi.hxx"
+#include "connectivity/FValue.hxx"
 
 namespace com { namespace sun { namespace star {
 
@@ -593,6 +594,20 @@ namespace dbtools
                             sal_Int32 sqlType,
                             sal_Int32 scale=0) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
 
+    /** call the appropiate set method for the specific sql type @see com::sun::star::sdbc::DataType
+        @param  _xParams        the parameters where to set the value
+        @param  parameterIndex  the index of the parameter, 1 based
+        @param  x               the value to set
+        @param  sqlType         the corresponding sql type @see com::sun::star::sdbc::DataType
+        @param  scale           the scale of the sql type can be 0
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    void setObjectWithInfo( const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XParameters>& _xParameters,
+                            sal_Int32 parameterIndex,
+                            const ::connectivity::ORowSetValue& x,
+                            sal_Int32 sqlType,
+                            sal_Int32 scale=0) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+
 
     /** implements <method scope="com.sun.star.sdb">XParameters::setObject</method>
         <p>The object which is to be set is analyzed, and in case it is a simlpe scalar type for which there
diff --git a/connectivity/source/commontools/FValue.cxx b/connectivity/source/commontools/FValue.cxx
index cd09efa227fe..7a85cca57738 100644
--- a/connectivity/source/commontools/FValue.cxx
+++ b/connectivity/source/commontools/FValue.cxx
@@ -254,6 +254,7 @@ void ORowSetValue::setTypeKind(sal_Int32 _eType)
             case DataType::BLOB:
             case DataType::CLOB:
             case DataType::OBJECT:
+            case DataType::OTHER:
                 (*this) = getAny();
                 break;
             default:
@@ -844,6 +845,7 @@ bool ORowSetValue::operator==(const ORowSetValue& _rRH) const
         case DataType::BLOB:
         case DataType::CLOB:
         case DataType::OBJECT:
+        case DataType::OTHER:
             bRet = false;
             break;
         default:
@@ -910,6 +912,7 @@ Any ORowSetValue::makeAny() const
             case DataType::BLOB:
             case DataType::CLOB:
             case DataType::OBJECT:
+            case DataType::OTHER:
                 rValue = getAny();
                 break;
             case DataType::BIT:
@@ -1016,6 +1019,19 @@ Any ORowSetValue::makeAny() const
                 else
                     aRet = ::rtl::OUString::valueOf((sal_Int64)*this);
                 break;
+            case DataType::CLOB:
+                {
+                    Any aValue( getAny() );
+                    Reference< XClob > xClob;
+                    if ( aValue >>= xClob )
+                    {
+                        if ( xClob.is() )
+                        {
+                            aRet = xClob->getSubString(1,(sal_Int32)xClob->length() );
+                        }
+                    }
+                }
+                break;
         }
     }
     return aRet;
@@ -1087,6 +1103,9 @@ sal_Bool ORowSetValue::getBool()    const
             case DataType::INTEGER:
                 bRet = m_bSigned ? (m_aValue.m_nInt32 != 0) : (*static_cast<sal_Int64*>(m_aValue.m_pValue) != sal_Int64(0));
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return bRet;
@@ -1128,6 +1147,8 @@ sal_Int8 ORowSetValue::getInt8()    const
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
+            case DataType::CLOB:
                 OSL_ASSERT(!"getInt8() for this type is not allowed!");
                 break;
             case DataType::BIT:
@@ -1152,6 +1173,9 @@ sal_Int8 ORowSetValue::getInt8()    const
                 else
                     nRet = static_cast<sal_Int8>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return nRet;
@@ -1193,6 +1217,8 @@ sal_Int16 ORowSetValue::getInt16()  const
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
+            case DataType::CLOB:
                 OSL_ASSERT(!"getInt16() for this type is not allowed!");
                 break;
             case DataType::BIT:
@@ -1217,6 +1243,9 @@ sal_Int16 ORowSetValue::getInt16()  const
                 else
                     nRet = static_cast<sal_Int16>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return nRet;
@@ -1258,6 +1287,8 @@ sal_Int32 ORowSetValue::getInt32()  const
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
+            case DataType::CLOB:
                 OSL_ASSERT(!"getInt32() for this type is not allowed!");
                 break;
             case DataType::BIT:
@@ -1282,6 +1313,9 @@ sal_Int32 ORowSetValue::getInt32()  const
                 else
                     nRet = static_cast<sal_Int32>(*static_cast<sal_Int64*>(m_aValue.m_pValue));
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return nRet;
@@ -1323,6 +1357,8 @@ sal_Int64 ORowSetValue::getLong()   const
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
+            case DataType::CLOB:
                 OSL_ASSERT(!"getInt32() for this type is not allowed!");
                 break;
             case DataType::BIT:
@@ -1347,6 +1383,9 @@ sal_Int64 ORowSetValue::getLong()   const
                 else
                     nRet = *(sal_Int64*)m_aValue.m_pValue;
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return nRet;
@@ -1392,6 +1431,8 @@ float ORowSetValue::getFloat()  const
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
+            case DataType::CLOB:
                 OSL_ASSERT(!"getDouble() for this type is not allowed!");
                 break;
             case DataType::BIT:
@@ -1416,6 +1457,9 @@ float ORowSetValue::getFloat()  const
                 else
                     nRet = float(*(sal_Int64*)m_aValue.m_pValue);
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return nRet;
@@ -1463,6 +1507,8 @@ double ORowSetValue::getDouble()    const
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
+            case DataType::CLOB:
                 OSL_ASSERT(!"getDouble() for this type is not allowed!");
                 break;
             case DataType::BIT:
@@ -1487,6 +1533,9 @@ double ORowSetValue::getDouble()    const
                 else
                     nRet = double(*(sal_Int64*)m_aValue.m_pValue);
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return nRet;
@@ -1548,6 +1597,8 @@ void ORowSetValue::setFromDouble(const double& _rVal,sal_Int32 _nDatatype)
         case DataType::BINARY:
         case DataType::VARBINARY:
         case DataType::LONGVARBINARY:
+        case DataType::BLOB:
+        case DataType::CLOB:
             OSL_ASSERT(!"setFromDouble() for this type is not allowed!");
             break;
         case DataType::BIT:
@@ -1655,6 +1706,9 @@ Sequence<sal_Int8>  ORowSetValue::getSequence() const
                     aValue.Year     = pDateTime->Year;
                 }
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return aValue;
@@ -1693,6 +1747,9 @@ Sequence<sal_Int8>  ORowSetValue::getSequence() const
                 break;
             case DataType::TIME:
                 aValue = *static_cast< ::com::sun::star::util::Time*>(m_aValue.m_pValue);
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return aValue;
@@ -1740,6 +1797,9 @@ Sequence<sal_Int8>  ORowSetValue::getSequence() const
             case DataType::TIMESTAMP:
                 aValue = *static_cast< ::com::sun::star::util::DateTime*>(m_aValue.m_pValue);
                 break;
+            default:
+                OSL_ENSURE(0,"Illegal conversion!");
+                break;
         }
     }
     return aValue;
@@ -1885,13 +1945,17 @@ void ORowSetValue::fill(sal_Int32 _nPos,
             (*this) = _xRow->getLong(_nPos);
         break;
     case DataType::CLOB:
-        (*this) = ::com::sun::star::uno::makeAny(_xRow->getCharacterStream(_nPos));
+        (*this) = ::com::sun::star::uno::makeAny(_xRow->getClob(_nPos));
         setTypeKind(DataType::CLOB);
         break;
     case DataType::BLOB:
-        (*this) = ::com::sun::star::uno::makeAny(_xRow->getBinaryStream(_nPos));
+        (*this) = ::com::sun::star::uno::makeAny(_xRow->getBlob(_nPos));
         setTypeKind(DataType::BLOB);
         break;
+    case DataType::OTHER:
+        (*this) = _xRow->getObject(_nPos,NULL);
+        setTypeKind(DataType::OTHER);
+        break;
     default:
         OSL_ENSURE( false, "ORowSetValue::fill: unsupported type!" );
         bReadData = false;
@@ -2037,6 +2101,25 @@ void ORowSetValue::fill(const Any& _rValue)
 
             break;
         }
+        case TypeClass_INTERFACE:
+            {
+                Reference< XClob > xClob;
+                if ( _rValue >>= xClob )
+                {
+                    (*this) = _rValue;
+                    setTypeKind(DataType::CLOB);
+                }
+                else
+                {
+                    Reference< XBlob > xBlob;
+                    if ( _rValue >>= xBlob )
+                    {
+                        (*this) = _rValue;
+                        setTypeKind(DataType::BLOB);
+                    }
+                }
+            }
+            break;
 
         default:
             OSL_ENSURE(0,"Unknown type");
diff --git a/connectivity/source/commontools/dbtools.cxx b/connectivity/source/commontools/dbtools.cxx
index 02e6e420142f..bb088937c313 100644
--- a/connectivity/source/commontools/dbtools.cxx
+++ b/connectivity/source/commontools/dbtools.cxx
@@ -213,6 +213,7 @@ sal_Int32 getDefaultNumberFormat(sal_Int32 _nDataType,
         case DataType::CHAR:
         case DataType::VARCHAR:
         case DataType::LONGVARCHAR:
+        case DataType::CLOB:
             nFormat = _xTypes->getStandardFormat(NumberFormat::TEXT, _rLocale);
             break;
         case DataType::DATE:
@@ -234,10 +235,10 @@ sal_Int32 getDefaultNumberFormat(sal_Int32 _nDataType,
         case DataType::STRUCT:
         case DataType::ARRAY:
         case DataType::BLOB:
-        case DataType::CLOB:
         case DataType::REF:
         default:
-            nFormat = NumberFormat::UNDEFINED;
+            nFormat = _xTypes->getStandardFormat(NumberFormat::UNDEFINED, _rLocale);
+            //nFormat = NumberFormat::UNDEFINED;
     }
     return nFormat;
 }
@@ -1850,9 +1851,20 @@ void setObjectWithInfo(const Reference<XParameters>& _xParams,
                        sal_Int32 parameterIndex,
                        const Any& x,
                        sal_Int32 sqlType,
-                       sal_Int32 /*scale*/)  throw(SQLException, RuntimeException)
+                       sal_Int32 scale)  throw(SQLException, RuntimeException)
+{
+    ORowSetValue aVal;
+    aVal.fill(x);
+    setObjectWithInfo(_xParams,parameterIndex,aVal,sqlType,scale);
+}
+// -----------------------------------------------------------------------------
+void setObjectWithInfo(const Reference<XParameters>& _xParams,
+                       sal_Int32 parameterIndex,
+                       const ::connectivity::ORowSetValue& _rValue,
+                       sal_Int32 sqlType,
+                       sal_Int32 scale)  throw(SQLException, RuntimeException)
 {
-    if(!x.hasValue())
+    if ( _rValue.isNull() )
         _xParams->setNull(parameterIndex,sqlType);
     else
     {
@@ -1860,65 +1872,62 @@ void setObjectWithInfo(const Reference<XParameters>& _xParams,
         {
             case DataType::DECIMAL:
             case DataType::NUMERIC:
-                _xParams->setObjectWithInfo(parameterIndex,x,sqlType,0);
+                _xParams->setObjectWithInfo(parameterIndex,_rValue.makeAny(),sqlType,scale);
                 break;
             case DataType::CHAR:
             case DataType::VARCHAR:
-            //case DataType::DECIMAL:
-            //case DataType::NUMERIC:
             case DataType::LONGVARCHAR:
-                _xParams->setString(parameterIndex,::comphelper::getString(x));
+                _xParams->setString(parameterIndex,_rValue);
                 break;
-            case DataType::BIGINT:
+            case DataType::CLOB:
                 {
-                    sal_Int64 nValue = 0;
-                    if(x >>= nValue)
+                    Any x(_rValue.makeAny());
+                    ::rtl::OUString sValue;
+                    if ( x >>= sValue )
+                        _xParams->setString(parameterIndex,sValue);
+                    else
                     {
-                        _xParams->setLong(parameterIndex,nValue);
-                        break;
+                        Reference< XClob > xClob;
+                        if(x >>= xClob)
+                            _xParams->setClob(parameterIndex,xClob);
+                        else
+                        {
+                            Reference< ::com::sun::star::io::XInputStream > xStream;
+                            if(x >>= xStream)
+                                _xParams->setCharacterStream(parameterIndex,xStream,xStream->available());
+                        }
                     }
                 }
                 break;
+            case DataType::BIGINT:
+                if ( _rValue.isSigned() )
+                    _xParams->setLong(parameterIndex,_rValue);
+                else
+                    _xParams->setString(parameterIndex,_rValue);
+                break;
 
             case DataType::FLOAT:
+                _xParams->setFloat(parameterIndex,_rValue);
+                break;
             case DataType::REAL:
-                {
-                    float nValue = 0;
-                    if(x >>= nValue)
-                    {
-                        _xParams->setFloat(parameterIndex,nValue);
-                        break;
-                    }
-                }
-                // run through if we couldn't set a float value
             case DataType::DOUBLE:
-                _xParams->setDouble(parameterIndex,::comphelper::getDouble(x));
+                _xParams->setDouble(parameterIndex,_rValue);
                 break;
             case DataType::DATE:
-                {
-                    ::com::sun::star::util::Date aValue;
-                    if(x >>= aValue)
-                        _xParams->setDate(parameterIndex,aValue);
-                }
+                _xParams->setDate(parameterIndex,_rValue);
                 break;
             case DataType::TIME:
-                {
-                    ::com::sun::star::util::Time aValue;
-                    if(x >>= aValue)
-                        _xParams->setTime(parameterIndex,aValue);
-                }
+                _xParams->setTime(parameterIndex,_rValue);
                 break;
             case DataType::TIMESTAMP:
-                {
-                    ::com::sun::star::util::DateTime aValue;
-                    if(x >>= aValue)
-                        _xParams->setTimestamp(parameterIndex,aValue);
-                }
+                _xParams->setTimestamp(parameterIndex,_rValue);
                 break;
             case DataType::BINARY:
             case DataType::VARBINARY:
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
                 {
+                    Any x(_rValue.makeAny());
                     Sequence< sal_Int8> aBytes;
                     if(x >>= aBytes)
                         _xParams->setBytes(parameterIndex,aBytes);
@@ -1944,16 +1953,24 @@ void setObjectWithInfo(const Reference<XParameters>& _xParams,
                 break;
             case DataType::BIT:
             case DataType::BOOLEAN:
-                _xParams->setBoolean(parameterIndex,::cppu::any2bool(x));
+                _xParams->setBoolean(parameterIndex,_rValue);
                 break;
-            case DataType::TINYINT:
-                _xParams->setByte(parameterIndex,(sal_Int8)::comphelper::getINT32(x));
+            if ( _rValue.isSigned() )
+                    _xParams->setByte(parameterIndex,_rValue);
+                else
+                    _xParams->setShort(parameterIndex,_rValue);
                 break;
             case DataType::SMALLINT:
-                _xParams->setShort(parameterIndex,(sal_Int16)::comphelper::getINT32(x));
+                if ( _rValue.isSigned() )
+                    _xParams->setShort(parameterIndex,_rValue);
+                else
+                    _xParams->setInt(parameterIndex,_rValue);
                 break;
             case DataType::INTEGER:
-                _xParams->setInt(parameterIndex,::comphelper::getINT32(x));
+                if ( _rValue.isSigned() )
+                    _xParams->setInt(parameterIndex,_rValue);
+                else
+                    _xParams->setLong(parameterIndex,_rValue);
                 break;
             default:
                 {
diff --git a/connectivity/source/commontools/predicateinput.cxx b/connectivity/source/commontools/predicateinput.cxx
index 45e937235dd1..f5d22e2937aa 100644
--- a/connectivity/source/commontools/predicateinput.cxx
+++ b/connectivity/source/commontools/predicateinput.cxx
@@ -148,9 +148,10 @@ namespace dbtools
             sal_Int32 nType = DataType::OTHER;
             _rxField->getPropertyValue( ::rtl::OUString::createFromAscii( "Type" ) ) >>= nType;
 
-            if  (   ( DataType::CHAR == nType )
-                ||  ( DataType::VARCHAR == nType )
+            if  (   ( DataType::CHAR        == nType )
+                ||  ( DataType::VARCHAR     == nType )
                 ||  ( DataType::LONGVARCHAR == nType )
+                ||  ( DataType::CLOB        == nType )
                 )
             {   // yes -> force a quoted text and try again
                 ::rtl::OUString sQuoted( _rStatement );
diff --git a/connectivity/source/drivers/ado/AResultSet.cxx b/connectivity/source/drivers/ado/AResultSet.cxx
index 1c53614bba04..8a5da6f94134 100644
--- a/connectivity/source/drivers/ado/AResultSet.cxx
+++ b/connectivity/source/drivers/ado/AResultSet.cxx
@@ -334,11 +334,9 @@ Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ ) throw
 }
 // -------------------------------------------------------------------------
 
-Any SAL_CALL OResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
+Any SAL_CALL OResultSet::getObject( sal_Int32 columnIndex, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
 {
-
-    ::dbtools::throwFeatureNotImplementedException( "XRow::getObject", *this );
-    return Any();
+    return getValue(columnIndex).makeAny();
 }
 // -------------------------------------------------------------------------
 
diff --git a/connectivity/source/drivers/ado/Aolevariant.cxx b/connectivity/source/drivers/ado/Aolevariant.cxx
index 09596da61bd6..b1b8235da3d8 100644
--- a/connectivity/source/drivers/ado/Aolevariant.cxx
+++ b/connectivity/source/drivers/ado/Aolevariant.cxx
@@ -39,8 +39,17 @@
 #include "diagnose_ex.h"
 #include "resource/sharedresources.hxx"
 #include "resource/ado_res.hrc"
-
+#include "com/sun/star/bridge/oleautomation/Date.hpp"
+#include "com/sun/star/bridge/oleautomation/Currency.hpp"
+#include "com/sun/star/bridge/oleautomation/SCode.hpp"
+#include "com/sun/star/bridge/oleautomation/Decimal.hpp"
+
+using namespace com::sun::star::beans;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::bridge::oleautomation;
 using namespace connectivity::ado;
+using ::rtl::OUString;
+
 OLEString::OLEString()
     :m_sStr(NULL)
 {
@@ -698,6 +707,88 @@ SAFEARRAY* OLEVariant::getUI1SAFEARRAYPtr() const
     return V_ARRAY(&varDest);
 }
 // -----------------------------------------------------------------------------
+::com::sun::star::uno::Any OLEVariant::makeAny() const
+{
+    ::com::sun::star::uno::Any aValue;
+    switch (V_VT(this))
+    {
+        case VT_EMPTY:
+        case VT_NULL:
+            aValue.setValue(NULL, Type());
+            break;
+        case VT_I2:
+            aValue.setValue( & iVal, getCppuType( (sal_Int16*)0));
+            break;
+        case VT_I4:
+            aValue.setValue( & lVal, getCppuType( (sal_Int32*)0));
+            break;
+        case VT_R4:
+            aValue.setValue( & fltVal, getCppuType( (float*)0));
+            break;
+        case VT_R8:
+            aValue.setValue(& dblVal, getCppuType( (double*)0));
+            break;
+        case VT_CY:
+         {
+             Currency cy(cyVal.int64);
+             aValue <<= cy;
+            break;
+         }
+        case VT_DATE:
+         {
+             aValue <<= (::com::sun::star::util::Date)*this;
+            break;
+         }
+        case VT_BSTR:
+        {
+            OUString b(reinterpret_cast<const sal_Unicode*>(bstrVal));
+            aValue.setValue( &b, getCppuType( &b));
+            break;
+        }
+        case VT_BOOL:
+        {
+            sal_Bool b= boolVal == VARIANT_TRUE;
+            aValue.setValue( &b, getCppuType( &b));
+            break;
+        }
+        case VT_I1:
+            aValue.setValue( & cVal, getCppuType((sal_Int8*)0));
+            break;
+        case VT_UI1: // there is no unsigned char in UNO
+            aValue.setValue( & bVal, getCppuType( (sal_Int8*)0));
+            break;
+        case VT_UI2:
+            aValue.setValue( & uiVal, getCppuType( (sal_uInt16*)0));
+            break;
+        case VT_UI4:
+            aValue.setValue( & ulVal, getCppuType( (sal_uInt32*)0));
+            break;
+        case VT_INT:
+            aValue.setValue( & intVal, getCppuType( (sal_Int32*)0));
+            break;
+        case VT_UINT:
+            aValue.setValue( & uintVal, getCppuType( (sal_uInt32*)0));
+            break;
+        case VT_VOID:
+            aValue.setValue( NULL, Type());
+            break;
+         case VT_DECIMAL:
+         {
+             Decimal dec;
+             dec.Scale = decVal.scale;
+             dec.Sign = decVal.sign;
+             dec.LowValue = decVal.Lo32;
+             dec.MiddleValue = decVal.Mid32;
+             dec.HighValue = decVal.Hi32;
+             aValue <<= dec;
+             break;
+         }
+
+        default:
+            break;
+    }
+    return aValue;
+}
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
diff --git a/connectivity/source/drivers/ado/adoimp.cxx b/connectivity/source/drivers/ado/adoimp.cxx
index 188303a1ba50..e3412babfdf6 100644
--- a/connectivity/source/drivers/ado/adoimp.cxx
+++ b/connectivity/source/drivers/ado/adoimp.cxx
@@ -157,8 +157,10 @@ DataTypeEnum ADOS::MapJdbc2ADOType(sal_Int32 _nType,sal_Int32 _nJetEngine)
         case DataType::BIT:             return adBoolean;           break;
         case DataType::BINARY:          return adBinary;            break;
         case DataType::VARCHAR:         return adVarWChar;          break;
+        case DataType::CLOB:
         case DataType::LONGVARCHAR:     return adLongVarWChar;      break;
         case DataType::VARBINARY:       return adVarBinary;         break;
+        case DataType::BLOB:
         case DataType::LONGVARBINARY:   return adLongVarBinary;     break;
         case DataType::CHAR:            return adWChar;             break;
         case DataType::TINYINT:         return isJetEngine(_nJetEngine) ? adUnsignedTinyInt : adTinyInt;break;
diff --git a/connectivity/source/drivers/file/FStatement.cxx b/connectivity/source/drivers/file/FStatement.cxx
index 07cdf95d7b44..6e583644e3b9 100644
--- a/connectivity/source/drivers/file/FStatement.cxx
+++ b/connectivity/source/drivers/file/FStatement.cxx
@@ -497,13 +497,16 @@ void OStatement_Base::construct(const ::rtl::OUString& sql)  throw(SQLException,
             // SELECT statement without columns -> error
             m_pConnection->throwGenericSQLException(STR_QUERY_NO_COLUMN,*this);
 
-        if ( m_aSQLIterator.getStatementType() == SQL_STATEMENT_CREATE_TABLE )
-            // CREATE TABLE is not supported at all
-            m_pConnection->throwGenericSQLException(STR_QUERY_TOO_COMPLEX,*this);
-
-        if ( ( m_aSQLIterator.getStatementType() == SQL_STATEMENT_ODBC_CALL ) || ( m_aSQLIterator.getStatementType() == SQL_STATEMENT_UNKNOWN ) )
-            // ODBC call or unknown statement type -> error
-            m_pConnection->throwGenericSQLException(STR_QUERY_TOO_COMPLEX,*this);
+        switch(m_aSQLIterator.getStatementType())
+        {
+            case SQL_STATEMENT_CREATE_TABLE:
+            case SQL_STATEMENT_ODBC_CALL:
+            case SQL_STATEMENT_UNKNOWN:
+                m_pConnection->throwGenericSQLException(STR_QUERY_TOO_COMPLEX,*this);
+                break;
+            default:
+                break;
+        }
 
         // at this moment we support only one table per select statement
         Reference< ::com::sun::star::lang::XUnoTunnel> xTunnel(xTabs.begin()->second,UNO_QUERY);
diff --git a/connectivity/source/drivers/jdbc/Boolean.cxx b/connectivity/source/drivers/jdbc/Boolean.cxx
index cac868d4792f..d778487655d5 100644
--- a/connectivity/source/drivers/jdbc/Boolean.cxx
+++ b/connectivity/source/drivers/jdbc/Boolean.cxx
@@ -40,17 +40,19 @@ jclass java_lang_Boolean::theClass = 0;
 
 java_lang_Boolean::~java_lang_Boolean()
 {}
-
-jclass java_lang_Boolean::getMyClass() const
+jclass java_lang_Boolean::st_getMyClass()
 {
     // die Klasse muss nur einmal geholt werden, daher statisch
     if( !theClass )
-    {
         theClass = findMyClass("java/lang/Boolean");
-    }
     return theClass;
 }
 
+jclass java_lang_Boolean::getMyClass() const
+{
+    return st_getMyClass();
+}
+
 java_lang_Boolean::java_lang_Boolean( sal_Bool _par0 ): java_lang_Object( NULL, (jobject)NULL )
 {
     SDBThreadAttach t;
diff --git a/connectivity/source/drivers/jdbc/CallableStatement.cxx b/connectivity/source/drivers/jdbc/CallableStatement.cxx
index 8cea582940d3..e6209a90f236 100644
--- a/connectivity/source/drivers/jdbc/CallableStatement.cxx
+++ b/connectivity/source/drivers/jdbc/CallableStatement.cxx
@@ -227,9 +227,8 @@ void SAL_CALL java_sql_CallableStatement::registerOutParameter( sal_Int32 parame
         static jmethodID mID(NULL);
         obtainMethodId(t.pEnv, cMethodName,cSignature, mID);
         // Parameter konvertieren
-        jstring str = convertwchar_tToJavaString(t.pEnv,typeName);
-        t.pEnv->CallVoidMethod( object, mID, parameterIndex,sqlType,str);
-        t.pEnv->DeleteLocalRef(str);
+        jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,typeName));
+        t.pEnv->CallVoidMethod( object, mID, parameterIndex,sqlType,str.get());
         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
     }
 }
@@ -336,23 +335,22 @@ void java_sql_CallableStatement::createStatement(JNIEnv* /*_pEnv*/)
         // Java-Call absetzen
         jobject out = NULL;
         // Parameter konvertieren
-        jstring str = convertwchar_tToJavaString(t.pEnv,m_sSqlStatement);
+        jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,m_sSqlStatement));
 
         static jmethodID mID(NULL);
         if ( !mID  )
             mID  = t.pEnv->GetMethodID( m_pConnection->getMyClass(), cMethodName, cSignature );
         if( mID ){
-            out = t.pEnv->CallObjectMethod( m_pConnection->getJavaObject(), mID, str ,m_nResultSetType,m_nResultSetConcurrency);
+            out = t.pEnv->CallObjectMethod( m_pConnection->getJavaObject(), mID, str.get() ,m_nResultSetType,m_nResultSetConcurrency);
         } //mID
         else
         {
             static const char * cSignature2 = "(Ljava/lang/String;)Ljava/sql/CallableStatement;";
             static jmethodID mID2 = t.pEnv->GetMethodID( m_pConnection->getMyClass(), cMethodName, cSignature2 );OSL_ENSURE(mID2,"Unknown method id!");
             if( mID2 ){
-                out = t.pEnv->CallObjectMethod( m_pConnection->getJavaObject(), mID2, str );
+                out = t.pEnv->CallObjectMethod( m_pConnection->getJavaObject(), mID2, str.get() );
             } //mID
         }
-        t.pEnv->DeleteLocalRef(str);
         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
 
         if ( out )
diff --git a/connectivity/source/drivers/jdbc/Clob.cxx b/connectivity/source/drivers/jdbc/Clob.cxx
index 632504448e06..ef64ca7b05e9 100644
--- a/connectivity/source/drivers/jdbc/Clob.cxx
+++ b/connectivity/source/drivers/jdbc/Clob.cxx
@@ -34,6 +34,8 @@
 #include "java/tools.hxx"
 #include "java/io/Reader.hxx"
 #include <connectivity/dbexception.hxx>
+#include <rtl/logfile.hxx>
+
 using namespace connectivity;
 //**************************************************************
 //************ Class: java.sql.Clob
@@ -61,6 +63,7 @@ jclass java_sql_Clob::getMyClass() const
 
 sal_Int64 SAL_CALL java_sql_Clob::length(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "jdbc", "Ocke.Janssen@sun.com", "java_sql_Clob::length" );
     jlong out(0);
     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
 
@@ -79,6 +82,7 @@ sal_Int64 SAL_CALL java_sql_Clob::length(  ) throw(::com::sun::star::sdbc::SQLEx
 
 ::rtl::OUString SAL_CALL java_sql_Clob::getSubString( sal_Int64 pos, sal_Int32 subStringLength ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "jdbc", "Ocke.Janssen@sun.com", "java_sql_Clob::getSubString" );
     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
     ::rtl::OUString aStr;
     {
@@ -98,6 +102,7 @@ sal_Int64 SAL_CALL java_sql_Clob::length(  ) throw(::com::sun::star::sdbc::SQLEx
 
 ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > SAL_CALL java_sql_Clob::getCharacterStream(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "jdbc", "Ocke.Janssen@sun.com", "java_sql_Clob::getCharacterStream" );
     SDBThreadAttach t;
     static jmethodID mID(NULL);
     jobject out = callObjectMethod(t.pEnv,"getCharacterStream","()Ljava/io/Reader;", mID);
@@ -108,6 +113,7 @@ sal_Int64 SAL_CALL java_sql_Clob::length(  ) throw(::com::sun::star::sdbc::SQLEx
 
 sal_Int64 SAL_CALL java_sql_Clob::position( const ::rtl::OUString& searchstr, sal_Int32 start ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "jdbc", "Ocke.Janssen@sun.com", "java_sql_Clob::position" );
     jlong out(0);
     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
 
@@ -130,6 +136,7 @@ sal_Int64 SAL_CALL java_sql_Clob::position( const ::rtl::OUString& searchstr, sa
 
 sal_Int64 SAL_CALL java_sql_Clob::positionOfClob( const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XClob >& /*pattern*/, sal_Int64 /*start*/ ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 {
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "jdbc", "Ocke.Janssen@sun.com", "java_sql_Clob::positionOfClob" );
     ::dbtools::throwFeatureNotImplementedException( "XClob::positionOfClob", *this );
     // this was put here in CWS warnings01. The previous implementation was defective, as it did ignore
     // the pattern parameter. Since the effort for proper implementation is rather high - we would need
diff --git a/connectivity/source/drivers/jdbc/JConnection.cxx b/connectivity/source/drivers/jdbc/JConnection.cxx
index 96325511807f..f7bbe5ee258a 100644
--- a/connectivity/source/drivers/jdbc/JConnection.cxx
+++ b/connectivity/source/drivers/jdbc/JConnection.cxx
@@ -553,10 +553,9 @@ Reference< XPreparedStatement > SAL_CALL java_sql_Connection::prepareCall( const
         static jmethodID mID(NULL);
         obtainMethodId(t.pEnv, cMethodName,cSignature, mID);
         // Parameter konvertieren
-        jstring str = convertwchar_tToJavaString(t.pEnv,sql);
+        jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,sql));
 
-        jobject out = t.pEnv->CallObjectMethod( object, mID, str );
-        t.pEnv->DeleteLocalRef(str);
+        jobject out = t.pEnv->CallObjectMethod( object, mID, str.get() );
         aStr = JavaString2String(t.pEnv, (jstring)out );
         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
     } //t.pEnv
@@ -810,8 +809,8 @@ sal_Bool java_sql_Connection::construct(const ::rtl::OUString& url,
         static const char * cSignature = "(Ljava/lang/String;Ljava/util/Properties;)Ljava/sql/Connection;";
         static const char * cMethodName = "connect";
         // Java-Call absetzen
-        jmethodID mID = NULL;
-        if ( !mID  )

+        static jmethodID mID = NULL;
+        if ( !mID  )
             mID  = t.pEnv->GetMethodID( m_Driver_theClass, cMethodName, cSignature );
         if ( mID )
         {
diff --git a/connectivity/source/drivers/jdbc/Object.cxx b/connectivity/source/drivers/jdbc/Object.cxx
index 6f4e78550dc0..73829b46ec64 100644
--- a/connectivity/source/drivers/jdbc/Object.cxx
+++ b/connectivity/source/drivers/jdbc/Object.cxx
@@ -43,7 +43,7 @@
 #include <vos/mutex.hxx>
 #include <osl/thread.h>
 #include <com/sun/star/uno/Sequence.hxx>
-
+#include "java/LocalRef.hxx"
 #include "resource/jdbc_log.hrc"
 #include <rtl/logfile.hxx>
 #include <comphelper/logging.hxx>
@@ -395,10 +395,9 @@ void java_lang_Object::callVoidMethodWithStringArg( const char* _pMethodName, jm
     OSL_ENSURE( t.pEnv, "java_lang_Object::callIntMethod: no Java enviroment anymore!" );
     obtainMethodId(t.pEnv, _pMethodName,"(Ljava/lang/String;)V", _inout_MethodID);
 
-    jstring str = convertwchar_tToJavaString(t.pEnv,_nArgument);
+    jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,_nArgument));
     // call method
-    t.pEnv->CallVoidMethod( object, _inout_MethodID , str);
-    t.pEnv->DeleteLocalRef(str);
+    t.pEnv->CallVoidMethod( object, _inout_MethodID , str.get());
     ThrowSQLException( t.pEnv, NULL );
 }
 // -------------------------------------------------------------------------
@@ -417,10 +416,9 @@ sal_Int32 java_lang_Object::callIntMethodWithStringArg( const char* _pMethodName
             //        *this
             //    );
 
-    jstring str = convertwchar_tToJavaString(t.pEnv,_nArgument);
+    jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,_nArgument));
     // call method
-    jint out = t.pEnv->CallIntMethod( object, _inout_MethodID , str);
-    t.pEnv->DeleteLocalRef(str);
+    jint out = t.pEnv->CallIntMethod( object, _inout_MethodID , str.get());
     ThrowSQLException( t.pEnv, NULL );
     return (sal_Int32)out;
 }
diff --git a/connectivity/source/drivers/jdbc/PreparedStatement.cxx b/connectivity/source/drivers/jdbc/PreparedStatement.cxx
index dbf7241885da..ae43b40b3a0b 100644
--- a/connectivity/source/drivers/jdbc/PreparedStatement.cxx
+++ b/connectivity/source/drivers/jdbc/PreparedStatement.cxx
@@ -45,7 +45,7 @@
 #include "resource/jdbc_log.hrc"
 #include "resource/common_res.hrc"
 #include "resource/sharedresources.hxx"
-
+#include "java/LocalRef.hxx"
 #include <string.h>
 
 using namespace connectivity;
@@ -138,10 +138,9 @@ void SAL_CALL java_sql_PreparedStatement::setString( sal_Int32 parameterIndex, c
         // Java-Call absetzen
         static jmethodID mID(NULL);
         obtainMethodId(t.pEnv, cMethodName,cSignature, mID);
-        jstring str = convertwchar_tToJavaString(t.pEnv,x);
-        t.pEnv->CallVoidMethod( object, mID, parameterIndex,str);
+        jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,x));
+        t.pEnv->CallVoidMethod( object, mID, parameterIndex,str.get());
         // und aufraeumen
-        t.pEnv->DeleteLocalRef(str);
         ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
     } //t.pEnv
 }
diff --git a/connectivity/source/drivers/jdbc/ResultSet.cxx b/connectivity/source/drivers/jdbc/ResultSet.cxx
index 677985ac6a90..257aa6405eee 100644
--- a/connectivity/source/drivers/jdbc/ResultSet.cxx
+++ b/connectivity/source/drivers/jdbc/ResultSet.cxx
@@ -30,10 +30,13 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_connectivity.hxx"
+#include "java/lang/String.hxx"
+#include "java/lang/Boolean.hxx"
 #include "java/sql/ResultSet.hxx"
 #include "java/math/BigDecimal.hxx"
 #include "java/sql/JStatement.hxx"
 #include "java/sql/SQLWarning.hxx"
+#include "java/sql/Timestamp.hxx"
 #include "java/sql/Array.hxx"
 #include "java/sql/Ref.hxx"
 #include "java/sql/Clob.hxx"
@@ -54,6 +57,7 @@
 #include "connectivity/dbexception.hxx"
 #include "resource/common_res.hrc"
 #include "resource/sharedresources.hxx"
+#include "java/LocalRef.hxx"
 
 #include <rtl/logfile.hxx>
 #include <string.h>
@@ -324,6 +328,7 @@ Any SAL_CALL java_sql_ResultSet::getObject( sal_Int32 columnIndex, const Referen
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "jdbc", "Ocke.Janssen@sun.com", "java_sql_ResultSet::getObject" );
     jobject out(0);
+    Any aRet;
     SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
     {
         jvalue args[2];
@@ -341,15 +346,43 @@ Any SAL_CALL java_sql_ResultSet::getObject( sal_Int32 columnIndex, const Referen
             obtainMethodId(t.pEnv, cMethodName,cSignature, mID);
         }
 
-            out = t.pEnv->CallObjectMethodA( object, mID, args);
-            t.pEnv->DeleteLocalRef((jstring)args[1].l);
-            ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
-            // und aufraeumen
-
+        out = t.pEnv->CallObjectMethodA( object, mID, args);
+        t.pEnv->DeleteLocalRef((jstring)args[1].l);
+        ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
+        // und aufraeumen
+        if ( out )
+        {
+            if ( t.pEnv->IsInstanceOf(out,java_lang_String::st_getMyClass()) )
+            {
+                java_lang_String aVal(t.pEnv,out);
+                aRet <<= (::rtl::OUString)aVal;
+            }
+            else if ( t.pEnv->IsInstanceOf(out,java_lang_Boolean::st_getMyClass()) )
+            {
+                java_lang_Boolean aVal(t.pEnv,out);
+                static jmethodID methodID = NULL;
+                aRet <<= aVal.callBooleanMethod("booleanValue",methodID);
+            }
+            else if ( t.pEnv->IsInstanceOf(out,java_sql_Date::st_getMyClass()) )
+            {
+                java_sql_Date aVal(t.pEnv,out);
+                aRet <<= (::com::sun::star::util::Date)aVal;
+            }
+            else if ( t.pEnv->IsInstanceOf(out,java_sql_Time::st_getMyClass()) )
+            {
+                java_sql_Time aVal(t.pEnv,out);
+                aRet <<= (::com::sun::star::util::Time)aVal;
+            }
+            else if ( t.pEnv->IsInstanceOf(out,java_sql_Timestamp::st_getMyClass()) )
+            {
+                java_sql_Timestamp aVal(t.pEnv,out);
+                aRet <<= (::com::sun::star::util::DateTime)aVal;
+            }
+            else
+                t.pEnv->DeleteLocalRef(out);
+        }
     } //t.pEnv
-    // ACHTUNG: der Aufrufer wird Eigentuemer des zurueckgelieferten Zeigers !!!
-    ::dbtools::throwFunctionNotSupportedException( "XRow::getObject", *this );
-    return out==0 ? Any() : Any();//new java_lang_Object( t.pEnv, out );
+    return aRet;
 }
 // -------------------------------------------------------------------------
 
@@ -689,9 +722,8 @@ void SAL_CALL java_sql_ResultSet::updateString( sal_Int32 columnIndex, const ::r
 
         {
             // Parameter konvertieren
-            jstring str = convertwchar_tToJavaString(t.pEnv,x);
-            t.pEnv->CallVoidMethod( object, mID,columnIndex,str);
-            t.pEnv->DeleteLocalRef(str);
+            jdbc::LocalRef< jstring > str( t.env(),convertwchar_tToJavaString(t.pEnv,x));
+            t.pEnv->CallVoidMethod( object, mID,columnIndex,str.get());
             ThrowLoggedSQLException( m_aLogger, t.pEnv, *this );
         }
     }
diff --git a/connectivity/source/drivers/jdbc/Timestamp.cxx b/connectivity/source/drivers/jdbc/Timestamp.cxx
index 8c30f7a14efc..065ffe11d3e7 100644
--- a/connectivity/source/drivers/jdbc/Timestamp.cxx
+++ b/connectivity/source/drivers/jdbc/Timestamp.cxx
@@ -71,6 +71,10 @@ java_sql_Date::~java_sql_Date()
 
 jclass java_sql_Date::getMyClass() const
 {
+    return st_getMyClass();
+}
+jclass java_sql_Date::st_getMyClass()
+{
     // die Klasse muss nur einmal geholt werden, daher statisch
     if( !theClass )
         theClass = findMyClass("java/sql/Date");
@@ -94,12 +98,15 @@ java_sql_Time::~java_sql_Time()
 
 jclass java_sql_Time::getMyClass() const
 {
+    return st_getMyClass();
+}
+jclass java_sql_Time::st_getMyClass()
+{
     // die Klasse muss nur einmal geholt werden, daher statisch
     if( !theClass )
         theClass = findMyClass("java/sql/Time");
     return theClass;
 }
-
 java_sql_Time::java_sql_Time( const ::com::sun::star::util::Time& _rOut ): java_util_Date( NULL, (jobject)NULL )
 {
     SDBThreadAttach t;
@@ -140,12 +147,15 @@ java_sql_Timestamp::~java_sql_Timestamp()
 
 jclass java_sql_Timestamp::getMyClass() const
 {
+    return st_getMyClass();
+}
+jclass java_sql_Timestamp::st_getMyClass()
+{
     // die Klasse muss nur einmal geholt werden, daher statisch
     if( !theClass )
         theClass = findMyClass("java/sql/Timestamp");
     return theClass;
 }
-
 java_sql_Timestamp::java_sql_Timestamp(const ::com::sun::star::util::DateTime& _rOut)
                    :java_util_Date( NULL, (jobject)NULL )
 {
diff --git a/connectivity/source/drivers/odbcbase/ODatabaseMetaData.cxx b/connectivity/source/drivers/odbcbase/ODatabaseMetaData.cxx
index b92206199c24..f923987cc04e 100644
--- a/connectivity/source/drivers/odbcbase/ODatabaseMetaData.cxx
+++ b/connectivity/source/drivers/odbcbase/ODatabaseMetaData.cxx
@@ -921,6 +921,7 @@ sal_Bool SAL_CALL ODatabaseMetaData::supportsConvert( sal_Int32 fromType, sal_In
             OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CONVERT_VARCHAR,nValue,*this);
             break;
         case DataType::LONGVARCHAR:
+        case DataType::CLOB:
             OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CONVERT_LONGVARCHAR,nValue,*this);
             break;
         case DataType::DATE:
@@ -939,6 +940,7 @@ sal_Bool SAL_CALL ODatabaseMetaData::supportsConvert( sal_Int32 fromType, sal_In
             OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CONVERT_VARBINARY,nValue,*this);
             break;
         case DataType::LONGVARBINARY:
+        case DataType::BLOB:
             OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CONVERT_LONGVARBINARY,nValue,*this);
             break;
         case DataType::SQLNULL:
@@ -959,12 +961,6 @@ sal_Bool SAL_CALL ODatabaseMetaData::supportsConvert( sal_Int32 fromType, sal_In
         case DataType::ARRAY:
             //  OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CORRELATION_NAME,nValue,*this);
             break;
-        case DataType::BLOB:
-            //  OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CORRELATION_NAME,nValue,*this);
-            break;
-        case DataType::CLOB:
-            //  OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CORRELATION_NAME,nValue,*this);
-            break;
         case DataType::REF:
             //  OTools::GetInfo(m_pConnection,m_aConnectionHandle,SQL_CORRELATION_NAME,nValue,*this);
             break;
@@ -1009,6 +1005,7 @@ sal_Bool SAL_CALL ODatabaseMetaData::supportsConvert( sal_Int32 fromType, sal_In
             bConvert = (nValue & SQL_CVT_VARCHAR) == SQL_CVT_VARCHAR;
             break;
         case DataType::LONGVARCHAR:
+        case DataType::CLOB:
             bConvert = (nValue & SQL_CVT_LONGVARCHAR) == SQL_CVT_LONGVARCHAR;
             break;
         case DataType::DATE:
@@ -1027,6 +1024,7 @@ sal_Bool SAL_CALL ODatabaseMetaData::supportsConvert( sal_Int32 fromType, sal_In
             bConvert = (nValue & SQL_CVT_VARBINARY) == SQL_CVT_VARBINARY;
             break;
         case DataType::LONGVARBINARY:
+        case DataType::BLOB:
             bConvert = (nValue & SQL_CVT_LONGVARBINARY) == SQL_CVT_LONGVARBINARY;
             break;
     }
diff --git a/connectivity/source/drivers/odbcbase/OPreparedStatement.cxx b/connectivity/source/drivers/odbcbase/OPreparedStatement.cxx
index 6e9d87e933ca..03d9912e4e22 100644
--- a/connectivity/source/drivers/odbcbase/OPreparedStatement.cxx
+++ b/connectivity/source/drivers/odbcbase/OPreparedStatement.cxx
@@ -343,9 +343,9 @@ void OPreparedStatement::setParameter(sal_Int32 parameterIndex,sal_Int32 _nType,
         case SQL_NUMERIC:
             ++nRealSize;
             break;
-        case SQL_BINARY:

-        case SQL_VARBINARY:

-            nRealSize=1;    //dummy buffer, binary data isn't copied

+        case SQL_BINARY:
+        case SQL_VARBINARY:
+            nRealSize=1;    //dummy buffer, binary data isn't copied
             break;
         default:
             break;
@@ -474,15 +474,17 @@ void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 s
 }
 // -------------------------------------------------------------------------
 
-void SAL_CALL OPreparedStatement::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) throw(SQLException, RuntimeException)
+void SAL_CALL OPreparedStatement::setClob( sal_Int32 parameterIndex, const Reference< XClob >& x ) throw(SQLException, RuntimeException)
 {
-    ::dbtools::throwFunctionNotSupportedException( "XParameters::setClob", *this );
+    if ( x.is() )
+        setStream(parameterIndex, x->getCharacterStream(), (SQLLEN)x->length(), DataType::LONGVARCHAR);
 }
 // -------------------------------------------------------------------------
 
-void SAL_CALL OPreparedStatement::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) throw(SQLException, RuntimeException)
+void SAL_CALL OPreparedStatement::setBlob( sal_Int32 parameterIndex, const Reference< XBlob >& x ) throw(SQLException, RuntimeException)
 {
-    ::dbtools::throwFunctionNotSupportedException( "XParameters::setBlob", *this );
+    if ( x.is() )
+        setStream(parameterIndex, x->getBinaryStream(), (SQLLEN)x->length(), DataType::LONGVARCHAR);
 }
 // -------------------------------------------------------------------------
 
@@ -497,7 +499,12 @@ void SAL_CALL OPreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const Re
     ::dbtools::throwFunctionNotSupportedException( "XParameters::setRef", *this );
 }
 // -------------------------------------------------------------------------
-
+void OPreparedStatement::setDecimal( sal_Int32 parameterIndex, const ::rtl::OUString& x )
+{
+    ::rtl::OString aString(::rtl::OUStringToOString(x,getOwnConnection()->getTextEncoding()));
+    setParameter(parameterIndex,DataType::DECIMAL,aString.getLength(),(void*)&x);
+}
+// -------------------------------------------------------------------------
 void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 parameterIndex, const Any& x, sal_Int32 sqlType, sal_Int32 scale ) throw(SQLException, RuntimeException)
 {
     checkDisposed(OStatement_BASE::rBHelper.bDisposed);
@@ -522,6 +529,12 @@ void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 parameterIndex, c
                 setNull(parameterIndex,sqlType);
             break;
         case DataType::DECIMAL:
+            {
+                ORowSetValue aValue;
+                aValue.fill(x);
+                setDecimal(parameterIndex,aValue);
+            }
+            break;
         case DataType::NUMERIC:
             {
                 ORowSetValue aValue;
@@ -569,13 +582,13 @@ void SAL_CALL OPreparedStatement::setBytes( sal_Int32 parameterIndex, const Sequ
 
 void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 {
-    setStream (parameterIndex, x, length, DataType::LONGVARCHAR);
+    setStream(parameterIndex, x, length, DataType::LONGVARCHAR);
 }
 // -------------------------------------------------------------------------
 
 void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 parameterIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
 {
-    setStream (parameterIndex, x, length, DataType::LONGVARBINARY);
+    setStream(parameterIndex, x, length, DataType::LONGVARBINARY);
 }
 // -------------------------------------------------------------------------
 
@@ -834,10 +847,10 @@ sal_Int32 OPreparedStatement::getPrecision ( sal_Int32 sqlType)
 // Sets an input stream as a parameter, using the given SQL type
 //--------------------------------------------------------------------
 
-void OPreparedStatement::setStream (
+void OPreparedStatement::setStream(
                                     sal_Int32 ParameterIndex,
                                     const Reference< XInputStream>& x,
-                                    sal_Int32 length,
+                                    SQLLEN length,
                                     sal_Int32 SQLtype)
                                     throw(SQLException)
 {
diff --git a/connectivity/source/drivers/odbcbase/OResultSet.cxx b/connectivity/source/drivers/odbcbase/OResultSet.cxx
index 8c885f0924ad..fb1a08147338 100644
--- a/connectivity/source/drivers/odbcbase/OResultSet.cxx
+++ b/connectivity/source/drivers/odbcbase/OResultSet.cxx
@@ -223,9 +223,11 @@ SQLRETURN OResultSet::unbind(sal_Bool _bUnbindHandle)
                     delete static_cast< double* >(reinterpret_cast< void * >(pValue->first));
                     break;
                 case DataType::LONGVARCHAR:
+                case DataType::CLOB:
                     delete [] static_cast< char* >(reinterpret_cast< void * >(pValue->first));
                     break;
                 case DataType::LONGVARBINARY:
+                case DataType::BLOB:
                     delete [] static_cast< char* >(reinterpret_cast< void * >(pValue->first));
                     break;
                 case DataType::DATE:
@@ -284,9 +286,11 @@ TVoidPtr OResultSet::allocBindColumn(sal_Int32 _nType,sal_Int32 _nColumnIndex)
             aPair = TVoidPtr(reinterpret_cast< sal_Int64 >(new double(0.0)),_nType);
             break;
         case DataType::LONGVARCHAR:
+        case DataType::CLOB:
             aPair = TVoidPtr(reinterpret_cast< sal_Int64 >(new char[2]),_nType);  // dient nur zum auffinden
             break;
         case DataType::LONGVARBINARY:
+        case DataType::BLOB:
             aPair = TVoidPtr(reinterpret_cast< sal_Int64 >(new char[2]),_nType);  // dient nur zum auffinden
             break;
         case DataType::DATE:
@@ -1499,6 +1503,7 @@ void OResultSet::fillRow(sal_Int32 _nToColumn)
             case DataType::DECIMAL:
             case DataType::NUMERIC:
             case DataType::LONGVARCHAR:
+            case DataType::CLOB:
                 {
                     ::std::map<sal_Int32,SWORD>::iterator aFind = m_aODBCColumnTypes.find(nColumn);
                     if ( aFind == m_aODBCColumnTypes.end() )
@@ -1514,6 +1519,7 @@ void OResultSet::fillRow(sal_Int32 _nToColumn)
                 *pColumn = getDouble(nColumn);
                 break;
             case DataType::LONGVARBINARY:
+            case DataType::BLOB:
                 *pColumn = getBytes(nColumn);
                 break;
             case DataType::DATE:
@@ -1719,6 +1725,7 @@ void OResultSet::fillNeededData(SQLRETURN _nRet)
                 case DataType::BINARY:
                 case DataType::VARBINARY:
                 case DataType::LONGVARBINARY:
+                case DataType::BLOB:
                     aSeq = m_aRow[nColumnIndex];
                     N3SQLPutData (m_aStatementHandle, aSeq.getArray(), aSeq.getLength());
                     break;
@@ -1730,6 +1737,7 @@ void OResultSet::fillNeededData(SQLRETURN _nRet)
                     break;
                 }
                 case DataType::LONGVARCHAR:
+                case DataType::CLOB:
                 {
                     ::rtl::OUString sRet;
                     sRet = m_aRow[nColumnIndex].getString();
diff --git a/connectivity/source/drivers/odbcbase/OTools.cxx b/connectivity/source/drivers/odbcbase/OTools.cxx
index 3cadb33cf188..daa6d28a0acf 100644
--- a/connectivity/source/drivers/odbcbase/OTools.cxx
+++ b/connectivity/source/drivers/odbcbase/OTools.cxx
@@ -135,6 +135,7 @@ void OTools::bindData(  SQLSMALLINT _nOdbcType,
     {
         case SQL_CHAR:
         case SQL_VARCHAR:
+        case SQL_DECIMAL:
             if(_bUseWChar)
             {
                 *pLen = SQL_NTS;
@@ -160,7 +161,7 @@ void OTools::bindData(  SQLSMALLINT _nOdbcType,
             *pLen = sizeof(sal_Int64);
             _nColumnSize = *pLen;
             break;
-        case SQL_DECIMAL:
+
         case SQL_NUMERIC:
             if(_bUseWChar)
             {
diff --git a/connectivity/source/inc/ado/Aolevariant.hxx b/connectivity/source/inc/ado/Aolevariant.hxx
index f15d78a37ed9..c9fd9807af41 100644
--- a/connectivity/source/inc/ado/Aolevariant.hxx
+++ b/connectivity/source/inc/ado/Aolevariant.hxx
@@ -161,6 +161,7 @@ namespace connectivity
             double          getDate()       const;
             CY              getCurrency()   const;
             SAFEARRAY*      getUI1SAFEARRAYPtr() const;
+            ::com::sun::star::uno::Any makeAny() const;
 
             static VARIANT_BOOL VariantBool(sal_Bool bEinBoolean);
 
diff --git a/connectivity/source/inc/java/lang/Boolean.hxx b/connectivity/source/inc/java/lang/Boolean.hxx
index 2f33ea27bc11..7cfd1bbc4aa1 100644
--- a/connectivity/source/inc/java/lang/Boolean.hxx
+++ b/connectivity/source/inc/java/lang/Boolean.hxx
@@ -48,6 +48,7 @@ namespace connectivity
         java_lang_Boolean( JNIEnv * pEnv, jobject myObj ) : java_lang_Object( pEnv, myObj ){}
 
         java_lang_Boolean( sal_Bool _par0 );
+        static jclass st_getMyClass();
     };
 }
 
diff --git a/connectivity/source/inc/java/sql/Timestamp.hxx b/connectivity/source/inc/java/sql/Timestamp.hxx
index ce6de39b5bb9..2d234e1b52a1 100644
--- a/connectivity/source/inc/java/sql/Timestamp.hxx
+++ b/connectivity/source/inc/java/sql/Timestamp.hxx
@@ -54,6 +54,7 @@ namespace connectivity
         java_sql_Date( const ::com::sun::star::util::Date& _rOut );
 
         operator ::com::sun::star::util::Date();
+        static jclass st_getMyClass();
     };
 
 
@@ -73,6 +74,7 @@ namespace connectivity
         java_sql_Time( JNIEnv * pEnv, jobject myObj ) : java_util_Date( pEnv, myObj ){}
         java_sql_Time( const ::com::sun::star::util::Time& _rOut );
         operator ::com::sun::star::util::Time();
+        static jclass st_getMyClass();
     };
 
     //**************************************************************
@@ -93,6 +95,7 @@ namespace connectivity
 
         sal_Int32 getNanos();
         void  setNanos(sal_Int32 n);
+        static jclass st_getMyClass();
     };
 }
 #endif // _CONNECTIVITY_JAVA_SQL_TIMESTAMP_HXX_
diff --git a/connectivity/source/inc/odbc/OPreparedStatement.hxx b/connectivity/source/inc/odbc/OPreparedStatement.hxx
index 9e6f6ca8a61f..d167c9edb9a0 100644
--- a/connectivity/source/inc/odbc/OPreparedStatement.hxx
+++ b/connectivity/source/inc/odbc/OPreparedStatement.hxx
@@ -89,7 +89,7 @@ namespace connectivity
             void FreeParams();
             void putParamData (sal_Int32 index) throw(::com::sun::star::sdbc::SQLException);
             void setStream (sal_Int32 ParameterIndex,const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream>& x,
-                                                        sal_Int32 length,sal_Int32 SQLtype) throw(::com::sun::star::sdbc::SQLException);
+                                                        SQLLEN length,sal_Int32 SQLtype) throw(::com::sun::star::sdbc::SQLException);
             sal_Int32 getParamLength (  sal_Int32 index);
             sal_Int8* getLengthBuf (sal_Int32 index);
             sal_Int8* getDataBuf (sal_Int32 index);
@@ -102,6 +102,7 @@ namespace connectivity
             sal_Bool isPrepared() const { return m_bPrepared;}
             void prepareStatement();
             void checkParameterIndex(sal_Int32 _parameterIndex);
+            void setDecimal( sal_Int32 parameterIndex, const ::rtl::OUString& x );
 
             /**
                 creates the driver specific resultset (factory)
diff --git a/connectivity/source/parse/sqlbison.y b/connectivity/source/parse/sqlbison.y
index 55d6c4d1313d..1680516e8dc0 100644
--- a/connectivity/source/parse/sqlbison.y
+++ b/connectivity/source/parse/sqlbison.y
@@ -2040,7 +2040,8 @@ join_spec:
 	  | named_columns_join
 	  ;
 join_type:
-		SQL_TOKEN_INNER
+		/* empty */ 	{$$ = SQL_NEW_RULE;}
+	  | SQL_TOKEN_INNER
 		{
 			$$ = SQL_NEW_RULE;
 			$$->append($1);
diff --git a/connectivity/source/parse/sqliterator.cxx b/connectivity/source/parse/sqliterator.cxx
index 26086495be89..6b839f0116dd 100644
--- a/connectivity/source/parse/sqliterator.cxx
+++ b/connectivity/source/parse/sqliterator.cxx
@@ -1601,7 +1601,6 @@ void OSQLParseTreeIterator::impl_traverse( sal_uInt32 _nIncludeMask )
     case SQL_STATEMENT_INSERT:
         break;
     default:
-        OSL_ENSURE( false, "OSQLParseTreeIterator::traverseAll: not yet implemented for this statement type!" );
         break;
     }
 }
diff --git a/connectivity/source/parse/sqlnode.cxx b/connectivity/source/parse/sqlnode.cxx
index a1fd44014314..8e915d8ead72 100644
--- a/connectivity/source/parse/sqlnode.cxx
+++ b/connectivity/source/parse/sqlnode.cxx
@@ -813,8 +813,9 @@ OSQLParseNode* OSQLParser::convertNode(sal_Int32 nType,OSQLParseNode*& pLiteral)
             case DataType::CHAR:
             case DataType::VARCHAR:
             case DataType::LONGVARCHAR:
-            if ( !SQL_ISRULE(pReturn,char_value_exp) && !buildStringNodes(pReturn) )
-                pReturn = NULL;
+            case DataType::CLOB:
+                if ( !SQL_ISRULE(pReturn,char_value_exp) && !buildStringNodes(pReturn) )
+                    pReturn = NULL;
             default:
                 break;
         }
@@ -829,6 +830,7 @@ OSQLParseNode* OSQLParser::convertNode(sal_Int32 nType,OSQLParseNode*& pLiteral)
                 case DataType::CHAR:
                 case DataType::VARCHAR:
                 case DataType::LONGVARCHAR:
+                case DataType::CLOB:
                     break;
                 case DataType::DATE:
                 case DataType::TIME:
@@ -872,12 +874,13 @@ OSQLParseNode* OSQLParser::convertNode(sal_Int32 nType,OSQLParseNode*& pLiteral)
                 case DataType::REAL:
                 case DataType::DOUBLE:
                     // kill thousand seperators if any
-                killThousandSeparator(pReturn);
+                    killThousandSeparator(pReturn);
                     break;
                 case DataType::CHAR:
                 case DataType::VARCHAR:
                 case DataType::LONGVARCHAR:
-                pReturn = buildNode_STR_NUM(pReturn);
+                case DataType::CLOB:
+                    pReturn = buildNode_STR_NUM(pReturn);
                     break;
                 default:
                     m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_INT_COMPARE);
@@ -893,12 +896,13 @@ OSQLParseNode* OSQLParser::convertNode(sal_Int32 nType,OSQLParseNode*& pLiteral)
                 case DataType::REAL:
                 case DataType::DOUBLE:
                         // kill thousand seperators if any
-                killThousandSeparator(pReturn);
+                    killThousandSeparator(pReturn);
                     break;
                 case DataType::CHAR:
                 case DataType::VARCHAR:
                 case DataType::LONGVARCHAR:
-                pReturn = buildNode_STR_NUM(pReturn);
+                case DataType::CLOB:
+                    pReturn = buildNode_STR_NUM(pReturn);
                     break;
                 case DataType::INTEGER:
                 default:
@@ -967,6 +971,7 @@ sal_Int16 OSQLParser::buildLikeRule(OSQLParseNode*& pAppend, OSQLParseNode*& pLi
         case DataType::CHAR:
         case DataType::VARCHAR:
         case DataType::LONGVARCHAR:
+        case DataType::CLOB:
             if(pLiteral->isRule())
             {
                 pAppend->append(pLiteral);
@@ -1228,6 +1233,7 @@ OSQLParseNode* OSQLParser::predicateTree(::rtl::OUString& rErrorMessage, const :
             case DataType::CHAR:
             case DataType::VARCHAR:
             case DataType::LONGVARCHAR:
+            case DataType::CLOB:
                 s_pScanner->SetRule(s_pScanner->GetSTRINGRule());
                 break;
             default:
@@ -2074,18 +2080,18 @@ void OSQLParseNode::absorptions(OSQLParseNode*& pSearchCondition)
         if ( SQL_ISRULE(p2ndSearch,boolean_primary) )
             p2ndSearch = p2ndSearch->getChild(1);
 
-        if ( *p2ndSearch->getChild(0) == *pSearchCondition->getChild(2-nPos) )
+        if ( *p2ndSearch->getChild(0) == *pSearchCondition->getChild(2-nPos) ) // a and ( a or b) -> a or b
         {
             pNewNode = pSearchCondition->removeAt((sal_uInt32)0);
             replaceAndReset(pSearchCondition,pNewNode);
 
         }
-        else if ( *p2ndSearch->getChild(2) == *pSearchCondition->getChild(2-nPos) )
+        else if ( *p2ndSearch->getChild(2) == *pSearchCondition->getChild(2-nPos) ) // a and ( b or a) -> a or b
         {
             pNewNode = pSearchCondition->removeAt((sal_uInt32)2);
             replaceAndReset(pSearchCondition,pNewNode);
         }
-        else if ( p2ndSearch->getByRule(OSQLParseNode::boolean_term) )
+        else if ( p2ndSearch->getByRule(OSQLParseNode::search_condition) )
         {
             // a and ( b or c ) -> ( a and b ) or ( a and c )
             // ( b or c ) and a -> ( a and b ) or ( a and c )
@@ -2096,7 +2102,13 @@ void OSQLParseNode::absorptions(OSQLParseNode*& pSearchCondition)
             OSQLParseNode* p1stAnd = MakeANDNode(pA,pB);
             OSQLParseNode* p2ndAnd = MakeANDNode(new OSQLParseNode(*pA),pC);
             pNewNode = MakeORNode(p1stAnd,p2ndAnd);
-            replaceAndReset(pSearchCondition,pNewNode);
+            OSQLParseNode* pNode = new OSQLParseNode(::rtl::OUString(),SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::boolean_primary));
+            pNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii("("),SQL_NODE_PUNCTUATION));
+            pNode->append(pNewNode);
+            pNode->append(new OSQLParseNode(::rtl::OUString::createFromAscii(")"),SQL_NODE_PUNCTUATION));
+            OSQLParseNode::eraseBraces(p1stAnd);
+            OSQLParseNode::eraseBraces(p2ndAnd);
+            replaceAndReset(pSearchCondition,pNode);
         }
     }
     // a or a and b || a or b and a