connectivity/source/drivers/odbcbase/OConnection.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: OConnection.cxx,v $
  10  * $Revision: 1.45 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_connectivity.hxx"
  33 #include "odbc/OTools.hxx"
  34 #include "odbc/OConnection.hxx"
  35 #include "odbc/ODatabaseMetaData.hxx"
  36 #include "odbc/OFunctions.hxx"
  37 #include "odbc/ODriver.hxx"
  38 #include "odbc/OStatement.hxx"
  39 #include "odbc/OPreparedStatement.hxx"
  40 #include <com/sun/star/sdbc/ColumnValue.hpp>
  41 #include <com/sun/star/sdbc/XRow.hpp>
  42 #include <com/sun/star/lang/DisposedException.hpp>
  43 #include <connectivity/dbcharset.hxx>
  44 #include <connectivity/FValue.hxx>
  45 #include <comphelper/extract.hxx>
  46 #include "diagnose_ex.h"
  47 #include <connectivity/dbexception.hxx>
  48
  49 #include <string.h>
  50
  51 using namespace connectivity::odbc;
  52 using namespace connectivity;
  53 using namespace dbtools;
  54
  55 //------------------------------------------------------------------------------
  56 using namespace com::sun::star::uno;
  57 using namespace com::sun::star::lang;
  58 using namespace com::sun::star::beans;
  59 using namespace com::sun::star::sdbc;
  60 // --------------------------------------------------------------------------------
  61 OConnection::OConnection(const SQLHANDLE _pDriverHandle,ODBCDriver*     _pDriver)
  62                          : OSubComponent<OConnection, OConnection_BASE>((::cppu::OWeakObject*)_pDriver, this)
  63                          ,m_pDriver(_pDriver)
  64                          ,m_pDriverHandleCopy(_pDriverHandle)
  65                          ,m_nStatementCount(0)
  66                          ,m_bClosed(sal_True)
  67                          ,m_bUseCatalog(sal_False)
  68                          ,m_bUseOldDateFormat(sal_False)
  69                          ,m_bParameterSubstitution(sal_False)
  70                          ,m_bIgnoreDriverPrivileges(sal_False)
  71                          ,m_bPreventGetVersionColumns(sal_False)
  72                          ,m_bReadOnly(sal_True)
  73 {
  74     m_pDriver->acquire();
  75 }
  76 //-----------------------------------------------------------------------------
  77 OConnection::~OConnection()
  78 {
  79     if(!isClosed(  ))
  80         close();
  81
  82     if ( SQL_NULL_HANDLE != m_aConnectionHandle )
  83         N3SQLFreeHandle( SQL_HANDLE_DBC, m_aConnectionHandle );
  84     m_aConnectionHandle = SQL_NULL_HANDLE;
  85
  86     m_pDriver->release();
  87     m_pDriver = NULL;
  88 }
  89 //-----------------------------------------------------------------------------
  90 void SAL_CALL OConnection::release() throw()
  91 {
  92     relase_ChildImpl();
  93 }
  94 // -----------------------------------------------------------------------------
  95 oslGenericFunction OConnection::getOdbcFunction(sal_Int32 _nIndex)  const
  96 {
  97     OSL_ENSURE(m_pDriver,"OConnection::getOdbcFunction: m_pDriver is null!");
  98     return m_pDriver->getOdbcFunction(_nIndex);
  99 }
 100 //-----------------------------------------------------------------------------
 101 SQLRETURN OConnection::OpenConnection(const ::rtl::OUString& aConnectStr,sal_Int32 nTimeOut, sal_Bool bSilent)
 102 {
 103     ::osl::MutexGuard aGuard( m_aMutex );
 104
 105     if (m_aConnectionHandle == SQL_NULL_HANDLE)
 106         return -1;
 107
 108     SQLRETURN nSQLRETURN = 0;
 109     SDB_ODBC_CHAR szConnStrOut[4096];
 110     SDB_ODBC_CHAR szConnStrIn[2048];
 111     SQLSMALLINT cbConnStrOut;
 112     memset(szConnStrOut,'\0',4096);
 113     memset(szConnStrIn,'\0',2048);
 114     ::rtl::OString aConStr(::rtl::OUStringToOString(aConnectStr,getTextEncoding()));
 115     memcpy(szConnStrIn, (SDB_ODBC_CHAR*) aConStr.getStr(), ::std::min<sal_Int32>((sal_Int32)2048,aConStr.getLength()));
 116
 117 #ifndef MACOSX
 118     N3SQLSetConnectAttr(m_aConnectionHandle,SQL_ATTR_LOGIN_TIMEOUT,(SQLPOINTER)nTimeOut,SQL_IS_UINTEGER);
 119     // Verbindung aufbauen
 120 #endif
 121
 122 #ifdef LINUX
 123     OSL_UNUSED( bSilent );
 124     nSQLRETURN = N3SQLDriverConnect(m_aConnectionHandle,
 125                       NULL,
 126                       szConnStrIn,
 127                       (SQLSMALLINT) ::std::min((sal_Int32)2048,aConStr.getLength()),
 128                       szConnStrOut,
 129                       (SQLSMALLINT) (sizeof(szConnStrOut)/sizeof(SDB_ODBC_CHAR)) -1,
 130                       &cbConnStrOut,
 131                       SQL_DRIVER_NOPROMPT);
 132     if (nSQLRETURN == SQL_ERROR || nSQLRETURN == SQL_NO_DATA || SQL_SUCCESS_WITH_INFO == nSQLRETURN)
 133         return nSQLRETURN;
 134 #else
 135
 136     SQLUSMALLINT nSilent =  bSilent ? SQL_DRIVER_NOPROMPT : SQL_DRIVER_COMPLETE;
 137     nSQLRETURN = N3SQLDriverConnect(m_aConnectionHandle,
 138                       NULL,
 139                       szConnStrIn,
 140                       (SQLSMALLINT) ::std::min<sal_Int32>((sal_Int32)2048,aConStr.getLength()),
 141                       szConnStrOut,
 142                       (SQLSMALLINT) sizeof szConnStrOut,
 143                       &cbConnStrOut,
 144                       nSilent);
 145     if (nSQLRETURN == SQL_ERROR || nSQLRETURN == SQL_NO_DATA)
 146         return nSQLRETURN;
 147
 148     m_bClosed = sal_False;
 149
 150 #endif //LINUX
 151
 152     try
 153     {
 154         ::rtl::OUString aVal;
 155         OTools::GetInfo(this,m_aConnectionHandle,SQL_DATA_SOURCE_READ_ONLY,aVal,*this,getTextEncoding());
 156         m_bReadOnly = !aVal.compareToAscii("Y");
 157     }
 158     catch(Exception&)
 159     {
 160         m_bReadOnly = sal_True;
 161     }
 162     try
 163     {
 164         ::rtl::OUString sVersion;
 165         OTools::GetInfo(this,m_aConnectionHandle,SQL_DRIVER_ODBC_VER,sVersion,*this,getTextEncoding());
 166         m_bUseOldDateFormat     =  sVersion == ::rtl::OUString::createFromAscii("02.50") || sVersion == ::rtl::OUString::createFromAscii("02.00");
 167     }
 168     catch(Exception&)
 169     {
 170     }
 171
 172
 173     // autocoomit ist immer default
 174
 175     if (!m_bReadOnly)
 176         N3SQLSetConnectAttr(m_aConnectionHandle,SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)SQL_AUTOCOMMIT_ON,SQL_IS_INTEGER);
 177
 178     return nSQLRETURN;
 179 }
 180 //-----------------------------------------------------------------------------
 181 SQLRETURN OConnection::Construct(const ::rtl::OUString& url,const Sequence< PropertyValue >& info)  throw(SQLException)
 182 {
 183     m_aConnectionHandle  = SQL_NULL_HANDLE;
 184     m_sURL      = url;
 185     setConnectionInfo(info);
 186
 187     // Connection allozieren
 188     N3SQLAllocHandle(SQL_HANDLE_DBC,m_pDriverHandleCopy,&m_aConnectionHandle);
 189     if(m_aConnectionHandle == SQL_NULL_HANDLE)
 190         throw SQLException();
 191
 192     sal_Int32 nLen = url.indexOf(':');
 193     nLen = url.indexOf(':',nLen+1);
 194     ::rtl::OUString aDSN(RTL_CONSTASCII_USTRINGPARAM("DSN=")), aUID, aPWD, aSysDrvSettings;
 195     aDSN += url.copy(nLen+1);
 196
 197     const char* pUser           = "user";
 198     const char* pTimeout        = "Timeout";
 199     const char* pSilent         = "Silent";
 200     const char* pPwd            = "password";
 201     const char* pUseCatalog = "UseCatalog";
 202     const char* pSysDrv         = "SystemDriverSettings";
 203     const char* pCharSet        = "CharSet";
 204     const char* pParaName       = "ParameterNameSubstitution";
 205     const char* pPrivName       = "IgnoreDriverPrivileges";
 206     const char* pVerColName = "PreventGetVersionColumns";   // #i60273#
 207     const char* pRetrieving     = "IsAutoRetrievingEnabled";
 208     const char* pRetriStmt      = "AutoRetrievingStatement";
 209
 210     sal_Int32 nTimeout = 20;
 211     sal_Bool bSilent = sal_True;
 212     const PropertyValue *pBegin = info.getConstArray();
 213     const PropertyValue *pEnd   = pBegin + info.getLength();
 214     for(;pBegin != pEnd;++pBegin)
 215     {
 216         if(!pBegin->Name.compareToAscii(pTimeout))
 217             OSL_VERIFY( pBegin->Value >>= nTimeout );
 218         else if(!pBegin->Name.compareToAscii(pSilent))
 219             OSL_VERIFY( pBegin->Value >>= bSilent );
 220         else if(!pBegin->Name.compareToAscii(pPrivName))
 221             OSL_VERIFY( pBegin->Value >>= m_bIgnoreDriverPrivileges );
 222         else if(!pBegin->Name.compareToAscii(pVerColName))
 223             OSL_VERIFY( pBegin->Value >>= m_bPreventGetVersionColumns );
 224         else if(!pBegin->Name.compareToAscii(pParaName))
 225             OSL_VERIFY( pBegin->Value >>= m_bParameterSubstitution );
 226         else if(!pBegin->Name.compareToAscii(pRetrieving))
 227         {
 228             sal_Bool bAutoRetrievingEnabled = sal_False;
 229             OSL_VERIFY( pBegin->Value >>= bAutoRetrievingEnabled );
 230             enableAutoRetrievingEnabled(bAutoRetrievingEnabled);
 231         }
 232         else if(!pBegin->Name.compareToAscii(pRetriStmt))
 233         {
 234             ::rtl::OUString sGeneratedValueStatement;
 235             OSL_VERIFY( pBegin->Value >>= sGeneratedValueStatement );
 236             setAutoRetrievingStatement(sGeneratedValueStatement);
 237         }
 238         else if(!pBegin->Name.compareToAscii(pUser))
 239         {
 240             OSL_VERIFY( pBegin->Value >>= aUID );
 241             aDSN = aDSN + ::rtl::OUString::createFromAscii(";UID=") + aUID;
 242         }
 243         else if(!pBegin->Name.compareToAscii(pPwd))
 244         {
 245             OSL_VERIFY( pBegin->Value >>= aPWD );
 246             aDSN = aDSN + ::rtl::OUString::createFromAscii(";PWD=") + aPWD;
 247         }
 248         else if(!pBegin->Name.compareToAscii(pUseCatalog))
 249         {
 250              OSL_VERIFY( pBegin->Value >>= m_bUseCatalog );
 251         }
 252         else if(!pBegin->Name.compareToAscii(pSysDrv))
 253         {
 254             OSL_VERIFY( pBegin->Value >>= aSysDrvSettings );
 255             aDSN += ::rtl::OUString::createFromAscii(";");
 256             aDSN += aSysDrvSettings;
 257         }
 258         else if(0 == pBegin->Name.compareToAscii(pCharSet))
 259         {
 260             ::rtl::OUString sIanaName;
 261             OSL_VERIFY( pBegin->Value >>= sIanaName );
 262
 263             ::dbtools::OCharsetMap aLookupIanaName;
 264             ::dbtools::OCharsetMap::const_iterator aLookup = aLookupIanaName.find(sIanaName, ::dbtools::OCharsetMap::IANA());
 265             if (aLookup != aLookupIanaName.end())
 266                 m_nTextEncoding = (*aLookup).getEncoding();
 267             else
 268                 m_nTextEncoding = RTL_TEXTENCODING_DONTKNOW;
 269             if(m_nTextEncoding == RTL_TEXTENCODING_DONTKNOW)
 270                 m_nTextEncoding = osl_getThreadTextEncoding();
 271         }
 272     }
 273     m_sUser = aUID;
 274
 275     SQLRETURN nSQLRETURN = OpenConnection(aDSN,nTimeout, bSilent);
 276     if (nSQLRETURN == SQL_ERROR || nSQLRETURN == SQL_NO_DATA)
 277     {
 278         OTools::ThrowException(this,nSQLRETURN,m_aConnectionHandle,SQL_HANDLE_DBC,*this,sal_False);
 279     }
 280     return nSQLRETURN;
 281 }
 282 // XServiceInfo
 283 // --------------------------------------------------------------------------------
 284 IMPLEMENT_SERVICE_INFO(OConnection, "com.sun.star.sdbc.drivers.odbc.OConnection", "com.sun.star.sdbc.Connection")
 285
 286 // --------------------------------------------------------------------------------
 287 Reference< XStatement > SAL_CALL OConnection::createStatement(  ) throw(SQLException, RuntimeException)
 288 {
 289     ::osl::MutexGuard aGuard( m_aMutex );
 290     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 291
 292     Reference< XStatement > xReturn = new OStatement(this);
 293     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 294     return xReturn;
 295 }
 296 // --------------------------------------------------------------------------------
 297 Reference< XPreparedStatement > SAL_CALL OConnection::prepareStatement( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
 298 {
 299     ::osl::MutexGuard aGuard( m_aMutex );
 300     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 301
 302     Reference< XPreparedStatement > xReturn = new OPreparedStatement(this,sql);
 303     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 304     return xReturn;
 305 }
 306 // --------------------------------------------------------------------------------
 307 Reference< XPreparedStatement > SAL_CALL OConnection::prepareCall( const ::rtl::OUString& /*sql*/ ) throw(SQLException, RuntimeException)
 308 {
 309     ::dbtools::throwFeatureNotImplementedException( "XConnection::prepareCall", *this );
 310     return NULL;
 311 }
 312 // --------------------------------------------------------------------------------
 313 ::rtl::OUString SAL_CALL OConnection::nativeSQL( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
 314 {
 315     ::osl::MutexGuard aGuard( m_aMutex );
 316
 317     ::rtl::OString aSql(::rtl::OUStringToOString(sql.getStr(),getTextEncoding()));
 318     char pOut[2048];
 319     SQLINTEGER nOutLen;
 320     OTools::ThrowException(this,N3SQLNativeSql(m_aConnectionHandle,(SDB_ODBC_CHAR*)aSql.getStr(),aSql.getLength(),(SDB_ODBC_CHAR*)pOut,sizeof pOut - 1,&nOutLen),m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 321     return ::rtl::OUString(pOut,nOutLen,getTextEncoding());
 322 }
 323 // --------------------------------------------------------------------------------
 324 void SAL_CALL OConnection::setAutoCommit( sal_Bool autoCommit ) throw(SQLException, RuntimeException)
 325 {
 326     ::osl::MutexGuard aGuard( m_aMutex );
 327     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 328
 329
 330     OTools::ThrowException(this,N3SQLSetConnectAttr(m_aConnectionHandle,
 331                                    SQL_ATTR_AUTOCOMMIT,
 332                                    (SQLPOINTER)((autoCommit) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF) ,SQL_IS_INTEGER),
 333                                    m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 334 }
 335 // --------------------------------------------------------------------------------
 336 sal_Bool SAL_CALL OConnection::getAutoCommit(  ) throw(SQLException, RuntimeException)
 337 {
 338     ::osl::MutexGuard aGuard( m_aMutex );
 339     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 340
 341
 342     sal_uInt32 nOption = 0;
 343     OTools::ThrowException(this,N3SQLGetConnectAttr(m_aConnectionHandle,
 344                                    SQL_ATTR_AUTOCOMMIT, &nOption,0,0),m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 345     return nOption == SQL_AUTOCOMMIT_ON ;
 346 }
 347 // --------------------------------------------------------------------------------
 348 void SAL_CALL OConnection::commit(  ) throw(SQLException, RuntimeException)
 349 {
 350     ::osl::MutexGuard aGuard( m_aMutex );
 351     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 352
 353
 354     OTools::ThrowException(this,N3SQLEndTran(SQL_HANDLE_DBC,m_aConnectionHandle,SQL_COMMIT),m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 355 }
 356 // --------------------------------------------------------------------------------
 357 void SAL_CALL OConnection::rollback(  ) throw(SQLException, RuntimeException)
 358 {
 359     ::osl::MutexGuard aGuard( m_aMutex );
 360     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 361
 362
 363     OTools::ThrowException(this,N3SQLEndTran(SQL_HANDLE_DBC,m_aConnectionHandle,SQL_ROLLBACK),m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 364 }
 365 // --------------------------------------------------------------------------------
 366 sal_Bool SAL_CALL OConnection::isClosed(  ) throw(SQLException, RuntimeException)
 367 {
 368     ::osl::MutexGuard aGuard( m_aMutex );
 369
 370     return OConnection_BASE::rBHelper.bDisposed;
 371 }
 372 // --------------------------------------------------------------------------------
 373 Reference< XDatabaseMetaData > SAL_CALL OConnection::getMetaData(  ) throw(SQLException, RuntimeException)
 374 {
 375     ::osl::MutexGuard aGuard( m_aMutex );
 376     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 377
 378     Reference< XDatabaseMetaData > xMetaData = m_xMetaData;
 379     if(!xMetaData.is())
 380     {
 381         xMetaData = new ODatabaseMetaData(m_aConnectionHandle,this);
 382         m_xMetaData = xMetaData;
 383     }
 384
 385     return xMetaData;
 386 }
 387 // --------------------------------------------------------------------------------
 388 void SAL_CALL OConnection::setReadOnly( sal_Bool readOnly ) throw(SQLException, RuntimeException)
 389 {
 390     ::osl::MutexGuard aGuard( m_aMutex );
 391     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 392
 393
 394     OTools::ThrowException(this,
 395         N3SQLSetConnectAttr(m_aConnectionHandle,SQL_ATTR_ACCESS_MODE,reinterpret_cast< SQLPOINTER >( readOnly ),SQL_IS_INTEGER),
 396         m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 397 }
 398 // --------------------------------------------------------------------------------
 399 sal_Bool SAL_CALL OConnection::isReadOnly() throw(SQLException, RuntimeException)
 400 {
 401     // const member which will initialized only once
 402     return m_bReadOnly;
 403 }
 404 // --------------------------------------------------------------------------------
 405 void SAL_CALL OConnection::setCatalog( const ::rtl::OUString& catalog ) throw(SQLException, RuntimeException)
 406 {
 407     ::osl::MutexGuard aGuard( m_aMutex );
 408     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 409
 410
 411     ::rtl::OString aCat(::rtl::OUStringToOString(catalog.getStr(),getTextEncoding()));
 412     OTools::ThrowException(this,
 413         N3SQLSetConnectAttr(m_aConnectionHandle,SQL_ATTR_CURRENT_CATALOG,(SDB_ODBC_CHAR*)aCat.getStr(),SQL_NTS),
 414         m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 415 }
 416 // --------------------------------------------------------------------------------
 417 ::rtl::OUString SAL_CALL OConnection::getCatalog(  ) throw(SQLException, RuntimeException)
 418 {
 419     ::osl::MutexGuard aGuard( m_aMutex );
 420     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 421
 422
 423     sal_Int32 nValueLen;
 424     char pCat[1024];
 425     OTools::ThrowException(this,
 426         N3SQLGetConnectAttr(m_aConnectionHandle,SQL_ATTR_CURRENT_CATALOG,(SDB_ODBC_CHAR*)pCat,(sizeof pCat)-1,&nValueLen),
 427         m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 428
 429     return ::rtl::OUString(pCat,nValueLen,getTextEncoding());
 430 }
 431 // --------------------------------------------------------------------------------
 432 void SAL_CALL OConnection::setTransactionIsolation( sal_Int32 level ) throw(SQLException, RuntimeException)
 433 {
 434     ::osl::MutexGuard aGuard( m_aMutex );
 435     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 436
 437
 438     OTools::ThrowException(this,N3SQLSetConnectAttr(m_aConnectionHandle,
 439                                    SQL_ATTR_TXN_ISOLATION,
 440                                    (SQLPOINTER)level,SQL_IS_INTEGER),
 441                                    m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 442 }
 443 // --------------------------------------------------------------------------------
 444 sal_Int32 SAL_CALL OConnection::getTransactionIsolation(  ) throw(SQLException, RuntimeException)
 445 {
 446     ::osl::MutexGuard aGuard( m_aMutex );
 447     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 448
 449
 450     sal_Int32 nTxn = 0;
 451     SQLINTEGER nValueLen;
 452     OTools::ThrowException(this,
 453         N3SQLGetConnectAttr(m_aConnectionHandle,SQL_ATTR_TXN_ISOLATION,&nTxn,sizeof nTxn,&nValueLen),
 454         m_aConnectionHandle,SQL_HANDLE_DBC,*this);
 455     return nTxn;
 456 }
 457 // --------------------------------------------------------------------------------
 458 Reference< ::com::sun::star::container::XNameAccess > SAL_CALL OConnection::getTypeMap(  ) throw(SQLException, RuntimeException)
 459 {
 460     ::osl::MutexGuard aGuard( m_aMutex );
 461     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 462
 463
 464     return NULL;
 465 }
 466 // --------------------------------------------------------------------------------
 467 void SAL_CALL OConnection::setTypeMap( const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
 468 {
 469     ::dbtools::throwFeatureNotImplementedException( "XConnection::setTypeMap", *this );
 470 }
 471 // --------------------------------------------------------------------------------
 472 // XCloseable
 473 void SAL_CALL OConnection::close(  ) throw(SQLException, RuntimeException)
 474 {
 475     {
 476         ::osl::MutexGuard aGuard( m_aMutex );
 477         checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 478
 479     }
 480     dispose();
 481 }
 482 // --------------------------------------------------------------------------------
 483 // XWarningsSupplier
 484 Any SAL_CALL OConnection::getWarnings(  ) throw(SQLException, RuntimeException)
 485 {
 486     return Any();
 487 }
 488 // --------------------------------------------------------------------------------
 489 void SAL_CALL OConnection::clearWarnings(  ) throw(SQLException, RuntimeException)
 490 {
 491 }
 492 //--------------------------------------------------------------------
 493 void OConnection::buildTypeInfo() throw( SQLException)
 494 {
 495     ::osl::MutexGuard aGuard( m_aMutex );
 496
 497     Reference< XResultSet> xRs = getMetaData ()->getTypeInfo ();
 498     if(xRs.is())
 499     {
 500         Reference< XRow> xRow(xRs,UNO_QUERY);
 501         // Information for a single SQL type
 502
 503         ::connectivity::ORowSetValue aValue;
 504         ::std::vector<sal_Int32> aTypes;
 505         Reference<XResultSetMetaData> xResultSetMetaData = Reference<XResultSetMetaDataSupplier>(xRs,UNO_QUERY)->getMetaData();
 506         sal_Int32 nCount = xResultSetMetaData->getColumnCount();
 507         // Loop on the result set until we reach end of file
 508         while (xRs->next ())
 509         {
 510             OTypeInfo aInfo;
 511             sal_Int32 nPos = 1;
 512             if ( aTypes.empty() )
 513             {
 514                 if ( nCount < 1 )
 515                     nCount = 18;
 516                 aTypes.reserve(nCount+1);
 517                 aTypes.push_back(-1);
 518                 for (sal_Int32 j = 1; j <= nCount ; ++j)
 519                     aTypes.push_back(xResultSetMetaData->getColumnType(j));
 520             }
 521
 522             aValue.fill(nPos,aTypes[nPos],xRow);
 523             aInfo.aTypeName             = aValue;
 524             ++nPos;
 525             aValue.fill(nPos,aTypes[nPos],xRow);
 526             aInfo.nType                 = aValue;
 527             ++nPos;
 528             aValue.fill(nPos,aTypes[nPos],xRow);
 529             aInfo.nPrecision            = aValue;
 530             ++nPos;
 531             aValue.fill(nPos,aTypes[nPos],xRow);
 532             aInfo.aLiteralPrefix        = aValue;
 533             ++nPos;
 534             aValue.fill(nPos,aTypes[nPos],xRow);
 535             aInfo.aLiteralSuffix        = aValue;
 536             ++nPos;
 537             aValue.fill(nPos,aTypes[nPos],xRow);
 538             aInfo.aCreateParams = aValue;
 539             ++nPos;
 540             aValue.fill(nPos,aTypes[nPos],xRow);
 541             aInfo.bNullable             = (sal_Int32)aValue == ColumnValue::NULLABLE;
 542             ++nPos;
 543             aValue.fill(nPos,aTypes[nPos],xRow);
 544             aInfo.bCaseSensitive        = (sal_Bool)aValue;
 545             ++nPos;
 546             aValue.fill(nPos,aTypes[nPos],xRow);
 547             aInfo.nSearchType           = aValue;
 548             ++nPos;
 549             aValue.fill(nPos,aTypes[nPos],xRow);
 550             aInfo.bUnsigned             = (sal_Bool)aValue;
 551             ++nPos;
 552             aValue.fill(nPos,aTypes[nPos],xRow);
 553             aInfo.bCurrency             = (sal_Bool)aValue;
 554             ++nPos;
 555             aValue.fill(nPos,aTypes[nPos],xRow);
 556             aInfo.bAutoIncrement        = (sal_Bool)aValue;
 557             ++nPos;
 558             aValue.fill(nPos,aTypes[nPos],xRow);
 559             aInfo.aLocalTypeName        = aValue;
 560             ++nPos;
 561             aValue.fill(nPos,aTypes[nPos],xRow);
 562             aInfo.nMinimumScale = aValue;
 563             ++nPos;
 564             aValue.fill(nPos,aTypes[nPos],xRow);
 565             aInfo.nMaximumScale = aValue;
 566             if ( nCount >= 18 )
 567             {
 568                 nPos = 18;
 569                 aValue.fill(nPos,aTypes[nPos],xRow);
 570                 aInfo.nNumPrecRadix     = aValue;
 571             }
 572
 573             // check if values are less than zero like it happens in a oracle jdbc driver
 574             if( aInfo.nPrecision < 0)
 575                 aInfo.nPrecision = 0;
 576             if( aInfo.nMinimumScale < 0)
 577                 aInfo.nMinimumScale = 0;
 578             if( aInfo.nMaximumScale < 0)
 579                 aInfo.nMaximumScale = 0;
 580             if( aInfo.nNumPrecRadix < 0)
 581                 aInfo.nNumPrecRadix = 10;
 582
 583             // Now that we have the type info, save it
 584             // in the Hashtable if we don't already have an
 585             // entry for this SQL type.
 586
 587             m_aTypeInfo.push_back(aInfo);
 588         }
 589
 590         // Close the result set/statement.
 591
 592         Reference< XCloseable> xClose(xRs,UNO_QUERY);
 593         if(xClose.is())
 594             xClose->close();
 595     }
 596 }
 597 //------------------------------------------------------------------------------
 598 void OConnection::disposing()
 599 {
 600     ::osl::MutexGuard aGuard(m_aMutex);
 601
 602     OConnection_BASE::disposing();
 603
 604     for (::std::map< SQLHANDLE,OConnection*>::iterator aConIter = m_aConnections.begin();aConIter != m_aConnections.end();++aConIter )
 605         aConIter->second->dispose();
 606
 607     ::std::map< SQLHANDLE,OConnection*>().swap(m_aConnections);
 608
 609     if(!m_bClosed)
 610         N3SQLDisconnect(m_aConnectionHandle);
 611     m_bClosed   = sal_True;
 612
 613     dispose_ChildImpl();
 614 }
 615 // -----------------------------------------------------------------------------
 616 OConnection* OConnection::cloneConnection()
 617 {
 618     return new OConnection(m_pDriverHandleCopy,m_pDriver);
 619 }
 620 // -----------------------------------------------------------------------------
 621 SQLHANDLE OConnection::createStatementHandle()
 622 {
 623     OConnection* pConnectionTemp = this;
 624     sal_Bool bNew = sal_False;
 625     try
 626     {
 627         sal_Int32 nMaxStatements = getMetaData()->getMaxStatements();
 628         if(nMaxStatements && nMaxStatements <= m_nStatementCount)
 629         {
 630             OConnection* pConnection = cloneConnection();
 631             pConnection->acquire();
 632             pConnection->Construct(m_sURL,getConnectionInfo());
 633             pConnectionTemp = pConnection;
 634             bNew = sal_True;
 635         }
 636     }
 637     catch(SQLException&)
 638     {
 639     }
 640
 641     SQLHANDLE aStatementHandle = SQL_NULL_HANDLE;
 642     SQLRETURN nRetcode = N3SQLAllocHandle(SQL_HANDLE_STMT,pConnectionTemp->getConnection(),&aStatementHandle);
 643     OSL_UNUSED( nRetcode );
 644     ++m_nStatementCount;
 645     if(bNew)
 646         m_aConnections.insert(::std::map< SQLHANDLE,OConnection*>::value_type(aStatementHandle,pConnectionTemp));
 647
 648     return aStatementHandle;
 649
 650 }
 651 // -----------------------------------------------------------------------------
 652 void OConnection::freeStatementHandle(SQLHANDLE& _pHandle)
 653 {
 654     ::std::map< SQLHANDLE,OConnection*>::iterator aFind = m_aConnections.find(_pHandle);
 655
 656     N3SQLFreeStmt(_pHandle,SQL_RESET_PARAMS);
 657     N3SQLFreeStmt(_pHandle,SQL_UNBIND);
 658     N3SQLFreeStmt(_pHandle,SQL_CLOSE);
 659     N3SQLFreeHandle(SQL_HANDLE_STMT,_pHandle);
 660
 661     _pHandle = SQL_NULL_HANDLE;
 662
 663     if(aFind != m_aConnections.end())
 664     {
 665         aFind->second->dispose();
 666         m_aConnections.erase(aFind);
 667     }
 668     --m_nStatementCount;
 669 }
 670 // -----------------------------------------------------------------------------
 671
 672
 673