connectivity/source/drivers/mysql_jdbc/YDriver.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 <mysql/YDriver.hxx>
  21 #include <mysql/YCatalog.hxx>
  22 #include <comphelper/namedvaluecollection.hxx>
  23 #include <comphelper/servicehelper.hxx>
  24 #include <comphelper/types.hxx>
  25 #include <cppuhelper/supportsservice.hxx>
  26 #include <connectivity/dbexception.hxx>
  27 #include <connectivity/dbcharset.hxx>
  28 #include <com/sun/star/sdbc/DriverManager.hpp>
  29 #include <com/sun/star/uno/XComponentContext.hpp>
  30 #include <TConnection.hxx>
  31 #include <strings.hrc>
  32 #include <resource/sharedresources.hxx>
  33
  34 namespace connectivity
  35 {
  36 using namespace mysql;
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::sdbc;
  39 using namespace ::com::sun::star::sdbcx;
  40 using namespace ::com::sun::star::beans;
  41 using namespace ::com::sun::star::lang;
  42
  43 namespace
  44 {
  45 OUString getJavaDriverClass(css::uno::Sequence<css::beans::PropertyValue> const& info)
  46 {
  47     return comphelper::NamedValueCollection(info).getOrDefault("JavaDriverClass",
  48                                                                OUString("com.mysql.jdbc.Driver"));
  49 }
  50 }
  51
  52 ODriverDelegator::ODriverDelegator(const Reference<XComponentContext>& _rxContext)
  53     : ODriverDelegator_BASE(m_aMutex)
  54     , m_xContext(_rxContext)
  55 {
  56 }
  57
  58 ODriverDelegator::~ODriverDelegator()
  59 {
  60     try
  61     {
  62         ::comphelper::disposeComponent(m_xODBCDriver);
  63         ::comphelper::disposeComponent(m_xNativeDriver);
  64         for (auto& rEntry : m_aJdbcDrivers)
  65             ::comphelper::disposeComponent(rEntry.second);
  66     }
  67     catch (const Exception&)
  68     {
  69     }
  70 }
  71
  72 void ODriverDelegator::disposing()
  73 {
  74     ::osl::MutexGuard aGuard(m_aMutex);
  75
  76     for (auto const& connection : m_aConnections)
  77     {
  78         Reference<XInterface> xTemp = connection.first.get();
  79         ::comphelper::disposeComponent(xTemp);
  80     }
  81     m_aConnections.clear();
  82     TWeakPairVector().swap(m_aConnections);
  83
  84     ODriverDelegator_BASE::disposing();
  85 }
  86
  87 namespace
  88 {
  89 enum class T_DRIVERTYPE
  90 {
  91     Odbc,
  92     Jdbc,
  93     Native
  94 };
  95
  96 bool isOdbcUrl(const OUString& _sUrl) { return _sUrl.startsWith("sdbc:mysql:odbc:"); }
  97
  98 bool isNativeUrl(const OUString& _sUrl) { return _sUrl.startsWith("sdbc:mysql:mysqlc:"); }
  99
 100 T_DRIVERTYPE lcl_getDriverType(const OUString& _sUrl)
 101 {
 102     T_DRIVERTYPE eRet = T_DRIVERTYPE::Jdbc;
 103     if (isOdbcUrl(_sUrl))
 104         eRet = T_DRIVERTYPE::Odbc;
 105     else if (isNativeUrl(_sUrl))
 106         eRet = T_DRIVERTYPE::Native;
 107     return eRet;
 108 }
 109
 110 OUString transformUrl(const OUString& _sUrl)
 111 {
 112     OUString sNewUrl = _sUrl.copy(11);
 113     if (isOdbcUrl(_sUrl))
 114         sNewUrl = "sdbc:" + sNewUrl;
 115     else if (isNativeUrl(_sUrl))
 116         sNewUrl = "sdbc:" + sNewUrl;
 117     else
 118     {
 119         sNewUrl = OUString::Concat("jdbc:mysql://") + sNewUrl.subView(5);
 120     }
 121     return sNewUrl;
 122 }
 123
 124 Reference<XDriver> lcl_loadDriver(const Reference<XComponentContext>& _rxContext,
 125                                   const OUString& _sUrl)
 126 {
 127     Reference<XDriverManager2> xDriverAccess = DriverManager::create(_rxContext);
 128     Reference<XDriver> xDriver = xDriverAccess->getDriverByURL(_sUrl);
 129     return xDriver;
 130 }
 131
 132 Sequence<PropertyValue> lcl_convertProperties(T_DRIVERTYPE _eType,
 133                                               const Sequence<PropertyValue>& info,
 134                                               const OUString& _sUrl)
 135 {
 136     std::vector<PropertyValue> aProps;
 137     const PropertyValue* pSupported = info.getConstArray();
 138     const PropertyValue* pEnd = pSupported + info.getLength();
 139
 140     aProps.reserve(info.getLength() + 5);
 141     bool jdc = false;
 142     for (; pSupported != pEnd; ++pSupported)
 143     {
 144         aProps.push_back(*pSupported);
 145         if (pSupported->Name == "JavaDriverClass")
 146         {
 147             jdc = true;
 148         }
 149     }
 150
 151     if (_eType == T_DRIVERTYPE::Odbc)
 152     {
 153         aProps.push_back(PropertyValue("Silent", 0, makeAny(true), PropertyState_DIRECT_VALUE));
 154         aProps.push_back(PropertyValue("PreventGetVersionColumns", 0, makeAny(true),
 155                                        PropertyState_DIRECT_VALUE));
 156     }
 157     else if (_eType == T_DRIVERTYPE::Jdbc)
 158     {
 159         if (!jdc)
 160         {
 161             aProps.push_back(PropertyValue("JavaDriverClass", 0,
 162                                            makeAny(OUString("com.mysql.jdbc.Driver")),
 163                                            PropertyState_DIRECT_VALUE));
 164         }
 165     }
 166     else
 167     {
 168         aProps.push_back(
 169             PropertyValue("PublicConnectionURL", 0, makeAny(_sUrl), PropertyState_DIRECT_VALUE));
 170     }
 171     aProps.push_back(
 172         PropertyValue("IsAutoRetrievingEnabled", 0, makeAny(true), PropertyState_DIRECT_VALUE));
 173     aProps.push_back(PropertyValue("AutoRetrievingStatement", 0,
 174                                    makeAny(OUString("SELECT LAST_INSERT_ID()")),
 175                                    PropertyState_DIRECT_VALUE));
 176     aProps.push_back(
 177         PropertyValue("ParameterNameSubstitution", 0, makeAny(true), PropertyState_DIRECT_VALUE));
 178     return Sequence<PropertyValue>(aProps.data(), aProps.size());
 179 }
 180 }
 181
 182 Reference<XDriver> ODriverDelegator::loadDriver(const OUString& url,
 183                                                 const Sequence<PropertyValue>& info)
 184 {
 185     Reference<XDriver> xDriver;
 186     const OUString sCuttedUrl = transformUrl(url);
 187     const T_DRIVERTYPE eType = lcl_getDriverType(url);
 188     if (eType == T_DRIVERTYPE::Odbc)
 189     {
 190         if (!m_xODBCDriver.is())
 191             m_xODBCDriver = lcl_loadDriver(m_xContext, sCuttedUrl);
 192         xDriver = m_xODBCDriver;
 193     } // if ( bIsODBC )
 194     else if (eType == T_DRIVERTYPE::Native)
 195     {
 196         if (!m_xNativeDriver.is())
 197             m_xNativeDriver = lcl_loadDriver(m_xContext, sCuttedUrl);
 198         xDriver = m_xNativeDriver;
 199     }
 200     else
 201     {
 202         OUString sDriverClass(getJavaDriverClass(info));
 203         TJDBCDrivers::iterator aFind = m_aJdbcDrivers.find(sDriverClass);
 204         if (aFind == m_aJdbcDrivers.end())
 205             aFind = m_aJdbcDrivers.emplace(sDriverClass, lcl_loadDriver(m_xContext, sCuttedUrl))
 206                         .first;
 207         xDriver = aFind->second;
 208     }
 209
 210     return xDriver;
 211 }
 212
 213 Reference<XConnection> SAL_CALL ODriverDelegator::connect(const OUString& url,
 214                                                           const Sequence<PropertyValue>& info)
 215 {
 216     Reference<XConnection> xConnection;
 217     if (acceptsURL(url))
 218     {
 219         Reference<XDriver> xDriver = loadDriver(url, info);
 220         if (xDriver.is())
 221         {
 222             OUString sCuttedUrl = transformUrl(url);
 223             const T_DRIVERTYPE eType = lcl_getDriverType(url);
 224             Sequence<PropertyValue> aConvertedProperties = lcl_convertProperties(eType, info, url);
 225             if (eType == T_DRIVERTYPE::Jdbc)
 226             {
 227                 ::comphelper::NamedValueCollection aSettings(info);
 228                 OUString sIanaName = aSettings.getOrDefault("CharSet", OUString());
 229                 if (!sIanaName.isEmpty())
 230                 {
 231                     ::dbtools::OCharsetMap aLookupIanaName;
 232                     ::dbtools::OCharsetMap::const_iterator aLookup
 233                         = aLookupIanaName.findIanaName(sIanaName);
 234                     if (aLookup != aLookupIanaName.end())
 235                     {
 236                         OUString sAdd;
 237                         if (RTL_TEXTENCODING_UTF8 == (*aLookup).getEncoding())
 238                         {
 239                             static constexpr OUStringLiteral s_sCharSetOp = u"useUnicode=true&";
 240                             if (!sCuttedUrl.matchIgnoreAsciiCase(s_sCharSetOp))
 241                             {
 242                                 sAdd = s_sCharSetOp;
 243                             } // if ( !sCuttedUrl.matchIgnoreAsciiCase(s_sCharSetOp) )
 244                         } // if ( RTL_TEXTENCODING_UTF8 == (*aLookup).getEncoding() )
 245                         if (sCuttedUrl.indexOf('?') == -1)
 246                             sCuttedUrl += "?";
 247                         else
 248                             sCuttedUrl += "&";
 249                         sCuttedUrl += sAdd + "characterEncoding=" + sIanaName;
 250                     }
 251                 }
 252             } // if ( !bIsODBC )
 253
 254             xConnection = xDriver->connect(sCuttedUrl, aConvertedProperties);
 255             if (xConnection.is())
 256             {
 257                 // now we have to set the URL to get the correct answer for metadata()->getURL()
 258                 auto pMetaConnection
 259                     = comphelper::getUnoTunnelImplementation<OMetaConnection>(xConnection);
 260                 if (pMetaConnection)
 261                     pMetaConnection->setURL(url);
 262                 m_aConnections.push_back(
 263                     TWeakPair(WeakReferenceHelper(xConnection),
 264                               TWeakConnectionPair(WeakReferenceHelper(), pMetaConnection)));
 265             }
 266         }
 267     }
 268     return xConnection;
 269 }
 270
 271 sal_Bool SAL_CALL ODriverDelegator::acceptsURL(const OUString& url)
 272 {
 273     Sequence<PropertyValue> info;
 274
 275     bool bOK = url.startsWith("sdbc:mysql:odbc:") || url.startsWith("sdbc:mysql:jdbc:")
 276                || (url.startsWith("sdbc:mysql:mysqlc:") && loadDriver(url, info).is());
 277     return bOK;
 278 }
 279
 280 Sequence<DriverPropertyInfo> SAL_CALL
 281 ODriverDelegator::getPropertyInfo(const OUString& url, const Sequence<PropertyValue>& info)
 282 {
 283     if (!acceptsURL(url))
 284         return Sequence<DriverPropertyInfo>();
 285
 286     Sequence<OUString> aBoolean{ "0", "1" };
 287
 288     std::vector<DriverPropertyInfo> aDriverInfo{
 289         { "CharSet", "CharSet of the database.", false, {}, {} },
 290         { "SuppressVersionColumns", "Display version columns (when available).", false, "0",
 291           aBoolean }
 292     };
 293     const T_DRIVERTYPE eType = lcl_getDriverType(url);
 294     if (eType == T_DRIVERTYPE::Jdbc)
 295     {
 296         aDriverInfo.push_back(DriverPropertyInfo("JavaDriverClass", "The JDBC driver class name.",
 297                                                  true, getJavaDriverClass(info),
 298                                                  Sequence<OUString>()));
 299     }
 300     else if (eType == T_DRIVERTYPE::Native)
 301     {
 302         aDriverInfo.push_back(DriverPropertyInfo(
 303             "LocalSocket", "The file path of a socket to connect to a local MySQL server.", false,
 304             OUString(), Sequence<OUString>()));
 305         aDriverInfo.push_back(DriverPropertyInfo(
 306             "NamedPipe", "The name of a pipe to connect to a local MySQL server.", false,
 307             OUString(), Sequence<OUString>()));
 308     }
 309
 310     return Sequence<DriverPropertyInfo>(aDriverInfo.data(), aDriverInfo.size());
 311 }
 312
 313 sal_Int32 SAL_CALL ODriverDelegator::getMajorVersion() { return 1; }
 314
 315 sal_Int32 SAL_CALL ODriverDelegator::getMinorVersion() { return 0; }
 316
 317 Reference<XTablesSupplier> SAL_CALL
 318 ODriverDelegator::getDataDefinitionByConnection(const Reference<XConnection>& connection)
 319 {
 320     ::osl::MutexGuard aGuard(m_aMutex);
 321     checkDisposed(ODriverDelegator_BASE::rBHelper.bDisposed);
 322
 323     Reference<XTablesSupplier> xTab;
 324     auto pConnection = comphelper::getUnoTunnelImplementation<OMetaConnection>(connection);
 325     if (pConnection)
 326     {
 327         TWeakPairVector::iterator i
 328             = std::find_if(m_aConnections.begin(), m_aConnections.end(),
 329                            [&pConnection](const TWeakPairVector::value_type& rConnection) {
 330                                return rConnection.second.second == pConnection;
 331                            });
 332         if (i != m_aConnections.end())
 333         {
 334             xTab.set(i->second.first.get(), UNO_QUERY);
 335             if (!xTab.is())
 336             {
 337                 xTab = new OMySQLCatalog(connection);
 338                 i->second.first = WeakReferenceHelper(xTab);
 339             }
 340         }
 341     } // if (pConnection)
 342     if (!xTab.is())
 343     {
 344         TWeakPairVector::iterator i
 345             = std::find_if(m_aConnections.begin(), m_aConnections.end(),
 346                            [&connection](const TWeakPairVector::value_type& rConnection) {
 347                                Reference<XConnection> xTemp(rConnection.first.get(), UNO_QUERY);
 348                                return xTemp == connection;
 349                            });
 350         if (i != m_aConnections.end())
 351         {
 352             xTab.set(i->second.first.get(), UNO_QUERY);
 353             if (!xTab.is())
 354             {
 355                 xTab = new OMySQLCatalog(connection);
 356                 i->second.first = WeakReferenceHelper(xTab);
 357             }
 358         }
 359     }
 360     return xTab;
 361 }
 362
 363 Reference<XTablesSupplier> SAL_CALL
 364 ODriverDelegator::getDataDefinitionByURL(const OUString& url, const Sequence<PropertyValue>& info)
 365 {
 366     if (!acceptsURL(url))
 367     {
 368         ::connectivity::SharedResources aResources;
 369         const OUString sMessage = aResources.getResourceString(STR_URI_SYNTAX_ERROR);
 370         ::dbtools::throwGenericSQLException(sMessage, *this);
 371     } // if ( ! acceptsURL(url) )
 372
 373     return getDataDefinitionByConnection(connect(url, info));
 374 }
 375
 376 // XServiceInfo
 377
 378 OUString SAL_CALL ODriverDelegator::getImplementationName()
 379 {
 380     return "org.openoffice.comp.drivers.MySQL.Driver";
 381 }
 382
 383 sal_Bool SAL_CALL ODriverDelegator::supportsService(const OUString& _rServiceName)
 384 {
 385     return cppu::supportsService(this, _rServiceName);
 386 }
 387
 388 Sequence<OUString> SAL_CALL ODriverDelegator::getSupportedServiceNames()
 389 {
 390     return { "com.sun.star.sdbc.Driver", "com.sun.star.sdbcx.Driver" };
 391 }
 392
 393 } // namespace connectivity
 394
 395 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 396 connectivity_mysql_ODriverDelegator_get_implementation(css::uno::XComponentContext* context,
 397                                                        css::uno::Sequence<css::uno::Any> const&)
 398 {
 399     try
 400     {
 401         return cppu::acquire(new connectivity::ODriverDelegator(context));
 402     }
 403     catch (...)
 404     {
 405         return nullptr;
 406     }
 407 }
 408
 409 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */