connectivity/source/drivers/mork/MConnection.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include "MConnection.hxx"
  11 #include "MDriver.hxx"
  12 #include "MDatabaseMetaData.hxx"
  13 #include "MCatalog.hxx"
  14 #include "MPreparedStatement.hxx"
  15 #include "MorkParser.hxx"
  16
  17 #include <connectivity/dbexception.hxx>
  18
  19 #include "resource/mork_res.hrc"
  20 #include "resource/common_res.hrc"
  21
  22 #include <com/sun/star/sdbc/TransactionIsolation.hpp>
  23
  24 #include <comphelper/processfactory.hxx>
  25
  26 using namespace dbtools;
  27
  28
  29 using namespace com::sun::star::uno;
  30 using namespace com::sun::star::lang;
  31 using namespace com::sun::star::beans;
  32 using namespace com::sun::star::sdbc;
  33 using namespace com::sun::star::sdbcx;
  34
  35
  36 namespace connectivity { namespace mork {
  37
  38 static const int defaultScope = 0x80;
  39
  40
  41 OConnection::OConnection(MorkDriver* _pDriver)
  42     :OSubComponent<OConnection, OConnection_BASE>(static_cast<cppu::OWeakObject*>(_pDriver), this)
  43     ,m_xDriver(_pDriver)
  44     ,m_aColumnAlias( _pDriver->getFactory() )
  45 {
  46     m_pBook = new MorkParser();
  47     m_pHistory = new MorkParser();
  48 }
  49
  50 OConnection::~OConnection()
  51 {
  52     if(!isClosed())
  53         close();
  54     delete m_pBook;
  55     delete m_pHistory;
  56 }
  57
  58 void SAL_CALL OConnection::release() throw()
  59 {
  60     release_ChildImpl();
  61 }
  62
  63
  64 void OConnection::construct(const OUString& url,const Sequence< PropertyValue >& info)  throw(SQLException)
  65 {
  66     (void) info; // avoid warnings
  67     SAL_INFO("connectivity.mork", "=> OConnection::construct()" );
  68     //  open file
  69     setURL(url);
  70
  71     // Skip 'sdbc:mozab: part of URL
  72
  73     sal_Int32 nLen = url.indexOf(':');
  74     nLen = url.indexOf(':',nLen+1);
  75     OSL_ENSURE( url.copy( 0, nLen ) == "sdbc:address", "OConnection::construct: invalid start of the URI - should never have survived XDriver::acceptsURL!" );
  76
  77     OUString aAddrbookURI(url.copy(nLen+1));
  78     // Get Scheme
  79     nLen = aAddrbookURI.indexOf(':');
  80     OUString aAddrbookScheme;
  81     OUString sAdditionalInfo;
  82     if ( nLen == -1 )
  83     {
  84         // There isn't any subschema: - but could be just subschema
  85         if ( !aAddrbookURI.isEmpty() )
  86         {
  87             aAddrbookScheme= aAddrbookURI;
  88         }
  89         else
  90         {
  91             SAL_WARN("connectivity.mork", "No subschema given!!!");
  92             throwGenericSQLException( STR_URI_SYNTAX_ERROR, *this );
  93         }
  94     }
  95     else
  96     {
  97         aAddrbookScheme = aAddrbookURI.copy(0, nLen);
  98         sAdditionalInfo = aAddrbookURI.copy( nLen + 1 );
  99     }
 100
 101     SAL_INFO("connectivity.mork", "URI = " << aAddrbookURI );
 102     SAL_INFO("connectivity.mork", "Scheme = " << aAddrbookScheme );
 103
 104     OUString abook;
 105     OUString history;
 106     const OUString UNITTEST_URL = "thunderbird:unittest:";
 107     sal_Int32 unittestIndex = url.indexOf(UNITTEST_URL);
 108
 109     // production?
 110     if (unittestIndex == -1)
 111     {
 112         OUString path = m_xDriver->getProfilePath();
 113         SAL_INFO("connectivity.mork", "ProfilePath: " << path);
 114         abook = path + "/abook.mab";
 115         history = path + "/history.mab";
 116         SAL_INFO("connectivity.mork", "AdressbookPath (abook): " << abook);
 117         SAL_INFO("connectivity.mork", "AdressbookPath (history): " << history);
 118     }
 119     else
 120     {
 121         abook = aAddrbookURI.replaceFirst(UNITTEST_URL, "");
 122         SAL_INFO("connectivity.mork", "unit test: " << abook);
 123     }
 124
 125     OString strPath = OUStringToOString(abook, RTL_TEXTENCODING_UTF8);
 126
 127     // Open and parse mork file
 128     if (!m_pBook->open(strPath.getStr()))
 129     {
 130         SAL_WARN("connectivity.mork", "Can not parse abook mork file: " << strPath);
 131         const OUString sError( getResources().getResourceStringWithSubstitution(
 132             STR_COULD_NOT_LOAD_FILE, "$filename$", abook));
 133         ::dbtools::throwGenericSQLException( sError, *this );
 134     }
 135
 136     // read history only in production
 137     if (unittestIndex == -1)
 138     {
 139         strPath = OUStringToOString(history, RTL_TEXTENCODING_UTF8);
 140         if (!m_pHistory->open(strPath.getStr()))
 141         {
 142             SAL_WARN("connectivity.mork", "Can not parse history mork file: " << strPath);
 143             const OUString sError( getResources().getResourceStringWithSubstitution(
 144                 STR_COULD_NOT_LOAD_FILE, "$filename$", history));
 145             ::dbtools::throwGenericSQLException( sError, *this );
 146         }
 147     }
 148
 149     // check that we can retrieve the tables:
 150     MorkTableMap *Tables = m_pBook->getTables( defaultScope );
 151     MorkTableMap::Map::const_iterator tableIter;
 152     if (Tables)
 153     {
 154         // Iterate all tables
 155         for ( tableIter = Tables->map.begin(); tableIter != Tables->map.end(); ++tableIter )
 156         {
 157             if ( 0 == tableIter->first ) continue;
 158             SAL_INFO("connectivity.mork", "table->first : " << tableIter->first);
 159         }
 160     }
 161     // check that we can retrieve the history tables:
 162     MorkTableMap *Tables_hist = m_pHistory->getTables( defaultScope );
 163     if (Tables_hist)
 164     {
 165         // Iterate all tables
 166         for ( tableIter = Tables_hist->map.begin(); tableIter != Tables_hist->map.end(); ++tableIter )
 167         {
 168             if ( 0 == tableIter->first ) continue;
 169             SAL_INFO("connectivity.mork", "table->first : " << tableIter->first);
 170         }
 171     }
 172 }
 173
 174 // XServiceInfo
 175
 176 IMPLEMENT_SERVICE_INFO(OConnection, "com.sun.star.sdbc.drivers.mork.OConnection", "com.sun.star.sdbc.Connection")
 177
 178
 179 Reference< XStatement > SAL_CALL OConnection::createStatement(  ) throw(SQLException, RuntimeException, std::exception)
 180 {
 181     SAL_INFO("connectivity.mork", "=> OConnection::createStatement()" );
 182
 183     ::osl::MutexGuard aGuard( m_aMutex );
 184     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 185
 186     // create a statement
 187     // the statement can only be executed once
 188     Reference< XStatement > xReturn = new OStatement(this);
 189     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 190     return xReturn;
 191 }
 192
 193 Reference< XPreparedStatement > SAL_CALL OConnection::prepareStatement( const OUString& _sSql ) throw(SQLException, RuntimeException, std::exception)
 194 {
 195     SAL_INFO("connectivity.mork", "=> OConnection::prepareStatement()" );
 196     SAL_INFO("connectivity.mork", "OConnection::prepareStatement( " << _sSql << " )");
 197
 198     ::osl::MutexGuard aGuard( m_aMutex );
 199     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 200
 201     // the pre
 202     // create a statement
 203     // the statement can only be executed more than once
 204     OPreparedStatement* pPrepared = new OPreparedStatement(this,_sSql);
 205     Reference< XPreparedStatement > xReturn = pPrepared;
 206     pPrepared->lateInit();
 207
 208     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 209     return xReturn;
 210 }
 211
 212 Reference< XPreparedStatement > SAL_CALL OConnection::prepareCall( const OUString& _sSql ) throw(SQLException, RuntimeException, std::exception)
 213 {
 214     SAL_INFO("connectivity.mork", "=> OConnection::prepareCall()" );
 215     SAL_INFO("connectivity.mork", "sql: " << _sSql);
 216     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::prepareCall", *this );
 217     SAL_INFO("connectivity.mork", "OConnection::prepareCall( " << _sSql << " )");
 218     return nullptr;
 219 }
 220
 221 OUString SAL_CALL OConnection::nativeSQL( const OUString& _sSql ) throw(SQLException, RuntimeException, std::exception)
 222 {
 223     SAL_INFO("connectivity.mork", "=> OConnection::nativeSQL()" );
 224     SAL_INFO("connectivity.mork", "sql: " << _sSql);
 225
 226     ::osl::MutexGuard aGuard( m_aMutex );
 227     // when you need to transform SQL92 to you driver specific you can do it here
 228     SAL_INFO("connectivity.mork", "OConnection::nativeSQL(" << _sSql << " )" );
 229
 230     return _sSql;
 231 }
 232
 233 void SAL_CALL OConnection::setAutoCommit( sal_Bool /*autoCommit*/ ) throw(SQLException, RuntimeException, std::exception)
 234 {
 235     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setAutoCommit", *this );
 236 }
 237
 238 sal_Bool SAL_CALL OConnection::getAutoCommit(  ) throw(SQLException, RuntimeException, std::exception)
 239 {
 240     // you have to distinguish which if you are in autocommit mode or not
 241     // at normal case true should be fine here
 242
 243     return true;
 244 }
 245
 246 void SAL_CALL OConnection::commit(  ) throw(SQLException, RuntimeException, std::exception)
 247 {
 248     // when you database does support transactions you should commit here
 249 }
 250
 251 void SAL_CALL OConnection::rollback(  ) throw(SQLException, RuntimeException, std::exception)
 252 {
 253     // same as commit but for the other case
 254 }
 255
 256 sal_Bool SAL_CALL OConnection::isClosed(  ) throw(SQLException, RuntimeException, std::exception)
 257 {
 258     ::osl::MutexGuard aGuard( m_aMutex );
 259
 260     // just simple -> we are close when we are disposed that means someone called dispose(); (XComponent)
 261     return OConnection_BASE::rBHelper.bDisposed;
 262 }
 263
 264 Reference< XDatabaseMetaData > SAL_CALL OConnection::getMetaData(  ) throw(SQLException, RuntimeException, std::exception)
 265 {
 266     SAL_INFO("connectivity.mork", "=> OConnection::getMetaData()" );
 267
 268     ::osl::MutexGuard aGuard( m_aMutex );
 269     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 270
 271     // here we have to create the class with biggest interface
 272     // The answer is 42 :-)
 273     Reference< XDatabaseMetaData > xMetaData = m_xMetaData;
 274     if(!xMetaData.is())
 275     {
 276         xMetaData = new ODatabaseMetaData(this); // need the connection because it can return it
 277         m_xMetaData = xMetaData;
 278     }
 279
 280     return xMetaData;
 281 }
 282
 283 void SAL_CALL OConnection::setReadOnly( sal_Bool /*readOnly*/ ) throw(SQLException, RuntimeException, std::exception)
 284 {
 285     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setReadOnly", *this );
 286 }
 287
 288 sal_Bool SAL_CALL OConnection::isReadOnly(  ) throw(SQLException, RuntimeException, std::exception)
 289 {
 290     // return if your connection to readonly
 291     return false;
 292 }
 293
 294 void SAL_CALL OConnection::setCatalog( const OUString& /*catalog*/ ) throw(SQLException, RuntimeException, std::exception)
 295 {
 296     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setCatalog", *this );
 297 }
 298
 299 OUString SAL_CALL OConnection::getCatalog(  ) throw(SQLException, RuntimeException, std::exception)
 300 {
 301     return OUString();
 302 }
 303
 304 void SAL_CALL OConnection::setTransactionIsolation( sal_Int32 /*level*/ ) throw(SQLException, RuntimeException, std::exception)
 305 {
 306     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setTransactionIsolation", *this );
 307 }
 308
 309 sal_Int32 SAL_CALL OConnection::getTransactionIsolation(  ) throw(SQLException, RuntimeException, std::exception)
 310 {
 311     // please have a look at @see com.sun.star.sdbc.TransactionIsolation
 312     return TransactionIsolation::NONE;
 313 }
 314
 315 Reference< css::container::XNameAccess > SAL_CALL OConnection::getTypeMap(  ) throw(SQLException, RuntimeException, std::exception)
 316 {
 317     // if your driver has special database types you can return it here
 318     return nullptr;
 319 }
 320
 321 void SAL_CALL OConnection::setTypeMap( const Reference< css::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException, std::exception)
 322 {
 323     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setTypeMap", *this );
 324 }
 325
 326 // XCloseable
 327 void SAL_CALL OConnection::close(  ) throw(SQLException, RuntimeException, std::exception)
 328 {
 329     // we just dispose us
 330     {
 331         ::osl::MutexGuard aGuard( m_aMutex );
 332         checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 333
 334     }
 335     dispose();
 336 }
 337
 338 // XWarningsSupplier
 339 Any SAL_CALL OConnection::getWarnings(  ) throw(SQLException, RuntimeException, std::exception)
 340 {
 341     // when you collected some warnings -> return it
 342     return Any();
 343 }
 344
 345 void SAL_CALL OConnection::clearWarnings(  ) throw(SQLException, RuntimeException, std::exception)
 346 {
 347     // you should clear your collected warnings here
 348 }
 349
 350 void OConnection::disposing()
 351 {
 352     // we noticed that we should be destroied in near future so we have to dispose our statements
 353     ::osl::MutexGuard aGuard(m_aMutex);
 354     dispose_ChildImpl();
 355     m_xCatalog.clear();
 356 }
 357
 358
 359 Reference< XTablesSupplier > SAL_CALL OConnection::createCatalog()
 360 {
 361     OSL_TRACE("IN OConnection::createCatalog()" );
 362     ::osl::MutexGuard aGuard( m_aMutex );
 363     Reference< XTablesSupplier > xTab = m_xCatalog;
 364     if(!m_xCatalog.is())
 365     {
 366         OCatalog *pCat = new OCatalog(this);
 367         xTab = pCat;
 368         m_xCatalog = xTab;
 369     }
 370     OSL_TRACE( "\tOUT OConnection::createCatalog()" );
 371     return xTab;
 372 }
 373
 374
 375 void OConnection::throwSQLException( const ErrorDescriptor& _rError, const Reference< XInterface >& _rxContext )
 376 {
 377     if ( _rError.getResId() != 0 )
 378     {
 379         OSL_ENSURE( ( _rError.getErrorCondition() == 0 ),
 380             "OConnection::throwSQLException: unsupported error code combination!" );
 381
 382         const OUString& sParameter( _rError.getParameter() );
 383         if ( !sParameter.isEmpty() )
 384         {
 385             const OUString sError( getResources().getResourceStringWithSubstitution(
 386                 _rError.getResId(),
 387                 "$1$", sParameter
 388              ) );
 389             ::dbtools::throwGenericSQLException( sError, _rxContext );
 390             OSL_FAIL( "OConnection::throwSQLException: unreachable (1)!" );
 391         }
 392
 393         throwGenericSQLException( _rError.getResId(), _rxContext );
 394         OSL_FAIL( "OConnection::throwSQLException: unreachable (2)!" );
 395     }
 396
 397     if ( _rError.getErrorCondition() != 0 )
 398     {
 399         SQLError aErrorHelper( comphelper::getComponentContext(getDriver()->getFactory()) );
 400         const OUString& sParameter( _rError.getParameter() );
 401         if ( !sParameter.isEmpty() )
 402             aErrorHelper.raiseException( _rError.getErrorCondition(), _rxContext, sParameter );
 403         else
 404             aErrorHelper.raiseException( _rError.getErrorCondition(), _rxContext);
 405         OSL_FAIL( "OConnection::throwSQLException: unreachable (3)!" );
 406     }
 407
 408     throwGenericSQLException( STR_UNSPECIFIED_ERROR, _rxContext );
 409 }
 410
 411
 412 void OConnection::throwSQLException( const sal_uInt16 _nErrorResourceId, const Reference< XInterface >& _rxContext )
 413 {
 414     ErrorDescriptor aError;
 415     aError.setResId( _nErrorResourceId );
 416     throwSQLException( aError, _rxContext );
 417 }
 418
 419 } } // namespace connectivity::mork
 420
 421 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */