| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| #include "mysqlc_connection.hxx" |
| #include "mysqlc_databasemetadata.hxx" |
| |
| |
| #include "mysqlc_driver.hxx" |
| #include "mysqlc_statement.hxx" |
| #include "mysqlc_preparedstatement.hxx" |
| #include "mysqlc_general.hxx" |
| |
| #include <preextstl.h> |
| #include <cppconn/driver.h> |
| #include <cppconn/connection.h> |
| #include <cppconn/statement.h> |
| #include <cppconn/metadata.h> |
| #include <cppconn/exception.h> |
| #include <postextstl.h> |
| |
| #include <com/sun/star/sdbc/ColumnValue.hpp> |
| #include <com/sun/star/sdbc/XRow.hpp> |
| #include <com/sun/star/sdbc/TransactionIsolation.hpp> |
| #include <com/sun/star/lang/DisposedException.hpp> |
| #include <com/sun/star/beans/NamedValue.hpp> |
| |
| #include <osl/module.hxx> |
| #include <osl/thread.h> |
| #include <osl/file.h> |
| #include <rtl/uri.hxx> |
| #include <rtl/ustrbuf.hxx> |
| |
| using namespace connectivity::mysqlc; |
| |
| #include <stdio.h> |
| |
| //------------------------------------------------------------------------------ |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::container; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::sdbc; |
| using ::osl::MutexGuard; |
| using ::rtl::OUString; |
| |
| |
| #define MYSQLC_URI_PREFIX "sdbc:mysqlc:" |
| |
| |
| /* {{{ OConnection::OConnection() -I- */ |
| OConnection::OConnection(MysqlCDriver& _rDriver, sql::Driver * _cppDriver) |
| :OMetaConnection_BASE(m_aMutex) |
| ,OSubComponent<OConnection, OConnection_BASE>((::cppu::OWeakObject*)&_rDriver, this) |
| ,m_xMetaData(NULL) |
| ,m_rDriver(_rDriver) |
| ,cppDriver(_cppDriver) |
| ,m_bClosed(sal_False) |
| ,m_bUseCatalog(sal_False) |
| ,m_bUseOldDateFormat(sal_False) |
| { |
| OSL_TRACE("OConnection::OConnection"); |
| m_rDriver.acquire(); |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::OConnection() -I- */ |
| OConnection::~OConnection() |
| { |
| OSL_TRACE("OConnection::~OConnection"); |
| if (!isClosed()) { |
| close(); |
| } |
| m_rDriver.release(); |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::release() -I- */ |
| void SAL_CALL OConnection::release() |
| throw() |
| { |
| OSL_TRACE("OConnection::release"); |
| relase_ChildImpl(); |
| } |
| /* }}} */ |
| |
| #ifndef SYSTEM_MYSQL |
| extern "C" { void SAL_CALL thisModule() {} } |
| #endif |
| |
| /* {{{ OConnection::construct() -I- */ |
| void OConnection::construct(const OUString& url, const Sequence< PropertyValue >& info) |
| throw(SQLException) |
| { |
| OSL_TRACE("OConnection::construct"); |
| MutexGuard aGuard(m_aMutex); |
| |
| sal_Int32 nIndex; |
| sal_Bool bEmbedded = sal_False; |
| OUString token; |
| OUString aHostName(RTL_CONSTASCII_USTRINGPARAM("localhost")); |
| sal_Int32 nPort = 3306; |
| OUString aDbName; |
| |
| m_settings.encoding = m_rDriver.getDefaultEncoding(); |
| m_settings.quoteIdentifier = OUString(); |
| |
| // parse url. Url has the following format: |
| // external server: sdbc:mysqlc:[hostname]:[port]/[dbname] |
| |
| if (!url.compareTo(OUString::createFromAscii(MYSQLC_URI_PREFIX), sizeof(MYSQLC_URI_PREFIX)-1)) { |
| nIndex = 12; |
| } else { |
| bEmbedded = sal_True; |
| nIndex = 20; |
| mysqlc_sdbc_driver::throwFeatureNotImplementedException("OConnection::construct (embedded MySQL)", *this); |
| } |
| |
| token = url.getToken(0, '/', nIndex); |
| if (token.getLength()) { |
| sal_Int32 nIndex1 = 0; |
| OUString hostandport = token.getToken(0,':', nIndex1); |
| if (hostandport.getLength()) { |
| aHostName = hostandport; |
| hostandport = token.getToken(0, ':', nIndex1); |
| if (hostandport.getLength() && nIndex1) { |
| nPort = hostandport.toInt32(); |
| } |
| token = url.getToken(0, '/', nIndex); |
| if (token.getLength() && nIndex) { |
| aDbName = token; |
| } |
| } |
| } |
| |
| // get user and password for mysql connection |
| const PropertyValue *pIter = info.getConstArray(); |
| const PropertyValue *pEnd = pIter + info.getLength(); |
| OUString aUser, aPass, sUnixSocket, sNamedPipe; |
| bool unixSocketPassed = false; |
| bool namedPipePassed = false; |
| |
| m_settings.connectionURL = url; |
| for (;pIter != pEnd;++pIter) { |
| if (!pIter->Name.compareToAscii("user")) { |
| OSL_VERIFY( pIter->Value >>= aUser ); |
| } else if (!pIter->Name.compareToAscii("password")) { |
| OSL_VERIFY( pIter->Value >>= aPass ); |
| } else if (!pIter->Name.compareToAscii("LocalSocket")) { |
| OSL_VERIFY( pIter->Value >>= sUnixSocket ); |
| unixSocketPassed = true; |
| } else if (!pIter->Name.compareToAscii("NamedPipe")) { |
| OSL_VERIFY( pIter->Value >>= sNamedPipe ); |
| namedPipePassed = true; |
| } else if ( !pIter->Name.compareToAscii("PublicConnectionURL")) { |
| OSL_VERIFY( pIter->Value >>= m_settings.connectionURL ); |
| } else if ( !pIter->Name.compareToAscii("NewURL")) { // legacy name for "PublicConnectionURL" |
| OSL_VERIFY( pIter->Value >>= m_settings.connectionURL ); |
| } |
| } |
| |
| if (bEmbedded == sal_False) { |
| try { |
| sql::ConnectOptionsMap connProps; |
| ext_std::string host_str = OUStringToOString(aHostName, m_settings.encoding).getStr(); |
| ext_std::string user_str = OUStringToOString(aUser, m_settings.encoding).getStr(); |
| ext_std::string pass_str = OUStringToOString(aPass, m_settings.encoding).getStr(); |
| ext_std::string schema_str = OUStringToOString(aDbName, m_settings.encoding).getStr(); |
| connProps["hostName"] = sql::ConnectPropertyVal(host_str); |
| connProps["userName"] = sql::ConnectPropertyVal(user_str); |
| connProps["password"] = sql::ConnectPropertyVal(pass_str); |
| connProps["schema"] = sql::ConnectPropertyVal(schema_str); |
| connProps["port"] = sql::ConnectPropertyVal((int)(nPort)); |
| if (unixSocketPassed) { |
| sql::SQLString socket_str = OUStringToOString(sUnixSocket, m_settings.encoding).getStr(); |
| connProps["socket"] = socket_str; |
| } else if (namedPipePassed) { |
| sql::SQLString pipe_str = OUStringToOString(sNamedPipe, m_settings.encoding).getStr(); |
| connProps["socket"] = pipe_str; |
| } |
| |
| #ifndef SYSTEM_MYSQL |
| ::rtl::OUString sMySQLClientLib( RTL_CONSTASCII_USTRINGPARAM( MYSQL_LIB ) ); |
| |
| ::rtl::OUString moduleBase; |
| OSL_VERIFY( ::osl::Module::getUrlFromAddress( &thisModule, moduleBase ) ); |
| ::rtl::OUString sMySQLClientLibURL; |
| try |
| { |
| sMySQLClientLibURL = ::rtl::Uri::convertRelToAbs( moduleBase, sMySQLClientLib.pData ); |
| } |
| catch ( const ::rtl::MalformedUriException& e ) |
| { |
| (void)e; // silence compiler |
| #if OSL_DEBUG_LEVEL > 0 |
| ::rtl::OString sMessage( "OConnection::construct: malformed URI: " ); |
| sMessage += ::rtl::OUStringToOString( e.getMessage(), osl_getThreadTextEncoding() ); |
| OSL_ENSURE( false, sMessage.getStr() ); |
| #endif |
| } |
| |
| ::rtl::OUString sMySQLClientLibPath; |
| osl_getSystemPathFromFileURL( sMySQLClientLibURL.pData, &sMySQLClientLibPath.pData ); |
| |
| sql::SQLString mysqlLib = ::rtl::OUStringToOString( sMySQLClientLibPath, osl_getThreadTextEncoding() ).getStr(); |
| connProps["clientlib"] = mysqlLib; |
| |
| OSL_TRACE("clientlib=%s", mysqlLib.c_str()); |
| #endif |
| |
| OSL_TRACE("hostName=%s", host_str.c_str()); |
| OSL_TRACE("port=%i", int(nPort)); |
| OSL_TRACE("userName=%s", user_str.c_str()); |
| OSL_TRACE("password=%s", pass_str.c_str()); |
| OSL_TRACE("schema=%s", schema_str.c_str()); |
| |
| m_settings.cppConnection.reset(cppDriver->connect(connProps)); |
| } catch (sql::SQLException &e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| } else { |
| // TODO: support for embedded server |
| } |
| |
| m_settings.schema = aDbName; |
| OSL_TRACE(OUStringToOString(m_settings.schema, getConnectionEncoding()).getStr()); |
| |
| // Check if the server is 4.1 or above |
| if (this->getMysqlVersion() < 40100) { |
| throw SQLException( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MySQL Connector/OO.org requires MySQL Server 4.1 or above" ) ), |
| *this, |
| ::rtl::OUString(), |
| 0, |
| Any()); |
| } |
| std::auto_ptr<sql::Statement> stmt(m_settings.cppConnection->createStatement()); |
| stmt->executeUpdate("SET session sql_mode='ANSI_QUOTES'"); |
| stmt->executeUpdate("SET NAMES utf8"); |
| } |
| /* }}} */ |
| |
| |
| // XServiceInfo |
| IMPLEMENT_SERVICE_INFO(OConnection, "com.sun.star.sdbc.drivers.mysqlc.OConnection", "com.sun.star.sdbc.Connection") |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| Reference< XStatement > SAL_CALL OConnection::createStatement() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::createStatement"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| // create a statement |
| Reference< XStatement > xReturn; |
| // the statement can only be executed once |
| try { |
| xReturn = new OStatement(this, m_settings.cppConnection->createStatement()); |
| m_aStatements.push_back(WeakReferenceHelper(xReturn)); |
| return xReturn; |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| return xReturn; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| Reference< XPreparedStatement > SAL_CALL OConnection::prepareStatement(const OUString& _sSql) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::prepareStatement"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| const ::rtl::OUString sSqlStatement = transFormPreparedStatement( _sSql ); |
| |
| Reference< XPreparedStatement > xStatement; |
| try { |
| // create a statement |
| // the statement can only be executed more than once |
| xStatement = new OPreparedStatement(this, |
| m_settings.cppConnection->prepareStatement(OUStringToOString(sSqlStatement, getConnectionEncoding()).getStr())); |
| m_aStatements.push_back( WeakReferenceHelper( xStatement ) ); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| return xStatement; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::prepareCall() -U- */ |
| Reference< XPreparedStatement > SAL_CALL OConnection::prepareCall(const OUString& /*_sSql*/ ) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::prepareCall"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| mysqlc_sdbc_driver::throwFeatureNotImplementedException("OConnection::prepareCall", *this); |
| return Reference< XPreparedStatement >(); |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::nativeSQL() -I- */ |
| OUString SAL_CALL OConnection::nativeSQL(const OUString& _sSql) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::nativeSQL"); |
| MutexGuard aGuard(m_aMutex); |
| |
| const ::rtl::OUString sSqlStatement = transFormPreparedStatement( _sSql ); |
| ::rtl::OUString sNativeSQL; |
| try { |
| sNativeSQL = mysqlc_sdbc_driver::convert(m_settings.cppConnection->nativeSQL(mysqlc_sdbc_driver::convert(sSqlStatement, getConnectionEncoding())), |
| getConnectionEncoding()); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| return sNativeSQL; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::setAutoCommit() -I- */ |
| void SAL_CALL OConnection::setAutoCommit(sal_Bool autoCommit) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::setAutoCommit"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| try { |
| m_settings.cppConnection->setAutoCommit(autoCommit == sal_True? true:false); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::getAutoCommit() -I- */ |
| sal_Bool SAL_CALL OConnection::getAutoCommit() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::getAutoCommit"); |
| // you have to distinguish which if you are in autocommit mode or not |
| // at normal case true should be fine here |
| |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| sal_Bool autoCommit = sal_False; |
| try { |
| autoCommit = m_settings.cppConnection->getAutoCommit() == true ? sal_True : sal_False; |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| return autoCommit; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::commit() -I- */ |
| void SAL_CALL OConnection::commit() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::commit"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| try { |
| m_settings.cppConnection->commit(); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::rollback() -I- */ |
| void SAL_CALL OConnection::rollback() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::rollback"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| try { |
| m_settings.cppConnection->rollback(); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::isClosed() -I- */ |
| sal_Bool SAL_CALL OConnection::isClosed() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::isClosed"); |
| MutexGuard aGuard(m_aMutex); |
| |
| // just simple -> we are close when we are disposed taht means someone called dispose(); (XComponent) |
| return (OConnection_BASE::rBHelper.bDisposed); |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| Reference< XDatabaseMetaData > SAL_CALL OConnection::getMetaData() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::getMetaData"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| Reference< XDatabaseMetaData > xMetaData = m_xMetaData; |
| if (!xMetaData.is()) { |
| try { |
| xMetaData = new ODatabaseMetaData(*this); // need the connection because it can return it |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| m_xMetaData = xMetaData; |
| } |
| |
| return xMetaData; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| void SAL_CALL OConnection::setReadOnly(sal_Bool readOnly) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::setReadOnly"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| m_settings.readOnly = readOnly; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| sal_Bool SAL_CALL OConnection::isReadOnly() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::isReadOnly"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| // return if your connection to readonly |
| return (m_settings.readOnly); |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| void SAL_CALL OConnection::setCatalog(const OUString& catalog) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::setCatalog"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| try { |
| // m_settings.cppConnection->setCatalog(OUStringToOString(catalog, m_settings.encoding).getStr()); |
| m_settings.cppConnection->setSchema(OUStringToOString(catalog, getConnectionEncoding()).getStr()); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| OUString SAL_CALL OConnection::getCatalog() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::getCatalog"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| OUString catalog; |
| try { |
| catalog = mysqlc_sdbc_driver::convert(m_settings.cppConnection->getSchema(), getConnectionEncoding()); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| return catalog; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| void SAL_CALL OConnection::setTransactionIsolation(sal_Int32 level) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::setTransactionIsolation"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| sql::enum_transaction_isolation cpplevel = sql::TRANSACTION_SERIALIZABLE; |
| |
| switch (level) { |
| case TransactionIsolation::READ_UNCOMMITTED: |
| cpplevel = sql::TRANSACTION_READ_UNCOMMITTED; |
| break; |
| case TransactionIsolation::READ_COMMITTED: |
| cpplevel = sql::TRANSACTION_READ_COMMITTED; |
| break; |
| case TransactionIsolation::REPEATABLE_READ: |
| cpplevel = sql::TRANSACTION_REPEATABLE_READ; |
| break; |
| case TransactionIsolation::SERIALIZABLE: |
| cpplevel = sql::TRANSACTION_SERIALIZABLE; |
| break; |
| case TransactionIsolation::NONE: |
| cpplevel = sql::TRANSACTION_SERIALIZABLE; |
| break; |
| default:; |
| /* XXX: Exception ?? */ |
| } |
| try { |
| m_settings.cppConnection->setTransactionIsolation(cpplevel); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::createStatement() -I- */ |
| sal_Int32 SAL_CALL OConnection::getTransactionIsolation() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::getTransactionIsolation"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| try { |
| switch (m_settings.cppConnection->getTransactionIsolation()) { |
| case sql::TRANSACTION_SERIALIZABLE: return TransactionIsolation::SERIALIZABLE; |
| case sql::TRANSACTION_REPEATABLE_READ: return TransactionIsolation::REPEATABLE_READ; |
| case sql::TRANSACTION_READ_COMMITTED: return TransactionIsolation::READ_COMMITTED; |
| case sql::TRANSACTION_READ_UNCOMMITTED: return TransactionIsolation::READ_UNCOMMITTED; |
| default: |
| ; |
| } |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| return TransactionIsolation::NONE; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::getTypeMap() -I- */ |
| Reference<XNameAccess> SAL_CALL OConnection::getTypeMap() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::getTypeMap"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| Reference<XNameAccess > t; |
| { |
| t = m_typeMap; |
| } |
| return (t); |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::setTypeMap() -I- */ |
| void SAL_CALL OConnection::setTypeMap(const Reference<XNameAccess >& typeMap) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::setTypeMap"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| m_typeMap = typeMap; |
| } |
| /* }}} */ |
| |
| |
| // XCloseable |
| /* {{{ OConnection::close() -I- */ |
| void SAL_CALL OConnection::close() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::close"); |
| /* |
| we need block, because the mutex is a local variable, |
| which will guard the block |
| */ |
| { |
| // we just dispose us |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| } |
| dispose(); |
| } |
| /* }}} */ |
| |
| |
| // XWarningsSupplier |
| /* {{{ OConnection::getWarnings() -I- */ |
| Any SAL_CALL OConnection::getWarnings() |
| throw(SQLException, RuntimeException) |
| { |
| Any x = Any(); |
| OSL_TRACE("OConnection::getWarnings"); |
| // when you collected some warnings -> return it |
| return x; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::clearWarnings() -I- */ |
| void SAL_CALL OConnection::clearWarnings() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::clearWarnings"); |
| // you should clear your collected warnings here# |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::buildTypeInfo() -I- */ |
| void OConnection::buildTypeInfo() |
| throw(SQLException) |
| { |
| OSL_TRACE("OConnection::buildTypeInfo"); |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::disposing() -I- */ |
| void OConnection::disposing() |
| { |
| OSL_TRACE("OConnection::disposing"); |
| // we noticed that we should be destroied in near future so we have to dispose our statements |
| MutexGuard aGuard(m_aMutex); |
| |
| for (OWeakRefArray::iterator i = m_aStatements.begin(); i != m_aStatements.end() ; ++i) { |
| Reference< XComponent > xComp(i->get(), UNO_QUERY); |
| if (xComp.is()) { |
| xComp->dispose(); |
| } |
| } |
| m_aStatements.clear(); |
| |
| m_bClosed = sal_True; |
| m_xMetaData = WeakReference< XDatabaseMetaData >(); |
| |
| dispose_ChildImpl(); |
| OConnection_BASE::disposing(); |
| } |
| /* }}} */ |
| |
| |
| /* ToDo - upcast the connection to MySQL_Connection and use ::getSessionVariable() */ |
| |
| /* {{{ OConnection::getMysqlVariable() -I- */ |
| OUString OConnection::getMysqlVariable(const char *varname) |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::getMysqlVariable"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| OUString ret; |
| ::rtl::OUStringBuffer aStatement; |
| aStatement.appendAscii( "SHOW SESSION VARIABLES LIKE '" ); |
| aStatement.appendAscii( varname ); |
| aStatement.append( sal_Unicode( '\'' ) ); |
| |
| try { |
| XStatement * stmt = new OStatement(this, m_settings.cppConnection->createStatement()); |
| Reference< XResultSet > rs = stmt->executeQuery( aStatement.makeStringAndClear() ); |
| if (rs.is() && rs->next()) { |
| Reference< XRow > xRow(rs, UNO_QUERY); |
| ret = xRow->getString(2); |
| } |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| |
| return ret; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::getMysqlVersion() -I- */ |
| sal_Int32 OConnection::getMysqlVersion() |
| throw(SQLException, RuntimeException) |
| { |
| OSL_TRACE("OConnection::getMysqlVersion"); |
| MutexGuard aGuard(m_aMutex); |
| checkDisposed(OConnection_BASE::rBHelper.bDisposed); |
| |
| sal_Int32 version(0); |
| try { |
| version = 10000 * m_settings.cppConnection->getMetaData()->getDatabaseMajorVersion(); |
| version += 100 * m_settings.cppConnection->getMetaData()->getDatabaseMinorVersion(); |
| version += m_settings.cppConnection->getMetaData()->getDatabasePatchVersion(); |
| } catch (sql::SQLException & e) { |
| mysqlc_sdbc_driver::translateAndThrow(e, *this, getConnectionEncoding()); |
| } |
| return version; |
| } |
| /* }}} */ |
| |
| |
| /* {{{ OConnection::sdbcColumnType() -I- */ |
| // TODO: Not used |
| //sal_Int32 OConnection::sdbcColumnType(OUString typeName) |
| //{ |
| // OSL_TRACE("OConnection::sdbcColumnType"); |
| // int i = 0; |
| // while (mysqlc_types[i].typeName) { |
| // if (OUString::createFromAscii(mysqlc_types[i].typeName).equals( |
| // typeName.toAsciiUpperCase())) |
| // { |
| // return mysqlc_types[i].dataType; |
| // } |
| // i++; |
| // } |
| // return 0; |
| //} |
| // ----------------------------------------------------------------------------- |
| ::rtl::OUString OConnection::transFormPreparedStatement(const ::rtl::OUString& _sSQL) |
| { |
| ::rtl::OUString sSqlStatement = _sSQL; |
| if ( !m_xParameterSubstitution.is() ) { |
| try { |
| Sequence< Any > aArgs(1); |
| Reference< XConnection> xCon = this; |
| aArgs[0] <<= NamedValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ActiveConnection")), makeAny(xCon)); |
| |
| m_xParameterSubstitution.set(m_rDriver.getFactory()->createInstanceWithArguments(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("org.openoffice.comp.helper.ParameterSubstitution")),aArgs),UNO_QUERY); |
| } catch(const Exception&) {} |
| } |
| if ( m_xParameterSubstitution.is() ) { |
| try { |
| sSqlStatement = m_xParameterSubstitution->substituteVariables(sSqlStatement,sal_True); |
| } catch(const Exception&) { } |
| } |
| return sSqlStatement; |
| } |
| |
| /* }}} */ |
| |
| /* |
| * Local variables: |
| * tab-width: 4 |
| * c-basic-offset: 4 |
| * End: |
| * vim600: noet sw=4 ts=4 fdm=marker |
| * vim<600: noet sw=4 ts=4 |
| */ |