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