connectivity/source/drivers/mysqlc/mysqlc_connection.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 "mysqlc_connection.hxx"
  21 #include "mysqlc_databasemetadata.hxx"
  22
  23 #include "mysqlc_driver.hxx"
  24 #include "mysqlc_statement.hxx"
  25 #include "mysqlc_preparedstatement.hxx"
  26 #include "mysqlc_general.hxx"
  27
  28 #include <com/sun/star/beans/NamedValue.hpp>
  29
  30 #include <osl/diagnose.h>
  31 #include <cppuhelper/supportsservice.hxx>
  32
  33 using namespace connectivity::mysqlc;
  34
  35 using namespace com::sun::star::uno;
  36 using namespace com::sun::star::container;
  37 using namespace com::sun::star::lang;
  38 using namespace com::sun::star::beans;
  39 using namespace com::sun::star::sdbc;
  40 using ::osl::MutexGuard;
  41
  42 #define MYSQLC_URI_PREFIX "sdbc:mysqlc:"
  43
  44 namespace
  45 {
  46 void lcl_executeUpdate(MYSQL* pMySql, const OString& sql)
  47 {
  48     mysql_real_query(pMySql, sql.getStr(), sql.getLength());
  49     // TODO handle error
  50 }
  51 }
  52
  53 OConnection::OConnection(MysqlCDriver& _rDriver)
  54     : OMetaConnection_BASE(m_aMutex)
  55     , m_mysql()
  56     , m_xMetaData(nullptr)
  57     , m_xDriver(&_rDriver)
  58 {
  59 }
  60
  61 OConnection::~OConnection()
  62 {
  63     if (!isClosed())
  64     {
  65         close();
  66     }
  67 }
  68
  69 void OConnection::construct(const OUString& url, const Sequence<PropertyValue>& info)
  70 {
  71     MutexGuard aGuard(m_aMutex);
  72
  73     mysql_library_init(0, nullptr, nullptr);
  74     mysql_init(&m_mysql);
  75
  76     // use TCP as connection
  77     mysql_protocol_type protocol = MYSQL_PROTOCOL_TCP;
  78     mysql_options(&m_mysql, MYSQL_OPT_PROTOCOL, &protocol);
  79     OString charset_name{ "utf8mb4" };
  80     mysql_options(&m_mysql, MYSQL_SET_CHARSET_NAME, charset_name.getStr());
  81
  82     sal_Int32 nIndex;
  83     OUString token;
  84     OUString aHostName("localhost");
  85     sal_Int32 nPort = 3306;
  86     OUString aDbName;
  87
  88     m_settings.encoding = MysqlCDriver::getDefaultEncoding();
  89
  90     // parse url. Url has the following format:
  91     // external server: sdbc:mysqlc:[hostname]:[port]/[dbname]
  92
  93     if (url.startsWith(MYSQLC_URI_PREFIX))
  94     {
  95         nIndex = 12;
  96     }
  97     else
  98     {
  99         // sdbc:mysql:mysqlc:[hostname]:[port]/[dbname]
 100         nIndex = 18;
 101     }
 102
 103     token = url.getToken(0, '/', nIndex);
 104     if (!token.isEmpty())
 105     {
 106         sal_Int32 nIndex1 = 0;
 107         OUString hostandport = token.getToken(0, ':', nIndex1);
 108         if (!hostandport.isEmpty())
 109         {
 110             aHostName = hostandport;
 111             hostandport = token.getToken(0, ':', nIndex1);
 112             if (!hostandport.isEmpty() && nIndex1)
 113             {
 114                 nPort = hostandport.toInt32();
 115             }
 116             token = url.getToken(0, '/', nIndex);
 117             if (!token.isEmpty() && nIndex)
 118             {
 119                 aDbName = token;
 120             }
 121         }
 122     }
 123
 124     // get user and password for mysql connection
 125     const PropertyValue* pIter = info.getConstArray();
 126     const PropertyValue* pEnd = pIter + info.getLength();
 127     OUString aUser, aPass, sUnixSocket, sNamedPipe;
 128     bool unixSocketPassed = false;
 129     bool namedPipePassed = false;
 130
 131     m_settings.connectionURL = url;
 132     for (; pIter != pEnd; ++pIter)
 133     {
 134         if (pIter->Name == "user")
 135         {
 136             OSL_VERIFY(pIter->Value >>= aUser);
 137         }
 138         else if (pIter->Name == "password")
 139         {
 140             OSL_VERIFY(pIter->Value >>= aPass);
 141         }
 142         else if (pIter->Name == "LocalSocket")
 143         {
 144             OSL_VERIFY(pIter->Value >>= sUnixSocket);
 145             unixSocketPassed = !sUnixSocket.isEmpty();
 146         }
 147         else if (pIter->Name == "NamedPipe")
 148         {
 149             OSL_VERIFY(pIter->Value >>= sNamedPipe);
 150             namedPipePassed = !sNamedPipe.isEmpty();
 151         }
 152         else if (pIter->Name == "PublicConnectionURL")
 153         {
 154             OSL_VERIFY(pIter->Value >>= m_settings.connectionURL);
 155         }
 156         else if (pIter->Name == "NewURL")
 157         { // legacy name for "PublicConnectionURL"
 158             OSL_VERIFY(pIter->Value >>= m_settings.connectionURL);
 159         }
 160     }
 161
 162     OString host_str = OUStringToOString(aHostName, m_settings.encoding);
 163     OString user_str = OUStringToOString(aUser, m_settings.encoding);
 164     OString pass_str = OUStringToOString(aPass, m_settings.encoding);
 165     OString schema_str = OUStringToOString(aDbName, m_settings.encoding);
 166     OString socket_str;
 167     if (unixSocketPassed)
 168     {
 169         socket_str = OUStringToOString(sUnixSocket, m_settings.encoding);
 170     }
 171     else if (namedPipePassed)
 172     {
 173         socket_str = OUStringToOString(sNamedPipe, m_settings.encoding);
 174     }
 175
 176     // flags can also be passed as last parameter
 177     if (!mysql_real_connect(&m_mysql, host_str.getStr(), user_str.getStr(), pass_str.getStr(),
 178                             schema_str.getStr(), nPort, socket_str.getStr(),
 179                             CLIENT_MULTI_STATEMENTS))
 180         mysqlc_sdbc_driver::throwSQLExceptionWithMsg(
 181             mysql_error(&m_mysql), mysql_sqlstate(&m_mysql), mysql_errno(&m_mysql), *this,
 182             getConnectionEncoding());
 183
 184     // Check if the server is 4.1 or above
 185     if (getMysqlVersion() < 40100)
 186     {
 187         throw SQLException("MariaDB LibreOffice Connector requires MySQL Server 4.1 or above",
 188                            *this, OUString(), 0, Any());
 189     }
 190
 191     lcl_executeUpdate(&m_mysql,
 192                       OString{ "SET session sql_mode='ANSI_QUOTES,NO_AUTO_VALUE_ON_ZERO'" });
 193     lcl_executeUpdate(&m_mysql, OString{ "SET NAMES utf8mb4" });
 194 }
 195
 196 OUString OConnection::getImplementationName()
 197 {
 198     return "com.sun.star.sdbc.drivers.mysqlc.OConnection";
 199 }
 200
 201 css::uno::Sequence<OUString> OConnection::getSupportedServiceNames()
 202 {
 203     return { "com.sun.star.sdbc.Connection" };
 204 }
 205
 206 sal_Bool OConnection::supportsService(OUString const& ServiceName)
 207 {
 208     return cppu::supportsService(this, ServiceName);
 209 }
 210
 211 Reference<XStatement> SAL_CALL OConnection::createStatement()
 212 {
 213     MutexGuard aGuard(m_aMutex);
 214     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 215
 216     // create a statement
 217     // the statement can only be executed once
 218     Reference<XStatement> xReturn = new OStatement(this);
 219     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 220
 221     return xReturn;
 222 }
 223
 224 Reference<XPreparedStatement> SAL_CALL OConnection::prepareStatement(const OUString& _sSql)
 225 {
 226     MutexGuard aGuard(m_aMutex);
 227     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 228     const OString sSqlStatement
 229         = OUStringToOString(_sSql, getConnectionEncoding()); // FIXME transform statement ?
 230
 231     MYSQL_STMT* pStmt = mysql_stmt_init(&m_mysql);
 232     mysql_stmt_prepare(pStmt, sSqlStatement.getStr(), sSqlStatement.getLength());
 233
 234     unsigned int nErrorNum = mysql_errno(&m_mysql);
 235     if (nErrorNum != 0)
 236         mysqlc_sdbc_driver::throwSQLExceptionWithMsg(mysql_error(&m_mysql),
 237                                                      mysql_sqlstate(&m_mysql), nErrorNum, *this,
 238                                                      getConnectionEncoding());
 239
 240     Reference<XPreparedStatement> xStatement = new OPreparedStatement(this, pStmt);
 241     m_aStatements.push_back(WeakReferenceHelper(xStatement));
 242     return xStatement;
 243 }
 244
 245 Reference<XPreparedStatement> SAL_CALL OConnection::prepareCall(const OUString& /*_sSql*/)
 246 {
 247     MutexGuard aGuard(m_aMutex);
 248     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 249
 250     mysqlc_sdbc_driver::throwFeatureNotImplementedException("OConnection::prepareCall", *this);
 251     return Reference<XPreparedStatement>();
 252 }
 253
 254 OUString SAL_CALL OConnection::nativeSQL(const OUString& /*_sSql*/)
 255 {
 256     MutexGuard aGuard(m_aMutex);
 257
 258     // const OUString sSqlStatement = transFormPreparedStatement( _sSql );
 259     // TODO
 260     return OUString();
 261 }
 262
 263 void SAL_CALL OConnection::setAutoCommit(sal_Bool autoCommit)
 264 {
 265     MutexGuard aGuard(m_aMutex);
 266     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 267     if (!mysql_autocommit(&m_mysql, autoCommit))
 268         mysqlc_sdbc_driver::throwSQLExceptionWithMsg(
 269             mysql_error(&m_mysql), mysql_sqlstate(&m_mysql), mysql_errno(&m_mysql), *this,
 270             getConnectionEncoding());
 271 }
 272
 273 sal_Bool SAL_CALL OConnection::getAutoCommit()
 274 {
 275     // you have to distinguish which if you are in autocommit mode or not
 276     // at normal case true should be fine here
 277
 278     // TODO use SELECT @@autocommit query for that
 279     MutexGuard aGuard(m_aMutex);
 280     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 281
 282     return false;
 283 }
 284
 285 void SAL_CALL OConnection::commit()
 286 {
 287     MutexGuard aGuard(m_aMutex);
 288     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 289
 290     if (!mysql_commit(&m_mysql))
 291         mysqlc_sdbc_driver::throwSQLExceptionWithMsg(
 292             mysql_error(&m_mysql), mysql_sqlstate(&m_mysql), mysql_errno(&m_mysql), *this,
 293             getConnectionEncoding());
 294 }
 295
 296 void SAL_CALL OConnection::rollback()
 297 {
 298     MutexGuard aGuard(m_aMutex);
 299     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 300
 301     if (!mysql_rollback(&m_mysql))
 302         mysqlc_sdbc_driver::throwSQLExceptionWithMsg(
 303             mysql_error(&m_mysql), mysql_sqlstate(&m_mysql), mysql_errno(&m_mysql), *this,
 304             getConnectionEncoding());
 305 }
 306
 307 sal_Bool SAL_CALL OConnection::isClosed()
 308 {
 309     MutexGuard aGuard(m_aMutex);
 310
 311     // just simple -> we are close when we are disposed that means someone called dispose(); (XComponent)
 312     return OConnection_BASE::rBHelper.bDisposed;
 313 }
 314
 315 Reference<XDatabaseMetaData> SAL_CALL OConnection::getMetaData()
 316 {
 317     MutexGuard aGuard(m_aMutex);
 318     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 319
 320     Reference<XDatabaseMetaData> xMetaData = m_xMetaData;
 321     if (!xMetaData.is())
 322     {
 323         xMetaData = new ODatabaseMetaData(*this, &m_mysql);
 324         m_xMetaData = xMetaData;
 325     }
 326
 327     return xMetaData;
 328 }
 329
 330 void SAL_CALL OConnection::setReadOnly(sal_Bool readOnly)
 331 {
 332     MutexGuard aGuard(m_aMutex);
 333     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 334
 335     m_settings.readOnly = readOnly;
 336 }
 337
 338 sal_Bool SAL_CALL OConnection::isReadOnly()
 339 {
 340     MutexGuard aGuard(m_aMutex);
 341     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 342
 343     // return if your connection to readonly
 344     return m_settings.readOnly;
 345 }
 346
 347 void SAL_CALL OConnection::setCatalog(const OUString& /*catalog*/)
 348 {
 349     MutexGuard aGuard(m_aMutex);
 350     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 351
 352     // TODO How?
 353 }
 354
 355 OUString SAL_CALL OConnection::getCatalog()
 356 {
 357     MutexGuard aGuard(m_aMutex);
 358     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 359
 360     // TODO How?
 361     return OUString{};
 362 }
 363
 364 void SAL_CALL OConnection::setTransactionIsolation(sal_Int32 /*level*/)
 365 {
 366     MutexGuard aGuard(m_aMutex);
 367     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 368
 369     // TODO
 370 }
 371
 372 sal_Int32 SAL_CALL OConnection::getTransactionIsolation()
 373 {
 374     MutexGuard aGuard(m_aMutex);
 375     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 376
 377     return 0; // TODO
 378 }
 379
 380 Reference<XNameAccess> SAL_CALL OConnection::getTypeMap()
 381 {
 382     MutexGuard aGuard(m_aMutex);
 383     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 384
 385     Reference<XNameAccess> t = m_typeMap;
 386     return t;
 387 }
 388
 389 void SAL_CALL OConnection::setTypeMap(const Reference<XNameAccess>& typeMap)
 390 {
 391     MutexGuard aGuard(m_aMutex);
 392     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 393
 394     m_typeMap = typeMap;
 395 }
 396
 397 // XCloseable
 398 void SAL_CALL OConnection::close()
 399 {
 400     /*
 401       we need block, because the mutex is a local variable,
 402       which will guard the block
 403     */
 404     {
 405         // we just dispose us
 406         MutexGuard aGuard(m_aMutex);
 407         checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 408     }
 409     mysql_close(&m_mysql);
 410     mysql_library_end();
 411     dispose();
 412 }
 413
 414 // XWarningsSupplier
 415 Any SAL_CALL OConnection::getWarnings()
 416 {
 417     Any x;
 418     // when you collected some warnings -> return it
 419     return x;
 420 }
 421
 422 void SAL_CALL OConnection::clearWarnings()
 423 {
 424     // you should clear your collected warnings here#
 425 }
 426
 427 void OConnection::disposing()
 428 {
 429     // we noticed that we should be destroyed in near future so we have to dispose our statements
 430     MutexGuard aGuard(m_aMutex);
 431
 432     for (auto const& statement : m_aStatements)
 433     {
 434         Reference<XComponent> xComp(statement.get(), UNO_QUERY);
 435         if (xComp.is())
 436         {
 437             xComp->dispose();
 438         }
 439     }
 440     m_aStatements.clear();
 441
 442     m_xMetaData = WeakReference<XDatabaseMetaData>();
 443
 444     OConnection_BASE::disposing();
 445 }
 446
 447 sal_Int32 OConnection::getMysqlVersion()
 448 {
 449     MutexGuard aGuard(m_aMutex);
 450     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 451
 452     unsigned long version = mysql_get_server_version(&m_mysql);
 453     return static_cast<sal_Int32>(version);
 454 }
 455
 456 OUString OConnection::transFormPreparedStatement(const OUString& _sSQL)
 457 {
 458     OUString sSqlStatement = _sSQL;
 459     if (!m_xParameterSubstitution.is())
 460     {
 461         try
 462         {
 463             Sequence<Any> aArgs(1);
 464             Reference<XConnection> xCon = this;
 465             aArgs[0] <<= NamedValue("ActiveConnection", makeAny(xCon));
 466
 467             m_xParameterSubstitution.set(
 468                 m_xDriver->getFactory()->createInstanceWithArguments(
 469                     "org.openoffice.comp.helper.ParameterSubstitution", aArgs),
 470                 UNO_QUERY);
 471         }
 472         catch (const Exception&)
 473         {
 474         }
 475     }
 476     if (m_xParameterSubstitution.is())
 477     {
 478         try
 479         {
 480             sSqlStatement = m_xParameterSubstitution->substituteVariables(sSqlStatement, true);
 481         }
 482         catch (const Exception&)
 483         {
 484         }
 485     }
 486     return sSqlStatement;
 487 }
 488
 489 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */