connectivity/source/drivers/hsqldb/HDriver.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <hsqldb/HDriver.hxx>
  21 #include <hsqldb/HConnection.hxx>
  22 #include <osl/diagnose.h>
  23 #include <sal/log.hxx>
  24 #include <connectivity/dbexception.hxx>
  25 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  26 #include <com/sun/star/sdbc/DriverManager.hpp>
  27 #include <com/sun/star/sdbc/XResultSet.hpp>
  28 #include <com/sun/star/sdbc/XRow.hpp>
  29 #include <com/sun/star/embed/XTransactionBroadcaster.hpp>
  30 #include <com/sun/star/embed/ElementModes.hpp>
  31 #include <TConnection.hxx>
  32 #include <hsqldb/HStorageMap.hxx>
  33 #include <jvmfwk/framework.hxx>
  34 #include <com/sun/star/reflection/XProxyFactory.hpp>
  35 #include <com/sun/star/embed/XStorage.hpp>
  36 #include <com/sun/star/frame/Desktop.hpp>
  37 #include <com/sun/star/util/XFlushable.hpp>
  38 #include "HTerminateListener.hxx"
  39 #include <hsqldb/HCatalog.hxx>
  40 #include <rtl/ustrbuf.hxx>
  41 #include <osl/file.h>
  42 #include <osl/process.h>
  43 #include <comphelper/namedvaluecollection.hxx>
  44 #include <comphelper/propertysequence.hxx>
  45 #include <comphelper/servicehelper.hxx>
  46 #include <cppuhelper/supportsservice.hxx>
  47 #include <comphelper/types.hxx>
  48 #include <unotools/confignode.hxx>
  49 #include <unotools/ucbstreamhelper.hxx>
  50 #include <strings.hrc>
  51 #include <resource/sharedresources.hxx>
  52 #include <i18nlangtag/languagetag.hxx>
  53 #include <comphelper/diagnose_ex.hxx>
  54 #include <o3tl/string_view.hxx>
  55
  56 #include <memory>
  57
  58
  59 namespace connectivity
  60 {
  61
  62     using namespace hsqldb;
  63     using namespace css::uno;
  64     using namespace css::sdbc;
  65     using namespace css::sdbcx;
  66     using namespace css::beans;
  67     using namespace css::frame;
  68     using namespace css::lang;
  69     using namespace css::embed;
  70     using namespace css::io;
  71     using namespace css::util;
  72
  73     constexpr OUString IMPL_NAME = u"com.sun.star.sdbcx.comp.hsqldb.Driver"_ustr;
  74
  75
  76
  77     ODriverDelegator::ODriverDelegator(const Reference< XComponentContext >& _rxContext)
  78         : ODriverDelegator_BASE(m_aMutex)
  79         ,m_xContext(_rxContext)
  80         ,m_bInShutDownConnections(false)
  81     {
  82     }
  83
  84
  85     ODriverDelegator::~ODriverDelegator()
  86     {
  87         try
  88         {
  89             ::comphelper::disposeComponent(m_xDriver);
  90         }
  91         catch(const Exception&)
  92         {
  93         }
  94     }
  95
  96
  97     void SAL_CALL ODriverDelegator::disposing()
  98     {
  99         ::osl::MutexGuard aGuard(m_aMutex);
 100
 101         try
 102         {
 103             for (const auto& rConnection : m_aConnections)
 104             {
 105                 Reference<XInterface > xTemp = rConnection.first.get();
 106                 ::comphelper::disposeComponent(xTemp);
 107             }
 108         }
 109         catch(Exception&)
 110         {
 111             // not interested in
 112         }
 113         m_aConnections.clear();
 114         TWeakPairVector().swap(m_aConnections);
 115
 116         cppu::WeakComponentImplHelperBase::disposing();
 117     }
 118
 119     Reference< XDriver > const & ODriverDelegator::loadDriver( )
 120     {
 121         if ( !m_xDriver.is() )
 122         {
 123             Reference<XDriverManager2> xDriverAccess = DriverManager::create( m_xContext );
 124             m_xDriver = xDriverAccess->getDriverByURL(u"jdbc:hsqldb:db"_ustr);
 125         }
 126
 127         return m_xDriver;
 128     }
 129
 130
 131     namespace
 132     {
 133         OUString lcl_getPermittedJavaMethods_nothrow( const Reference< XComponentContext >& _rxContext )
 134         {
 135             OUString aConfigPath =
 136                 "/org.openoffice.Office.DataAccess/DriverSettings/" +
 137                 IMPL_NAME +
 138                 "/PermittedJavaMethods";
 139             ::utl::OConfigurationTreeRoot aConfig( ::utl::OConfigurationTreeRoot::createWithComponentContext(
 140                 _rxContext, aConfigPath ) );
 141
 142             OUStringBuffer aPermittedMethods;
 143             const Sequence< OUString > aNodeNames( aConfig.getNodeNames() );
 144             for ( auto const & nodeName : aNodeNames )
 145             {
 146                 OUString sPermittedMethod;
 147                 OSL_VERIFY( aConfig.getNodeValue( nodeName ) >>= sPermittedMethod );
 148
 149                 if ( !aPermittedMethods.isEmpty() )
 150                     aPermittedMethods.append( ';' );
 151                 aPermittedMethods.append( sPermittedMethod );
 152             }
 153
 154             return aPermittedMethods.makeStringAndClear();
 155         }
 156     }
 157
 158
 159     Reference< XConnection > SAL_CALL ODriverDelegator::connect( const OUString& url, const Sequence< PropertyValue >& info )
 160     {
 161         Reference< XConnection > xConnection;
 162         if ( acceptsURL(url) )
 163         {
 164             Reference< XDriver > xDriver = loadDriver();
 165             if ( xDriver.is() )
 166             {
 167                 OUString sURL;
 168                 Reference<XStorage> xStorage;
 169                 const PropertyValue* pIter = info.getConstArray();
 170                 const PropertyValue* pEnd = pIter + info.getLength();
 171
 172                 for (;pIter != pEnd; ++pIter)
 173                 {
 174                     if ( pIter->Name == "Storage" )
 175                     {
 176                         xStorage.set(pIter->Value,UNO_QUERY);
 177                     }
 178                     else if ( pIter->Name == "URL" )
 179                     {
 180                         pIter->Value >>= sURL;
 181                     }
 182                 }
 183
 184                 if ( !xStorage.is() || sURL.isEmpty() )
 185                 {
 186                     ::connectivity::SharedResources aResources;
 187                     const OUString sMessage = aResources.getResourceString(STR_NO_STORAGE);
 188                     ::dbtools::throwGenericSQLException(sMessage ,*this);
 189                 }
 190
 191                 OUString sSystemPath;
 192                 osl_getSystemPathFromFileURL( sURL.pData, &sSystemPath.pData );
 193                 if ( sURL.isEmpty() || sSystemPath.isEmpty() )
 194                 {
 195                     ::connectivity::SharedResources aResources;
 196                     const OUString sMessage = aResources.getResourceString(STR_INVALID_FILE_URL);
 197                     ::dbtools::throwGenericSQLException(sMessage ,*this);
 198                 }
 199
 200                 bool bIsNewDatabase = !xStorage->hasElements();
 201
 202                 ::comphelper::NamedValueCollection aProperties;
 203
 204                 // properties for accessing the embedded storage
 205                 OUString sKey = StorageContainer::registerStorage( xStorage, sSystemPath );
 206                 aProperties.put( u"storage_key"_ustr, sKey );
 207                 aProperties.put( u"storage_class_name"_ustr,
 208                     u"com.sun.star.sdbcx.comp.hsqldb.StorageAccess"_ustr );
 209                 aProperties.put( u"fileaccess_class_name"_ustr,
 210                     u"com.sun.star.sdbcx.comp.hsqldb.StorageFileAccess"_ustr );
 211
 212                 // JDBC driver and driver's classpath
 213                 aProperties.put( u"JavaDriverClass"_ustr, u"org.hsqldb.jdbcDriver"_ustr );
 214                 aProperties.put( u"JavaDriverClassPath"_ustr,
 215 #ifdef SYSTEM_HSQLDB
 216                         u"" HSQLDB_JAR
 217 #else
 218                         u"vnd.sun.star.expand:$LO_JAVA_DIR/hsqldb.jar"
 219 #endif
 220                         " vnd.sun.star.expand:$LO_JAVA_DIR/sdbc_hsqldb.jar"_ustr );
 221
 222                 // auto increment handling
 223                 aProperties.put( u"IsAutoRetrievingEnabled"_ustr, true );
 224                 aProperties.put( u"AutoRetrievingStatement"_ustr,
 225                     u"CALL IDENTITY()"_ustr );
 226                 aProperties.put( u"IgnoreDriverPrivileges"_ustr, true );
 227
 228                 // don't want to expose HSQLDB's schema capabilities which exist since 1.8.0RC10
 229                 aProperties.put( u"default_schema"_ustr,
 230                     u"true"_ustr );
 231
 232                 // security: permitted Java classes
 233                 NamedValue aPermittedClasses(
 234                     u"hsqldb.method_class_names"_ustr,
 235                     Any( lcl_getPermittedJavaMethods_nothrow( m_xContext ) )
 236                 );
 237                 aProperties.put( u"SystemProperties"_ustr, Sequence< NamedValue >( &aPermittedClasses, 1 ) );
 238
 239                 OUString sMessage;
 240                 try
 241                 {
 242                     static constexpr OUString sProperties(  u"properties"_ustr  );
 243                     if ( !bIsNewDatabase && xStorage->isStreamElement(sProperties) )
 244                     {
 245                         Reference<XStream > xStream = xStorage->openStreamElement(sProperties,ElementModes::READ);
 246                         if ( xStream.is() )
 247                         {
 248                             std::unique_ptr<SvStream> pStream( ::utl::UcbStreamHelper::CreateStream(xStream) );
 249                             if (pStream)
 250                             {
 251                                 OStringBuffer sLine;
 252                                 OString sVersionString;
 253                                 while ( pStream->ReadLine(sLine) )
 254                                 {
 255                                     if ( sLine.isEmpty() )
 256                                         continue;
 257                                     sal_Int32 nIdx {0};
 258                                     const std::string_view sIniKey = o3tl::getToken(sLine, 0, '=', nIdx);
 259                                     const OString sValue(o3tl::getToken(sLine, 0, '=', nIdx));
 260                                     if( sIniKey == "hsqldb.compatible_version" )
 261                                     {
 262                                         sVersionString = sValue;
 263                                     }
 264                                     else
 265                                     {
 266                                         if (sIniKey == "version" && sVersionString.isEmpty())
 267                                         {
 268                                             sVersionString = sValue;
 269                                         }
 270                                     }
 271                                 }
 272                                 if (!sVersionString.isEmpty())
 273                                 {
 274                                     sal_Int32 nIdx {0};
 275                                     const sal_Int32 nMajor = o3tl::toInt32(o3tl::getToken(sVersionString, 0, '.', nIdx));
 276                                     const sal_Int32 nMinor = o3tl::toInt32(o3tl::getToken(sVersionString, 0, '.', nIdx));
 277                                     const sal_Int32 nMicro = o3tl::toInt32(o3tl::getToken(sVersionString, 0, '.', nIdx));
 278                                     if (     nMajor > 1
 279                                         || ( nMajor == 1 && nMinor > 8 )
 280                                         || ( nMajor == 1 && nMinor == 8 && nMicro > 0 ) )
 281                                     {
 282                                         ::connectivity::SharedResources aResources;
 283                                         sMessage = aResources.getResourceString(STR_ERROR_NEW_VERSION);
 284                                     }
 285                                 }
 286                             }
 287                         } // if ( xStream.is() )
 288                         ::comphelper::disposeComponent(xStream);
 289                     }
 290
 291                     // disallow any database/script files that contain a "SCRIPT[.*]" entry (this is belt and braces
 292                     // in that bundled hsqldb 1.8.0 is patched to also reject them)
 293                     //
 294                     // hsqldb 2.6.0 release notes have: added system role SCRIPT_OPS for export / import of database structure and data
 295                     // which seems to provide a builtin way to do this with contemporary hsqldb
 296                     static constexpr OUString sScript(u"script"_ustr);
 297                     if (!bIsNewDatabase && xStorage->isStreamElement(sScript))
 298                     {
 299                         Reference<XStream > xStream = xStorage->openStreamElement(sScript, ElementModes::READ);
 300                         if (xStream.is())
 301                         {
 302                             std::unique_ptr<SvStream> pStream(::utl::UcbStreamHelper::CreateStream(xStream));
 303                             if (pStream)
 304                             {
 305                                 OStringBuffer sLine;
 306                                 while (pStream->ReadLine(sLine))
 307                                 {
 308                                     OString sText = sLine.makeStringAndClear().trim();
 309                                     if (sText.startsWithIgnoreAsciiCase("SCRIPT"))
 310                                     {
 311                                         ::connectivity::SharedResources aResources;
 312                                         sMessage = aResources.getResourceString(STR_COULD_NOT_LOAD_FILE).replaceFirst("$filename$", sSystemPath);
 313                                         break;
 314                                     }
 315                                 }
 316                             }
 317                         } // if ( xStream.is() )
 318                         ::comphelper::disposeComponent(xStream);
 319                     }
 320
 321                 }
 322                 catch(Exception&)
 323                 {
 324                 }
 325                 if ( !sMessage.isEmpty() )
 326                 {
 327                     ::dbtools::throwGenericSQLException(sMessage ,*this);
 328                 }
 329
 330                 // readonly?
 331                 Reference<XPropertySet> xProp(xStorage,UNO_QUERY);
 332                 if ( xProp.is() )
 333                 {
 334                     sal_Int32 nMode = 0;
 335                     xProp->getPropertyValue(u"OpenMode"_ustr) >>= nMode;
 336                     if ( (nMode & ElementModes::WRITE) != ElementModes::WRITE )
 337                     {
 338                         aProperties.put( u"readonly"_ustr, u"true"_ustr );
 339                     }
 340                 }
 341
 342                 Sequence< PropertyValue > aConnectionArgs;
 343                 aProperties >>= aConnectionArgs;
 344                 OUString sConnectURL = "jdbc:hsqldb:" + sSystemPath;
 345                 Reference<XConnection> xOrig;
 346                 try
 347                 {
 348                     xOrig = xDriver->connect( sConnectURL, aConnectionArgs );
 349                 }
 350                 catch(const Exception&)
 351                 {
 352                     StorageContainer::revokeStorage(sKey,nullptr);
 353                     throw;
 354                 }
 355
 356                 // if the storage is completely empty, then we just created a new HSQLDB
 357                 // In this case, do some initializations.
 358                 if ( bIsNewDatabase && xOrig.is() )
 359                     onConnectedNewDatabase( xOrig );
 360
 361                 if ( xOrig.is() )
 362                 {
 363                     // now we have to set the URL to get the correct answer for metadata()->getURL()
 364                     auto pMetaConnection = comphelper::getFromUnoTunnel<OMetaConnection>(xOrig);
 365                     if ( pMetaConnection )
 366                         pMetaConnection->setURL(url);
 367
 368                     Reference<XComponent> xComp(xOrig,UNO_QUERY);
 369                     if ( xComp.is() )
 370                         xComp->addEventListener(this);
 371
 372                     // we want to close all connections when the office shuts down
 373                     static Reference< XTerminateListener> s_xTerminateListener = [&]()
 374                     {
 375                         Reference< XDesktop2 > xDesktop = Desktop::create( m_xContext );
 376
 377                         rtl::Reference<OConnectionController> tmp = new OConnectionController(this);
 378                         xDesktop->addTerminateListener(tmp);
 379                         return tmp;
 380                     }();
 381                     Reference< XComponent> xIfc = new OHsqlConnection( this, xOrig, m_xContext );
 382                     xConnection.set(xIfc,UNO_QUERY);
 383                     m_aConnections.push_back(TWeakPair(WeakReferenceHelper(xOrig),TWeakConnectionPair(sKey,TWeakRefPair(WeakReferenceHelper(xConnection),WeakReferenceHelper()))));
 384
 385                     Reference<XTransactionBroadcaster> xBroad(xStorage,UNO_QUERY);
 386                     if ( xBroad.is() )
 387                     {
 388                         xBroad->addTransactionListener(Reference<XTransactionListener>(this));
 389                     }
 390                 }
 391             }
 392         }
 393         return xConnection;
 394     }
 395
 396
 397     sal_Bool SAL_CALL ODriverDelegator::acceptsURL( const OUString& url )
 398     {
 399         bool bEnabled = false;
 400         javaFrameworkError e = jfw_getEnabled(&bEnabled);
 401         switch (e) {
 402         case JFW_E_NONE:
 403             break;
 404         case JFW_E_DIRECT_MODE:
 405             SAL_INFO(
 406                 "connectivity.hsqldb",
 407                 "jfw_getEnabled: JFW_E_DIRECT_MODE, assuming true");
 408             bEnabled = true;
 409             break;
 410         default:
 411             SAL_WARN(
 412                 "connectivity.hsqldb", "jfw_getEnabled: error code " << +e);
 413             break;
 414         }
 415         return bEnabled  && url == "sdbc:embedded:hsqldb";
 416     }
 417
 418
 419     Sequence< DriverPropertyInfo > SAL_CALL ODriverDelegator::getPropertyInfo( const OUString& url, const Sequence< PropertyValue >& /*info*/ )
 420     {
 421         if ( !acceptsURL(url) )
 422             return Sequence< DriverPropertyInfo >();
 423         return
 424         {
 425             {
 426                 u"Storage"_ustr,
 427                 u"Defines the storage where the database will be stored."_ustr,
 428                 true,
 429                 {},
 430                 {}
 431             },
 432             {
 433                 u"URL"_ustr,
 434                 u"Defines the url of the data source."_ustr,
 435                 true,
 436                 {},
 437                 {}
 438             },
 439             {
 440                 u"AutoRetrievingStatement"_ustr,
 441                 u"Defines the statement which will be executed to retrieve auto increment values."_ustr,
 442                 false,
 443                 u"CALL IDENTITY()"_ustr,
 444                 {}
 445             }
 446         };
 447     }
 448
 449
 450     sal_Int32 SAL_CALL ODriverDelegator::getMajorVersion(  )
 451     {
 452         return 1;
 453     }
 454
 455
 456     sal_Int32 SAL_CALL ODriverDelegator::getMinorVersion(  )
 457     {
 458         return 0;
 459     }
 460
 461
 462     Reference< XTablesSupplier > SAL_CALL ODriverDelegator::getDataDefinitionByConnection( const Reference< XConnection >& connection )
 463     {
 464         ::osl::MutexGuard aGuard( m_aMutex );
 465         checkDisposed(ODriverDelegator_BASE::rBHelper.bDisposed);
 466
 467         Reference< XTablesSupplier > xTab;
 468
 469         TWeakPairVector::iterator i = std::find_if(m_aConnections.begin(), m_aConnections.end(),
 470             [&connection](const TWeakPairVector::value_type& rConnection) {
 471                 return rConnection.second.second.first.get() == connection.get(); });
 472         if (i != m_aConnections.end())
 473         {
 474             xTab.set(i->second.second.second,UNO_QUERY);
 475             if ( !xTab.is() )
 476             {
 477                 xTab = new OHCatalog(connection);
 478                 i->second.second.second = WeakReferenceHelper(xTab);
 479             }
 480         }
 481
 482         return xTab;
 483     }
 484
 485
 486     Reference< XTablesSupplier > SAL_CALL ODriverDelegator::getDataDefinitionByURL( const OUString& url, const Sequence< PropertyValue >& info )
 487     {
 488         if ( ! acceptsURL(url) )
 489         {
 490             ::connectivity::SharedResources aResources;
 491             const OUString sMessage = aResources.getResourceString(STR_URI_SYNTAX_ERROR);
 492             ::dbtools::throwGenericSQLException(sMessage ,*this);
 493         }
 494
 495         return getDataDefinitionByConnection(connect(url,info));
 496     }
 497
 498     // XServiceInfo
 499
 500     OUString SAL_CALL ODriverDelegator::getImplementationName(  )
 501     {
 502         return IMPL_NAME;
 503     }
 504
 505     sal_Bool SAL_CALL ODriverDelegator::supportsService( const OUString& _rServiceName )
 506     {
 507         return cppu::supportsService(this, _rServiceName);
 508     }
 509
 510     Sequence< OUString > SAL_CALL ODriverDelegator::getSupportedServiceNames(  )
 511     {
 512         return { u"com.sun.star.sdbc.Driver"_ustr, u"com.sun.star.sdbcx.Driver"_ustr };
 513     }
 514
 515     void SAL_CALL ODriverDelegator::createCatalog( const Sequence< PropertyValue >& /*info*/ )
 516     {
 517         ::dbtools::throwFeatureNotImplementedSQLException( u"XCreateCatalog::createCatalog"_ustr, *this );
 518     }
 519
 520     void ODriverDelegator::shutdownConnection(const TWeakPairVector::iterator& _aIter )
 521     {
 522         OSL_ENSURE(m_aConnections.end() != _aIter,"Iterator equals .end()");
 523         bool bLastOne = true;
 524         try
 525         {
 526             Reference<XConnection> _xConnection(_aIter->first.get(),UNO_QUERY);
 527
 528             if ( _xConnection.is() )
 529             {
 530                 Reference<XStatement> xStmt = _xConnection->createStatement();
 531                 if ( xStmt.is() )
 532                 {
 533                     Reference<XResultSet> xRes = xStmt->executeQuery(u"SELECT COUNT(*) FROM INFORMATION_SCHEMA.SYSTEM_SESSIONS WHERE USER_NAME ='SA'"_ustr);
 534                     Reference<XRow> xRow(xRes,UNO_QUERY);
 535                     if ( xRow.is() && xRes->next() )
 536                         bLastOne = xRow->getInt(1) == 1;
 537                     if ( bLastOne )
 538                         xStmt->execute(u"SHUTDOWN"_ustr);
 539                 }
 540             }
 541         }
 542         catch(Exception&)
 543         {
 544         }
 545         if ( bLastOne )
 546         {
 547             // Reference<XTransactionListener> xListener(*this,UNO_QUERY);
 548             // a shutdown should commit all changes to the db files
 549             StorageContainer::revokeStorage(_aIter->second.first,nullptr);
 550         }
 551         if ( !m_bInShutDownConnections )
 552             m_aConnections.erase(_aIter);
 553     }
 554
 555     void SAL_CALL ODriverDelegator::disposing( const css::lang::EventObject& Source )
 556     {
 557         ::osl::MutexGuard aGuard(m_aMutex);
 558         Reference<XConnection> xCon(Source.Source,UNO_QUERY);
 559         if ( xCon.is() )
 560         {
 561             TWeakPairVector::iterator i = std::find_if(m_aConnections.begin(), m_aConnections.end(),
 562                 [&xCon](const TWeakPairVector::value_type& rConnection) { return rConnection.first.get() == xCon.get(); });
 563
 564             if (i != m_aConnections.end())
 565                 shutdownConnection(i);
 566         }
 567         else
 568         {
 569             Reference< XStorage> xStorage(Source.Source,UNO_QUERY);
 570             if ( xStorage.is() )
 571             {
 572                 OUString sKey = StorageContainer::getRegisteredKey(xStorage);
 573                 TWeakPairVector::iterator i = std::find_if(m_aConnections.begin(),m_aConnections.end(),
 574                     [&sKey] (const TWeakPairVector::value_type& conn) {
 575                         return conn.second.first == sKey;
 576                     });
 577
 578                 if ( i != m_aConnections.end() )
 579                     shutdownConnection(i);
 580             }
 581         }
 582     }
 583
 584     void ODriverDelegator::shutdownConnections()
 585     {
 586         m_bInShutDownConnections = true;
 587         for (const auto& rConnection : m_aConnections)
 588         {
 589             try
 590             {
 591                 Reference<XConnection> xCon(rConnection.first,UNO_QUERY);
 592                 ::comphelper::disposeComponent(xCon);
 593             }
 594             catch(Exception&)
 595             {
 596             }
 597         }
 598         m_aConnections.clear();
 599         m_bInShutDownConnections = true;
 600     }
 601
 602     void ODriverDelegator::flushConnections()
 603     {
 604         for (const auto& rConnection : m_aConnections)
 605         {
 606             try
 607             {
 608                 Reference<XFlushable> xCon(rConnection.second.second.first.get(),UNO_QUERY);
 609                 if (xCon.is())
 610                     xCon->flush();
 611             }
 612             catch(Exception&)
 613             {
 614                 DBG_UNHANDLED_EXCEPTION("connectivity.hsqldb");
 615             }
 616         }
 617     }
 618
 619     void SAL_CALL ODriverDelegator::preCommit( const css::lang::EventObject& aEvent )
 620     {
 621         ::osl::MutexGuard aGuard(m_aMutex);
 622
 623         Reference< XStorage> xStorage(aEvent.Source,UNO_QUERY);
 624         OUString sKey = StorageContainer::getRegisteredKey(xStorage);
 625         if ( sKey.isEmpty() )
 626             return;
 627
 628         TWeakPairVector::const_iterator i = std::find_if(m_aConnections.begin(), m_aConnections.end(),
 629             [&sKey] (const TWeakPairVector::value_type& conn) {
 630                 return conn.second.first == sKey;
 631             });
 632
 633         OSL_ENSURE( i != m_aConnections.end(), "ODriverDelegator::preCommit: they're committing a storage which I do not know!" );
 634         if ( i == m_aConnections.end() )
 635             return;
 636
 637         try
 638         {
 639             Reference<XConnection> xConnection(i->first,UNO_QUERY);
 640             if ( xConnection.is() )
 641             {
 642                 Reference< XStatement> xStmt = xConnection->createStatement();
 643                 OSL_ENSURE( xStmt.is(), "ODriverDelegator::preCommit: no statement!" );
 644                 if ( xStmt.is() )
 645                     xStmt->execute( u"SET WRITE_DELAY 0"_ustr );
 646
 647                 bool bPreviousAutoCommit = xConnection->getAutoCommit();
 648                 xConnection->setAutoCommit( false );
 649                 xConnection->commit();
 650                 xConnection->setAutoCommit( bPreviousAutoCommit );
 651
 652                 if ( xStmt.is() )
 653                     xStmt->execute( u"SET WRITE_DELAY 60"_ustr );
 654             }
 655         }
 656         catch(Exception&)
 657         {
 658             TOOLS_WARN_EXCEPTION( "connectivity.hsqldb", "ODriverDelegator::preCommit" );
 659         }
 660     }
 661
 662     void SAL_CALL ODriverDelegator::commited( const css::lang::EventObject& /*aEvent*/ )
 663     {
 664     }
 665
 666     void SAL_CALL ODriverDelegator::preRevert( const css::lang::EventObject& /*aEvent*/ )
 667     {
 668     }
 669
 670     void SAL_CALL ODriverDelegator::reverted( const css::lang::EventObject& /*aEvent*/ )
 671     {
 672     }
 673
 674     namespace
 675     {
 676
 677         const char* lcl_getCollationForLocale( const OUString& _rLocaleString, bool _bAcceptCountryMismatch = false )
 678         {
 679             static const char* pTranslations[] =
 680             {
 681                 "af-ZA", "Afrikaans",
 682                 "am-ET", "Amharic",
 683                 "ar", "Arabic",
 684                 "as-IN", "Assamese",
 685                 "az-AZ", "Azerbaijani_Latin",
 686                 "az-cyrillic", "Azerbaijani_Cyrillic",
 687                 "be-BY", "Belarusian",
 688                 "bg-BG", "Bulgarian",
 689                 "bn-IN", "Bengali",
 690                 "bo-CN", "Tibetan",
 691                 "bs-BA", "Bosnian",
 692                 "ca-ES", "Catalan",
 693                 "cs-CZ", "Czech",
 694                 "cy-GB", "Welsh",
 695                 "da-DK", "Danish",
 696                 "de-DE", "German",
 697                 "el-GR", "Greek",
 698                 "en-US", "Latin1_General",
 699                 "es-ES", "Spanish",
 700                 "et-EE", "Estonian",
 701                 "eu", "Basque",
 702                 "fi-FI", "Finnish",
 703                 "fr-FR", "French",
 704                 "gn-PY", "Guarani",
 705                 "gu-IN", "Gujarati",
 706                 "ha-NG", "Hausa",
 707                 "he-IL", "Hebrew",
 708                 "hi-IN", "Hindi",
 709                 "hr-HR", "Croatian",
 710                 "hu-HU", "Hungarian",
 711                 "hy-AM", "Armenian",
 712                 "id-ID", "Indonesian",
 713                 "ig-NG", "Igbo",
 714                 "is-IS", "Icelandic",
 715                 "it-IT", "Italian",
 716                 "iu-CA", "Inuktitut",
 717                 "ja-JP", "Japanese",
 718                 "ka-GE", "Georgian",
 719                 "kk-KZ", "Kazakh",
 720                 "km-KH", "Khmer",
 721                 "kn-IN", "Kannada",
 722                 "ko-KR", "Korean",
 723                 "kok-IN", "Konkani",
 724                 "ks", "Kashmiri",
 725                 "ky-KG", "Kirghiz",
 726                 "lo-LA", "Lao",
 727                 "lt-LT", "Lithuanian",
 728                 "lv-LV", "Latvian",
 729                 "mi-NZ", "Maori",
 730                 "mk-MK", "Macedonian",
 731                 "ml-IN", "Malayalam",
 732                 "mn-MN", "Mongolian",
 733                 "mni-IN", "Manipuri",
 734                 "mr-IN", "Marathi",
 735                 "ms-MY", "Malay",
 736                 "mt-MT", "Maltese",
 737                 "my-MM", "Burmese",
 738                 "nb-NO", "Danish_Norwegian",
 739                 "ne-NP", "Nepali",
 740                 "nl-NL", "Dutch",
 741                 "nn-NO", "Norwegian",
 742                 "or-IN", "Odia",
 743                 "pa-IN", "Punjabi",
 744                 "pl-PL", "Polish",
 745                 "ps-AF", "Pashto",
 746                 "pt-PT", "Portuguese",
 747                 "ro-RO", "Romanian",
 748                 "ru-RU", "Russian",
 749                 "sa-IN", "Sanskrit",
 750                 "sd-IN", "Sindhi",
 751                 "sk-SK", "Slovak",
 752                 "sl-SI", "Slovenian",
 753                 "so-SO", "Somali",
 754                 "sq-AL", "Albanian",
 755                 "sr-YU", "Serbian_Cyrillic",
 756                 "sv-SE", "Swedish",
 757                 "sw-KE", "Swahili",
 758                 "ta-IN", "Tamil",
 759                 "te-IN", "Telugu",
 760                 "tg-TJ", "Tajik",
 761                 "th-TH", "Thai",
 762                 "tk-TM", "Turkmen",
 763                 "tn-BW", "Tswana",
 764                 "tr-TR", "Turkish",
 765                 "tt-RU", "Tatar",
 766                 "uk-UA", "Ukrainian",
 767                 "ur-PK", "Urdu",
 768                 "uz-UZ", "Uzbek_Latin",
 769                 "ven-ZA", "Venda",
 770                 "vi-VN", "Vietnamese",
 771                 "yo-NG", "Yoruba",
 772                 "zh-CN", "Chinese",
 773                 "zu-ZA", "Zulu",
 774                 nullptr, nullptr
 775             };
 776
 777             OUString sLocaleString( _rLocaleString );
 778             char nCompareTermination = 0;
 779
 780             if ( _bAcceptCountryMismatch )
 781             {
 782                 // strip the country part from the compare string
 783                 sal_Int32 nCountrySep = sLocaleString.indexOf( '-' );
 784                 if ( nCountrySep > -1 )
 785                     sLocaleString = sLocaleString.copy( 0, nCountrySep );
 786
 787                 // the entries in the translation table are compared until the
 788                 // - character only, not until the terminating 0
 789                 nCompareTermination = '-';
 790             }
 791
 792             const char** pLookup = pTranslations;
 793             for ( ; *pLookup; pLookup +=2 )
 794             {
 795                 sal_Int32 nCompareUntil = 0;
 796                 while ( (*pLookup)[ nCompareUntil ] != nCompareTermination && (*pLookup)[ nCompareUntil ] != 0 )
 797                     ++nCompareUntil;
 798
 799                 if ( sLocaleString.equalsAsciiL( *pLookup, nCompareUntil ) )
 800                     return *( pLookup + 1 );
 801             }
 802
 803             if ( !_bAcceptCountryMismatch )
 804                 // second round, this time without matching the country
 805                 return lcl_getCollationForLocale( _rLocaleString, true );
 806
 807             OSL_FAIL( "lcl_getCollationForLocale: unknown locale string, falling back to Latin1_General!" );
 808             return "Latin1_General";
 809         }
 810
 811
 812         OUString lcl_getSystemLocale( const Reference< XComponentContext >& _rxContext )
 813         {
 814             OUString sLocaleString = u"en-US"_ustr;
 815             try
 816             {
 817
 818                 Reference< XMultiServiceFactory > xConfigProvider(
 819                     css::configuration::theDefaultProvider::get( _rxContext ) );
 820
 821
 822                 // arguments for creating the config access
 823                 Sequence<Any> aArguments(comphelper::InitAnyPropertySequence(
 824                 {
 825                     {"nodepath", Any(u"/org.openoffice.Setup/L10N"_ustr)}, // the path to the node to open
 826                     {"depth", Any(sal_Int32(-1))}, // the depth: -1 means unlimited
 827                 }));
 828                 // create the access
 829                 Reference< XPropertySet > xNode(
 830                     xConfigProvider->createInstanceWithArguments(
 831                         u"com.sun.star.configuration.ConfigurationAccess"_ustr,
 832                         aArguments ),
 833                     UNO_QUERY );
 834                 OSL_ENSURE( xNode.is(), "lcl_getSystemLocale: invalid access returned (should throw an exception instead)!" );
 835
 836
 837                 // ask for the system locale setting
 838                 if ( xNode.is() )
 839                     xNode->getPropertyValue(u"ooSetupSystemLocale"_ustr) >>= sLocaleString;
 840             }
 841             catch( const Exception& )
 842             {
 843                 TOOLS_WARN_EXCEPTION( "connectivity.hsqldb", "lcl_getSystemLocale" );
 844             }
 845             if ( sLocaleString.isEmpty() )
 846             {
 847                 rtl_Locale* pProcessLocale = nullptr;
 848                 osl_getProcessLocale( &pProcessLocale );
 849                 sLocaleString = LanguageTag( *pProcessLocale).getBcp47();
 850             }
 851             return sLocaleString;
 852         }
 853     }
 854
 855     void ODriverDelegator::onConnectedNewDatabase( const Reference< XConnection >& _rxConnection )
 856     {
 857         try
 858         {
 859             Reference< XStatement > xStatement = _rxConnection->createStatement();
 860             OSL_ENSURE( xStatement.is(), "ODriverDelegator::onConnectedNewDatabase: could not create a statement!" );
 861             if ( xStatement.is() )
 862             {
 863                 OUStringBuffer aStatement( "SET DATABASE COLLATION \"" );
 864                 aStatement.appendAscii( lcl_getCollationForLocale( lcl_getSystemLocale( m_xContext ) ) );
 865                 aStatement.append( "\"" );
 866
 867                 xStatement->execute( aStatement.makeStringAndClear() );
 868             }
 869         }
 870         catch( const Exception& )
 871         {
 872             TOOLS_WARN_EXCEPTION( "connectivity.hsqldb", "ODriverDelegator::onConnectedNewDatabase" );
 873         }
 874     }
 875
 876
 877 }   // namespace connectivity
 878
 879
 880 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 881 connectivity_hsqldb_ODriverDelegator_implementation(
 882     css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
 883 {
 884     return cppu::acquire(new connectivity::ODriverDelegator(context));
 885 }
 886
 887
 888 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */