connectivity/source/commontools/dbexception.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <connectivity/dbexception.hxx>
  30 #include <comphelper/types.hxx>
  31 #include <cppuhelper/exc_hlp.hxx>
  32 #include <osl/diagnose.h>
  33 #include <com/sun/star/sdb/SQLContext.hpp>
  34 #include <com/sun/star/sdbc/SQLWarning.hpp>
  35 #include <com/sun/star/sdb/SQLErrorEvent.hpp>
  36 #include "TConnection.hxx"
  37 #include "resource/common_res.hrc"
  38 #include "resource/sharedresources.hxx"
  39
  40 //.........................................................................
  41 namespace dbtools
  42 {
  43 //.........................................................................
  44
  45     using namespace ::com::sun::star::uno;
  46     using namespace ::com::sun::star::sdb;
  47     using namespace ::com::sun::star::sdbc;
  48     using namespace ::comphelper;
  49     using namespace ::connectivity;
  50
  51 //==============================================================================
  52 //= SQLExceptionInfo - encapsulating the type info of an SQLException-derived class
  53 //==============================================================================
  54 //------------------------------------------------------------------------------
  55 SQLExceptionInfo::SQLExceptionInfo()
  56     :m_eType(UNDEFINED)
  57 {
  58 }
  59
  60 //------------------------------------------------------------------------------
  61 SQLExceptionInfo::SQLExceptionInfo(const ::com::sun::star::sdbc::SQLException& _rError)
  62 {
  63     m_aContent <<= _rError;
  64     implDetermineType();
  65 }
  66
  67 //------------------------------------------------------------------------------
  68 SQLExceptionInfo::SQLExceptionInfo(const ::com::sun::star::sdbc::SQLWarning& _rError)
  69 {
  70     m_aContent <<= _rError;
  71     implDetermineType();
  72 }
  73
  74 //------------------------------------------------------------------------------
  75 SQLExceptionInfo::SQLExceptionInfo(const ::com::sun::star::sdb::SQLContext& _rError)
  76 {
  77     m_aContent <<= _rError;
  78     implDetermineType();
  79 }
  80
  81 //------------------------------------------------------------------------------
  82 SQLExceptionInfo::SQLExceptionInfo( const ::rtl::OUString& _rSimpleErrorMessage )
  83 {
  84     SQLException aError;
  85     aError.Message = _rSimpleErrorMessage;
  86     m_aContent <<= aError;
  87     implDetermineType();
  88 }
  89
  90 //------------------------------------------------------------------------------
  91 SQLExceptionInfo::SQLExceptionInfo(const SQLExceptionInfo& _rCopySource)
  92     :m_aContent(_rCopySource.m_aContent)
  93     ,m_eType(_rCopySource.m_eType)
  94 {
  95 }
  96
  97 //------------------------------------------------------------------------------
  98 const SQLExceptionInfo& SQLExceptionInfo::operator=(const ::com::sun::star::sdbc::SQLException& _rError)
  99 {
 100     m_aContent <<= _rError;
 101     implDetermineType();
 102     return *this;
 103 }
 104
 105 //------------------------------------------------------------------------------
 106 const SQLExceptionInfo& SQLExceptionInfo::operator=(const ::com::sun::star::sdbc::SQLWarning& _rError)
 107 {
 108     m_aContent <<= _rError;
 109     implDetermineType();
 110     return *this;
 111 }
 112
 113 //------------------------------------------------------------------------------
 114 const SQLExceptionInfo& SQLExceptionInfo::operator=(const ::com::sun::star::sdb::SQLContext& _rError)
 115 {
 116     m_aContent <<= _rError;
 117     implDetermineType();
 118     return *this;
 119 }
 120
 121 //------------------------------------------------------------------------------
 122 const SQLExceptionInfo& SQLExceptionInfo::operator=(const ::com::sun::star::sdb::SQLErrorEvent& _rErrorEvent)
 123 {
 124     m_aContent = _rErrorEvent.Reason;
 125     implDetermineType();
 126     return *this;
 127 }
 128
 129 //------------------------------------------------------------------------------
 130 const SQLExceptionInfo& SQLExceptionInfo::operator=(const ::com::sun::star::uno::Any& _rCaughtSQLException)
 131 {
 132     m_aContent = _rCaughtSQLException;
 133     implDetermineType();
 134     return *this;
 135 }
 136
 137 //------------------------------------------------------------------------------
 138 SQLExceptionInfo::SQLExceptionInfo(const ::com::sun::star::sdb::SQLErrorEvent& _rError)
 139 {
 140     m_aContent = _rError.Reason;
 141     implDetermineType();
 142 }
 143
 144 //------------------------------------------------------------------------------
 145 SQLExceptionInfo::SQLExceptionInfo(const staruno::Any& _rError)
 146 {
 147     const staruno::Type& aSQLExceptionType = ::getCppuType(reinterpret_cast< ::com::sun::star::sdbc::SQLException*>(NULL));
 148     sal_Bool bValid = isAssignableFrom(aSQLExceptionType, _rError.getValueType());
 149     if (bValid)
 150         m_aContent = _rError;
 151     // no assertion here : if used with the NextException member of an SQLException bValid==sal_False is allowed.
 152
 153     implDetermineType();
 154 }
 155
 156 //------------------------------------------------------------------------------
 157 void SQLExceptionInfo::implDetermineType()
 158 {
 159     staruno::Type aContentType = m_aContent.getValueType();
 160
 161     const Type& aSQLExceptionType = ::getCppuType( reinterpret_cast< SQLException* >( NULL ) );
 162     const Type& aSQLWarningType = ::getCppuType( reinterpret_cast< SQLWarning* >( NULL ) );
 163     const Type& aSQLContextType  = ::getCppuType( reinterpret_cast< SQLContext* >( NULL ) );
 164
 165     if ( isAssignableFrom( aSQLContextType, m_aContent.getValueType() ) )
 166         m_eType = SQL_CONTEXT;
 167     else if ( isAssignableFrom( aSQLWarningType, m_aContent.getValueType() ) )
 168         m_eType = SQL_WARNING;
 169     else if ( isAssignableFrom( aSQLExceptionType, m_aContent.getValueType() ) )
 170         m_eType = SQL_EXCEPTION;
 171     else
 172     {
 173         m_eType = UNDEFINED;
 174         m_aContent.clear();
 175     }
 176 }
 177
 178 //------------------------------------------------------------------------------
 179 sal_Bool SQLExceptionInfo::isKindOf(TYPE _eType) const
 180 {
 181     switch (_eType)
 182     {
 183         case SQL_CONTEXT:
 184             return (m_eType == SQL_CONTEXT);
 185         case SQL_WARNING:
 186             return (m_eType == SQL_CONTEXT) || (m_eType == SQL_WARNING);
 187         case SQL_EXCEPTION:
 188             return (m_eType == SQL_CONTEXT) || (m_eType == SQL_WARNING) || (m_eType == SQL_EXCEPTION);
 189         case UNDEFINED:
 190             return (m_eType == UNDEFINED);
 191     }
 192     return sal_False;
 193 }
 194
 195 //------------------------------------------------------------------------------
 196 SQLExceptionInfo::operator const ::com::sun::star::sdbc::SQLException*() const
 197 {
 198     OSL_ENSURE(isKindOf(SQL_EXCEPTION), "SQLExceptionInfo::operator SQLException* : invalid call !");
 199     return reinterpret_cast<const ::com::sun::star::sdbc::SQLException*>(m_aContent.getValue());
 200 }
 201
 202 //------------------------------------------------------------------------------
 203 SQLExceptionInfo::operator const ::com::sun::star::sdbc::SQLWarning*() const
 204 {
 205     OSL_ENSURE(isKindOf(SQL_WARNING), "SQLExceptionInfo::operator SQLException* : invalid call !");
 206     return reinterpret_cast<const ::com::sun::star::sdbc::SQLWarning*>(m_aContent.getValue());
 207 }
 208
 209 //------------------------------------------------------------------------------
 210 SQLExceptionInfo::operator const ::com::sun::star::sdb::SQLContext*() const
 211 {
 212     OSL_ENSURE(isKindOf(SQL_CONTEXT), "SQLExceptionInfo::operator SQLException* : invalid call !");
 213     return reinterpret_cast<const ::com::sun::star::sdb::SQLContext*>(m_aContent.getValue());
 214 }
 215
 216 //------------------------------------------------------------------------------
 217 void SQLExceptionInfo::prepend( const ::rtl::OUString& _rErrorMessage, const sal_Char* _pAsciiSQLState, const sal_Int32 _nErrorCode )
 218 {
 219     SQLException aException;
 220     aException.Message = _rErrorMessage;
 221     aException.ErrorCode = _nErrorCode;
 222     aException.SQLState = _pAsciiSQLState ? ::rtl::OUString::createFromAscii( _pAsciiSQLState ) : ::rtl::OUString("S1000" );
 223     aException.NextException = m_aContent;
 224     m_aContent <<= aException;
 225
 226     m_eType = SQL_EXCEPTION;
 227 }
 228
 229 //------------------------------------------------------------------------------
 230 void SQLExceptionInfo::append( TYPE _eType, const ::rtl::OUString& _rErrorMessage, const sal_Char* _pAsciiSQLState, const sal_Int32 _nErrorCode )
 231 {
 232     // create the to-be-appended exception
 233     Any aAppend;
 234     switch ( _eType )
 235     {
 236     case SQL_EXCEPTION: aAppend <<= SQLException(); break;
 237     case SQL_WARNING:   aAppend <<= SQLWarning();   break;
 238     case SQL_CONTEXT:   aAppend <<= SQLContext();   break;
 239     default:
 240         OSL_FAIL( "SQLExceptionInfo::append: invalid exception type: this will crash!" );
 241         break;
 242     }
 243
 244     SQLException* pAppendException( static_cast< SQLException* >( const_cast< void* >( aAppend.getValue() ) ) );
 245     pAppendException->Message = _rErrorMessage;
 246     pAppendException->SQLState = ::rtl::OUString::createFromAscii( _pAsciiSQLState );
 247     pAppendException->ErrorCode = _nErrorCode;
 248
 249     // find the end of the current chain
 250     Any* pChainIterator = &m_aContent;
 251     SQLException* pLastException = NULL;
 252     const Type& aSQLExceptionType( ::getCppuType< SQLException >() );
 253     while ( pChainIterator )
 254     {
 255         if ( !pChainIterator->hasValue() )
 256             break;
 257
 258         if ( !isAssignableFrom( aSQLExceptionType, pChainIterator->getValueType() ) )
 259             break;
 260
 261         pLastException = static_cast< SQLException* >( const_cast< void* >( pChainIterator->getValue() ) );
 262         pChainIterator = &pLastException->NextException;
 263     }
 264
 265     // append
 266     if ( pLastException )
 267         pLastException->NextException = aAppend;
 268     else
 269     {
 270         m_aContent = aAppend;
 271         m_eType = _eType;
 272     }
 273 }
 274
 275 //------------------------------------------------------------------------------
 276 void SQLExceptionInfo::doThrow()
 277 {
 278     if ( m_aContent.getValueTypeClass() == TypeClass_EXCEPTION )
 279         ::cppu::throwException( m_aContent );
 280     throw RuntimeException();
 281 }
 282
 283 //==============================================================================
 284 //= SQLExceptionIteratorHelper
 285 //==============================================================================
 286
 287 //------------------------------------------------------------------------------
 288 SQLExceptionIteratorHelper::SQLExceptionIteratorHelper( const SQLExceptionInfo& _rChainStart )
 289     :m_pCurrent( NULL )
 290     ,m_eCurrentType( SQLExceptionInfo::UNDEFINED )
 291 {
 292     if ( _rChainStart.isValid() )
 293     {
 294         m_pCurrent = (const SQLException*)_rChainStart;
 295         m_eCurrentType = _rChainStart.getType();
 296     }
 297 }
 298
 299 //------------------------------------------------------------------------------
 300 SQLExceptionIteratorHelper::SQLExceptionIteratorHelper( const ::com::sun::star::sdbc::SQLException& _rChainStart )
 301     :m_pCurrent( &_rChainStart )
 302     ,m_eCurrentType( SQLExceptionInfo::SQL_EXCEPTION )
 303 {
 304 }
 305
 306 //------------------------------------------------------------------------------
 307 SQLExceptionIteratorHelper::SQLExceptionIteratorHelper( const ::com::sun::star::sdbc::SQLWarning& _rChainStart )
 308     :m_pCurrent( &_rChainStart )
 309     ,m_eCurrentType( SQLExceptionInfo::SQL_WARNING )
 310 {
 311 }
 312
 313 //------------------------------------------------------------------------------
 314 SQLExceptionIteratorHelper::SQLExceptionIteratorHelper( const ::com::sun::star::sdb::SQLContext& _rChainStart )
 315     :m_pCurrent( &_rChainStart )
 316     ,m_eCurrentType( SQLExceptionInfo::SQL_CONTEXT )
 317 {
 318 }
 319
 320 //------------------------------------------------------------------------------
 321 void SQLExceptionIteratorHelper::current( SQLExceptionInfo& _out_rInfo ) const
 322 {
 323     switch ( m_eCurrentType )
 324     {
 325     case SQLExceptionInfo::SQL_EXCEPTION:
 326         _out_rInfo = *m_pCurrent;
 327         break;
 328
 329     case SQLExceptionInfo::SQL_WARNING:
 330         _out_rInfo = *static_cast< const SQLWarning* >( m_pCurrent );
 331         break;
 332
 333     case SQLExceptionInfo::SQL_CONTEXT:
 334         _out_rInfo = *static_cast< const SQLContext* >( m_pCurrent );
 335         break;
 336
 337     default:
 338         _out_rInfo = Any();
 339         break;
 340     }
 341 }
 342
 343 //------------------------------------------------------------------------------
 344 const ::com::sun::star::sdbc::SQLException* SQLExceptionIteratorHelper::next()
 345 {
 346     OSL_ENSURE( hasMoreElements(), "SQLExceptionIteratorHelper::next : invalid call (please use hasMoreElements)!" );
 347
 348     const ::com::sun::star::sdbc::SQLException* pReturn = current();
 349     if ( !m_pCurrent )
 350         return pReturn;
 351
 352     // check for the next element within the chain
 353     const Type aTypeException( ::cppu::UnoType< SQLException >::get() );
 354
 355     Type aNextElementType = m_pCurrent->NextException.getValueType();
 356     if ( !isAssignableFrom( aTypeException, aNextElementType ) )
 357     {
 358         // no SQLException at all in the next chain element
 359         m_pCurrent = NULL;
 360         m_eCurrentType = SQLExceptionInfo::UNDEFINED;
 361         return pReturn;
 362     }
 363
 364     m_pCurrent = static_cast< const SQLException* >( m_pCurrent->NextException.getValue() );
 365
 366     // no finally determine the proper type of the exception
 367     const Type aTypeContext( ::cppu::UnoType< SQLContext >::get() );
 368     if ( isAssignableFrom( aTypeContext, aNextElementType ) )
 369     {
 370         m_eCurrentType = SQLExceptionInfo::SQL_CONTEXT;
 371         return pReturn;
 372     }
 373
 374     const Type aTypeWarning( ::cppu::UnoType< SQLWarning >::get() );
 375     if ( isAssignableFrom( aTypeWarning, aNextElementType ) )
 376     {
 377         m_eCurrentType = SQLExceptionInfo::SQL_WARNING;
 378         return pReturn;
 379     }
 380
 381     // a simple SQLException
 382     m_eCurrentType = SQLExceptionInfo::SQL_EXCEPTION;
 383     return pReturn;
 384 }
 385
 386 //------------------------------------------------------------------------------
 387 void SQLExceptionIteratorHelper::next( SQLExceptionInfo& _out_rInfo )
 388 {
 389     current( _out_rInfo );
 390     next();
 391 }
 392
 393 //------------------------------------------------------------
 394 void throwFunctionSequenceException(const Reference< XInterface >& _Context, const Any& _Next)  throw ( ::com::sun::star::sdbc::SQLException )
 395 {
 396     ::connectivity::SharedResources aResources;
 397     throw SQLException(
 398         aResources.getResourceString(STR_ERRORMSG_SEQUENCE),
 399         _Context,
 400         getStandardSQLState( SQL_FUNCTION_SEQUENCE_ERROR ),
 401         0,
 402         _Next
 403     );
 404 }
 405 // -----------------------------------------------------------------------------
 406 void throwInvalidIndexException(const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _Context,
 407         const ::com::sun::star::uno::Any& _Next)  throw ( ::com::sun::star::sdbc::SQLException )
 408 {
 409     ::connectivity::SharedResources aResources;
 410     throw SQLException(
 411         aResources.getResourceString(STR_INVALID_INDEX),
 412         _Context,
 413         getStandardSQLState( SQL_INVALID_DESCRIPTOR_INDEX ),
 414         0,
 415         _Next
 416     );
 417 }
 418 // -----------------------------------------------------------------------------
 419 void throwFunctionNotSupportedException(const ::rtl::OUString& _rMsg,
 420         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _Context,
 421         const ::com::sun::star::uno::Any& _Next)  throw ( ::com::sun::star::sdbc::SQLException )
 422 {
 423     throw SQLException(
 424         _rMsg,
 425         _Context,
 426         getStandardSQLState( SQL_FUNCTION_NOT_SUPPORTED ),
 427         0,
 428         _Next
 429     );
 430 }
 431 // -----------------------------------------------------------------------------
 432 void throwFunctionNotSupportedException( const sal_Char* _pAsciiFunctionName, const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _rxContext,
 433         const ::com::sun::star::uno::Any* _pNextException ) throw ( ::com::sun::star::sdbc::SQLException )
 434 {
 435     ::connectivity::SharedResources aResources;
 436     const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
 437             STR_UNSUPPORTED_FUNCTION,
 438             "$functionname$", ::rtl::OUString::createFromAscii( _pAsciiFunctionName )
 439          ) );
 440     throwFunctionNotSupportedException(
 441         sError,
 442         _rxContext,
 443         _pNextException ? *_pNextException : Any()
 444     );
 445 }
 446 // -----------------------------------------------------------------------------
 447 void throwGenericSQLException(const ::rtl::OUString& _rMsg, const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _rxSource)
 448     throw (::com::sun::star::sdbc::SQLException)
 449 {
 450     throwGenericSQLException(_rMsg, _rxSource, Any());
 451 }
 452
 453 // -----------------------------------------------------------------------------
 454 void throwGenericSQLException(const ::rtl::OUString& _rMsg, const Reference< XInterface >& _rxSource, const Any& _rNextException)
 455     throw (SQLException)
 456 {
 457     throw SQLException( _rMsg, _rxSource, getStandardSQLState( SQL_GENERAL_ERROR ), 0, _rNextException);
 458 }
 459
 460 // -----------------------------------------------------------------------------
 461 void throwFeatureNotImplementedException( const sal_Char* _pAsciiFeatureName, const Reference< XInterface >& _rxContext, const Any* _pNextException )
 462     throw (SQLException)
 463 {
 464     ::connectivity::SharedResources aResources;
 465     const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
 466             STR_UNSUPPORTED_FEATURE,
 467             "$featurename$", ::rtl::OUString::createFromAscii( _pAsciiFeatureName )
 468          ) );
 469
 470     throw SQLException(
 471         sError,
 472         _rxContext,
 473         getStandardSQLState( SQL_FEATURE_NOT_IMPLEMENTED ),
 474         0,
 475         _pNextException ? *_pNextException : Any()
 476     );
 477 }
 478
 479 // -----------------------------------------------------------------------------
 480 void throwSQLException( const sal_Char* _pAsciiMessage, const sal_Char* _pAsciiState,
 481         const Reference< XInterface >& _rxContext, const sal_Int32 _nErrorCode, const Any* _pNextException ) throw (SQLException)
 482 {
 483     throw SQLException(
 484         ::rtl::OUString::createFromAscii( _pAsciiMessage ),
 485         _rxContext,
 486         ::rtl::OUString::createFromAscii( _pAsciiState ),
 487         _nErrorCode,
 488         _pNextException ? *_pNextException : Any()
 489     );
 490 }
 491
 492 // -----------------------------------------------------------------------------
 493 void throwSQLException( const sal_Char* _pAsciiMessage, StandardSQLState _eSQLState,
 494         const Reference< XInterface >& _rxContext, const sal_Int32 _nErrorCode,
 495         const Any* _pNextException ) throw (SQLException)
 496 {
 497     throwSQLException( _pAsciiMessage, getStandardSQLStateAscii( _eSQLState ), _rxContext, _nErrorCode, _pNextException );
 498 }
 499
 500 // -----------------------------------------------------------------------------
 501 void throwSQLException( const ::rtl::OUString& _rMessage, StandardSQLState _eSQLState,
 502         const Reference< XInterface >& _rxContext, const sal_Int32 _nErrorCode,
 503         const Any* _pNextException ) throw (SQLException)
 504 {
 505     throw SQLException(
 506         _rMessage,
 507         _rxContext,
 508         getStandardSQLState( _eSQLState ),
 509         _nErrorCode,
 510         _pNextException ? *_pNextException : Any()
 511     );
 512 }
 513
 514 // -----------------------------------------------------------------------------
 515 const sal_Char* getStandardSQLStateAscii( StandardSQLState _eState )
 516 {
 517     const sal_Char* pAsciiState = NULL;
 518     switch ( _eState )
 519     {
 520         case SQL_WRONG_PARAMETER_NUMBER:    pAsciiState = "07001"; break;
 521         case SQL_INVALID_DESCRIPTOR_INDEX:  pAsciiState = "07009"; break;
 522         case SQL_UNABLE_TO_CONNECT:         pAsciiState = "08001"; break;
 523         case SQL_NUMERIC_OUT_OF_RANGE:      pAsciiState = "22003"; break;
 524         case SQL_INVALID_DATE_TIME:         pAsciiState = "22007"; break;
 525         case SQL_INVALID_CURSOR_STATE:      pAsciiState = "24000"; break;
 526         case SQL_TABLE_OR_VIEW_EXISTS:      pAsciiState = "42S01"; break;
 527         case SQL_TABLE_OR_VIEW_NOT_FOUND:   pAsciiState = "42S02"; break;
 528         case SQL_INDEX_ESISTS:              pAsciiState = "42S11"; break;
 529         case SQL_INDEX_NOT_FOUND:           pAsciiState = "42S12"; break;
 530         case SQL_COLUMN_EXISTS:             pAsciiState = "42S21"; break;
 531         case SQL_COLUMN_NOT_FOUND:          pAsciiState = "42S22"; break;
 532         case SQL_GENERAL_ERROR:             pAsciiState = "HY000"; break;
 533         case SQL_INVALID_SQL_DATA_TYPE:     pAsciiState = "HY004"; break;
 534         case SQL_OPERATION_CANCELED:        pAsciiState = "HY008"; break;
 535         case SQL_FUNCTION_SEQUENCE_ERROR:   pAsciiState = "HY010"; break;
 536         case SQL_INVALID_CURSOR_POSITION:   pAsciiState = "HY109"; break;
 537         case SQL_INVALID_BOOKMARK_VALUE:    pAsciiState = "HY111"; break;
 538         case SQL_FEATURE_NOT_IMPLEMENTED:   pAsciiState = "HYC00"; break;
 539         case SQL_FUNCTION_NOT_SUPPORTED:    pAsciiState = "IM001"; break;
 540         case SQL_CONNECTION_DOES_NOT_EXIST: pAsciiState = "08003"; break;
 541
 542         default:
 543             break;
 544     }
 545     if ( !pAsciiState )
 546         throw RuntimeException();
 547     return pAsciiState;
 548 }
 549
 550 // -----------------------------------------------------------------------------
 551 ::rtl::OUString getStandardSQLState( StandardSQLState _eState )
 552 {
 553     return ::rtl::OUString::createFromAscii( getStandardSQLStateAscii( _eState ) );
 554 }
 555
 556 // -----------------------------------------------------------------------------
 557 //.........................................................................
 558 }   // namespace dbtools
 559 //.........................................................................
 560
 561
 562 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */