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