diff options
Diffstat (limited to 'connectivity/source/drivers/mork')
36 files changed, 7974 insertions, 0 deletions
diff --git a/connectivity/source/drivers/mork/MCatalog.cxx b/connectivity/source/drivers/mork/MCatalog.cxx new file mode 100644 index 000000000..743d1e5ab --- /dev/null +++ b/connectivity/source/drivers/mork/MCatalog.cxx @@ -0,0 +1,104 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include "MCatalog.hxx" +#include "MConnection.hxx" +#include "MTables.hxx" + +#include <com/sun/star/sdbc/XRow.hpp> + + +using namespace connectivity::mork; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::container; + + +OCatalog::OCatalog(OConnection* _pCon) : connectivity::sdbcx::OCatalog(_pCon) + ,m_pConnection(_pCon) +{ +// osl_atomic_increment( &m_refCount ); +// refreshTables(); +// refreshViews(); +// refreshGroups(); +// refreshUsers(); +// osl_atomic_decrement( &m_refCount ); +} + +void OCatalog::refreshTables() +{ + ::std::vector< OUString> aVector; + Sequence< OUString > aTypes { "%" }; + Reference< XResultSet > xResult = m_xMetaData->getTables(Any(), + "%", "%", aTypes); + + if(xResult.is()) + { + Reference< XRow > xRow(xResult,UNO_QUERY); + OUString aName; + while(xResult->next()) + { + aName = xRow->getString(3); + aVector.push_back(aName); + } + } + if(m_pTables) + m_pTables->reFill(aVector); + else + m_pTables.reset( new OTables(m_xMetaData,*this,m_aMutex,aVector) ); +} + +void OCatalog::refreshViews() +{ +} + +void OCatalog::refreshGroups() +{ +} + +void OCatalog::refreshUsers() +{ +} + + +// XTablesSupplier +Reference< XNameAccess > SAL_CALL OCatalog::getTables( ) +{ + ::osl::MutexGuard aGuard(m_aMutex); + checkDisposed(rBHelper.bDisposed); + + try + { + if(!m_pTables || OConnection::getForceLoadTables()) + refreshTables(); + } + catch( const RuntimeException& ) + { + // allowed to leave this method + throw; + } + catch( const Exception& ) + { + // allowed + } + + return m_pTables.get(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MCatalog.hxx b/connectivity/source/drivers/mork/MCatalog.hxx new file mode 100644 index 000000000..170809f7c --- /dev/null +++ b/connectivity/source/drivers/mork/MCatalog.hxx @@ -0,0 +1,52 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCATALOG_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCATALOG_HXX + +#include <sdbcx/VCatalog.hxx> + +namespace connectivity +{ + namespace mork + { + // please don't name the class the same name as in another namespaces + // some compilers have problems with this task as I noticed on windows + class OConnection; + class OCatalog : public connectivity::sdbcx::OCatalog + { + OConnection* m_pConnection; // used to get the metadata + + public: + // implementation of the pure virtual methods + virtual void refreshTables() override; + virtual void refreshViews() override ; + virtual void refreshGroups() override; + virtual void refreshUsers() override ; + virtual css::uno::Reference< css::container::XNameAccess > SAL_CALL getTables( ) override; + public: + explicit OCatalog(OConnection* _pCon); + + OConnection* getConnection() const { return m_pConnection; } + + }; + } +} +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCATALOG_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MColumnAlias.cxx b/connectivity/source/drivers/mork/MColumnAlias.cxx new file mode 100644 index 000000000..b320d8c45 --- /dev/null +++ b/connectivity/source/drivers/mork/MColumnAlias.cxx @@ -0,0 +1,133 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include "MColumnAlias.hxx" + +#include <com/sun/star/container/XHierarchicalNameAccess.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <officecfg/Office/DataAccess.hxx> + +#include <osl/diagnose.h> +#include <sal/log.hxx> + +#include <algorithm> + +using namespace ::connectivity::mork; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::container; + + +OColumnAlias::OColumnAlias( const css::uno::Reference< css::lang::XMultiServiceFactory >& _rxORB ) +{ + static const char* s_pProgrammaticNames[] = + { + "FirstName", + "LastName", + "DisplayName", + "NickName", + "PrimaryEmail", + "SecondEmail", + "PreferMailFormat", + "WorkPhone", + "HomePhone", + "FaxNumber", + "PagerNumber", + "CellularNumber", + "HomeAddress", + "HomeAddress2", + "HomeCity", + "HomeState", + "HomeZipCode", + "HomeCountry", + "WorkAddress", + "WorkAddress2", + "WorkCity", + "WorkState", + "WorkZipCode", + "WorkCountry", + "JobTitle", + "Department", + "Company", + "WebPage1", + "WebPage2", + "BirthYear", + "BirthMonth", + "BirthDay", + "Custom1", + "Custom2", + "Custom3", + "Custom4", + "Notes", + }; + + for ( size_t i = 0; i < SAL_N_ELEMENTS( s_pProgrammaticNames ); ++i ) + m_aAliasMap[ OUString::createFromAscii( s_pProgrammaticNames[i] ) ] = AliasEntry( s_pProgrammaticNames[i], i ); + + initialize( _rxORB ); +} + + +void OColumnAlias::initialize( const css::uno::Reference< css::lang::XMultiServiceFactory >& _rxORB ) +{ + Reference< XNameAccess > xAliasesNode( + officecfg::Office::DataAccess::DriverSettings:: + com_sun_star_comp_sdbc_MozabDriver::ColumnAliases::get( + comphelper::getComponentContext(_rxORB)), + UNO_QUERY_THROW); + const Sequence< OUString > aProgrammaticNames(xAliasesNode->getElementNames()); + for (const auto& rProgrammaticName : aProgrammaticNames) { + OString sAsciiProgrammaticName( + OUStringToOString( + rProgrammaticName, RTL_TEXTENCODING_ASCII_US)); + auto j = std::find_if(m_aAliasMap.begin(), m_aAliasMap.end(), + [&sAsciiProgrammaticName](const AliasMap::value_type& rEntry) { + return rEntry.second.programmaticAsciiName == sAsciiProgrammaticName; }); + if (j != m_aAliasMap.end()) { + OUString sAssignedAlias; + xAliasesNode->getByName(rProgrammaticName) >>= + sAssignedAlias; + if (sAssignedAlias.isEmpty()) { + sAssignedAlias = rProgrammaticName; + } + AliasEntry entry(j->second); + m_aAliasMap.erase(j); + m_aAliasMap[sAssignedAlias] = entry; + } + else { + SAL_WARN( + "connectivity.mork", + "unknown programmatic name " << rProgrammaticName + <<" from configuration"); + } + } +} + + +OString OColumnAlias::getProgrammaticNameOrFallbackToUTF8Alias( const OUString& _rAlias ) const +{ + AliasMap::const_iterator pos = m_aAliasMap.find( _rAlias ); + if ( pos == m_aAliasMap.end() ) + { + OSL_FAIL( "OColumnAlias::getProgrammaticNameOrFallbackToUTF8Alias: no programmatic name for this alias!" ); + return OUStringToOString( _rAlias, RTL_TEXTENCODING_UTF8 ); + } + return pos->second.programmaticAsciiName; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MColumnAlias.hxx b/connectivity/source/drivers/mork/MColumnAlias.hxx new file mode 100644 index 000000000..3900b324b --- /dev/null +++ b/connectivity/source/drivers/mork/MColumnAlias.hxx @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCOLUMNALIAS_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCOLUMNALIAS_HXX + +#include <unotools/confignode.hxx> + +#include <unordered_map> + +namespace connectivity +{ + namespace mork + { + class OColumnAlias + { + public: + struct AliasEntry + { + OString programmaticAsciiName; + size_t columnPosition; + + AliasEntry() + :programmaticAsciiName() + ,columnPosition( 0 ) + { + } + AliasEntry( const char* _programmaticAsciiName, size_t _columnPosition ) + :programmaticAsciiName( _programmaticAsciiName ) + ,columnPosition( _columnPosition ) + { + } + }; + typedef std::unordered_map< OUString, AliasEntry > AliasMap; + + private: + AliasMap m_aAliasMap; + + public: + explicit OColumnAlias( const css::uno::Reference< css::lang::XMultiServiceFactory > & ); + + OString getProgrammaticNameOrFallbackToUTF8Alias( const OUString& _rAlias ) const; + + AliasMap::const_iterator begin() const { return m_aAliasMap.begin(); } + AliasMap::const_iterator end() const { return m_aAliasMap.end(); } + + + private: + void initialize( const css::uno::Reference< css::lang::XMultiServiceFactory >& _rxORB ); + }; + } +} +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCOLUMNALIAS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MColumns.cxx b/connectivity/source/drivers/mork/MColumns.cxx new file mode 100644 index 000000000..c9163a6ab --- /dev/null +++ b/connectivity/source/drivers/mork/MColumns.cxx @@ -0,0 +1,80 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include "MColumns.hxx" +#include <com/sun/star/sdbc/XRow.hpp> +#include <connectivity/sdbcx/VColumn.hxx> + +using namespace connectivity::mork; +using namespace connectivity::sdbcx; +using namespace connectivity; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbc; + + +sdbcx::ObjectType OColumns::createObject(const OUString& _rName) +{ + const Any aCatalog; + const OUString sCatalogName; + const OUString sSchemaName(m_pTable->getSchema()); + const OUString sTableName(m_pTable->getTableName()); + Reference< XResultSet > xResult = m_pTable->getConnection()->getMetaData()->getColumns( + aCatalog, sSchemaName, sTableName, _rName); + + sdbcx::ObjectType xRet; + if(xResult.is()) + { + Reference< XRow > xRow(xResult,UNO_QUERY); + while(xResult->next()) + { + if(xRow->getString(4) == _rName) + { + sal_Int32 nType = xRow->getInt(5); + OUString sTypeName = xRow->getString(6); + sal_Int32 nPrec = xRow->getInt(7); + + OColumn* pRet = new OColumn(_rName, + sTypeName, + xRow->getString(13), + xRow->getString(12), + xRow->getInt(11), + nPrec, + xRow->getInt(9), + nType, + false,false,false,true, + sCatalogName, + sSchemaName, + sTableName); + xRet = pRet; + break; + } + } + } + + return xRet; +} + + +void OColumns::impl_refresh() +{ + m_pTable->refreshColumns(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MColumns.hxx b/connectivity/source/drivers/mork/MColumns.hxx new file mode 100644 index 000000000..b0774af27 --- /dev/null +++ b/connectivity/source/drivers/mork/MColumns.hxx @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCOLUMNS_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCOLUMNS_HXX + +#include <connectivity/sdbcx/VCollection.hxx> +#include "MTable.hxx" + +namespace connectivity +{ + namespace mork + { + class OColumns final : public sdbcx::OCollection + { + OTable* m_pTable; + + virtual sdbcx::ObjectType createObject(const OUString& _rName) override; + virtual void impl_refresh() override; + public: + OColumns( OTable* _pTable, + ::osl::Mutex& _rMutex, + const ::std::vector< OUString> &_rVector + ) : sdbcx::OCollection(*_pTable, true, _rMutex, _rVector) + ,m_pTable(_pTable) + {} + }; + } +} +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCOLUMNS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MConnection.cxx b/connectivity/source/drivers/mork/MConnection.cxx new file mode 100644 index 000000000..e6658b6dc --- /dev/null +++ b/connectivity/source/drivers/mork/MConnection.cxx @@ -0,0 +1,377 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "MConnection.hxx" +#include "MDriver.hxx" +#include "MDatabaseMetaData.hxx" +#include "MCatalog.hxx" +#include "MPreparedStatement.hxx" +#include "MorkParser.hxx" + +#include <connectivity/dbexception.hxx> +#include <sal/log.hxx> + +#include <strings.hrc> + +#include <com/sun/star/sdbc/TransactionIsolation.hpp> + +using namespace dbtools; + + +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; +using namespace com::sun::star::beans; +using namespace com::sun::star::sdbc; +using namespace com::sun::star::sdbcx; + + +namespace connectivity::mork { + +static const int defaultScope = 0x80; + + +OConnection::OConnection(MorkDriver* _pDriver) + :m_xDriver(_pDriver) + ,m_aColumnAlias( _pDriver->getFactory() ) +{ + m_pBook.reset( new MorkParser() ); + m_pHistory.reset( new MorkParser() ); +} + +OConnection::~OConnection() +{ + if(!isClosed()) + close(); + m_pBook.reset(); + m_pHistory.reset(); +} + +void OConnection::construct(const OUString& url) +{ + SAL_INFO("connectivity.mork", "=> OConnection::construct()" ); + // open file + setURL(url); + + // Skip 'sdbc:mozab: part of URL + + sal_Int32 nLen = url.indexOf(':'); + nLen = url.indexOf(':',nLen+1); + OSL_ENSURE( url.startsWith("sdbc:address:"), "OConnection::construct: invalid start of the URI - should never have survived XDriver::acceptsURL!" ); + + OUString aAddrbookURI(url.copy(nLen+1)); + // Get Scheme + nLen = aAddrbookURI.indexOf(':'); + OUString aAddrbookScheme; + if ( nLen == -1 ) + { + // There isn't any subschema: - but could be just subschema + if ( !aAddrbookURI.isEmpty() ) + { + aAddrbookScheme= aAddrbookURI; + } + else + { + SAL_WARN("connectivity.mork", "No subschema given!!!"); + throwGenericSQLException( STR_URI_SYNTAX_ERROR, *this ); + } + } + else + { + aAddrbookScheme = aAddrbookURI.copy(0, nLen); + } + + SAL_INFO("connectivity.mork", "URI = " << aAddrbookURI ); + SAL_INFO("connectivity.mork", "Scheme = " << aAddrbookScheme ); + + OUString abook; + OUString history; + const OUString UNITTEST_URL = "thunderbird:unittest:"; + sal_Int32 unittestIndex = url.indexOf(UNITTEST_URL); + + // production? + if (unittestIndex == -1) + { + OUString path = m_xDriver->getProfilePath(); + SAL_INFO("connectivity.mork", "ProfilePath: " << path); + abook = path + "/abook.mab"; + history = path + "/history.mab"; + SAL_INFO("connectivity.mork", "AdressbookPath (abook): " << abook); + SAL_INFO("connectivity.mork", "AdressbookPath (history): " << history); + } + else + { + abook = aAddrbookURI.replaceFirst(UNITTEST_URL, ""); + SAL_INFO("connectivity.mork", "unit test: " << abook); + } + + OString strPath = OUStringToOString(abook, RTL_TEXTENCODING_UTF8); + + // Open and parse mork file + if (!m_pBook->open(strPath.getStr())) + { + SAL_WARN("connectivity.mork", "Can not parse abook mork file: " << strPath); + const OUString sError( getResources().getResourceStringWithSubstitution( + STR_COULD_NOT_LOAD_FILE, "$filename$", abook)); + ::dbtools::throwGenericSQLException( sError, *this ); + } + + // read history only in production + if (unittestIndex == -1) + { + strPath = OUStringToOString(history, RTL_TEXTENCODING_UTF8); + if (!m_pHistory->open(strPath.getStr())) + { + SAL_WARN("connectivity.mork", "Can not parse history mork file: " << strPath); + const OUString sError( getResources().getResourceStringWithSubstitution( + STR_COULD_NOT_LOAD_FILE, "$filename$", history)); + ::dbtools::throwGenericSQLException( sError, *this ); + } + } + + // check that we can retrieve the tables: + MorkTableMap *Tables = m_pBook->getTables( defaultScope ); + if (Tables) + { + // Iterate all tables + for ( const auto& rEntry : Tables->map ) + { + if ( 0 == rEntry.first ) continue; + SAL_INFO("connectivity.mork", "table->first : " << rEntry.first); + } + } + // check that we can retrieve the history tables: + MorkTableMap *Tables_hist = m_pHistory->getTables( defaultScope ); + if (Tables_hist) + { + // Iterate all tables + for ( const auto& rEntry : Tables_hist->map ) + { + if ( 0 == rEntry.first ) continue; + SAL_INFO("connectivity.mork", "table->first : " << rEntry.first); + } + } +} + +// XServiceInfo + +IMPLEMENT_SERVICE_INFO(OConnection, "com.sun.star.sdbc.drivers.mork.OConnection", "com.sun.star.sdbc.Connection") + + +Reference< XStatement > SAL_CALL OConnection::createStatement( ) +{ + SAL_INFO("connectivity.mork", "=> OConnection::createStatement()" ); + + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OConnection_BASE::rBHelper.bDisposed); + + // create a statement + // the statement can only be executed once + Reference< XStatement > xReturn = new OStatement(this); + m_aStatements.push_back(WeakReferenceHelper(xReturn)); + return xReturn; +} + +Reference< XPreparedStatement > SAL_CALL OConnection::prepareStatement( const OUString& _sSql ) +{ + SAL_INFO("connectivity.mork", "=> OConnection::prepareStatement()" ); + SAL_INFO("connectivity.mork", "OConnection::prepareStatement( " << _sSql << " )"); + + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OConnection_BASE::rBHelper.bDisposed); + + // the pre + // create a statement + // the statement can only be executed more than once + OPreparedStatement* pPrepared = new OPreparedStatement(this,_sSql); + Reference< XPreparedStatement > xReturn = pPrepared; + pPrepared->lateInit(); + + m_aStatements.push_back(WeakReferenceHelper(xReturn)); + return xReturn; +} + +Reference< XPreparedStatement > SAL_CALL OConnection::prepareCall( const OUString& _sSql ) +{ + SAL_INFO("connectivity.mork", "=> OConnection::prepareCall()" ); + SAL_INFO("connectivity.mork", "sql: " << _sSql); + ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::prepareCall", *this ); + SAL_INFO("connectivity.mork", "OConnection::prepareCall( " << _sSql << " )"); + return nullptr; +} + +OUString SAL_CALL OConnection::nativeSQL( const OUString& _sSql ) +{ + SAL_INFO("connectivity.mork", "=> OConnection::nativeSQL()" ); + SAL_INFO("connectivity.mork", "sql: " << _sSql); + + ::osl::MutexGuard aGuard( m_aMutex ); + // when you need to transform SQL92 to you driver specific you can do it here + SAL_INFO("connectivity.mork", "OConnection::nativeSQL(" << _sSql << " )" ); + + return _sSql; +} + +void SAL_CALL OConnection::setAutoCommit( sal_Bool /*autoCommit*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setAutoCommit", *this ); +} + +sal_Bool SAL_CALL OConnection::getAutoCommit( ) +{ + // you have to distinguish which if you are in autocommit mode or not + // at normal case true should be fine here + + return true; +} + +void SAL_CALL OConnection::commit( ) +{ + // when you database does support transactions you should commit here +} + +void SAL_CALL OConnection::rollback( ) +{ + // same as commit but for the other case +} + +sal_Bool SAL_CALL OConnection::isClosed( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + // just simple -> we are close when we are disposed that means someone called dispose(); (XComponent) + return OConnection_BASE::rBHelper.bDisposed; +} + +Reference< XDatabaseMetaData > SAL_CALL OConnection::getMetaData( ) +{ + SAL_INFO("connectivity.mork", "=> OConnection::getMetaData()" ); + + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OConnection_BASE::rBHelper.bDisposed); + + // here we have to create the class with biggest interface + // The answer is 42 :-) + Reference< XDatabaseMetaData > xMetaData = m_xMetaData; + if(!xMetaData.is()) + { + xMetaData = new ODatabaseMetaData(this); // need the connection because it can return it + m_xMetaData = xMetaData; + } + + return xMetaData; +} + +void SAL_CALL OConnection::setReadOnly( sal_Bool /*readOnly*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setReadOnly", *this ); +} + +sal_Bool SAL_CALL OConnection::isReadOnly( ) +{ + // return if your connection to readonly + return false; +} + +void SAL_CALL OConnection::setCatalog( const OUString& /*catalog*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setCatalog", *this ); +} + +OUString SAL_CALL OConnection::getCatalog( ) +{ + return OUString(); +} + +void SAL_CALL OConnection::setTransactionIsolation( sal_Int32 /*level*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setTransactionIsolation", *this ); +} + +sal_Int32 SAL_CALL OConnection::getTransactionIsolation( ) +{ + // please have a look at @see com.sun.star.sdbc.TransactionIsolation + return TransactionIsolation::NONE; +} + +Reference< css::container::XNameAccess > SAL_CALL OConnection::getTypeMap( ) +{ + // if your driver has special database types you can return it here + return nullptr; +} + +void SAL_CALL OConnection::setTypeMap( const Reference< css::container::XNameAccess >& /*typeMap*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setTypeMap", *this ); +} + +// XCloseable +void SAL_CALL OConnection::close( ) +{ + // we just dispose us + { + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OConnection_BASE::rBHelper.bDisposed); + + } + dispose(); +} + +// XWarningsSupplier +Any SAL_CALL OConnection::getWarnings( ) +{ + // when you collected some warnings -> return it + return Any(); +} + +void SAL_CALL OConnection::clearWarnings( ) +{ + // you should clear your collected warnings here +} + +void OConnection::disposing() +{ + // we noticed that we should be destroyed in near future so we have to dispose our statements + ::osl::MutexGuard aGuard(m_aMutex); + m_xCatalog.clear(); +} + +Reference< XTablesSupplier > OConnection::createCatalog() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + Reference< XTablesSupplier > xTab = m_xCatalog; + if(!m_xCatalog.is()) + { + OCatalog *pCat = new OCatalog(this); + xTab = pCat; + m_xCatalog = xTab; + } + return xTab; +} + +void OConnection::throwSQLException( const ErrorDescriptor& _rError, const Reference< XInterface >& _rxContext ) +{ + if (_rError.getResId() != nullptr) + { + throwGenericSQLException( _rError.getResId(), _rxContext ); + OSL_FAIL( "OConnection::throwSQLException: unreachable (2)!" ); + } + + throwGenericSQLException( STR_UNSPECIFIED_ERROR, _rxContext ); +} + +void OConnection::throwSQLException( const char* pErrorResourceId, const Reference< XInterface >& _rxContext ) +{ + ErrorDescriptor aError; + aError.setResId(pErrorResourceId); + throwSQLException(aError, _rxContext); +} + +} // namespace connectivity::mork + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MConnection.hxx b/connectivity/source/drivers/mork/MConnection.hxx new file mode 100644 index 000000000..0bcb936bd --- /dev/null +++ b/connectivity/source/drivers/mork/MConnection.hxx @@ -0,0 +1,98 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCONNECTION_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCONNECTION_HXX + +#include <TConnection.hxx> +#include "MColumnAlias.hxx" + +#include <com/sun/star/sdbcx/XTablesSupplier.hpp> + +// do we want here namespace too? +class MorkParser; + +namespace connectivity +{ + namespace mork + { + class MorkDriver; + class ErrorDescriptor; + + typedef connectivity::OMetaConnection OConnection_BASE; // implements basics and text encoding + + class OConnection final : public OConnection_BASE + { + // Data attributes + + rtl::Reference<MorkDriver> m_xDriver; // Pointer to the owning + // driver object + OColumnAlias m_aColumnAlias; + // Mork Parser (abook) + std::unique_ptr<MorkParser> m_pBook; + // Mork Parser (history) + std::unique_ptr<MorkParser> m_pHistory; + // Store Catalog + css::uno::Reference< css::sdbcx::XTablesSupplier> m_xCatalog; + + public: + /// @throws css::sdbc::SQLException + void construct( const OUString& url); + explicit OConnection(MorkDriver* const driver); + virtual ~OConnection() override; + + const rtl::Reference<MorkDriver>& getDriver() const {return m_xDriver;}; + MorkParser* getMorkParser(const OString& t) {return t == "CollectedAddressBook" ? m_pHistory.get() : m_pBook.get();}; + + // OComponentHelper + virtual void SAL_CALL disposing() override; + + // XServiceInfo + DECLARE_SERVICE_INFO(); + // XConnection + virtual css::uno::Reference< css::sdbc::XStatement > SAL_CALL createStatement( ) override; + virtual css::uno::Reference< css::sdbc::XPreparedStatement > SAL_CALL prepareStatement( const OUString& sql ) override; + virtual css::uno::Reference< css::sdbc::XPreparedStatement > SAL_CALL prepareCall( const OUString& sql ) override; + virtual OUString SAL_CALL nativeSQL( const OUString& sql ) override; + virtual void SAL_CALL setAutoCommit( sal_Bool autoCommit ) override; + virtual sal_Bool SAL_CALL getAutoCommit( ) override; + virtual void SAL_CALL commit( ) override; + virtual void SAL_CALL rollback( ) override; + virtual sal_Bool SAL_CALL isClosed( ) override; + virtual css::uno::Reference< css::sdbc::XDatabaseMetaData > SAL_CALL getMetaData( ) override; + virtual void SAL_CALL setReadOnly( sal_Bool readOnly ) override; + virtual sal_Bool SAL_CALL isReadOnly( ) override; + virtual void SAL_CALL setCatalog( const OUString& catalog ) override; + virtual OUString SAL_CALL getCatalog( ) override; + virtual void SAL_CALL setTransactionIsolation( sal_Int32 level ) override; + virtual sal_Int32 SAL_CALL getTransactionIsolation( ) override; + virtual css::uno::Reference< css::container::XNameAccess > SAL_CALL getTypeMap( ) override; + virtual void SAL_CALL setTypeMap( const css::uno::Reference< css::container::XNameAccess >& typeMap ) override; + // XCloseable + virtual void SAL_CALL close( ) override; + // XWarningsSupplier + virtual css::uno::Any SAL_CALL getWarnings( ) override; + virtual void SAL_CALL clearWarnings() override; + + const OColumnAlias & getColumnAlias() const { return m_aColumnAlias; } + + static bool getForceLoadTables() {return true;} + + // Added to enable me to use SQLInterpreter which requires an + // XNameAccess i/f to access tables. + css::uno::Reference< css::sdbcx::XTablesSupplier > createCatalog(); + + void throwSQLException( const ErrorDescriptor& _rError, const css::uno::Reference< css::uno::XInterface >& _rxContext ); + void throwSQLException( const char* pErrorResourceId, const css::uno::Reference< css::uno::XInterface >& _rxContext ); + }; + } +} +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MCONNECTION_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MDatabaseMetaData.cxx b/connectivity/source/drivers/mork/MDatabaseMetaData.cxx new file mode 100644 index 000000000..7858230b0 --- /dev/null +++ b/connectivity/source/drivers/mork/MDatabaseMetaData.cxx @@ -0,0 +1,957 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "MConnection.hxx" +#include "MDatabaseMetaData.hxx" + +#include <com/sun/star/sdbc/TransactionIsolation.hpp> +#include <com/sun/star/sdbc/ColumnSearch.hpp> +#include <sal/log.hxx> +#include <vector> + +#include "MDatabaseMetaDataHelper.hxx" + +using namespace connectivity::mork; +using namespace connectivity; + +using namespace com::sun::star::uno; +using namespace com::sun::star::sdbc; + + +namespace connectivity::mork +{ + static sal_Int32 const s_nCOLUMN_SIZE = 256; + static sal_Int32 const s_nDECIMAL_DIGITS = 0; + static sal_Int32 const s_nNULLABLE = 1; + static sal_Int32 const s_nCHAR_OCTET_LENGTH = 65535; +} + +ODatabaseMetaData::ODatabaseMetaData(OConnection* _pCon) + : ::connectivity::ODatabaseMetaDataBase(_pCon,_pCon->getConnectionInfo()) + ,m_pConnection(_pCon) + ,m_pMetaDataHelper(new MDatabaseMetaDataHelper) +{ + OSL_ENSURE(m_pConnection,"ODatabaseMetaData::ODatabaseMetaData: No connection set!"); +} + +ODatabaseMetaData::~ODatabaseMetaData() +{ +} + + +ODatabaseMetaDataResultSet::ORows ODatabaseMetaData::getColumnRows( + const OUString& tableNamePattern, + const OUString& columnNamePattern ) +{ + SAL_INFO("connectivity.mork", "=> ODatabaseMetaData::getColumnRows()" ); + SAL_INFO("connectivity.mork", "tableNamePattern: " << tableNamePattern); + SAL_INFO("connectivity.mork", "columnNamePattern: " << columnNamePattern); + + ODatabaseMetaDataResultSet::ORows aRows; + ODatabaseMetaDataResultSet::ORow aRow(19); + + ::osl::MutexGuard aGuard( m_aMutex ); + std::vector< OUString > tables; + connectivity::mork::MDatabaseMetaDataHelper::getTableStrings(m_pConnection, tables); + + // **************************************************** + // Some entries in a row never change, so set them now + // **************************************************** + + // Catalog + aRow[1] = new ORowSetValueDecorator(OUString()); + // Schema + aRow[2] = new ORowSetValueDecorator(OUString()); + // DATA_TYPE + aRow[5] = new ORowSetValueDecorator(static_cast<sal_Int16>(DataType::VARCHAR)); + // TYPE_NAME, not used + aRow[6] = new ORowSetValueDecorator(OUString("VARCHAR")); + // COLUMN_SIZE + aRow[7] = new ORowSetValueDecorator(s_nCOLUMN_SIZE); + // BUFFER_LENGTH, not used + aRow[8] = ODatabaseMetaDataResultSet::getEmptyValue(); + // DECIMAL_DIGITS. + aRow[9] = new ORowSetValueDecorator(s_nDECIMAL_DIGITS); + // NUM_PREC_RADIX + aRow[10] = new ORowSetValueDecorator(sal_Int32(10)); + // NULLABLE + aRow[11] = new ORowSetValueDecorator(s_nNULLABLE); + // REMARKS + aRow[12] = ODatabaseMetaDataResultSet::getEmptyValue(); + // COULUMN_DEF, not used + aRow[13] = ODatabaseMetaDataResultSet::getEmptyValue(); + // SQL_DATA_TYPE, not used + aRow[14] = ODatabaseMetaDataResultSet::getEmptyValue(); + // SQL_DATETIME_SUB, not used + aRow[15] = ODatabaseMetaDataResultSet::getEmptyValue(); + // CHAR_OCTET_LENGTH, refer to [5] + aRow[16] = new ORowSetValueDecorator(s_nCHAR_OCTET_LENGTH); + // IS_NULLABLE + aRow[18] = new ORowSetValueDecorator(OUString("YES")); + + // Iterate over all tables + for(const OUString & table : tables) { + if(match(tableNamePattern, table,'\0')) { + // TABLE_NAME + aRow[3] = new ORowSetValueDecorator( table ); + + const OColumnAlias& colNames = m_pConnection->getColumnAlias(); + + SAL_INFO("connectivity.mork", "\tTableName = : " << table); + // Iterate over all columns in the table. + for (const auto& [rName, rAlias] : colNames) + { + if ( match( columnNamePattern, rName, '\0' ) ) + { + SAL_INFO("connectivity.mork", "\t\tColumnNam : " << rName); + + // COLUMN_NAME + aRow[4] = new ORowSetValueDecorator( rName ); + // ORDINAL_POSITION + aRow[17] = new ORowSetValueDecorator( static_cast< sal_Int32 >( rAlias.columnPosition ) + 1 ); + aRows.push_back(aRow); + } + } + } + } + return aRows; +} + +OUString ODatabaseMetaData::impl_getCatalogSeparator_throw( ) +{ + return OUString(); +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxBinaryLiteralLength( ) +{ + return 65535; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxRowSize( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxCatalogNameLength( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxCharLiteralLength( ) +{ + return 254; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnNameLength( ) +{ + return 20; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInIndex( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxCursorNameLength( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxConnections( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInTable( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 ODatabaseMetaData::impl_getMaxStatements_throw( ) +{ + return 0; +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxTableNameLength( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 ODatabaseMetaData::impl_getMaxTablesInSelect_throw( ) +{ + // We only support a single table + return 1; +} + + +sal_Bool SAL_CALL ODatabaseMetaData::doesMaxRowSizeIncludeBlobs( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::storesLowerCaseQuotedIdentifiers( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::storesLowerCaseIdentifiers( ) +{ + return false; +} + +bool ODatabaseMetaData::impl_storesMixedCaseQuotedIdentifiers_throw( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::storesMixedCaseIdentifiers( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::storesUpperCaseQuotedIdentifiers( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::storesUpperCaseIdentifiers( ) +{ + return false; +} + +bool ODatabaseMetaData::impl_supportsAlterTableWithAddColumn_throw( ) +{ + return false; +} + +bool ODatabaseMetaData::impl_supportsAlterTableWithDropColumn_throw( ) +{ + return false; +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxIndexLength( ) +{ + return 0; // 0 means no limit +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsNonNullableColumns( ) +{ + return false; +} + +OUString SAL_CALL ODatabaseMetaData::getCatalogTerm( ) +{ + return OUString(); +} + +OUString ODatabaseMetaData::impl_getIdentifierQuoteString_throw( ) +{ + // normally this is " + return "\""; +} + +OUString SAL_CALL ODatabaseMetaData::getExtraNameCharacters( ) +{ + return OUString(); +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsDifferentTableCorrelationNames( ) +{ + return true; +} + +bool ODatabaseMetaData::impl_isCatalogAtStart_throw( ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::dataDefinitionIgnoredInTransactions( ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::dataDefinitionCausesTransactionCommit( ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsDataManipulationTransactionsOnly( ) +{ + //We support create table + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsDataDefinitionAndDataManipulationTransactions( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsPositionedDelete( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsPositionedUpdate( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenStatementsAcrossRollback( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenStatementsAcrossCommit( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenCursorsAcrossCommit( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsOpenCursorsAcrossRollback( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsTransactionIsolationLevel( sal_Int32 /*level*/ ) +{ + return false; +} + +bool ODatabaseMetaData::impl_supportsSchemasInDataManipulation_throw( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsANSI92FullSQL( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsANSI92EntryLevelSQL( ) +{ + return true; // should be supported at least +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsIntegrityEnhancementFacility( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSchemasInIndexDefinitions( ) +{ + return false; +} + +bool ODatabaseMetaData::impl_supportsSchemasInTableDefinitions_throw( ) +{ + return false; +} + +bool ODatabaseMetaData::impl_supportsCatalogsInTableDefinitions_throw( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsCatalogsInIndexDefinitions( ) +{ + return false; +} + +bool ODatabaseMetaData::impl_supportsCatalogsInDataManipulation_throw( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsOuterJoins( ) +{ + return false; +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxStatementLength( ) +{ + return 0;// 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxProcedureNameLength( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxSchemaNameLength( ) +{ + return 0; // 0 means no limit +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsTransactions( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::allProceduresAreCallable( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsStoredProcedures( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSelectForUpdate( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::allTablesAreSelectable( ) +{ + // We allow you to select from any table. + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::isReadOnly( ) +{ + //we support insert/update/delete now + //But we have to set this to return sal_True otherwise the UI will add create "table/edit table" + //entry to the popup menu. We should avoid them. + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::usesLocalFiles( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::usesLocalFilePerTable( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsTypeConversion( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::nullPlusNonNullIsNull( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsColumnAliasing( ) +{ + // Support added for this. + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsTableCorrelationNames( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsConvert( sal_Int32 /*fromType*/, sal_Int32 /*toType*/ ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsExpressionsInOrderBy( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsGroupBy( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsGroupByBeyondSelect( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsGroupByUnrelated( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsMultipleTransactions( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsMultipleResultSets( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsLikeEscapeClause( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsOrderByUnrelated( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsUnion( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsUnionAll( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsMixedCaseIdentifiers( ) +{ + return true; +} + +bool ODatabaseMetaData::impl_supportsMixedCaseQuotedIdentifiers_throw( ) +{ + // Any case may be used + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedAtEnd( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedAtStart( ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedHigh( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::nullsAreSortedLow( ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSchemasInProcedureCalls( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSchemasInPrivilegeDefinitions( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsCatalogsInProcedureCalls( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsCatalogsInPrivilegeDefinitions( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsCorrelatedSubqueries( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInComparisons( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInExists( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInIns( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsSubqueriesInQuantifieds( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsANSI92IntermediateSQL( ) +{ + return false; +} + +OUString SAL_CALL ODatabaseMetaData::getURL( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + return m_pConnection->getURL(); +} + +OUString SAL_CALL ODatabaseMetaData::getUserName( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getDriverName( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getDriverVersion() +{ + OUString aValue = OUString::number(1); + return aValue; +} + +OUString SAL_CALL ODatabaseMetaData::getDatabaseProductVersion( ) +{ + OUString aValue = OUString::number(0); + return aValue; +} + +OUString SAL_CALL ODatabaseMetaData::getDatabaseProductName( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getProcedureTerm( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getSchemaTerm( ) +{ + return OUString(); +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getDriverMajorVersion( ) +{ + return 1; +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getDefaultTransactionIsolation( ) +{ + return TransactionIsolation::NONE; +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getDriverMinorVersion( ) +{ + return 0; +} + +OUString SAL_CALL ODatabaseMetaData::getSQLKeywords( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getSearchStringEscape( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getStringFunctions( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getTimeDateFunctions( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getSystemFunctions( ) +{ + return OUString(); +} + +OUString SAL_CALL ODatabaseMetaData::getNumericFunctions( ) +{ + return OUString(); +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsExtendedSQLGrammar( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsCoreSQLGrammar( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsMinimumSQLGrammar( ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsFullOuterJoins( ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsLimitedOuterJoins( ) +{ + return false; +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInGroupBy( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInOrderBy( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxColumnsInSelect( ) +{ + return 0; // 0 means no limit +} + +sal_Int32 SAL_CALL ODatabaseMetaData::getMaxUserNameLength( ) +{ + return 0; // 0 means no limit +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsResultSetType( sal_Int32 /*setType*/ ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsResultSetConcurrency( sal_Int32 /*setType*/, sal_Int32 /*concurrency*/ ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::ownUpdatesAreVisible( sal_Int32 /*setType*/ ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::ownDeletesAreVisible( sal_Int32 /*setType*/ ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::ownInsertsAreVisible( sal_Int32 /*setType*/ ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::othersUpdatesAreVisible( sal_Int32 /*setType*/ ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::othersDeletesAreVisible( sal_Int32 /*setType*/ ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::othersInsertsAreVisible( sal_Int32 /*setType*/ ) +{ + return false; +} + +sal_Bool SAL_CALL ODatabaseMetaData::updatesAreDetected( sal_Int32 /*setType*/ ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::deletesAreDetected( sal_Int32 /*setType*/ ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::insertsAreDetected( sal_Int32 /*setType*/ ) +{ + return true; +} + +sal_Bool SAL_CALL ODatabaseMetaData::supportsBatchUpdates( ) +{ + return false; +} + +// here follow all methods which return a resultset +// the first methods is an example implementation how to use this resultset +// of course you could implement it on your and you should do this because +// the general way is more memory expensive + +Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTableTypes( ) +{ + // there exists no possibility to get table types so we have to check + static const OUStringLiteral sTableTypes[] = + { + "TABLE", + "VIEW" + // Currently we only support a 'TABLE' and 'VIEW' nothing more complex + + // OUString("SYSTEM TABLE"), + // OUString("GLOBAL TEMPORARY"), + // OUString("LOCAL TEMPORARY"), + // OUString("ALIAS"), + // OUString("SYNONYM") + }; + ::connectivity::ODatabaseMetaDataResultSet* pResult = new ::connectivity::ODatabaseMetaDataResultSet(ODatabaseMetaDataResultSet::eTableTypes); + Reference< XResultSet > xRef = pResult; + + // here we fill the rows which should be visible when ask for data from the resultset returned here + ODatabaseMetaDataResultSet::ORows aRows; + for(const auto & sTableType : sTableTypes) + { + ODatabaseMetaDataResultSet::ORow aRow; + aRow.push_back(ODatabaseMetaDataResultSet::getEmptyValue()); + aRow.push_back(new ORowSetValueDecorator(OUString(sTableType))); + // bound row + aRows.push_back(aRow); + } + // here we set the rows at the resultset + pResult->setRows(aRows); + return xRef; +} + +Reference< XResultSet > ODatabaseMetaData::impl_getTypeInfo_throw( ) +{ + // this returns an empty resultset where the column-names are already set + // in special the metadata of the resultset already returns the right columns + ODatabaseMetaDataResultSet* pResultSet = new ODatabaseMetaDataResultSet(ODatabaseMetaDataResultSet::eTypeInfo); + Reference< XResultSet > xResultSet = pResultSet; + static ODatabaseMetaDataResultSet::ORows aRows = [&]() + { + ODatabaseMetaDataResultSet::ORows tmp; + ODatabaseMetaDataResultSet::ORow aRow; + aRow.reserve(19); + aRow.push_back(ODatabaseMetaDataResultSet::getEmptyValue()); + aRow.push_back(new ORowSetValueDecorator(OUString("VARCHAR"))); + aRow.push_back(new ORowSetValueDecorator(DataType::VARCHAR)); + aRow.push_back(new ORowSetValueDecorator(sal_Int32(s_nCHAR_OCTET_LENGTH))); + aRow.push_back(ODatabaseMetaDataResultSet::getQuoteValue()); + aRow.push_back(ODatabaseMetaDataResultSet::getQuoteValue()); + aRow.push_back(ODatabaseMetaDataResultSet::getEmptyValue()); + // aRow.push_back(new ORowSetValueDecorator((sal_Int32)ColumnValue::NULLABLE)); + aRow.push_back(ODatabaseMetaDataResultSet::get1Value()); + aRow.push_back(ODatabaseMetaDataResultSet::get1Value()); + aRow.push_back(new ORowSetValueDecorator(sal_Int32(ColumnSearch::CHAR))); + aRow.push_back(ODatabaseMetaDataResultSet::get1Value()); + aRow.push_back(ODatabaseMetaDataResultSet::get0Value()); + aRow.push_back(ODatabaseMetaDataResultSet::get0Value()); + aRow.push_back(ODatabaseMetaDataResultSet::getEmptyValue()); + aRow.push_back(ODatabaseMetaDataResultSet::get0Value()); + aRow.push_back(ODatabaseMetaDataResultSet::get0Value()); + aRow.push_back(ODatabaseMetaDataResultSet::getEmptyValue()); + aRow.push_back(ODatabaseMetaDataResultSet::getEmptyValue()); + aRow.push_back(new ORowSetValueDecorator(sal_Int32(10))); + + tmp.push_back(aRow); + return tmp; + }(); + pResultSet->setRows(aRows); + return xResultSet; +} + +Reference< XResultSet > SAL_CALL ODatabaseMetaData::getColumns( + const Any& /*catalog*/, const OUString& /*schemaPattern*/, const OUString& tableNamePattern, + const OUString& columnNamePattern ) +{ + // this returns an empty resultset where the column-names are already set + // in special the metadata of the resultset already returns the right columns + ODatabaseMetaDataResultSet* pResultSet = new ODatabaseMetaDataResultSet(ODatabaseMetaDataResultSet::eColumns); + Reference< XResultSet > xResultSet = pResultSet; + pResultSet->setRows( getColumnRows( tableNamePattern, columnNamePattern )); + return xResultSet; +} + +Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTables( + const Any& /*catalog*/, const OUString& /*schemaPattern*/, + const OUString& tableNamePattern, const Sequence< OUString >& /*types*/ ) +{ + SAL_INFO("connectivity.mork", "=> ODatabaseMetaData::getTables()" ); + // this returns an empty resultset where the column-names are already set + // in special the metadata of the resultset already returns the right columns + ODatabaseMetaDataResultSet* pResultSet = new ODatabaseMetaDataResultSet(ODatabaseMetaDataResultSet::eTables); + Reference< XResultSet > xResultSet = pResultSet; + + // ODatabaseMetaDataResultSet::ORows aRows; + // aRows = m_pDbMetaDataHelper->getTables( m_pConnection, tableNamePattern ); + // pResultSet->setRows( aRows ); + ODatabaseMetaDataResultSet::ORows _rRows; + connectivity::mork::MDatabaseMetaDataHelper::getTables( m_pConnection, tableNamePattern, _rRows ); + pResultSet->setRows( _rRows ); + + return xResultSet; +} + +Reference< XResultSet > SAL_CALL ODatabaseMetaData::getTablePrivileges( + const Any& /*catalog*/, const OUString& /*schemaPattern*/, const OUString& tableNamePattern ) +{ + SAL_INFO("connectivity.mork", "=> ODatabaseMetaData::getTablePrivileges()" ); + ::connectivity::ODatabaseMetaDataResultSet* pResult = new ::connectivity::ODatabaseMetaDataResultSet(ODatabaseMetaDataResultSet::eTablePrivileges); + Reference< XResultSet > xRef = pResult; + + std::vector< OUString > tables; + connectivity::mork::MDatabaseMetaDataHelper::getTableStrings( m_pConnection, tables); + + ::connectivity::ODatabaseMetaDataResultSet::ORows aRows; + ::connectivity::ODatabaseMetaDataResultSet::ORow aRow(8); + aRows.reserve(8); + aRow[0] = ::connectivity::ODatabaseMetaDataResultSet::getEmptyValue(); + aRow[1] = ::connectivity::ODatabaseMetaDataResultSet::getEmptyValue(); + aRow[3] = ::connectivity::ODatabaseMetaDataResultSet::getEmptyValue(); + aRow[4] = ::connectivity::ODatabaseMetaDataResultSet::getEmptyValue(); + aRow[5] = new ::connectivity::ORowSetValueDecorator(getUserName()); + aRow[7] = new ::connectivity::ORowSetValueDecorator(OUString("NO")); + + + // Iterate over all tables + for(const OUString & table : tables) { + if(match(tableNamePattern, table,'\0')) + { + // TABLE_NAME + aRow[2] = new ORowSetValueDecorator( table ); + + SAL_INFO("connectivity.mork", "\tTableName = : " << table); + + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getSelectValue(); + aRows.push_back(aRow); + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getInsertValue(); + aRows.push_back(aRow); + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getDeleteValue(); + aRows.push_back(aRow); + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getUpdateValue(); + aRows.push_back(aRow); + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getCreateValue(); + aRows.push_back(aRow); + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getReadValue(); + aRows.push_back(aRow); + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getAlterValue(); + aRows.push_back(aRow); + aRow[6] = ::connectivity::ODatabaseMetaDataResultSet::getDropValue(); + aRows.push_back(aRow); + } + } + pResult->setRows(aRows); + return xRef; +} + +Reference< XResultSet > SAL_CALL ODatabaseMetaData::getUDTs( const Any& /*catalog*/, const OUString& /*schemaPattern*/, const OUString& /*typeNamePattern*/, const Sequence< sal_Int32 >& /*types*/ ) +{ + return nullptr; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MDatabaseMetaData.hxx b/connectivity/source/drivers/mork/MDatabaseMetaData.hxx new file mode 100644 index 000000000..8677fc7aa --- /dev/null +++ b/connectivity/source/drivers/mork/MDatabaseMetaData.hxx @@ -0,0 +1,191 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDATABASEMETADATA_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDATABASEMETADATA_HXX + +#include <memory> +#include <TDatabaseMetaDataBase.hxx> +#include "MConnection.hxx" + +namespace connectivity +{ + namespace mork + { + class MDatabaseMetaDataHelper; + + //************ Class: ODatabaseMetaData + + + class ODatabaseMetaData : public ODatabaseMetaDataBase + { + OConnection* m_pConnection; + std::unique_ptr<MDatabaseMetaDataHelper> + m_pMetaDataHelper; + + /// @throws css::sdbc::SQLException + ODatabaseMetaDataResultSet::ORows getColumnRows( const OUString& tableNamePattern, const OUString& columnNamePattern ); + + protected: + virtual ~ODatabaseMetaData() override; + + public: + explicit ODatabaseMetaData(OConnection* _pCon); + + private: + virtual css::uno::Reference< css::sdbc::XResultSet > impl_getTypeInfo_throw() override; + // cached database information + virtual OUString impl_getIdentifierQuoteString_throw( ) override; + virtual bool impl_isCatalogAtStart_throw( ) override; + virtual OUString impl_getCatalogSeparator_throw( ) override; + virtual bool impl_supportsCatalogsInTableDefinitions_throw( ) override; + virtual bool impl_supportsSchemasInTableDefinitions_throw( ) override ; + virtual bool impl_supportsCatalogsInDataManipulation_throw( ) override; + virtual bool impl_supportsSchemasInDataManipulation_throw( ) override ; + virtual bool impl_supportsMixedCaseQuotedIdentifiers_throw( ) override ; + virtual bool impl_supportsAlterTableWithAddColumn_throw( ) override; + virtual bool impl_supportsAlterTableWithDropColumn_throw( ) override; + virtual sal_Int32 impl_getMaxStatements_throw( ) override; + virtual sal_Int32 impl_getMaxTablesInSelect_throw( ) override; + virtual bool impl_storesMixedCaseQuotedIdentifiers_throw( ) override; + + // as I mentioned before this interface is really BIG + // XDatabaseMetaData + virtual sal_Bool SAL_CALL allProceduresAreCallable( ) override; + virtual sal_Bool SAL_CALL allTablesAreSelectable( ) override; + virtual OUString SAL_CALL getURL( ) override; + virtual OUString SAL_CALL getUserName( ) override; + virtual sal_Bool SAL_CALL isReadOnly( ) override; + virtual sal_Bool SAL_CALL nullsAreSortedHigh( ) override; + virtual sal_Bool SAL_CALL nullsAreSortedLow( ) override; + virtual sal_Bool SAL_CALL nullsAreSortedAtStart( ) override; + virtual sal_Bool SAL_CALL nullsAreSortedAtEnd( ) override; + virtual OUString SAL_CALL getDatabaseProductName( ) override; + virtual OUString SAL_CALL getDatabaseProductVersion( ) override; + virtual OUString SAL_CALL getDriverName( ) override; + virtual OUString SAL_CALL getDriverVersion( ) override; + virtual sal_Int32 SAL_CALL getDriverMajorVersion( ) override; + virtual sal_Int32 SAL_CALL getDriverMinorVersion( ) override; + virtual sal_Bool SAL_CALL usesLocalFiles( ) override; + virtual sal_Bool SAL_CALL usesLocalFilePerTable( ) override; + virtual sal_Bool SAL_CALL supportsMixedCaseIdentifiers( ) override; + virtual sal_Bool SAL_CALL storesUpperCaseIdentifiers( ) override; + virtual sal_Bool SAL_CALL storesLowerCaseIdentifiers( ) override; + virtual sal_Bool SAL_CALL storesMixedCaseIdentifiers( ) override; + virtual sal_Bool SAL_CALL storesUpperCaseQuotedIdentifiers( ) override; + virtual sal_Bool SAL_CALL storesLowerCaseQuotedIdentifiers( ) override; + virtual OUString SAL_CALL getSQLKeywords( ) override; + virtual OUString SAL_CALL getNumericFunctions( ) override; + virtual OUString SAL_CALL getStringFunctions( ) override; + virtual OUString SAL_CALL getSystemFunctions( ) override; + virtual OUString SAL_CALL getTimeDateFunctions( ) override; + virtual OUString SAL_CALL getSearchStringEscape( ) override; + virtual OUString SAL_CALL getExtraNameCharacters( ) override; + virtual sal_Bool SAL_CALL supportsColumnAliasing( ) override; + virtual sal_Bool SAL_CALL nullPlusNonNullIsNull( ) override; + virtual sal_Bool SAL_CALL supportsTypeConversion( ) override; + virtual sal_Bool SAL_CALL supportsConvert( sal_Int32 fromType, sal_Int32 toType ) override; + virtual sal_Bool SAL_CALL supportsTableCorrelationNames( ) override; + virtual sal_Bool SAL_CALL supportsDifferentTableCorrelationNames( ) override; + virtual sal_Bool SAL_CALL supportsExpressionsInOrderBy( ) override; + virtual sal_Bool SAL_CALL supportsOrderByUnrelated( ) override; + virtual sal_Bool SAL_CALL supportsGroupBy( ) override; + virtual sal_Bool SAL_CALL supportsGroupByUnrelated( ) override; + virtual sal_Bool SAL_CALL supportsGroupByBeyondSelect( ) override; + virtual sal_Bool SAL_CALL supportsLikeEscapeClause( ) override; + virtual sal_Bool SAL_CALL supportsMultipleResultSets( ) override; + virtual sal_Bool SAL_CALL supportsMultipleTransactions( ) override; + virtual sal_Bool SAL_CALL supportsNonNullableColumns( ) override; + virtual sal_Bool SAL_CALL supportsMinimumSQLGrammar( ) override; + virtual sal_Bool SAL_CALL supportsCoreSQLGrammar( ) override; + virtual sal_Bool SAL_CALL supportsExtendedSQLGrammar( ) override; + virtual sal_Bool SAL_CALL supportsANSI92EntryLevelSQL( ) override; + virtual sal_Bool SAL_CALL supportsANSI92IntermediateSQL( ) override; + virtual sal_Bool SAL_CALL supportsANSI92FullSQL( ) override; + virtual sal_Bool SAL_CALL supportsIntegrityEnhancementFacility( ) override; + virtual sal_Bool SAL_CALL supportsOuterJoins( ) override; + virtual sal_Bool SAL_CALL supportsFullOuterJoins( ) override; + virtual sal_Bool SAL_CALL supportsLimitedOuterJoins( ) override; + virtual OUString SAL_CALL getSchemaTerm( ) override; + virtual OUString SAL_CALL getProcedureTerm( ) override; + virtual OUString SAL_CALL getCatalogTerm( ) override; + virtual sal_Bool SAL_CALL supportsSchemasInProcedureCalls( ) override; + virtual sal_Bool SAL_CALL supportsSchemasInIndexDefinitions( ) override; + virtual sal_Bool SAL_CALL supportsSchemasInPrivilegeDefinitions( ) override; + virtual sal_Bool SAL_CALL supportsCatalogsInProcedureCalls( ) override; + virtual sal_Bool SAL_CALL supportsCatalogsInIndexDefinitions( ) override; + virtual sal_Bool SAL_CALL supportsCatalogsInPrivilegeDefinitions( ) override; + virtual sal_Bool SAL_CALL supportsPositionedDelete( ) override; + virtual sal_Bool SAL_CALL supportsPositionedUpdate( ) override; + virtual sal_Bool SAL_CALL supportsSelectForUpdate( ) override; + virtual sal_Bool SAL_CALL supportsStoredProcedures( ) override; + virtual sal_Bool SAL_CALL supportsSubqueriesInComparisons( ) override; + virtual sal_Bool SAL_CALL supportsSubqueriesInExists( ) override; + virtual sal_Bool SAL_CALL supportsSubqueriesInIns( ) override; + virtual sal_Bool SAL_CALL supportsSubqueriesInQuantifieds( ) override; + virtual sal_Bool SAL_CALL supportsCorrelatedSubqueries( ) override; + virtual sal_Bool SAL_CALL supportsUnion( ) override; + virtual sal_Bool SAL_CALL supportsUnionAll( ) override; + virtual sal_Bool SAL_CALL supportsOpenCursorsAcrossCommit( ) override; + virtual sal_Bool SAL_CALL supportsOpenCursorsAcrossRollback( ) override; + virtual sal_Bool SAL_CALL supportsOpenStatementsAcrossCommit( ) override; + virtual sal_Bool SAL_CALL supportsOpenStatementsAcrossRollback( ) override; + virtual sal_Int32 SAL_CALL getMaxBinaryLiteralLength( ) override; + virtual sal_Int32 SAL_CALL getMaxCharLiteralLength( ) override; + virtual sal_Int32 SAL_CALL getMaxColumnNameLength( ) override; + virtual sal_Int32 SAL_CALL getMaxColumnsInGroupBy( ) override; + virtual sal_Int32 SAL_CALL getMaxColumnsInIndex( ) override; + virtual sal_Int32 SAL_CALL getMaxColumnsInOrderBy( ) override; + virtual sal_Int32 SAL_CALL getMaxColumnsInSelect( ) override; + virtual sal_Int32 SAL_CALL getMaxColumnsInTable( ) override; + virtual sal_Int32 SAL_CALL getMaxConnections( ) override; + virtual sal_Int32 SAL_CALL getMaxCursorNameLength( ) override; + virtual sal_Int32 SAL_CALL getMaxIndexLength( ) override; + virtual sal_Int32 SAL_CALL getMaxSchemaNameLength( ) override; + virtual sal_Int32 SAL_CALL getMaxProcedureNameLength( ) override; + virtual sal_Int32 SAL_CALL getMaxCatalogNameLength( ) override; + virtual sal_Int32 SAL_CALL getMaxRowSize( ) override; + virtual sal_Bool SAL_CALL doesMaxRowSizeIncludeBlobs( ) override; + virtual sal_Int32 SAL_CALL getMaxStatementLength( ) override; + virtual sal_Int32 SAL_CALL getMaxTableNameLength( ) override; + virtual sal_Int32 SAL_CALL getMaxUserNameLength( ) override; + virtual sal_Int32 SAL_CALL getDefaultTransactionIsolation( ) override; + virtual sal_Bool SAL_CALL supportsTransactions( ) override; + virtual sal_Bool SAL_CALL supportsTransactionIsolationLevel( sal_Int32 level ) override; + virtual sal_Bool SAL_CALL supportsDataDefinitionAndDataManipulationTransactions( ) override; + virtual sal_Bool SAL_CALL supportsDataManipulationTransactionsOnly( ) override; + virtual sal_Bool SAL_CALL dataDefinitionCausesTransactionCommit( ) override; + virtual sal_Bool SAL_CALL dataDefinitionIgnoredInTransactions( ) override; + + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL getTables( const css::uno::Any& catalog, const OUString& schemaPattern, const OUString& tableNamePattern, const css::uno::Sequence< OUString >& types ) override; + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL getTableTypes( ) override; + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL getTablePrivileges( const css::uno::Any& catalog, const OUString& schemaPattern, const OUString& tableNamePattern ) override; + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL getColumns( const css::uno::Any& catalog, const OUString& schemaPattern, const OUString& tableNamePattern, const OUString& columnNamePattern ) override; + + virtual sal_Bool SAL_CALL supportsResultSetType( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL supportsResultSetConcurrency( sal_Int32 setType, sal_Int32 concurrency ) override; + virtual sal_Bool SAL_CALL ownUpdatesAreVisible( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL ownDeletesAreVisible( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL ownInsertsAreVisible( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL othersUpdatesAreVisible( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL othersDeletesAreVisible( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL othersInsertsAreVisible( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL updatesAreDetected( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL deletesAreDetected( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL insertsAreDetected( sal_Int32 setType ) override; + virtual sal_Bool SAL_CALL supportsBatchUpdates( ) override; + + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL getUDTs( const css::uno::Any& catalog, const OUString& schemaPattern, const OUString& typeNamePattern, const css::uno::Sequence< sal_Int32 >& types ) override; + }; + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDATABASEMETADATA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.cxx b/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.cxx new file mode 100644 index 000000000..ca699bafa --- /dev/null +++ b/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.cxx @@ -0,0 +1,123 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "MConnection.hxx" +#include "MDatabaseMetaDataHelper.hxx" + +// do we need it? +static ::osl::Mutex m_aMetaMutex; + +#include <sal/log.hxx> + +#include "MorkParser.hxx" + +using namespace connectivity; +using namespace connectivity::mork; + + +MDatabaseMetaDataHelper::MDatabaseMetaDataHelper() +{ + SAL_INFO("connectivity.mork", "=> MDatabaseMetaDataHelper::MDatabaseMetaDataHelper()" ); +} + + +MDatabaseMetaDataHelper::~MDatabaseMetaDataHelper() +{ +} + +void MDatabaseMetaDataHelper::getTableStrings( OConnection* _pCon, + std::vector< OUString >& _rStrings) +{ + SAL_INFO("connectivity.mork", "=> MDatabaseMetaDataHelper::getTableStrings()"); + + /* add default tables */ + _rStrings.push_back("AddressBook"); + _rStrings.push_back("CollectedAddressBook"); + + /* retrieve list table names (not from collected ab) */ + std::set<std::string> lists; + MorkParser* pMork = _pCon->getMorkParser("AddressBook"); + pMork->retrieveLists(lists); + for (auto const& elem : lists) + { + OUString groupTableName = OStringToOUString(elem.c_str(), RTL_TEXTENCODING_UTF8); + SAL_INFO("connectivity.mork", "add Table " << groupTableName); + + _rStrings.push_back(groupTableName); + // remember the list in the mork parser, we'll use it later + pMork->lists_.push_back(groupTableName); + } + + std::set<std::string> lists_history; + pMork = _pCon->getMorkParser("CollectedAddressBook"); + pMork->retrieveLists(lists_history); + for (auto const& elem : lists_history) + { + OUString groupTableName = OStringToOUString(elem.c_str(), RTL_TEXTENCODING_UTF8); + SAL_INFO("connectivity.mork", "add Table " << groupTableName); + + _rStrings.push_back(groupTableName); + // remember the list in the mork parser, we'll use it later + pMork->lists_.push_back(groupTableName); + } +} + +void MDatabaseMetaDataHelper::getTables( OConnection* _pCon, + const OUString& tableNamePattern, + ODatabaseMetaDataResultSet::ORows& _rRows) +{ + + SAL_INFO("connectivity.mork", "=> MDatabaseMetaDataHelper::getTables()"); + + static ODatabaseMetaDataResultSet::ORows aRows; + + SAL_INFO("connectivity.mork", "=> MDatabaseMetaDataHelper::getTables()" ); + SAL_INFO("connectivity.mork", "tableNamePattern : " << tableNamePattern); + ::osl::MutexGuard aGuard( m_aMetaMutex ); + + ODatabaseMetaDataResultSet::ORows().swap(aRows); // this makes real clear where memory is freed as well + aRows.clear(); + + std::vector< OUString > tables; + + getTableStrings( _pCon, tables ); + + for (OUString& aTableName : tables) { + ODatabaseMetaDataResultSet::ORow aRow { nullptr, nullptr, nullptr }; + + SAL_INFO("connectivity.mork", "TableName: " << aTableName ); + + + // return tables to caller + if (match( tableNamePattern, aTableName, '\0' )) + { + if ( aTableName.isEmpty() ) { + aTableName = "AddressBook"; + } + + SAL_INFO("connectivity.mork", "TableName: " << aTableName); + + aRow.push_back( new ORowSetValueDecorator( aTableName ) ); // Table/View name + if ((aTableName == "AddressBook") || (aTableName == "CollectedAddressBook")) + { + aRow.push_back( new ORowSetValueDecorator( OUString("TABLE") ) ); // Table type + } + else + { + aRow.push_back( new ORowSetValueDecorator( OUString("VIEW") ) ); // View type + } + aRow.push_back( ODatabaseMetaDataResultSet::getEmptyValue() ); // Remarks + aRows.push_back(aRow); + } + } + + _rRows = aRows; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.hxx b/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.hxx new file mode 100644 index 000000000..0ae96dac9 --- /dev/null +++ b/connectivity/source/drivers/mork/MDatabaseMetaDataHelper.hxx @@ -0,0 +1,39 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDATABASEMETADATAHELPER_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDATABASEMETADATAHELPER_HXX + +#include <FDatabaseMetaDataResultSet.hxx> +#include "MConnection.hxx" + +namespace connectivity +{ + namespace mork + { + class MDatabaseMetaDataHelper + { + public: + MDatabaseMetaDataHelper(); + ~MDatabaseMetaDataHelper(); + + + static void getTableStrings( OConnection* _pCon, + std::vector< OUString >& _rStrings); + + static void getTables( OConnection* _pCon, + const OUString& tableNamePattern, + ODatabaseMetaDataResultSet::ORows& _rRows); + }; + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDATABASEMETADATAHELPER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MDriver.cxx b/connectivity/source/drivers/mork/MDriver.cxx new file mode 100644 index 000000000..0351b6c3e --- /dev/null +++ b/connectivity/source/drivers/mork/MDriver.cxx @@ -0,0 +1,133 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include "MDriver.hxx" +#include "MConnection.hxx" + +#include <com/sun/star/mozilla/XMozillaBootstrap.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> + +#include <sal/log.hxx> + +using namespace connectivity::mork; + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * com_sun_star_comp_sdbc_MorkDriver_get_implementation( + css::uno::XComponentContext* context, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new MorkDriver(context)); +} + +MorkDriver::MorkDriver(const css::uno::Reference< css::uno::XComponentContext >& context): + context_(context), + m_xFactory(context_->getServiceManager(), css::uno::UNO_QUERY) +{ + SAL_INFO("connectivity.mork", "=> MorkDriver::MorkDriver()" ); +} + +OUString SAL_CALL MorkDriver::getImplementationName() +{ + return MORK_DRIVER_IMPL_NAME; +} + +sal_Bool SAL_CALL MorkDriver::supportsService(const OUString& serviceName) +{ + return cppu::supportsService(this, serviceName); +} + +css::uno::Sequence< OUString > MorkDriver::getSupportedServiceNames() +{ + return { "com.sun.star.sdbc.Driver" }; +} + +css::uno::Reference< css::sdbc::XConnection > MorkDriver::connect( + OUString const & url, + css::uno::Sequence< css::beans::PropertyValue > const &) +{ + SAL_INFO("connectivity.mork", "=> MorkDriver::connect()" ); + + // Profile discovery + css::uno::Reference<css::uno::XInterface> xInstance = context_->getServiceManager()->createInstanceWithContext("com.sun.star.mozilla.MozillaBootstrap", context_); + OSL_ENSURE( xInstance.is(), "failed to create instance" ); + + css::uno::Reference<css::mozilla::XMozillaBootstrap> xMozillaBootstrap(xInstance, css::uno::UNO_QUERY); + OSL_ENSURE( xMozillaBootstrap.is(), "failed to create instance" ); + + if (xMozillaBootstrap.is()) + { + OUString defaultProfile = xMozillaBootstrap->getDefaultProfile(css::mozilla::MozillaProductType_Thunderbird); + + if (!defaultProfile.isEmpty()) + { + m_sProfilePath = xMozillaBootstrap->getProfilePath(css::mozilla::MozillaProductType_Thunderbird, defaultProfile); + SAL_INFO("connectivity.mork", "Using Thunderbird profile " << m_sProfilePath); + } + } + + css::uno::Reference< css::sdbc::XConnection > xCon; + OConnection* pCon = new OConnection(this); + xCon = pCon; // important here because otherwise the connection could be deleted inside (refcount goes -> 0) + pCon->construct(url); + return xCon; +} + +sal_Bool MorkDriver::acceptsURL(OUString const & url) +{ + SAL_INFO("connectivity.mork", "=> MorkDriver::acceptsURL()" ); + // Skip 'sdbc:mozab: part of URL + + sal_Int32 nLen = url.indexOf(':'); + nLen = url.indexOf(':',nLen+1); + OUString aAddrbookURI(url.copy(nLen+1)); + // Get Scheme + nLen = aAddrbookURI.indexOf(':'); + OUString aAddrbookScheme; + if ( nLen == -1 ) + { + // There isn't any subschema: - but could be just subschema + if ( !aAddrbookURI.isEmpty() ) + { + aAddrbookScheme= aAddrbookURI; + } + else if( url == "sdbc:address:" ) + { + return false; + } + else + { + return false; + } + } + else + { + aAddrbookScheme = aAddrbookURI.copy(0, nLen); + } + + return aAddrbookScheme == "thunderbird" || aAddrbookScheme == "mozilla"; +} + +css::uno::Sequence< css::sdbc::DriverPropertyInfo > MorkDriver::getPropertyInfo( + OUString const &, + css::uno::Sequence< css::beans::PropertyValue > const &) +{ + //... TODO + return css::uno::Sequence< css::sdbc::DriverPropertyInfo >(); +} + +sal_Int32 MorkDriver::getMajorVersion() { + //... TODO + return 0; +} + +sal_Int32 MorkDriver::getMinorVersion() { + //... TODO + return 0; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MDriver.hxx b/connectivity/source/drivers/mork/MDriver.hxx new file mode 100644 index 000000000..6f6946af6 --- /dev/null +++ b/connectivity/source/drivers/mork/MDriver.hxx @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDRIVER_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MDRIVER_HXX + +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/sdbc/DriverPropertyInfo.hpp> + +#include <com/sun/star/sdbc/XDriver.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <cppuhelper/implbase.hxx> + +#define MORK_DRIVER_IMPL_NAME "com.sun.star.comp.sdbc.MorkDriver" + +namespace com::sun::star { + namespace uno { + class XComponentContext; + class XInterface; + } +} + +namespace connectivity::mork { +class ProfileAccess; + +class MorkDriver: + public cppu::WeakImplHelper< css::lang::XServiceInfo, css::sdbc::XDriver > +{ +public: + explicit MorkDriver(const css::uno::Reference< css::uno::XComponentContext >& context); + + const css::uno::Reference< com::sun::star::lang::XMultiServiceFactory >& getFactory() const {return m_xFactory;} + const OUString& getProfilePath() const {return m_sProfilePath;} +private: + + MorkDriver(const MorkDriver&) = delete; + MorkDriver& operator=(const MorkDriver&) = delete; + + virtual ~MorkDriver() override {} + + virtual OUString SAL_CALL getImplementationName() override; + + virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override; + + virtual css::uno::Sequence< OUString > SAL_CALL + getSupportedServiceNames() override; + + virtual css::uno::Reference< css::sdbc::XConnection > SAL_CALL connect( + OUString const & url, + css::uno::Sequence< css::beans::PropertyValue > const & info) override; + + virtual sal_Bool SAL_CALL acceptsURL( + OUString const & url) override; + + virtual css::uno::Sequence< css::sdbc::DriverPropertyInfo > SAL_CALL + getPropertyInfo( + OUString const & url, + css::uno::Sequence< css::beans::PropertyValue > const & info) override; + + virtual sal_Int32 SAL_CALL getMajorVersion() override; + + virtual sal_Int32 SAL_CALL getMinorVersion() override; + + css::uno::Reference< css::uno::XComponentContext > context_; + css::uno::Reference< css::lang::XMultiServiceFactory > m_xFactory; + OUString m_sProfilePath; +}; + +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MErrorResource.hxx b/connectivity/source/drivers/mork/MErrorResource.hxx new file mode 100644 index 000000000..0691b1813 --- /dev/null +++ b/connectivity/source/drivers/mork/MErrorResource.hxx @@ -0,0 +1,56 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MERRORRESOURCE_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MERRORRESOURCE_HXX + +namespace connectivity +{ + namespace mork + { + class ErrorDescriptor + { + private: + const char* m_pErrorResourceId; + + public: + ErrorDescriptor() + :m_pErrorResourceId(nullptr) + { + } + + void setResId(const char* pErrorResourceId) + { + m_pErrorResourceId = pErrorResourceId; + } + void reset() + { + m_pErrorResourceId = nullptr; + } + + const char* getResId() const { return m_pErrorResourceId; } + + bool is() const { return m_pErrorResourceId != nullptr; } + }; + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MERRORRESOURCE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MPreparedStatement.cxx b/connectivity/source/drivers/mork/MPreparedStatement.cxx new file mode 100644 index 000000000..f2cd8fdc7 --- /dev/null +++ b/connectivity/source/drivers/mork/MPreparedStatement.cxx @@ -0,0 +1,486 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include <connectivity/sdbcx/VColumn.hxx> +#include "MPreparedStatement.hxx" +#include "MResultSetMetaData.hxx" +#include <connectivity/dbtools.hxx> +#include <comphelper/types.hxx> +#include <com/sun/star/sdbc/ColumnValue.hpp> +#include <sal/log.hxx> + +using namespace ::comphelper; +using namespace connectivity; +using namespace connectivity::mork; +using namespace com::sun::star::uno; +using namespace com::sun::star::sdbc; +using namespace com::sun::star::container; +using namespace com::sun::star::util; + +IMPLEMENT_SERVICE_INFO(OPreparedStatement,"com.sun.star.sdbcx.mork.PreparedStatement","com.sun.star.sdbc.PreparedStatement"); + + +OPreparedStatement::OPreparedStatement( OConnection* _pConnection,const OUString& sql) + :OCommonStatement(_pConnection) + ,m_sSqlStatement(sql) + ,m_pResultSet() +{ +} + +OPreparedStatement::~OPreparedStatement() +{ +} + +void OPreparedStatement::lateInit() +{ + if ( eSelect != parseSql( m_sSqlStatement ) ) + throw SQLException(); +} + +void SAL_CALL OPreparedStatement::disposing() +{ + ::osl::MutexGuard aGuard(m_aMutex); + + OCommonStatement::disposing(); + + m_xMetaData.clear(); + if(m_aParameterRow.is()) + { + m_aParameterRow->clear(); + m_aParameterRow = nullptr; + } + m_xParamColumns = nullptr; +} + +OCommonStatement::StatementType OPreparedStatement::parseSql( const OUString& sql , bool bAdjusted ) +{ + StatementType eStatementType = OCommonStatement::parseSql( sql, bAdjusted ); + if ( eStatementType != eSelect ) + return eStatementType; + + m_xParamColumns = new OSQLColumns(); + + // describe all parameters need for the resultset + describeParameter(); + + Reference<XIndexAccess> xNames(m_xColNames,UNO_QUERY); + OResultSet::setBoundedColumns( m_aRow, m_xParamColumns, xNames, false, m_xDBMetaData, m_aColMapping ); + + return eStatementType; +} + +void OPreparedStatement::initializeResultSet( OResultSet* _pResult ) +{ + OCommonStatement::initializeResultSet( _pResult ); + _pResult->setParameterRow( m_aParameterRow ); +} + + +void OPreparedStatement::clearCachedResultSet() +{ + OCommonStatement::clearCachedResultSet(); + m_pResultSet.clear(); + m_xMetaData.clear(); +} + +void OPreparedStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult ) +{ + OCommonStatement::cacheResultSet( _pResult ); + OSL_PRECOND( m_pResultSet == nullptr, "OPreparedStatement::parseSql: you should call clearCachedResultSet before!" ); + m_pResultSet = _pResult; +} + + +void SAL_CALL OPreparedStatement::acquire() throw() +{ + OCommonStatement::acquire(); +} + +void SAL_CALL OPreparedStatement::release() throw() +{ + OCommonStatement::release(); +} + +Any SAL_CALL OPreparedStatement::queryInterface( const Type & rType ) +{ + Any aRet = OCommonStatement::queryInterface(rType); + if(!aRet.hasValue()) + aRet = OPreparedStatement_BASE::queryInterface(rType); + return aRet; +} + +css::uno::Sequence< css::uno::Type > SAL_CALL OPreparedStatement::getTypes( ) +{ + return ::comphelper::concatSequences(OPreparedStatement_BASE::getTypes(),OCommonStatement::getTypes()); +} + + +Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + bool bReadOnly = true; + if ( m_pResultSet.is() ) + bReadOnly = m_pResultSet->determineReadOnly(); + // if we do not have a result set, then we have not been executed, yet. In this case, assuming readonly=true is + // okay, /me thinks. + + if ( !m_xMetaData.is() ) + m_xMetaData = new OResultSetMetaData( m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,bReadOnly ); + + return m_xMetaData; +} + + +sal_Bool SAL_CALL OPreparedStatement::execute( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + Reference< XResultSet> xResult = executeQuery(); + return xResult.is(); +} + + +sal_Int32 SAL_CALL OPreparedStatement::executeUpdate( ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XStatement::executeUpdate", *this ); + return 0; +} + + +void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const OUString& x ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + setParameter( parameterIndex, x ); +} + + +Reference< XConnection > SAL_CALL OPreparedStatement::getConnection( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + return Reference< XConnection >(m_pConnection.get()); +} + + +Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + // our statement has already been parsed in lateInit, no need to do all this (potentially expensive) + // stuff again. Just execute. + return impl_executeCurrentQuery(); +} + + +void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 /*parameterIndex*/, sal_Bool /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setBoolean", *this ); +} + +void SAL_CALL OPreparedStatement::setByte( sal_Int32 /*parameterIndex*/, sal_Int8 /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setByte", *this ); +} + + +void SAL_CALL OPreparedStatement::setDate( sal_Int32 /*parameterIndex*/, const Date& /*aData*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setDate", *this ); +} + + +void SAL_CALL OPreparedStatement::setTime( sal_Int32 /*parameterIndex*/, const css::util::Time& /*aVal*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setTime", *this ); +} + + +void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 /*parameterIndex*/, const DateTime& /*aVal*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setTimestamp", *this ); +} + + +void SAL_CALL OPreparedStatement::setDouble( sal_Int32 /*parameterIndex*/, double /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setDouble", *this ); +} + + +void SAL_CALL OPreparedStatement::setFloat( sal_Int32 /*parameterIndex*/, float /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setFloat", *this ); +} + + +void SAL_CALL OPreparedStatement::setInt( sal_Int32 /*parameterIndex*/, sal_Int32 /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setInt", *this ); +} + + +void SAL_CALL OPreparedStatement::setLong( sal_Int32 /*parameterIndex*/, sal_Int64 /*aVal*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setLong", *this ); +} + + +void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/ ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + checkAndResizeParameters(parameterIndex); + + (*m_aParameterRow)[parameterIndex].setNull(); +} + + +void SAL_CALL OPreparedStatement::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setClob", *this ); +} + + +void SAL_CALL OPreparedStatement::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setBlob", *this ); +} + + +void SAL_CALL OPreparedStatement::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setArray", *this ); +} + + +void SAL_CALL OPreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const Reference< XRef >& /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setRef", *this ); +} + + +void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 /*parameterIndex*/, const Any& /*x*/, sal_Int32 /*sqlType*/, sal_Int32 /*scale*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setObjectWithInfo", *this ); +} + + +void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const OUString& /*typeName*/ ) +{ + setNull(parameterIndex,sqlType); +} + + +void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) +{ + ::dbtools::implSetObject(this,parameterIndex,x); +} + + +void SAL_CALL OPreparedStatement::setShort( sal_Int32 /*parameterIndex*/, sal_Int16 /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setShort", *this ); +} + + +void SAL_CALL OPreparedStatement::setBytes( sal_Int32 /*parameterIndex*/, const Sequence< sal_Int8 >& /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setBytes", *this ); +} + + +void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 /*parameterIndex*/, const Reference< css::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setCharacterStream", *this ); +} + + +void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 /*parameterIndex*/, const Reference< css::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XParameters::setBinaryStream", *this ); +} + + +void SAL_CALL OPreparedStatement::clearParameters( ) +{ +} + +void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) +{ + switch(nHandle) + { + case PROPERTY_ID_RESULTSETCONCURRENCY: + break; + case PROPERTY_ID_RESULTSETTYPE: + break; + case PROPERTY_ID_FETCHDIRECTION: + break; + case PROPERTY_ID_USEBOOKMARKS: + break; + default: + OCommonStatement::setFastPropertyValue_NoBroadcast(nHandle,rValue); + } +} + + +void OPreparedStatement::checkAndResizeParameters(sal_Int32 parameterIndex) +{ + ::connectivity::checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + if ( !m_aParameterRow.is() ) { + m_aParameterRow = new OValueVector(); + m_aParameterRow->push_back(sal_Int32(0)); + } + + if (static_cast<sal_Int32>(m_aParameterRow->size()) <= parameterIndex) + m_aParameterRow->resize(parameterIndex+1); +} + +void OPreparedStatement::setParameter(sal_Int32 parameterIndex, const +ORowSetValue& x) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkAndResizeParameters(parameterIndex); + + SAL_INFO( + "connectivity.mork", + "setParameter(" << parameterIndex << ", '" << x.getString() << "')"); + (*m_aParameterRow)[parameterIndex] = x; +} + + +void OPreparedStatement::AddParameter(OSQLParseNode const * pParameter, const Reference<XPropertySet>& _xCol) +{ + OSL_ENSURE(SQL_ISRULE(pParameter,parameter),"OResultSet::AddParameter: Argument is not a Parameter"); + OSL_ENSURE(pParameter->count() > 0,"OResultSet: error in parse tree"); + + OUString sParameterName; + + // set up Parameter-Column: + sal_Int32 eType = DataType::VARCHAR; + sal_uInt32 nPrecision = 255; + sal_Int32 nScale = 0; + sal_Int32 nNullable = ColumnValue::NULLABLE; + + if (_xCol.is()) + { + // Type, Precision, Scale ... utilize the selected Columns, + // then this Column will get the value assigned or with this + // Column will the value be compared. + eType = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))); + nPrecision = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))); + nScale = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))); + nNullable = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE))); + _xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sParameterName; + } + + Reference<XPropertySet> xParaColumn = new connectivity::sdbcx::OColumn(sParameterName + ,OUString() + ,OUString() + ,OUString() + ,nNullable + ,nPrecision + ,nScale + ,eType + ,false + ,false + ,false + ,m_pSQLIterator->isCaseSensitive() + ,OUString() + ,OUString() + ,OUString()); + m_xParamColumns->push_back(xParaColumn); +} + +void OPreparedStatement::describeColumn(OSQLParseNode const * _pParameter, + OSQLParseNode const * _pNode, + const OSQLTable& _xTable) +{ + Reference<XPropertySet> xProp; + if(SQL_ISRULE(_pNode,column_ref)) + { + OUString sColumnName,sTableRange; + m_pSQLIterator->getColumnRange(_pNode,sColumnName,sTableRange); + if(!sColumnName.isEmpty()) + { + Reference<XNameAccess> xNameAccess = _xTable->getColumns(); + if(xNameAccess->hasByName(sColumnName)) + xNameAccess->getByName(sColumnName) >>= xProp; + AddParameter(_pParameter,xProp); + } + } + // else + // AddParameter(_pParameter,xProp); +} + +void OPreparedStatement::describeParameter() +{ + std::vector< OSQLParseNode*> aParseNodes; + scanParameter(m_pParseTree.get(), aParseNodes); + if(aParseNodes.empty()) + return; + + m_xParamColumns = new OSQLColumns(); + const OSQLTables& rTabs = m_pSQLIterator->getTables(); + if(!rTabs.empty()) + { + OSQLTable xTable = rTabs.begin()->second; + for (auto const& parseNode : aParseNodes) + { + describeColumn(parseNode,parseNode->getParent()->getChild(0),xTable); + } + } +} + + +void OPreparedStatement::scanParameter(OSQLParseNode* pParseNode,std::vector< OSQLParseNode*>& _rParaNodes) +{ + OSL_ENSURE(pParseNode != nullptr,"OResultSet: internal error: invalid ParseNode"); + + // Parameter Name-Row found? + if (SQL_ISRULE(pParseNode,parameter)) + { + OSL_ENSURE(pParseNode->count() >= 1,"OResultSet: Faulty Parse Tree"); + OSL_ENSURE(pParseNode->getChild(0)->getNodeType() == SQLNodeType::Punctuation,"OResultSet: Faulty Parse Tree"); + + _rParaNodes.push_back(pParseNode); + // further search isn't necessary + return; + } + + // Search on in Parse Tree + for (size_t i = 0; i < pParseNode->count(); i++) + scanParameter(pParseNode->getChild(i),_rParaNodes); +} + +css::uno::Reference< css::sdbc::XResultSet > SAL_CALL OPreparedStatement::getResultSet( ) +{ + return nullptr; +} + +sal_Int32 SAL_CALL OPreparedStatement::getUpdateCount( ) +{ + return 0; +} + +sal_Bool SAL_CALL OPreparedStatement::getMoreResults( ) +{ + return false; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MPreparedStatement.hxx b/connectivity/source/drivers/mork/MPreparedStatement.hxx new file mode 100644 index 000000000..c40ffc909 --- /dev/null +++ b/connectivity/source/drivers/mork/MPreparedStatement.hxx @@ -0,0 +1,134 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MPREPAREDSTATEMENT_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MPREPAREDSTATEMENT_HXX + +#include "MResultSet.hxx" +#include <com/sun/star/sdbc/XParameters.hpp> +#include <com/sun/star/sdbc/XMultipleResults.hpp> +#include <cppuhelper/implbase5.hxx> + +namespace connectivity +{ + namespace mork + { + + typedef ::cppu::ImplHelper5< css::sdbc::XPreparedStatement, + css::sdbc::XParameters, + css::sdbc::XResultSetMetaDataSupplier, + css::sdbc::XMultipleResults, + css::lang::XServiceInfo> OPreparedStatement_BASE; + + class OPreparedStatement final : public OCommonStatement, + public OPreparedStatement_BASE + { + // Data attributes + + OUString m_sSqlStatement; + css::uno::Reference< css::sdbc::XResultSetMetaData > m_xMetaData; + ::rtl::Reference< OResultSet > m_pResultSet; + ::rtl::Reference<connectivity::OSQLColumns> m_xParamColumns; // the parameter columns + OValueRow m_aParameterRow; + + virtual void SAL_CALL setFastPropertyValue_NoBroadcast(sal_Int32 nHandle, + const css::uno::Any& rValue) override; + virtual ~OPreparedStatement() override; + + virtual void SAL_CALL disposing() override; + + // OCommonStatement overridables + virtual StatementType + parseSql( const OUString& sql , bool bAdjusted = false) override; + virtual void initializeResultSet( OResultSet* _pResult ) override; + virtual void clearCachedResultSet() override; + virtual void cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult ) override; + + + void checkAndResizeParameters(sal_Int32 parameterIndex); + void setParameter(sal_Int32 parameterIndex, const ORowSetValue& x); + + void AddParameter(connectivity::OSQLParseNode const * pParameter, + const css::uno::Reference< css::beans::XPropertySet>& _xCol); + void scanParameter(OSQLParseNode* pParseNode,std::vector< OSQLParseNode*>& _rParaNodes); + void describeColumn(OSQLParseNode const * _pParameter, OSQLParseNode const * _pNode, const OSQLTable& _xTable); + void describeParameter(); + + public: + DECLARE_SERVICE_INFO(); + // A ctor need for returning the object + OPreparedStatement( OConnection* _pConnection,const OUString& sql); + void lateInit(); + + //XInterface + virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + virtual void SAL_CALL acquire() throw() override; + virtual void SAL_CALL release() throw() override; + //XTypeProvider + virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes( ) override; + + // XPreparedStatement + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL executeQuery( ) override; + virtual sal_Int32 SAL_CALL executeUpdate( ) override; + virtual sal_Bool SAL_CALL execute( ) override; + virtual css::uno::Reference< css::sdbc::XConnection > SAL_CALL getConnection( ) override; + // XParameters + virtual void SAL_CALL setNull( sal_Int32 parameterIndex, sal_Int32 sqlType ) override; + virtual void SAL_CALL setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const OUString& typeName ) override; + virtual void SAL_CALL setBoolean( sal_Int32 parameterIndex, sal_Bool x ) override; + virtual void SAL_CALL setByte( sal_Int32 parameterIndex, sal_Int8 x ) override; + virtual void SAL_CALL setShort( sal_Int32 parameterIndex, sal_Int16 x ) override; + virtual void SAL_CALL setInt( sal_Int32 parameterIndex, sal_Int32 x ) override; + virtual void SAL_CALL setLong( sal_Int32 parameterIndex, sal_Int64 x ) override; + virtual void SAL_CALL setFloat( sal_Int32 parameterIndex, float x ) override; + virtual void SAL_CALL setDouble( sal_Int32 parameterIndex, double x ) override; + virtual void SAL_CALL setString( sal_Int32 parameterIndex, const OUString& x ) override; + virtual void SAL_CALL setBytes( sal_Int32 parameterIndex, const css::uno::Sequence< sal_Int8 >& x ) override; + virtual void SAL_CALL setDate( sal_Int32 parameterIndex, const css::util::Date& x ) override; + virtual void SAL_CALL setTime( sal_Int32 parameterIndex, const css::util::Time& x ) override; + virtual void SAL_CALL setTimestamp( sal_Int32 parameterIndex, const css::util::DateTime& x ) override; + virtual void SAL_CALL setBinaryStream( sal_Int32 parameterIndex, const css::uno::Reference< css::io::XInputStream >& x, sal_Int32 length ) override; + virtual void SAL_CALL setCharacterStream( sal_Int32 parameterIndex, const css::uno::Reference< css::io::XInputStream >& x, sal_Int32 length ) override; + virtual void SAL_CALL setObject( sal_Int32 parameterIndex, const css::uno::Any& x ) override; + virtual void SAL_CALL setObjectWithInfo( sal_Int32 parameterIndex, const css::uno::Any& x, sal_Int32 targetSqlType, sal_Int32 scale ) override; + virtual void SAL_CALL setRef( sal_Int32 parameterIndex, const css::uno::Reference< css::sdbc::XRef >& x ) override; + virtual void SAL_CALL setBlob( sal_Int32 parameterIndex, const css::uno::Reference< css::sdbc::XBlob >& x ) override; + virtual void SAL_CALL setClob( sal_Int32 parameterIndex, const css::uno::Reference< css::sdbc::XClob >& x ) override; + virtual void SAL_CALL setArray( sal_Int32 parameterIndex, const css::uno::Reference< css::sdbc::XArray >& x ) override; + virtual void SAL_CALL clearParameters( ) override; + // XResultSetMetaDataSupplier + virtual css::uno::Reference< css::sdbc::XResultSetMetaData > SAL_CALL getMetaData( ) override; + // XMultipleResults + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL getResultSet( ) override; + virtual sal_Int32 SAL_CALL getUpdateCount( ) override; + virtual sal_Bool SAL_CALL getMoreResults( ) override; + + public: + using OCommonStatement::executeQuery; + using OCommonStatement::executeUpdate; + using OCommonStatement::execute; + private: + using OPropertySetHelper::getFastPropertyValue; + }; + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MPREPAREDSTATEMENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MQueryHelper.cxx b/connectivity/source/drivers/mork/MQueryHelper.cxx new file mode 100644 index 000000000..aaf8cac6a --- /dev/null +++ b/connectivity/source/drivers/mork/MQueryHelper.cxx @@ -0,0 +1,321 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include "MColumnAlias.hxx" +#include "MQueryHelper.hxx" +#include "MConnection.hxx" + +#include "MorkParser.hxx" +#include <string> +#include <vector> +#include <algorithm> + +#include <strings.hrc> + +#include <unotools/textsearch.hxx> +#include <sal/log.hxx> + +using namespace connectivity::mork; +using namespace connectivity; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::sdbc; + + +static +std::vector<bool> entryMatchedByExpression(MQueryHelper* _aQuery, MQueryExpression const * _aExpr, MQueryHelperResultEntry* entry); + +MQueryHelperResultEntry::MQueryHelperResultEntry() +{ +} + +MQueryHelperResultEntry::~MQueryHelperResultEntry() +{ +} + +OUString MQueryHelperResultEntry::getValue( const OString &key ) const +{ + FieldMap::const_iterator iter = m_Fields.find( key ); + if ( iter == m_Fields.end() ) + { + return OUString(); + } + else + { + return iter->second; + } +} + +void MQueryHelperResultEntry::setValue( const OString &key, const OUString & rValue) +{ + m_Fields[ key ] = rValue; +} + +MQueryHelper::MQueryHelper(const OColumnAlias& _ca) + :m_rColumnAlias( _ca ) + ,m_aError() +{ + m_aResults.clear(); +} + +MQueryHelper::~MQueryHelper() +{ + clear_results(); +} + + +void MQueryHelper::setAddressbook(OUString const &ab) +{ + ::osl::MutexGuard aGuard(m_aMutex); + m_aAddressbook = ab; +} + +void MQueryHelper::append(std::unique_ptr<MQueryHelperResultEntry> resEnt) +{ + assert(resEnt); + m_aResults.push_back( std::move(resEnt) ); +} + +void MQueryHelper::clear_results() +{ + m_aResults.clear(); +} + +void MQueryHelper::reset() +{ + clear_results(); + m_aError.reset(); +} + +MQueryHelperResultEntry* +MQueryHelper::getByIndex(sal_uInt32 nRow) +{ + // Row numbers are from 1 to N, need to ensure this, and then + // subtract 1 + if ( nRow < 1 ) { + return nullptr; + } + return m_aResults[nRow -1].get(); +} + +sal_Int32 MQueryHelper::getResultCount() const +{ + sal_Int32 result = static_cast<sal_Int32>(m_aResults.size()); + + return result; +} + +bool MQueryHelper::getRowValue( ORowSetValue& rValue, sal_Int32 nDBRow,const OUString& aDBColumnName, sal_Int32 nType ) +{ + MQueryHelperResultEntry* pResEntry = getByIndex( nDBRow ); + + OSL_ENSURE( pResEntry != nullptr, "xResEntry == NULL"); + if (pResEntry == nullptr ) + { + rValue.setNull(); + return false; + } + switch ( nType ) + { + case DataType::VARCHAR: + rValue = pResEntry->getValue( m_rColumnAlias.getProgrammaticNameOrFallbackToUTF8Alias( aDBColumnName ) ); + break; + + default: + rValue.setNull(); + break; + } + + return true; +} + +sal_Int32 MQueryHelper::executeQuery(OConnection* xConnection, MQueryExpression & expr) +{ + reset(); + + OString oStringTable = OUStringToOString( m_aAddressbook, RTL_TEXTENCODING_UTF8 ); + std::set<int> listRecords; + bool handleListTable = false; + MorkParser* pMork; + + // check if we are retrieving the default table + if (oStringTable == "AddressBook" || oStringTable == "CollectedAddressBook") + { + pMork = xConnection->getMorkParser(oStringTable); + } + else + { + // Let's try to retrieve the list in Collected Addresses book + pMork = xConnection->getMorkParser("CollectedAddressBook"); + if (std::find(pMork->lists_.begin(), pMork->lists_.end(), m_aAddressbook) == pMork->lists_.end()) + { + // so the list is in Address book + // TODO : manage case where an address book has been created + pMork = xConnection->getMorkParser("AddressBook"); + } + handleListTable = true; + // retrieve row ids for that list table + std::string listTable = oStringTable.getStr(); + pMork->getRecordKeysForListTable(listTable, listRecords); + } + + MorkTableMap *Tables = pMork->getTables( 0x80 ); + if (!Tables) + return -1; + + MorkRowMap *Rows = nullptr; + + // Iterate all tables + for (auto & table : Tables->map) + { + if (table.first != 1) break; + Rows = MorkParser::getRows( 0x80, &table.second ); + if ( Rows ) + { + // Iterate all rows + for (auto const& row : Rows->map) + { + // list specific table + // only retrieve rowIds that belong to that list table. + if (handleListTable) + { + int rowId = row.first; + // belongs this row id to the list table? + if (listRecords.end() == listRecords.find(rowId)) + { + // no, skip it + continue; + } + } + + std::unique_ptr<MQueryHelperResultEntry> entry(new MQueryHelperResultEntry()); + for (auto const& cell : row.second) + { + std::string column = pMork->getColumn(cell.first); + std::string value = pMork->getValue(cell.second); + OString key(column.c_str(), static_cast<sal_Int32>(column.size())); + OString valueOString(value.c_str(), static_cast<sal_Int32>(value.size())); + OUString valueOUString = OStringToOUString( valueOString, RTL_TEXTENCODING_UTF8 ); + entry->setValue(key, valueOUString); + } + bool result = true; + for (bool elem : entryMatchedByExpression(this, &expr, entry.get())) + { + result = result && elem; + } + if (result) + { + append(std::move(entry)); + } + } + } + } + return 0; +} + +std::vector<bool> entryMatchedByExpression(MQueryHelper* _aQuery, MQueryExpression const * _aExpr, MQueryHelperResultEntry* entry) +{ + std::vector<bool> resultVector; + for (auto const& expr : _aExpr->getExpressions()) + { + if ( expr->isStringExpr() ) { + MQueryExpressionString* evStr = static_cast<MQueryExpressionString*> (expr); + // Set the 'name' property of the boolString. + OString attrName = _aQuery->getColumnAlias().getProgrammaticNameOrFallbackToUTF8Alias( evStr->getName() ); + SAL_INFO("connectivity.mork", "Name = " << attrName); + bool bRequiresValue = true; + OUString currentValue = entry->getValue(attrName); + if (evStr->getCond() == MQueryOp::Exists || evStr->getCond() == MQueryOp::DoesNotExist) + { + bRequiresValue = false; + } + if (bRequiresValue) + { + SAL_INFO("connectivity.mork", "Value = " << evStr->getValue() ); + const OUString& searchedValue = evStr->getValue(); + if (evStr->getCond() == MQueryOp::Is) { + SAL_INFO("connectivity.mork", "MQueryOp::Is; done"); + resultVector.push_back(currentValue == searchedValue); + } else if (evStr->getCond() == MQueryOp::IsNot) { + SAL_INFO("connectivity.mork", "MQueryOp::IsNot; done"); + resultVector.push_back(currentValue != searchedValue); + } else if (evStr->getCond() == MQueryOp::EndsWith) { + SAL_INFO("connectivity.mork", "MQueryOp::EndsWith; done"); + resultVector.push_back(currentValue.endsWith(searchedValue)); + } else if (evStr->getCond() == MQueryOp::BeginsWith) { + SAL_INFO("connectivity.mork", "MQueryOp::BeginsWith; done"); + resultVector.push_back(currentValue.startsWith(searchedValue)); + } else if (evStr->getCond() == MQueryOp::Contains) { + SAL_INFO("connectivity.mork", "MQueryOp::Contains; done"); + resultVector.push_back(currentValue.indexOf(searchedValue) != -1); + } else if (evStr->getCond() == MQueryOp::DoesNotContain) { + SAL_INFO("connectivity.mork", "MQueryOp::DoesNotContain; done"); + resultVector.push_back(currentValue.indexOf(searchedValue) == -1); + } else if (evStr->getCond() == MQueryOp::RegExp) { + SAL_INFO("connectivity.mork", "MQueryOp::RegExp; done"); + utl::SearchParam param( + searchedValue, utl::SearchParam::SearchType::Regexp); + utl::TextSearch ts(param, LANGUAGE_DONTKNOW); + sal_Int32 start = 0; + sal_Int32 end = currentValue.getLength(); + resultVector.push_back( + ts.SearchForward(currentValue, &start, &end)); + } + } else if (evStr->getCond() == MQueryOp::Exists) { + SAL_INFO("connectivity.mork", "MQueryOp::Exists; done"); + resultVector.push_back(!currentValue.isEmpty()); + } else if (evStr->getCond() == MQueryOp::DoesNotExist) { + SAL_INFO("connectivity.mork", "MQueryOp::DoesNotExist; done"); + resultVector.push_back(currentValue.isEmpty()); + } + } + else if ( expr->isExpr() ) { + SAL_INFO("connectivity.mork", "Appending Subquery Expression"); + MQueryExpression* queryExpression = static_cast<MQueryExpression*> (expr); + // recursive call + std::vector<bool> subquery_result = entryMatchedByExpression(_aQuery, queryExpression, entry); + MQueryExpression::bool_cond condition = queryExpression->getExpressionCondition(); + if (condition == MQueryExpression::OR) { + bool result = false; + for (bool elem : subquery_result) + { + result = result || elem; + } + resultVector.push_back(result); + } else { + assert(condition == MQueryExpression::AND && "only OR or AND should exist"); + bool result = true; + for (bool elem : subquery_result) + { + result = result && elem; + } + resultVector.push_back(result); + } + } + else { + // Should never see this... + SAL_WARN("connectivity.mork", "Unknown Expression Type!"); + _aQuery->getError().setResId(STR_ERROR_GET_ROW); + return resultVector; + } + } + return resultVector; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MQueryHelper.hxx b/connectivity/source/drivers/mork/MQueryHelper.hxx new file mode 100644 index 000000000..67d2b081d --- /dev/null +++ b/connectivity/source/drivers/mork/MQueryHelper.hxx @@ -0,0 +1,184 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MQUERYHELPER_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MQUERYHELPER_HXX + +#include <connectivity/FValue.hxx> +#include "MErrorResource.hxx" +#include "MColumnAlias.hxx" + +namespace connectivity +{ + namespace mork + { + class OConnection; + class MQueryHelper; + class ErrorDescriptor; + + namespace MQueryOp { + typedef enum { + Exists = 0, + DoesNotExist = 1, + Contains = 2, + DoesNotContain = 3, + Is = 4, + IsNot = 5, + BeginsWith = 6, + EndsWith = 7, + RegExp = 8 + } cond_type; + } + + class MQueryExpressionBase { + public: + enum class node_type { + StringExpr, + Expr + }; + + protected: + node_type m_eNodeType; + + explicit MQueryExpressionBase( node_type _eNodeType ) : m_eNodeType( _eNodeType ) {} + + public: + virtual ~MQueryExpressionBase() {} + + bool isStringExpr( ) const { return m_eNodeType == node_type::StringExpr; } + bool isExpr( ) const { return m_eNodeType == node_type::Expr; } + }; + + class MQueryExpressionString final : public MQueryExpressionBase { + OUString m_aName; // LHS + MQueryOp::cond_type m_aBooleanCondition; + OUString m_aValue; // RHS + + public: + + MQueryExpressionString( const OUString& lhs, + MQueryOp::cond_type cond, + const OUString& rhs ) + : MQueryExpressionBase( MQueryExpressionBase::node_type::StringExpr ) + , m_aName( lhs ) + , m_aBooleanCondition( cond ) + , m_aValue( rhs ) + { + } + + MQueryExpressionString( const OUString& lhs, + MQueryOp::cond_type cond ) + : MQueryExpressionBase( MQueryExpressionBase::node_type::StringExpr ) + , m_aName( lhs ) + , m_aBooleanCondition( cond ) + , m_aValue( OUString() ) + { + } + + const OUString& getName() const { return m_aName; } + MQueryOp::cond_type getCond() const { return m_aBooleanCondition; } + const OUString& getValue() const { return m_aValue; } + }; + + class MQueryExpression final : public MQueryExpressionBase + { + friend class MQueryHelper; + + public: + typedef std::vector< MQueryExpressionBase* > ExprVector; + + typedef enum { + AND, + OR + } bool_cond; + + // All expressions on a peer level use same condition operator + void setExpressionCondition( bool_cond _cond ) + { m_aExprCondType = _cond; } + + void addExpression(MQueryExpressionBase * expr) + { m_aExprVector.push_back(expr); } + + ExprVector const & getExpressions( ) const + { return m_aExprVector; } + + // All expressions on a peer level use same condition operator + bool_cond getExpressionCondition( ) const + { return m_aExprCondType; } + + MQueryExpression() : MQueryExpressionBase( MQueryExpressionBase::node_type::Expr ), + m_aExprCondType( OR ) + {} + + private: + ExprVector m_aExprVector; + bool_cond m_aExprCondType; + + MQueryExpression(const MQueryExpression&) = delete; + MQueryExpression& operator=(const MQueryExpression&) = delete; + }; + + class MQueryHelperResultEntry + { + private: + typedef std::unordered_map< OString, OUString > FieldMap; + + FieldMap m_Fields; + + public: + MQueryHelperResultEntry(); + ~MQueryHelperResultEntry(); + + OUString getValue( const OString &key ) const; + void setValue( const OString &key, const OUString & rValue); + }; + + class MQueryHelper final + { + private: + + mutable ::osl::Mutex m_aMutex; + std::vector< std::unique_ptr<MQueryHelperResultEntry> > m_aResults; + void append(std::unique_ptr<MQueryHelperResultEntry> resEnt ); + void clear_results(); + OColumnAlias m_rColumnAlias; + ErrorDescriptor m_aError; + OUString m_aAddressbook; + + public: + explicit MQueryHelper(const OColumnAlias& _ca); + ~MQueryHelper(); + + void reset(); + MQueryHelperResultEntry* getByIndex( sal_uInt32 nRow ); + sal_Int32 getResultCount() const; + bool getRowValue( ORowSetValue& rValue, sal_Int32 nDBRow,const OUString& aDBColumnName, sal_Int32 nType ); + sal_Int32 executeQuery(OConnection* xConnection, MQueryExpression & expr); + const OColumnAlias& getColumnAlias() const { return m_rColumnAlias; } + bool hadError() const { return m_aError.is(); } + ErrorDescriptor& getError() { return m_aError; } + + void setAddressbook( OUString const &); + }; + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MQUERYHELPER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MResultSet.cxx b/connectivity/source/drivers/mork/MResultSet.cxx new file mode 100644 index 000000000..ab6b11a9d --- /dev/null +++ b/connectivity/source/drivers/mork/MResultSet.cxx @@ -0,0 +1,1710 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <com/sun/star/sdbc/ResultSetType.hpp> +#include <com/sun/star/sdbc/FetchDirection.hpp> +#include <com/sun/star/sdbc/ResultSetConcurrency.hpp> +#include <com/sun/star/sdbcx/CompareBookmark.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <connectivity/dbtools.hxx> +#include <comphelper/types.hxx> +#include <cppuhelper/typeprovider.hxx> +#include <o3tl/safeint.hxx> +#include <sal/log.hxx> + +#include <vector> +#include <algorithm> +#include "MResultSet.hxx" +#include <sqlbison.hxx> +#include "MResultSetMetaData.hxx" +#include <FDatabaseMetaDataResultSet.hxx> + +#include <strings.hrc> + +using namespace ::comphelper; +using namespace connectivity; +using namespace connectivity::mork; +using namespace ::cppu; +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; +using namespace com::sun::star::beans; +using namespace com::sun::star::sdbc; +using namespace com::sun::star::sdbcx; +using namespace com::sun::star::container; +using namespace com::sun::star::io; +using namespace com::sun::star::util; + + +// IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.OResultSet","com.sun.star.sdbc.ResultSet"); +OUString SAL_CALL OResultSet::getImplementationName( ) +{ + return "com.sun.star.sdbcx.mork.ResultSet"; +} + + Sequence< OUString > SAL_CALL OResultSet::getSupportedServiceNames( ) +{ + return {"com.sun.star.sdbc.ResultSet","com.sun.star.sdbcx.ResultSet"}; +} + +sal_Bool SAL_CALL OResultSet::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + + +OResultSet::OResultSet(OCommonStatement* pStmt, const std::shared_ptr< connectivity::OSQLParseTreeIterator >& _pSQLIterator ) + : OResultSet_BASE(m_aMutex) + ,OPropertySetHelper(OResultSet_BASE::rBHelper) + ,m_pStatement(pStmt) + ,m_xStatement(*pStmt) + ,m_nRowPos(0) + ,m_bWasNull(false) + ,m_nResultSetType(ResultSetType::SCROLL_INSENSITIVE) + ,m_nFetchDirection(FetchDirection::FORWARD) + ,m_pSQLIterator( _pSQLIterator ) + ,m_pParseTree( _pSQLIterator->getParseTree() ) + ,m_aQueryHelper(pStmt->getOwnConnection()->getColumnAlias()) + ,m_CurrentRowCount(0) + ,m_nParamIndex(0) + ,m_bIsAlwaysFalseQuery(false) + ,m_bIsReadOnly(TRISTATE_INDET) +{ + //m_aQuery.setMaxNrOfReturns(pStmt->getOwnConnection()->getMaxResultRecords()); +} + +OResultSet::~OResultSet() +{ +} + + +void OResultSet::disposing() +{ + OPropertySetHelper::disposing(); + + ::osl::MutexGuard aGuard(m_aMutex); + + m_xStatement.clear(); + m_xMetaData.clear(); + m_pParseTree = nullptr; + m_xColumns = nullptr; + m_pKeySet = nullptr; + m_xTable.clear(); +} + +Any SAL_CALL OResultSet::queryInterface( const Type & rType ) +{ + Any aRet = OPropertySetHelper::queryInterface(rType); + if(!aRet.hasValue()) + aRet = OResultSet_BASE::queryInterface(rType); + return aRet; +} + + Sequence< Type > SAL_CALL OResultSet::getTypes( ) +{ + OTypeCollection aTypes( cppu::UnoType<css::beans::XMultiPropertySet>::get(), + cppu::UnoType<css::beans::XFastPropertySet>::get(), + cppu::UnoType<css::beans::XPropertySet>::get()); + + return ::comphelper::concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes()); +} + +void OResultSet::methodEntry() +{ + checkDisposed(OResultSet_BASE::rBHelper.bDisposed); + if ( !m_xTable.is() ) + { + OSL_FAIL( "OResultSet::methodEntry: looks like we're disposed, but how is this possible?" ); + throw DisposedException( OUString(), *this ); + } +} + + +sal_Int32 SAL_CALL OResultSet::findColumn( const OUString& columnName ) +{ + ResultSetEntryGuard aGuard( *this ); + + // find the first column with the name columnName + Reference< XResultSetMetaData > xMeta = getMetaData(); + sal_Int32 nLen = xMeta->getColumnCount(); + sal_Int32 i = 1; + for(;i<=nLen;++i) + { + if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) : + columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i))) + return i; + } + + ::dbtools::throwInvalidColumnException( columnName, *this ); + assert(false); + return 0; // Never reached +} + +Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ ) +{ + return nullptr; +} + +Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) +{ + return nullptr; +} + + +sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 /*columnIndex*/ ) +{ + ResultSetEntryGuard aGuard( *this ); + m_bWasNull = true; + return false; +} + + +sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 /*columnIndex*/ ) +{ + return 0; +} + + +Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 /*columnIndex*/ ) +{ + return Sequence< sal_Int8 >(); +} + + +Date SAL_CALL OResultSet::getDate( sal_Int32 /*columnIndex*/ ) +{ + return Date(); +} + + +double SAL_CALL OResultSet::getDouble( sal_Int32 /*columnIndex*/ ) +{ + return 0.0; +} + + +float SAL_CALL OResultSet::getFloat( sal_Int32 /*columnIndex*/ ) +{ + return 0; +} + + +sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 /*columnIndex*/ ) +{ + return 0; +} + + +sal_Int32 SAL_CALL OResultSet::getRow( ) +{ + ResultSetEntryGuard aGuard( *this ); + + SAL_INFO("connectivity.mork", "return = " << m_nRowPos); + return m_nRowPos; +} + + +sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 /*columnIndex*/ ) +{ + return sal_Int64(); +} + + +Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData( ) +{ + ResultSetEntryGuard aGuard( *this ); + + if(!m_xMetaData.is()) + m_xMetaData = new OResultSetMetaData( + m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first, m_xTable.get(), determineReadOnly()); + return m_xMetaData; +} + +Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 /*columnIndex*/ ) +{ + return nullptr; +} + + +Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 /*columnIndex*/ ) +{ + return nullptr; +} + +Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 /*columnIndex*/ ) +{ + return nullptr; +} + + +Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ ) +{ + return nullptr; +} + + +Any SAL_CALL OResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< css::container::XNameAccess >& /*typeMap*/ ) +{ + return Any(); +} + + +sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 /*columnIndex*/ ) +{ + return 0; +} + + +void OResultSet::checkIndex(sal_Int32 columnIndex ) +{ + if(columnIndex <= 0 || columnIndex > static_cast<sal_Int32>(m_xColumns->size())) + ::dbtools::throwInvalidIndexException(*this); +} + +sal_uInt32 OResultSet::currentRowCount() +{ + if ( m_bIsAlwaysFalseQuery ) + return 0; + //return 0;//m_aQuery.getRealRowCount() - deletedCount(); + // new implementation + return m_aQueryHelper.getResultCount(); +} + + +bool OResultSet::fetchCurrentRow( ) +{ + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + return fetchRow(getCurrentCardNumber()); +} + + +bool OResultSet::fetchRow(sal_Int32 cardNumber,bool bForceReload) +{ + SAL_INFO("connectivity.mork", "cardNumber = " << cardNumber); + if (!bForceReload) + { + // Check whether we've already fetched the row... + if ( !(*m_aRow)[0].isNull() && static_cast<sal_Int32>((*m_aRow)[0]) == cardNumber ) + return true; + } +// else +// m_aQuery.resyncRow(cardNumber); + + if ( !validRow( cardNumber ) ) + return false; + + (*m_aRow)[0] = cardNumber; + sal_Int32 nCount = m_aColumnNames.getLength(); + //m_RowStates = m_aQuery.getRowStates(cardNumber); + for( sal_Int32 i = 1; i <= nCount; i++ ) + { + if ( (*m_aRow)[i].isBound() ) + { + + // Everything in the addressbook is a string! + + if ( !m_aQueryHelper.getRowValue( (*m_aRow)[i], cardNumber, m_aColumnNames[i-1], DataType::VARCHAR )) + { + m_pStatement->getOwnConnection()->throwSQLException( m_aQueryHelper.getError(), *this ); + } + } + } + return true; + +} + + +const ORowSetValue& OResultSet::getValue(sal_Int32 cardNumber, sal_Int32 columnIndex ) +{ + if ( !fetchRow( cardNumber ) ) + { + OSL_FAIL("fetchRow() returned False" ); + m_bWasNull = true; + return *ODatabaseMetaDataResultSet::getEmptyValue(); + } + + m_bWasNull = (*m_aRow)[columnIndex].isNull(); + return (*m_aRow)[columnIndex]; + +} + + +OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) +{ + ResultSetEntryGuard aGuard( *this ); + + OSL_ENSURE(m_xColumns.is(), "Need the Columns!!"); + OSL_ENSURE(columnIndex <= static_cast<sal_Int32>(m_xColumns->size()), "Trying to access invalid columns number"); + checkIndex( columnIndex ); + + // If this query was sorted then we should have a valid KeySet, so use it + return getValue(getCurrentCardNumber(), mapColumn( columnIndex ) ); + +} + + +Time SAL_CALL OResultSet::getTime( sal_Int32 /*columnIndex*/ ) +{ + ResultSetEntryGuard aGuard( *this ); + return Time(); +} + + +DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 /*columnIndex*/ ) +{ + ResultSetEntryGuard aGuard( *this ); + return DateTime(); +} + + +sal_Bool SAL_CALL OResultSet::isBeforeFirst( ) +{ + ResultSetEntryGuard aGuard( *this ); + + // here you have to implement your movements + // return true means there is no data + return( m_nRowPos < 1 ); +} + +sal_Bool SAL_CALL OResultSet::isAfterLast( ) +{ + SAL_WARN("connectivity.mork", "OResultSet::isAfterLast() NOT IMPLEMENTED!"); + ResultSetEntryGuard aGuard( *this ); + + return m_nRowPos > currentRowCount(); +} + +sal_Bool SAL_CALL OResultSet::isFirst( ) +{ + ResultSetEntryGuard aGuard( *this ); + + return m_nRowPos == 1; +} + +sal_Bool SAL_CALL OResultSet::isLast( ) +{ + SAL_WARN("connectivity.mork", "OResultSet::isLast() NOT IMPLEMENTED!"); + ResultSetEntryGuard aGuard( *this ); + +// return sal_True; + return m_nRowPos == currentRowCount(); +} + +void SAL_CALL OResultSet::beforeFirst( ) +{ + ResultSetEntryGuard aGuard( *this ); + + // move before the first row so that isBeforeFirst returns false + if ( first() ) + previous(); +} + +void SAL_CALL OResultSet::afterLast( ) +{ + ResultSetEntryGuard aGuard( *this ); + + if(last()) + next(); +} + + +void SAL_CALL OResultSet::close() +{ + dispose(); +} + + +sal_Bool SAL_CALL OResultSet::first( ) +{ + return seekRow( FIRST_POS ); +} + + +sal_Bool SAL_CALL OResultSet::last( ) +{ + return seekRow( LAST_POS ); +} + +sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row ) +{ + return seekRow( ABSOLUTE_POS, row ); +} + +sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row ) +{ + return seekRow( RELATIVE_POS, row ); +} + +sal_Bool SAL_CALL OResultSet::previous( ) +{ + ResultSetEntryGuard aGuard( *this ); + return seekRow( PRIOR_POS ); +} + +Reference< XInterface > SAL_CALL OResultSet::getStatement( ) +{ + ResultSetEntryGuard aGuard( *this ); + return m_xStatement; +} + + +sal_Bool SAL_CALL OResultSet::rowDeleted( ) +{ + SAL_WARN("connectivity.mork", "OResultSet::rowDeleted() NOT IMPLEMENTED!"); + ResultSetEntryGuard aGuard( *this ); + return true;//return ((m_RowStates & RowStates_Deleted) == RowStates_Deleted) ; +} + +sal_Bool SAL_CALL OResultSet::rowInserted( ) +{ + SAL_WARN("connectivity.mork", "OResultSet::rowInserted() NOT IMPLEMENTED!"); + ResultSetEntryGuard aGuard( *this ); + return true;//return ((m_RowStates & RowStates_Inserted) == RowStates_Inserted); +} + +sal_Bool SAL_CALL OResultSet::rowUpdated( ) +{ + SAL_WARN("connectivity.mork", "OResultSet::rowUpdated() NOT IMPLEMENTED!"); + ResultSetEntryGuard aGuard( *this ); + return true;// return ((m_RowStates & RowStates_Updated) == RowStates_Updated) ; +} + + +sal_Bool SAL_CALL OResultSet::next( ) +{ + return seekRow( NEXT_POS ); +} + + +sal_Bool SAL_CALL OResultSet::wasNull( ) +{ + ResultSetEntryGuard aGuard( *this ); + + return m_bWasNull; +} + + +void SAL_CALL OResultSet::cancel( ) +{ +} + +void SAL_CALL OResultSet::clearWarnings( ) +{ +} + +Any SAL_CALL OResultSet::getWarnings( ) +{ + return Any(); +} + +void SAL_CALL OResultSet::refreshRow( ) +{ + if (fetchRow(getCurrentCardNumber(),true)) { + //force fetch current row will cause we lose all change to the current row + m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_REFRESH_ROW, *this ); + } +} + +IPropertyArrayHelper* OResultSet::createArrayHelper( ) const +{ + Sequence< Property > aProps(5); + Property* pProperties = aProps.getArray(); + sal_Int32 nPos = 0; + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION), + PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0); + + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE), + PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0); + + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISBOOKMARKABLE), + PROPERTY_ID_ISBOOKMARKABLE, cppu::UnoType<bool>::get(), PropertyAttribute::READONLY); + + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY), + PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY); + + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE), + PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY); + + return new OPropertyArrayHelper(aProps); +} + +IPropertyArrayHelper & OResultSet::getInfoHelper() +{ + return *getArrayHelper(); +} + +sal_Bool OResultSet::convertFastPropertyValue( + Any & /*rConvertedValue*/, + Any & /*rOldValue*/, + sal_Int32 nHandle, + const Any& /*rValue*/ ) +{ + OSL_FAIL( "OResultSet::convertFastPropertyValue: not implemented!" ); + switch(nHandle) + { + case PROPERTY_ID_ISBOOKMARKABLE: + case PROPERTY_ID_RESULTSETCONCURRENCY: + case PROPERTY_ID_RESULTSETTYPE: + throw css::lang::IllegalArgumentException(); + case PROPERTY_ID_FETCHDIRECTION: + case PROPERTY_ID_FETCHSIZE: + default: + ; + } + return false; +} + +void OResultSet::setFastPropertyValue_NoBroadcast( + sal_Int32 nHandle, + const Any& /*rValue*/ + ) +{ + OSL_FAIL( "OResultSet::setFastPropertyValue_NoBroadcast: not implemented!" ); + switch(nHandle) + { + case PROPERTY_ID_ISBOOKMARKABLE: + case PROPERTY_ID_RESULTSETCONCURRENCY: + case PROPERTY_ID_RESULTSETTYPE: + throw Exception("cannot set prop " + OUString::number(nHandle), nullptr); + case PROPERTY_ID_FETCHDIRECTION: + break; + case PROPERTY_ID_FETCHSIZE: + break; + default: + ; + } +} + +void OResultSet::getFastPropertyValue( + Any& rValue, + sal_Int32 nHandle + ) const +{ + switch(nHandle) + { + case PROPERTY_ID_RESULTSETCONCURRENCY: + rValue <<= sal_Int32(ResultSetConcurrency::UPDATABLE); + break; + case PROPERTY_ID_RESULTSETTYPE: + rValue <<= m_nResultSetType; + break; + case PROPERTY_ID_FETCHDIRECTION: + rValue <<= m_nFetchDirection; + break; + case PROPERTY_ID_FETCHSIZE: + rValue <<= sal_Int32(0); + break; + case PROPERTY_ID_ISBOOKMARKABLE: + const_cast< OResultSet* >( this )->determineReadOnly(); + rValue <<= (m_bIsReadOnly == TRISTATE_FALSE); + break; + } +} + +void SAL_CALL OResultSet::acquire() throw() +{ + OResultSet_BASE::acquire(); +} + +void SAL_CALL OResultSet::release() throw() +{ + OResultSet_BASE::release(); +} + +css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + + +void OResultSet::parseParameter( const OSQLParseNode* pNode, OUString& rMatchString ) +{ + OSL_ENSURE(pNode->count() > 0,"Error parsing parameter in Parse Tree"); + OSQLParseNode *pMark = pNode->getChild(0); + + // Initialize to empty string + rMatchString.clear(); + + OUString aParameterName; + if (SQL_ISPUNCTUATION(pMark,"?")) { + aParameterName = "?"; + } + else if (SQL_ISPUNCTUATION(pMark,":")) { + aParameterName = pNode->getChild(1)->getTokenValue(); + } + // XXX - Now we know name, what's value???? + m_nParamIndex ++; + SAL_INFO( + "connectivity.mork", + "Parameter name [" << m_nParamIndex << "]: " << aParameterName); + + if ( m_aParameterRow.is() ) { + OSL_ENSURE( m_nParamIndex < static_cast<sal_Int32>(m_aParameterRow->size()) + 1, "More parameters than values found" ); + rMatchString = (*m_aParameterRow)[static_cast<sal_uInt16>(m_nParamIndex)]; + SAL_INFO("connectivity.mork", "Prop Value: " << rMatchString); + } + else { + SAL_INFO("connectivity.mork", "Prop Value: Invalid ParameterRow!"); + } +} + +#define WILDCARD "%" +#define ALT_WILDCARD "*" +static const sal_Unicode MATCHCHAR = '_'; + +void OResultSet::analyseWhereClause( const OSQLParseNode* parseTree, + MQueryExpression &queryExpression) +{ + OUString columnName; + MQueryOp::cond_type op( MQueryOp::Is ); + OUString matchString; + + if ( parseTree == nullptr ) + return; + + if ( m_pSQLIterator->getParseTree() != nullptr ) { + ::rtl::Reference<OSQLColumns> xColumns = m_pSQLIterator->getParameters(); + if(xColumns.is()) + { + OUString aColName, aParameterValue; + sal_Int32 i = 1; + for (auto const& column : *xColumns) + { + column->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName; + SAL_INFO("connectivity.mork", "Prop Column Name: " << aColName); + if ( m_aParameterRow.is() ) { + aParameterValue = (*m_aParameterRow)[static_cast<sal_uInt16>(i)]; + SAL_INFO("connectivity.mork", "Prop Value: " << aParameterValue); + } + else { + SAL_INFO("connectivity.mork", "Prop Value: Invalid ParameterRow!"); + } + i++; + } + } + + } + + if ( SQL_ISRULE(parseTree,where_clause) ) + { + // Reset Parameter Counter + resetParameters(); + analyseWhereClause( parseTree->getChild( 1 ), queryExpression ); + } + else if ( parseTree->count() == 3 && // Handle ()'s + SQL_ISPUNCTUATION(parseTree->getChild(0),"(") && + SQL_ISPUNCTUATION(parseTree->getChild(2),")")) + { + MQueryExpression *subExpression = new MQueryExpression(); + analyseWhereClause( parseTree->getChild( 1 ), *subExpression ); + queryExpression.addExpression( subExpression ); + } + else if ((SQL_ISRULE(parseTree,search_condition) || SQL_ISRULE(parseTree,boolean_term)) + && parseTree->count() == 3) // Handle AND/OR + { + // TODO - Need to take care or AND, for now match is always OR + analyseWhereClause( parseTree->getChild( 0 ), queryExpression ); + analyseWhereClause( parseTree->getChild( 2 ), queryExpression ); + + if (SQL_ISTOKEN(parseTree->getChild(1),OR)) { // OR-Operator + queryExpression.setExpressionCondition( MQueryExpression::OR ); + } + else if (SQL_ISTOKEN(parseTree->getChild(1),AND)) { // AND-Operator + queryExpression.setExpressionCondition( MQueryExpression::AND ); + } + else { + OSL_FAIL("analyseSQL: Error in Parse Tree"); + } + } + else if (SQL_ISRULE(parseTree,comparison_predicate)) + { + OSL_ENSURE(parseTree->count() == 3, "Error parsing COMPARE predicate"); + if (!(SQL_ISRULE(parseTree->getChild(0),column_ref) || + parseTree->getChild(2)->getNodeType() == SQLNodeType::String || + parseTree->getChild(2)->getNodeType() == SQLNodeType::IntNum || + parseTree->getChild(2)->getNodeType() == SQLNodeType::ApproxNum || + SQL_ISTOKEN(parseTree->getChild(2),TRUE) || + SQL_ISTOKEN(parseTree->getChild(2),FALSE) || + SQL_ISRULE(parseTree->getChild(2),parameter) || + // odbc date + (SQL_ISRULE(parseTree->getChild(2),set_fct_spec) && SQL_ISPUNCTUATION(parseTree->getChild(2)->getChild(0),"{")))) + { + m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this ); + } + + OSQLParseNode *pPrec = parseTree->getChild(1); + if (pPrec->getNodeType() == SQLNodeType::Equal) + op = MQueryOp::Is; + else if (pPrec->getNodeType() == SQLNodeType::NotEqual) + op = MQueryOp::IsNot; + + OUString sTableRange; + if(SQL_ISRULE(parseTree->getChild(0),column_ref)) + m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange); + else if(parseTree->getChild(0)->isToken()) + columnName = parseTree->getChild(0)->getTokenValue(); + + if ( SQL_ISRULE(parseTree->getChild(2),parameter) ) { + parseParameter( parseTree->getChild(2), matchString ); + } + else { + matchString = parseTree->getChild(2)->getTokenValue(); + } + + if ( columnName == "0" && op == MQueryOp::Is && matchString == "1" ) { + m_bIsAlwaysFalseQuery = true; + } + queryExpression.addExpression( new MQueryExpressionString( columnName, op, matchString )); + } + else if (SQL_ISRULE(parseTree,like_predicate)) + { + OSL_ENSURE(parseTree->count() == 2, "Error parsing LIKE predicate"); + + if ( !SQL_ISRULE(parseTree->getChild(0), column_ref) ) + { + m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_COLUMN, *this ); + } + + + OSQLParseNode *pColumn; + OSQLParseNode *pAtom; + OSQLParseNode *pOptEscape; + const OSQLParseNode* pPart2 = parseTree->getChild(1); + pColumn = parseTree->getChild(0); // Match Item + pAtom = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-2)); // Match String + pOptEscape = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-1)); // Opt Escape Rule + (void)pOptEscape; + const bool bNot = SQL_ISTOKEN(pPart2->getChild(0), NOT); + + if (!(pAtom->getNodeType() == SQLNodeType::String || + pAtom->getNodeType() == SQLNodeType::Name || + SQL_ISRULE(pAtom,parameter) || + ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQLNodeType::Name ) || + ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQLNodeType::String ) + ) ) + { + m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_STRING, *this ); + } + + OUString sTableRange; + if(SQL_ISRULE(pColumn,column_ref)) + m_pSQLIterator->getColumnRange(pColumn,columnName,sTableRange); + + SAL_INFO("connectivity.mork", "ColumnName = " << columnName); + + if ( SQL_ISRULE(pAtom,parameter) ) { + parseParameter( pAtom, matchString ); + // Replace all '*' with '%' : UI Usually does this but not with + // Parameters for some reason. + matchString = matchString.replaceAll( ALT_WILDCARD, WILDCARD ); + } + else + { + matchString = pAtom->getTokenValue(); + } + + // Determine where '%' character is... + + if ( matchString == WILDCARD ) + { + // String containing only a '%' and nothing else + op = MQueryOp::Exists; + // Will be ignored for Exists case, but clear anyway. + matchString.clear(); + } + else if ( matchString.indexOf ( WILDCARD ) == -1 && + matchString.indexOf ( MATCHCHAR ) == -1 ) + { + // Simple string , eg. "to match" + if ( bNot ) + op = MQueryOp::DoesNotContain; + else + op = MQueryOp::Contains; + } + else if ( matchString.startsWith( WILDCARD ) + && matchString.endsWith( WILDCARD ) + && matchString.indexOf ( WILDCARD, 1 ) == matchString.lastIndexOf ( WILDCARD ) + && matchString.indexOf( MATCHCHAR ) == -1 + ) + { + // Relatively simple "%string%" - ie, contains... + // Cut '%' from front and rear + matchString = matchString.replaceAt( 0, 1, OUString() ); + matchString = matchString.replaceAt( matchString.getLength() -1 , 1, OUString() ); + + if (bNot) + op = MQueryOp::DoesNotContain; + else + op = MQueryOp::Contains; + } + else if ( bNot ) + { + // We currently can't handle a 'NOT LIKE' when there are '%' or + // '_' dispersed throughout + m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_NOT_LIKE_TOO_COMPLEX, *this ); + } + else + { + if ( (matchString.indexOf ( WILDCARD ) == matchString.lastIndexOf ( WILDCARD )) + && matchString.indexOf( MATCHCHAR ) == -1 + ) + { + // One occurrence of '%' - no '_' matches... + if ( matchString.startsWith( WILDCARD ) ) + { + op = MQueryOp::EndsWith; + matchString = matchString.replaceAt( 0, 1, OUString()); + } + else if ( matchString.indexOf ( WILDCARD ) == matchString.getLength() -1 ) + { + op = MQueryOp::BeginsWith; + matchString = matchString.replaceAt( matchString.getLength() -1 , 1, OUString() ); + } + else + { + sal_Int32 pos = matchString.indexOf ( WILDCARD ); + matchString = matchString.replaceAt( pos, 1, ".*" ); + op = MQueryOp::RegExp; + } + + } + else + { + // Most Complex, need to use a RE + sal_Int32 pos; + while ( (pos = matchString.indexOf ( WILDCARD )) != -1 ) + { + matchString = matchString.replaceAt( pos, 1, ".*" ); + } + + while ( (pos = matchString.indexOf( MATCHCHAR )) != -1 ) + { + matchString = matchString.replaceAt( pos, 1, "." ); + } + + op = MQueryOp::RegExp; + } + } + + queryExpression.addExpression( new MQueryExpressionString( columnName, op, matchString )); + } + else if (SQL_ISRULE(parseTree,test_for_null)) + { + OSL_ENSURE(parseTree->count() == 2,"Error in ParseTree"); + const OSQLParseNode* pPart2 = parseTree->getChild(1); + OSL_ENSURE(SQL_ISTOKEN(pPart2->getChild(0),IS),"Error in ParseTree"); + + if (!SQL_ISRULE(parseTree->getChild(0),column_ref)) + { + m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_IS_NULL_COLUMN, *this ); + } + + if (SQL_ISTOKEN(pPart2->getChild(1),NOT)) + { + op = MQueryOp::Exists; + } + else + { + op = MQueryOp::DoesNotExist; + } + + OUString sTableRange; + m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange); + + queryExpression.addExpression( new MQueryExpressionString( columnName, op )); + } + else + { + SAL_WARN("connectivity.mork", "Unexpected statement!!!" ); + m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this ); + } +} + +void OResultSet::fillRowData() +{ + OSL_ENSURE( m_pStatement, "Require a statement" ); + + MQueryExpression queryExpression; + + OConnection* pConnection = static_cast<OConnection*>(m_pStatement->getConnection().get()); + m_xColumns = m_pSQLIterator->getSelectColumns(); + + OSL_ENSURE(m_xColumns.is(), "Need the Columns!!"); + + const OUString sPropertyName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME); + OUString sName; + sal_Int32 i = 1; + for (const auto& rxColumn : *m_xColumns) + { + rxColumn->getPropertyValue(sPropertyName) >>= sName; + SAL_INFO( + "connectivity.mork", "Query Columns : (" << i << ") " << sName); + i++; + } + + // Generate Match Conditions for Query + const OSQLParseNode* pParseTree = m_pSQLIterator->getWhereTree(); + + m_bIsAlwaysFalseQuery = false; + if ( pParseTree != nullptr ) + { + // Extract required info + + analyseWhereClause( pParseTree, queryExpression ); + } + // If the query is a 0=1 then set Row count to 0 and return + if ( m_bIsAlwaysFalseQuery ) + { + m_bIsReadOnly = TRISTATE_TRUE; + return; + } + + OUString aStr( m_xTable->getName() ); + m_aQueryHelper.setAddressbook( aStr ); + + sal_Int32 rv = m_aQueryHelper.executeQuery(pConnection, queryExpression); + if ( rv == -1 ) { + m_pStatement->getOwnConnection()->throwSQLException( STR_ERR_EXECUTING_QUERY, *this ); + } + + if (m_aQueryHelper.hadError()) + { + m_pStatement->getOwnConnection()->throwSQLException( m_aQueryHelper.getError(), *this ); + } + + //determine whether the address book is readonly + determineReadOnly(); + + SAL_INFO("connectivity.mork", "executeQuery returned " << rv); +} + + +static bool matchRow( OValueRow const & row1, OValueRow const & row2 ) +{ + // the first column is the bookmark column + return std::equal(std::next(row1->begin()), row1->end(), std::next(row2->begin()), + [](const ORowSetValue& a, const ORowSetValue& b) { return !a.isBound() || a == b; }); +} + +sal_Int32 OResultSet::getRowForCardNumber(sal_Int32 nCardNum) +{ + SAL_INFO("connectivity.mork", "nCardNum = " << nCardNum); + + if ( m_pKeySet.is() ) + { + sal_Int32 nPos; + for(nPos=0;nPos < static_cast<sal_Int32>(m_pKeySet->size());nPos++) + { + if (nCardNum == (*m_pKeySet)[nPos]) + { + SAL_INFO("connectivity.mork", "return = " << nPos+1); + return nPos+1; + } + } + } + + m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this ); + + return 0; +} + +void OResultSet::executeQuery() +{ + ResultSetEntryGuard aGuard( *this ); + + OSL_ENSURE( m_xTable.is(), "Need a Table object"); + if(!m_xTable.is()) + { + const OSQLTables& rTabs = m_pSQLIterator->getTables(); + if (rTabs.empty() || !rTabs.begin()->second.is()) + m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this ); + + m_xTable = static_cast< OTable* > (rTabs.begin()->second.get()); + } + + m_nRowPos = 0; + + fillRowData(); + + OSL_ENSURE(m_xColumns.is(), "Need the Columns!!"); + + switch( m_pSQLIterator->getStatementType() ) + { + case OSQLStatementType::Select: + { + if(m_bIsAlwaysFalseQuery) { + break; + } + else if(isCount()) + { + m_pStatement->getOwnConnection()->throwSQLException( STR_NO_COUNT_SUPPORT, *this ); + } + else + { + bool bDistinct = false; + OSQLParseNode *pDistinct = m_pParseTree->getChild(1); + if (pDistinct && pDistinct->getTokenID() == SQL_TOKEN_DISTINCT) + { + if(!IsSorted()) + { + m_aOrderbyColumnNumber.push_back(m_aColMapping[1]); + m_aOrderbyAscending.push_back(TAscendingOrder::DESC); + } + bDistinct = true; + } + + OSortIndex::TKeyTypeVector eKeyType(m_aOrderbyColumnNumber.size()); + std::vector<sal_Int16>::size_type index = 0; + for (const auto& rColIndex : m_aOrderbyColumnNumber) + { + OSL_ENSURE(static_cast<sal_Int32>(m_aRow->size()) > rColIndex,"Invalid Index"); + switch ((m_aRow->begin()+rColIndex)->getTypeKind()) + { + case DataType::CHAR: + case DataType::VARCHAR: + eKeyType[index] = OKeyType::String; + break; + + case DataType::OTHER: + case DataType::TINYINT: + case DataType::SMALLINT: + case DataType::INTEGER: + case DataType::DECIMAL: + case DataType::NUMERIC: + case DataType::REAL: + case DataType::DOUBLE: + case DataType::DATE: + case DataType::TIME: + case DataType::TIMESTAMP: + case DataType::BIT: + eKeyType[index] = OKeyType::Double; + break; + + // Other types aren't implemented (so they are always FALSE) + default: + eKeyType[index] = OKeyType::NONE; + OSL_FAIL("MResultSet::executeQuery: Order By Data Type not implemented"); + break; + } + ++index; + } + + if (IsSorted()) + { + // Implement Sorting + + // So that we can sort we need to wait until the executed + // query to the mozilla addressbooks has returned all + // values. + + OSortIndex aSortIndex(eKeyType,m_aOrderbyAscending); + +#if OSL_DEBUG_LEVEL > 0 + for ( std::vector<sal_Int32>::size_type i = 0; i < m_aColMapping.size(); i++ ) + SAL_INFO( + "connectivity.mork", + "Mapped: " << i << " -> " << m_aColMapping[i]); +#endif + for ( sal_Int32 nRow = 1; nRow <= m_aQueryHelper.getResultCount(); nRow++ ) { + + std::unique_ptr<OKeyValue> pKeyValue = OKeyValue::createKeyValue(nRow); + + for (const auto& rColIndex : m_aOrderbyColumnNumber) + { + const ORowSetValue& value = getValue(nRow, rColIndex); + + SAL_INFO( + "connectivity.mork", + "Adding Value: (" << nRow << "," << rColIndex + << ") : " << value.getString()); + + pKeyValue->pushKey(new ORowSetValueDecorator(value)); + } + + aSortIndex.AddKeyValue( std::move(pKeyValue) ); + } + + m_pKeySet = aSortIndex.CreateKeySet(); + m_CurrentRowCount = static_cast<sal_Int32>(m_pKeySet->size()); +#if OSL_DEBUG_LEVEL > 0 + for( OKeySet::size_type i = 0; i < m_pKeySet->size(); i++ ) + SAL_INFO( + "connectivity.mork", + "Sorted: " << i << " -> " << (*m_pKeySet)[i]); +#endif + + beforeFirst(); // Go back to start + } + else //we always need m_pKeySet now + m_pKeySet = new OKeySet(); + + // Handle the DISTINCT case + if ( bDistinct && m_pKeySet.is() ) + { + OValueRow aSearchRow = new OValueVector( m_aRow->size() ); + + for(sal_Int32 & i : *m_pKeySet) + { + fetchRow( i ); // Fills m_aRow + if ( matchRow( m_aRow, aSearchRow ) ) + { + i = 0; // Marker for later to be removed + } + else + { + // They don't match, so it's not a duplicate. + // Use the current Row as the next one to match against + *aSearchRow = *m_aRow; + } + } + // Now remove any keys marked with a 0 + m_pKeySet->erase(std::remove_if(m_pKeySet->begin(),m_pKeySet->end() + ,[](sal_Int32 n) { return n == 0; }) + ,m_pKeySet->end()); + + } + } + } break; + + case OSQLStatementType::Update: + case OSQLStatementType::Delete: + case OSQLStatementType::Insert: + break; + default: + m_pStatement->getOwnConnection()->throwSQLException( STR_STMT_TYPE_NOT_SUPPORTED, *this ); + break; + } +} + +void OResultSet::setBoundedColumns(const OValueRow& _rRow, + const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns, + const Reference<XIndexAccess>& _xNames, + bool _bSetColumnMapping, + const Reference<XDatabaseMetaData>& _xMetaData, + std::vector<sal_Int32>& _rColMapping) +{ + ::comphelper::UStringMixEqual aCase(_xMetaData->supportsMixedCaseQuotedIdentifiers()); + + Reference<XPropertySet> xTableColumn; + OUString sTableColumnName, sSelectColumnRealName; + + const OUString sName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME); + const OUString sRealName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME); + + std::vector< OUString> aColumnNames; + aColumnNames.reserve(_rxColumns->size()); + OValueVector::iterator aRowIter = _rRow->begin()+1; + for (sal_Int32 i=0; // the first column is the bookmark column + aRowIter != _rRow->end(); + ++i, ++aRowIter + ) + { + try + { + // get the table column and its name + _xNames->getByIndex(i) >>= xTableColumn; + OSL_ENSURE(xTableColumn.is(), "OResultSet::setBoundedColumns: invalid table column!"); + if (xTableColumn.is()) + xTableColumn->getPropertyValue(sName) >>= sTableColumnName; + else + sTableColumnName.clear(); + + // look if we have such a select column + // TODO: would like to have a O(log n) search here ... + sal_Int32 nColumnPos = 0; + for (const auto& rxColumn : *_rxColumns) + { + if ( nColumnPos < static_cast<sal_Int32>(aColumnNames.size()) ) + sSelectColumnRealName = aColumnNames[nColumnPos]; + else + { + if(rxColumn->getPropertySetInfo()->hasPropertyByName(sRealName)) + rxColumn->getPropertyValue(sRealName) >>= sSelectColumnRealName; + else + rxColumn->getPropertyValue(sName) >>= sSelectColumnRealName; + aColumnNames.push_back(sSelectColumnRealName); + } + + if (aCase(sTableColumnName, sSelectColumnRealName)) + { + if(_bSetColumnMapping) + { + sal_Int32 nSelectColumnPos = nColumnPos + 1; + // the getXXX methods are 1-based ... + sal_Int32 nTableColumnPos = i + 1; + // get first table column is the bookmark column + + SAL_INFO( + "connectivity.mork", + "Set Col Mapping: " << nSelectColumnPos << " -> " + << nTableColumnPos); + _rColMapping[nSelectColumnPos] = nTableColumnPos; + } + + aRowIter->setBound(true); + aRowIter->setTypeKind(DataType::VARCHAR); + } + + ++nColumnPos; + } + } + catch (Exception&) + { + OSL_FAIL("OResultSet::setBoundedColumns: caught an Exception!"); + } + } +} + + +bool OResultSet::isCount() const +{ + return (m_pParseTree && + m_pParseTree->count() > 2 && + SQL_ISRULE(m_pParseTree->getChild(2),scalar_exp_commalist) && + SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0),derived_column) && + SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0)->getChild(0),general_set_fct) && + m_pParseTree->getChild(2)->getChild(0)->getChild(0)->count() == 4 + ); +} + + +// Check for valid row in m_aQuery + +bool OResultSet::validRow( sal_uInt32 nRow) +{ + sal_Int32 nNumberOfRecords = m_aQueryHelper.getResultCount(); + + if (( nRow == 0 ) || + ( nRow > o3tl::make_unsigned(nNumberOfRecords)) ){ + SAL_INFO("connectivity.mork", "validRow(" << nRow << "): return False"); + return false; + } + SAL_INFO("connectivity.mork", "validRow(" << nRow << "): return True"); + + return true; +} + +void OResultSet::fillKeySet(sal_Int32 nMaxCardNumber) +{ + impl_ensureKeySet(); + if (m_CurrentRowCount < nMaxCardNumber) + { + sal_Int32 nKeyValue; + if ( static_cast<sal_Int32>(m_pKeySet->capacity()) < nMaxCardNumber ) + m_pKeySet->reserve(nMaxCardNumber + 20 ); + + for (nKeyValue = m_CurrentRowCount+1; nKeyValue <= nMaxCardNumber; nKeyValue ++) + m_pKeySet->push_back( nKeyValue ); + m_CurrentRowCount = nMaxCardNumber; + } +} + +sal_Int32 OResultSet::deletedCount() +{ + impl_ensureKeySet(); + return m_CurrentRowCount - static_cast<sal_Int32>(m_pKeySet->size()); + +} + +bool OResultSet::seekRow( eRowPosition pos, sal_Int32 nOffset ) +{ + ResultSetEntryGuard aGuard( *this ); + if ( !m_pKeySet.is() ) + m_pStatement->getOwnConnection()->throwSQLException( STR_ILLEGAL_MOVEMENT, *this ); + + sal_Int32 nNumberOfRecords = m_aQueryHelper.getResultCount(); + sal_Int32 nRetrievedRows = currentRowCount(); + sal_Int32 nCurPos = m_nRowPos; + + SAL_INFO("connectivity.mork", "nCurPos = " << nCurPos); + switch( pos ) { + case NEXT_POS: + nCurPos++; + break; + case PRIOR_POS: + if ( nCurPos > 0 ) + nCurPos--; + break; + case FIRST_POS: + nCurPos = 1; + break; + case LAST_POS: + nCurPos = nRetrievedRows; + break; + case ABSOLUTE_POS: + nCurPos = nOffset; + break; + case RELATIVE_POS: + nCurPos += sal_uInt32( nOffset ); + break; + } + + if ( nCurPos <= 0 ) { + m_nRowPos = 0; + SAL_INFO( + "connectivity.mork", "return False, m_nRowPos = " << m_nRowPos); + return false; + } + sal_Int32 nCurCard; + if ( nCurPos < static_cast<sal_Int32>(m_pKeySet->size()) ) //The requested row is exist in m_pKeySet, so we just use it + { + nCurCard = (*m_pKeySet)[nCurPos-1]; + } + else //The requested row has not been retrieved until now. We should get the right card for it. + nCurCard = nCurPos + deletedCount(); + + if ( nCurCard > nNumberOfRecords) { + fillKeySet(nNumberOfRecords); + m_nRowPos = static_cast<sal_uInt32>(m_pKeySet->size() + 1); + SAL_INFO( + "connectivity.mork", "return False, m_nRowPos = " << m_nRowPos); + return false; + } + //Insert new retrieved items for later use + fillKeySet(nNumberOfRecords); + m_nRowPos = static_cast<sal_uInt32>(nCurPos); + SAL_INFO("connectivity.mork", "return True, m_nRowPos = " << m_nRowPos); + fetchCurrentRow(); + return true; +} + +void OResultSet::setColumnMapping(const std::vector<sal_Int32>& _aColumnMapping) +{ + m_aColMapping = _aColumnMapping; +#if OSL_DEBUG_LEVEL > 0 + for ( size_t i = 0; i < m_aColMapping.size(); i++ ) + SAL_INFO( + "connectivity.mork", + "Set Mapped: " << i << " -> " << m_aColMapping[i]); +#endif +} + + +css::uno::Any OResultSet::getBookmark( ) +{ + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + ResultSetEntryGuard aGuard( *this ); + if ( !fetchCurrentRow() ) { + m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this ); + } + + OSL_ENSURE((!m_aRow->isDeleted()),"getBookmark called for deleted row"); + return makeAny(static_cast<sal_Int32>((*m_aRow)[0])); +} +sal_Bool OResultSet::moveToBookmark( const css::uno::Any& bookmark ) +{ + ResultSetEntryGuard aGuard( *this ); + SAL_INFO( + "connectivity.mork", "bookmark = " << comphelper::getINT32(bookmark)); + sal_Int32 nCardNum = comphelper::getINT32(bookmark); + m_nRowPos = getRowForCardNumber(nCardNum); + fetchCurrentRow(); + return true; +} +sal_Bool OResultSet::moveRelativeToBookmark( const css::uno::Any& bookmark, sal_Int32 rows ) +{ + ResultSetEntryGuard aGuard( *this ); + SAL_INFO( + "connectivity.mork", + "bookmark = " << comphelper::getINT32(bookmark) << " rows= " << rows); + sal_Int32 nCardNum = comphelper::getINT32(bookmark); + m_nRowPos = getRowForCardNumber(nCardNum); + return seekRow(RELATIVE_POS,rows ); +} +sal_Int32 OResultSet::compareBookmarks( const css::uno::Any& lhs, const css::uno::Any& rhs ) +{ + ResultSetEntryGuard aGuard( *this ); + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + sal_Int32 nFirst=0; + sal_Int32 nSecond=0; + sal_Int32 nResult=0; + + if ( !( lhs >>= nFirst ) || !( rhs >>= nSecond ) ) { + m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this ); + } + + if(nFirst < nSecond) + nResult = CompareBookmark::LESS; + else if(nFirst > nSecond) + nResult = CompareBookmark::GREATER; + else + nResult = CompareBookmark::EQUAL; + + return nResult; +} +sal_Bool OResultSet::hasOrderedBookmarks( ) +{ + ResultSetEntryGuard aGuard( *this ); + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + return true; +} +sal_Int32 OResultSet::hashBookmark( const css::uno::Any& bookmark ) +{ + ResultSetEntryGuard aGuard( *this ); + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + return comphelper::getINT32(bookmark); +} + +sal_Int32 OResultSet::getCurrentCardNumber() +{ + if ( ( m_nRowPos == 0 ) || !m_pKeySet.is() ) + return 0; + if (m_pKeySet->size() < m_nRowPos) + return 0; + return (*m_pKeySet)[m_nRowPos-1]; +} +void OResultSet::checkPendingUpdate() +{ + OSL_FAIL( "OResultSet::checkPendingUpdate() not implemented" ); +/* + const sal_Int32 nCurrentRow = getCurrentCardNumber(); + + if ((m_nNewRow && nCurrentRow != m_nNewRow) + || ( m_nUpdatedRow && m_nUpdatedRow != nCurrentRow)) + { + const OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution( + STR_COMMIT_ROW, + "$position$", OUString::valueOf(nCurrentRow) + ) ); + ::dbtools::throwGenericSQLException(sError,*this); + } +*/ + +} +void OResultSet::updateValue(sal_Int32 columnIndex ,const ORowSetValue& x) +{ + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + ResultSetEntryGuard aGuard( *this ); + if ( !fetchCurrentRow() ) { + m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this ); + } + + checkPendingUpdate(); + + checkIndex(columnIndex ); + columnIndex = mapColumn(columnIndex); + + (*m_aRow)[columnIndex].setBound(true); + (*m_aRow)[columnIndex] = x; +} + + +void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) +{ + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + ResultSetEntryGuard aGuard( *this ); + if ( !fetchCurrentRow() ) + m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this ); + + checkPendingUpdate(); + checkIndex(columnIndex ); + columnIndex = mapColumn(columnIndex); + + (*m_aRow)[columnIndex].setBound(true); + (*m_aRow)[columnIndex].setNull(); +} + + +void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) +{ + updateValue(columnIndex, static_cast<bool>(x)); +} + +void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) +{ + updateValue(columnIndex,x); +} + + +void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) +{ + updateValue(columnIndex,x); +} + +void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) +{ + updateValue(columnIndex,x); +} + +void SAL_CALL OResultSet::updateLong( sal_Int32 /*columnIndex*/, sal_Int64 /*x*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XRowUpdate::updateLong", *this ); +} + +void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x ) +{ + updateValue(columnIndex,x); +} + + +void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x ) +{ + updateValue(columnIndex,x); +} + +void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const OUString& x ) +{ + updateValue(columnIndex,x); +} + +void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) +{ + updateValue(columnIndex,x); +} + +void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const css::util::Date& x ) +{ + updateValue(columnIndex,x); +} + + +void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const css::util::Time& x ) +{ + updateValue(columnIndex,x); +} + + +void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const css::util::DateTime& x ) +{ + updateValue(columnIndex,x); +} + + +void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length ) +{ + ResultSetEntryGuard aGuard( *this ); + + if(!x.is()) + ::dbtools::throwFunctionSequenceException(*this); + + Sequence<sal_Int8> aSeq; + x->readBytes(aSeq,length); + updateValue(columnIndex,aSeq); +} + +void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< css::io::XInputStream >& x, sal_Int32 length ) +{ + updateBinaryStream(columnIndex,x,length); +} + +void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) +{ + if (!::dbtools::implUpdateObject(this, columnIndex, x)) + { + const OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution( + STR_COLUMN_NOT_UPDATEABLE, + "$position$", OUString::number(columnIndex) + ) ); + ::dbtools::throwGenericSQLException(sError,*this); + } // if (!::dbtools::implUpdateObject(this, columnIndex, x)) + } + + +void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ ) +{ + if (!::dbtools::implUpdateObject(this, columnIndex, x)) + { + const OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution( + STR_COLUMN_NOT_UPDATEABLE, + "$position$", OUString::number(columnIndex) + ) ); + ::dbtools::throwGenericSQLException(sError,*this); + } +} + +// XResultSetUpdate + +void SAL_CALL OResultSet::insertRow( ) +{ + ResultSetEntryGuard aGuard( *this ); + SAL_INFO("connectivity.mork", "in, m_nRowPos = " << m_nRowPos); +// m_RowStates = RowStates_Inserted; + updateRow(); + //m_aQueryHelper.setRowStates(getCurrentCardNumber(),m_RowStates); + SAL_INFO("connectivity.mork", "out, m_nRowPos = " << m_nRowPos); +} + +void SAL_CALL OResultSet::updateRow( ) +{ + OSL_FAIL( "OResultSet::updateRow( ) not implemented" ); +} + +void SAL_CALL OResultSet::deleteRow( ) +{ + OSL_FAIL( "OResultSet::deleteRow( ) not implemented" ); +} + +void SAL_CALL OResultSet::cancelRowUpdates( ) +{ + OSL_FAIL( "OResultSet::cancelRowUpdates( ) not implemented" ); +} + +void SAL_CALL OResultSet::moveToInsertRow( ) +{ + OSL_FAIL( "OResultSet::moveToInsertRow( ) not implemented" ); +} + +void SAL_CALL OResultSet::moveToCurrentRow( ) +{ + ResultSetEntryGuard aGuard( *this ); + SAL_INFO("connectivity.mork", "m_nRowPos = " << m_nRowPos); + if (rowInserted()) + { + m_nRowPos = 0; + fetchCurrentRow(); + } +} + +bool OResultSet::determineReadOnly() +{ +// OSL_FAIL( "OResultSet::determineReadOnly( ) not implemented" ); + + if (m_bIsReadOnly == TRISTATE_INDET) + { + m_bIsReadOnly = TRISTATE_TRUE; +// OConnection* xConnection = static_cast<OConnection*>(m_pStatement->getConnection().get()); +// m_bIsReadOnly = !m_aQueryHelper.isWritable(xConnection) || m_bIsAlwaysFalseQuery; + } + + return m_bIsReadOnly != TRISTATE_FALSE; +} + +void OResultSet::setTable(OTable* _rTable) +{ + m_xTable = _rTable; + m_xTableColumns = m_xTable->getColumns(); + if(m_xTableColumns.is()) + m_aColumnNames = m_xTableColumns->getElementNames(); +} + +void OResultSet::setOrderByColumns(const std::vector<sal_Int32>& _aColumnOrderBy) +{ + m_aOrderbyColumnNumber = _aColumnOrderBy; +} + +void OResultSet::setOrderByAscending(const std::vector<TAscendingOrder>& _aOrderbyAsc) +{ + m_aOrderbyAscending = _aOrderbyAsc; +} +Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows( const Sequence< Any >& /*rows*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XDeleteRows::deleteRows", *this ); + return Sequence< sal_Int32 >(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MResultSet.hxx b/connectivity/source/drivers/mork/MResultSet.hxx new file mode 100644 index 000000000..0531781d7 --- /dev/null +++ b/connectivity/source/drivers/mork/MResultSet.hxx @@ -0,0 +1,350 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MRESULTSET_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MRESULTSET_HXX + +#include <com/sun/star/sdbc/XResultSet.hpp> +#include <com/sun/star/sdbc/XRow.hpp> +#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp> +#include <com/sun/star/sdbc/XCloseable.hpp> +#include <com/sun/star/sdbc/XColumnLocate.hpp> +#include <com/sun/star/util/XCancellable.hpp> +#include <com/sun/star/sdbc/XWarningsSupplier.hpp> +#include <com/sun/star/sdbc/XResultSetUpdate.hpp> +#include <com/sun/star/sdbcx/XRowLocate.hpp> +#include <com/sun/star/sdbcx/XDeleteRows.hpp> +#include <com/sun/star/sdbc/XRowUpdate.hpp> +#include <cppuhelper/compbase.hxx> +#include <comphelper/proparrhlp.hxx> +#include <tools/gen.hxx> +#include <rtl/ref.hxx> +#include "MStatement.hxx" +#include "MQueryHelper.hxx" +#include <connectivity/CommonTools.hxx> +#include <connectivity/FValue.hxx> +#include <connectivity/sqliterator.hxx> +#include <TSortIndex.hxx> + +namespace connectivity +{ + namespace mork + { + + /* + ** java_sql_ResultSet + */ + typedef ::cppu::WeakComponentImplHelper< css::sdbc::XResultSet, + css::sdbc::XRow, + css::sdbc::XResultSetMetaDataSupplier, + css::util::XCancellable, + css::sdbc::XWarningsSupplier, + css::sdbc::XCloseable, + css::sdbc::XColumnLocate, + css::sdbc::XResultSetUpdate, + css::sdbc::XRowUpdate, + css::sdbcx::XRowLocate, + css::sdbcx::XDeleteRows, + css::lang::XServiceInfo> OResultSet_BASE; + + + typedef sal_Int64 TVoidPtr; + typedef std::allocator< TVoidPtr > TVoidAlloc; + typedef std::vector<TVoidPtr> TVoidVector; + + class OResultSet : public cppu::BaseMutex, + public OResultSet_BASE, + public ::cppu::OPropertySetHelper, + public ::comphelper::OPropertyArrayUsageHelper<OResultSet> + { + protected: + OCommonStatement* m_pStatement; + css::uno::Reference< css::uno::XInterface> m_xStatement; + css::uno::Reference< css::sdbc::XResultSetMetaData> m_xMetaData; + sal_uInt32 m_nRowPos; + bool m_bWasNull; + sal_Int32 m_nResultSetType; + sal_Int32 m_nFetchDirection; + + + std::shared_ptr< ::connectivity::OSQLParseTreeIterator > + m_pSQLIterator; + const connectivity::OSQLParseNode* m_pParseTree; + + // OPropertyArrayUsageHelper + virtual ::cppu::IPropertyArrayHelper* createArrayHelper( ) const override; + // OPropertySetHelper + virtual ::cppu::IPropertyArrayHelper & SAL_CALL getInfoHelper() override; + + virtual sal_Bool SAL_CALL convertFastPropertyValue( + css::uno::Any & rConvertedValue, + css::uno::Any & rOldValue, + sal_Int32 nHandle, + const css::uno::Any& rValue ) override; + virtual void SAL_CALL setFastPropertyValue_NoBroadcast( + sal_Int32 nHandle, + const css::uno::Any& rValue + ) override; + virtual void SAL_CALL getFastPropertyValue( + css::uno::Any& rValue, + sal_Int32 nHandle + ) const override; + + // you can't delete objects of this type + virtual ~OResultSet() override; + public: + DECLARE_SERVICE_INFO(); + + OResultSet(OCommonStatement* pStmt, const std::shared_ptr< ::connectivity::OSQLParseTreeIterator >& _pSQLIterator ); + + // ::cppu::OComponentHelper + virtual void SAL_CALL disposing() override; + // XInterface + virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + virtual void SAL_CALL acquire() throw() override; + virtual void SAL_CALL release() throw() override; + //XTypeProvider + virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes( ) override; + // XPropertySet + virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo( ) override; + // XResultSet + virtual sal_Bool SAL_CALL next( ) override; + virtual sal_Bool SAL_CALL isBeforeFirst( ) override; + virtual sal_Bool SAL_CALL isAfterLast( ) override; + virtual sal_Bool SAL_CALL isFirst( ) override; + virtual sal_Bool SAL_CALL isLast( ) override; + virtual void SAL_CALL beforeFirst( ) override; + virtual void SAL_CALL afterLast( ) override; + virtual sal_Bool SAL_CALL first( ) override; + virtual sal_Bool SAL_CALL last( ) override; + virtual sal_Int32 SAL_CALL getRow( ) override; + virtual sal_Bool SAL_CALL absolute( sal_Int32 row ) override; + virtual sal_Bool SAL_CALL relative( sal_Int32 rows ) override; + virtual sal_Bool SAL_CALL previous( ) override; + virtual void SAL_CALL refreshRow( ) override; + virtual sal_Bool SAL_CALL rowUpdated( ) override; + virtual sal_Bool SAL_CALL rowInserted( ) override; + virtual sal_Bool SAL_CALL rowDeleted( ) override; + virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getStatement( ) override; + // XRow + virtual sal_Bool SAL_CALL wasNull( ) override; + virtual OUString SAL_CALL getString( sal_Int32 columnIndex ) override; + virtual sal_Bool SAL_CALL getBoolean( sal_Int32 columnIndex ) override; + virtual sal_Int8 SAL_CALL getByte( sal_Int32 columnIndex ) override; + virtual sal_Int16 SAL_CALL getShort( sal_Int32 columnIndex ) override; + virtual sal_Int32 SAL_CALL getInt( sal_Int32 columnIndex ) override; + virtual sal_Int64 SAL_CALL getLong( sal_Int32 columnIndex ) override; + virtual float SAL_CALL getFloat( sal_Int32 columnIndex ) override; + virtual double SAL_CALL getDouble( sal_Int32 columnIndex ) override; + virtual css::uno::Sequence< sal_Int8 > SAL_CALL getBytes( sal_Int32 columnIndex ) override; + virtual css::util::Date SAL_CALL getDate( sal_Int32 columnIndex ) override; + virtual css::util::Time SAL_CALL getTime( sal_Int32 columnIndex ) override; + virtual css::util::DateTime SAL_CALL getTimestamp( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< css::io::XInputStream > SAL_CALL getBinaryStream( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< css::io::XInputStream > SAL_CALL getCharacterStream( sal_Int32 columnIndex ) override; + virtual css::uno::Any SAL_CALL getObject( sal_Int32 columnIndex, const css::uno::Reference< css::container::XNameAccess >& typeMap ) override; + virtual css::uno::Reference< css::sdbc::XRef > SAL_CALL getRef( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< css::sdbc::XBlob > SAL_CALL getBlob( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< css::sdbc::XClob > SAL_CALL getClob( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< css::sdbc::XArray > SAL_CALL getArray( sal_Int32 columnIndex ) override; + // XResultSetMetaDataSupplier + virtual css::uno::Reference< css::sdbc::XResultSetMetaData > SAL_CALL getMetaData( ) override; + // XCancellable + virtual void SAL_CALL cancel( ) override; + // XCloseable + virtual void SAL_CALL close( ) override; + // XWarningsSupplier + virtual css::uno::Any SAL_CALL getWarnings( ) override; + virtual void SAL_CALL clearWarnings( ) override; + // XColumnLocate + virtual sal_Int32 SAL_CALL findColumn( const OUString& columnName ) override; + + // XResultSetUpdate + virtual void SAL_CALL insertRow( ) override; + virtual void SAL_CALL updateRow( ) override; + virtual void SAL_CALL deleteRow( ) override; + virtual void SAL_CALL cancelRowUpdates( ) override; + virtual void SAL_CALL moveToInsertRow( ) override; + virtual void SAL_CALL moveToCurrentRow( ) override; + // XRowUpdate + virtual void SAL_CALL updateNull( sal_Int32 columnIndex ) override; + virtual void SAL_CALL updateBoolean( sal_Int32 columnIndex, sal_Bool x ) override; + virtual void SAL_CALL updateByte( sal_Int32 columnIndex, sal_Int8 x ) override; + virtual void SAL_CALL updateShort( sal_Int32 columnIndex, sal_Int16 x ) override; + virtual void SAL_CALL updateInt( sal_Int32 columnIndex, sal_Int32 x ) override; + virtual void SAL_CALL updateLong( sal_Int32 columnIndex, sal_Int64 x ) override; + virtual void SAL_CALL updateFloat( sal_Int32 columnIndex, float x ) override; + virtual void SAL_CALL updateDouble( sal_Int32 columnIndex, double x ) override; + virtual void SAL_CALL updateString( sal_Int32 columnIndex, const OUString& x ) override; + virtual void SAL_CALL updateBytes( sal_Int32 columnIndex, const css::uno::Sequence< sal_Int8 >& x ) override; + virtual void SAL_CALL updateDate( sal_Int32 columnIndex, const css::util::Date& x ) override; + virtual void SAL_CALL updateTime( sal_Int32 columnIndex, const css::util::Time& x ) override; + virtual void SAL_CALL updateTimestamp( sal_Int32 columnIndex, const css::util::DateTime& x ) override; + virtual void SAL_CALL updateBinaryStream( sal_Int32 columnIndex, const css::uno::Reference< css::io::XInputStream >& x, sal_Int32 length ) override; + virtual void SAL_CALL updateCharacterStream( sal_Int32 columnIndex, const css::uno::Reference< css::io::XInputStream >& x, sal_Int32 length ) override; + virtual void SAL_CALL updateObject( sal_Int32 columnIndex, const css::uno::Any& x ) override; + virtual void SAL_CALL updateNumericObject( sal_Int32 columnIndex, const css::uno::Any& x, sal_Int32 scale ) override; + // XRowLocate + virtual css::uno::Any SAL_CALL getBookmark( ) override; + virtual sal_Bool SAL_CALL moveToBookmark( const css::uno::Any& bookmark ) override; + virtual sal_Bool SAL_CALL moveRelativeToBookmark( const css::uno::Any& bookmark, sal_Int32 rows ) override; + virtual sal_Int32 SAL_CALL compareBookmarks( const css::uno::Any& first, const css::uno::Any& second ) override; + virtual sal_Bool SAL_CALL hasOrderedBookmarks( ) override; + virtual sal_Int32 SAL_CALL hashBookmark( const css::uno::Any& bookmark ) override; + // XDeleteRows + virtual css::uno::Sequence< sal_Int32 > SAL_CALL deleteRows( const css::uno::Sequence< css::uno::Any >& rows ) override; + +protected: + //MQuery m_aQuery; + MQueryHelper m_aQueryHelper; + rtl::Reference<OTable> m_xTable; + sal_Int32 m_CurrentRowCount; + css::uno::Reference< css::container::XNameAccess > + m_xTableColumns; + + std::vector<sal_Int32> m_aColMapping; // pos 0 is unused so we don't have to decrement 1 every time + std::vector<sal_Int32> m_aOrderbyColumnNumber; + std::vector<TAscendingOrder> m_aOrderbyAscending; + css::uno::Sequence< OUString> m_aColumnNames; + OValueRow m_aRow; + OValueRow m_aParameterRow; + sal_Int32 m_nParamIndex; + bool m_bIsAlwaysFalseQuery; + ::rtl::Reference<OKeySet> m_pKeySet; + TriState m_bIsReadOnly; + void resetParameters() { m_nParamIndex = 0; } + + ::rtl::Reference<connectivity::OSQLColumns> m_xColumns; // this are the select columns + + void parseParameter( const OSQLParseNode* pNode, OUString& rMatchString ); + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + void fillRowData(); + void analyseWhereClause( const OSQLParseNode* parseTree, + MQueryExpression &queryExpression); + + bool isCount() const; + + bool IsSorted() const { return !m_aOrderbyColumnNumber.empty(); } + + enum eRowPosition { + NEXT_POS, PRIOR_POS, FIRST_POS, LAST_POS, ABSOLUTE_POS, RELATIVE_POS + }; + + sal_uInt32 currentRowCount(); + + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + bool fetchRow(sal_Int32 rowIndex,bool bForceReload=false); + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + bool fetchCurrentRow(); + bool validRow( sal_uInt32 nRow ); + bool seekRow( eRowPosition pos, sal_Int32 nOffset = 0 ); + sal_Int32 deletedCount(); + void fillKeySet(sal_Int32 nMaxCardNumber); //When we get new rows, fill the m_pKeySet items for them + sal_Int32 getRowForCardNumber(sal_Int32 nCardNum); + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + const ORowSetValue& getValue(sal_Int32 rowIndex, sal_Int32 columnIndex); + + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + void updateValue(sal_Int32 columnIndex,const ORowSetValue& x ); + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + static void checkPendingUpdate(); + sal_Int32 getCurrentCardNumber(); + +public: + bool determineReadOnly(); + // MozAddressbook Specific methods + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + void executeQuery(); + + void setTable(OTable* _rTable); + + void setParameterRow(const OValueRow& _rParaRow) + { m_aParameterRow = _rParaRow; } + + void setBindingRow(const OValueRow& _aRow) + { m_aRow = _aRow; } + + void setColumnMapping(const std::vector<sal_Int32>& _aColumnMapping); + + void setOrderByColumns(const std::vector<sal_Int32>& _aColumnOrderBy); + + void setOrderByAscending(const std::vector<TAscendingOrder>& _aOrderbyAsc); + + inline sal_Int32 mapColumn(sal_Int32 column); + + /// @throws css::sdbc::SQLException + void checkIndex(sal_Int32 columnIndex ); + + static void setBoundedColumns( + const OValueRow& _rRow, + const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns, + const css::uno::Reference< css::container::XIndexAccess>& _xNames, + bool _bSetColumnMapping, + const css::uno::Reference< css::sdbc::XDatabaseMetaData>& _xMetaData, + std::vector<sal_Int32>& _rColMapping); + + ::osl::Mutex& getMutex() { return m_aMutex; } + void methodEntry(); + + private: + void impl_ensureKeySet() + { + if ( !m_pKeySet.is() ) + m_pKeySet = new OKeySet(); + } + + protected: + using OPropertySetHelper::getFastPropertyValue; + }; + + inline sal_Int32 OResultSet::mapColumn(sal_Int32 column) + { + sal_Int32 map = column; + + OSL_ENSURE(column > 0, "OResultSet::mapColumn: invalid column index!"); + // the first column (index 0) is for convenience only. The + // first real select column is no 1. + if ((column > 0) && (column < static_cast<sal_Int32>(m_aColMapping.size()))) + map = m_aColMapping[column]; + + return map; + } + + class ResultSetEntryGuard : public ::osl::MutexGuard + { + public: + explicit ResultSetEntryGuard( OResultSet& _rRS ) : ::osl::MutexGuard( _rRS.getMutex() ) + { + _rRS.methodEntry(); + } + }; + + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MRESULTSET_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MResultSetMetaData.cxx b/connectivity/source/drivers/mork/MResultSetMetaData.cxx new file mode 100644 index 000000000..e05eced22 --- /dev/null +++ b/connectivity/source/drivers/mork/MResultSetMetaData.cxx @@ -0,0 +1,192 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <connectivity/dbexception.hxx> +#include <comphelper/types.hxx> +#include <comphelper/extract.hxx> +#include <tools/diagnose_ex.h> +#include "MResultSetMetaData.hxx" +#include <com/sun/star/sdbc/DataType.hpp> + +using namespace connectivity::mork; +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; +using namespace com::sun::star::sdbc; +using namespace com::sun::star::beans; +using namespace ::dbtools; +using namespace ::comphelper; + + +OResultSetMetaData::~OResultSetMetaData() +{ + m_xColumns = nullptr; +} + + +void OResultSetMetaData::checkColumnIndex(sal_Int32 column) +{ + if(column <= 0 || column > static_cast<sal_Int32>(m_xColumns->size())) + throwInvalidIndexException(*this); +} + +sal_Int32 SAL_CALL OResultSetMetaData::getColumnDisplaySize( sal_Int32 column ) +{ + return getPrecision(column); +} + + +sal_Int32 SAL_CALL OResultSetMetaData::getColumnType( sal_Int32 /*column*/ ) +{ + return DataType::VARCHAR; // at the moment there exists only this type +} + + +sal_Int32 SAL_CALL OResultSetMetaData::getColumnCount( ) +{ + return static_cast<sal_Int32>(m_xColumns->size()); +} + + +sal_Bool SAL_CALL OResultSetMetaData::isCaseSensitive( sal_Int32 /*column*/ ) +{ + return false; +} + + +OUString SAL_CALL OResultSetMetaData::getSchemaName( sal_Int32 /*column*/ ) +{ + return OUString(); +} + + +OUString SAL_CALL OResultSetMetaData::getColumnName( sal_Int32 column ) +{ + checkColumnIndex(column); + + OUString sColumnName; + try + { + Reference< XPropertySet > xColumnProps( (*m_xColumns)[column-1], UNO_SET_THROW ); + OSL_VERIFY( xColumnProps->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_NAME ) ) >>= sColumnName ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("connectivity.mork"); + } + return sColumnName; +} + +OUString SAL_CALL OResultSetMetaData::getTableName( sal_Int32 /*column*/ ) +{ + return m_aTableName; +} + +OUString SAL_CALL OResultSetMetaData::getCatalogName( sal_Int32 /*column*/ ) +{ + return OUString(); +} + +OUString SAL_CALL OResultSetMetaData::getColumnTypeName( sal_Int32 column ) +{ + checkColumnIndex(column); + return getString((*m_xColumns)[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME))); +} + +OUString SAL_CALL OResultSetMetaData::getColumnLabel( sal_Int32 column ) +{ + return getColumnName(column); +} + +OUString SAL_CALL OResultSetMetaData::getColumnServiceName( sal_Int32 /*column*/ ) +{ + return OUString(); +} + + +sal_Bool SAL_CALL OResultSetMetaData::isCurrency( sal_Int32 column ) +{ + checkColumnIndex(column); + return getBOOL((*m_xColumns)[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY))); +} + + +sal_Bool SAL_CALL OResultSetMetaData::isAutoIncrement( sal_Int32 /*column*/ ) +{ + return false; +} + +sal_Bool SAL_CALL OResultSetMetaData::isSigned( sal_Int32 /*column*/ ) +{ + return false; +} + +sal_Int32 SAL_CALL OResultSetMetaData::getPrecision( sal_Int32 column ) +{ + checkColumnIndex(column); + return getINT32((*m_xColumns)[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))); +} + +sal_Int32 SAL_CALL OResultSetMetaData::getScale( sal_Int32 column ) +{ + checkColumnIndex(column); + return getINT32((*m_xColumns)[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))); +} + + +sal_Int32 SAL_CALL OResultSetMetaData::isNullable( sal_Int32 column ) +{ + checkColumnIndex(column); + return getINT32((*m_xColumns)[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE))); +} + + +sal_Bool SAL_CALL OResultSetMetaData::isSearchable( sal_Int32 /*column*/ ) +{ + if ( !m_pTable || !m_pTable->getConnection() ) + { + OSL_FAIL( "OResultSetMetaData::isSearchable: suspicious: called without table or connection!" ); + return false; + } + + return true; +} + + +sal_Bool SAL_CALL OResultSetMetaData::isReadOnly( sal_Int32 column ) +{ + checkColumnIndex(column); + bool bReadOnly = (*m_xColumns)[column-1]->getPropertySetInfo()->hasPropertyByName(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FUNCTION)) && + ::cppu::any2bool((*m_xColumns)[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FUNCTION))); + + return m_bReadOnly || bReadOnly || OTable::isReadOnly(); +} + + +sal_Bool SAL_CALL OResultSetMetaData::isDefinitelyWritable( sal_Int32 column ) +{ + return !isReadOnly(column); +} + +sal_Bool SAL_CALL OResultSetMetaData::isWritable( sal_Int32 column ) +{ + return !isReadOnly(column); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MResultSetMetaData.hxx b/connectivity/source/drivers/mork/MResultSetMetaData.hxx new file mode 100644 index 000000000..5362a4ac0 --- /dev/null +++ b/connectivity/source/drivers/mork/MResultSetMetaData.hxx @@ -0,0 +1,88 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MRESULTSETMETADATA_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MRESULTSETMETADATA_HXX + +#include <com/sun/star/sdbc/XResultSetMetaData.hpp> +#include <cppuhelper/implbase.hxx> +#include <rtl/ref.hxx> +#include "MTable.hxx" + +namespace connectivity +{ + namespace mork + { + + //************ Class: ResultSetMetaData + + typedef ::cppu::WeakImplHelper<css::sdbc::XResultSetMetaData> OResultSetMetaData_BASE; + + class OResultSetMetaData : public OResultSetMetaData_BASE + { + OUString m_aTableName; + ::rtl::Reference<connectivity::OSQLColumns> m_xColumns; + OTable* m_pTable; + bool m_bReadOnly; + + protected: + virtual ~OResultSetMetaData() override; + public: + // a constructor that is needed to return the object: + // OResultSetMetaData(OConnection* _pConnection) : m_pConnection(_pConnection){} + OResultSetMetaData(const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns, + const OUString& _aTableName,OTable* _pTable,bool aReadOnly + ) + :m_aTableName(_aTableName) + ,m_xColumns(_rxColumns) + ,m_pTable(_pTable) + ,m_bReadOnly(aReadOnly) + {} + + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + void checkColumnIndex(sal_Int32 column); + virtual sal_Int32 SAL_CALL getColumnCount( ) override; + virtual sal_Bool SAL_CALL isAutoIncrement( sal_Int32 column ) override; + virtual sal_Bool SAL_CALL isCaseSensitive( sal_Int32 column ) override; + virtual sal_Bool SAL_CALL isSearchable( sal_Int32 column ) override; + virtual sal_Bool SAL_CALL isCurrency( sal_Int32 column ) override; + virtual sal_Int32 SAL_CALL isNullable( sal_Int32 column ) override; + virtual sal_Bool SAL_CALL isSigned( sal_Int32 column ) override; + virtual sal_Int32 SAL_CALL getColumnDisplaySize( sal_Int32 column ) override; + virtual OUString SAL_CALL getColumnLabel( sal_Int32 column ) override; + virtual OUString SAL_CALL getColumnName( sal_Int32 column ) override; + virtual OUString SAL_CALL getSchemaName( sal_Int32 column ) override; + virtual sal_Int32 SAL_CALL getPrecision( sal_Int32 column ) override; + virtual sal_Int32 SAL_CALL getScale( sal_Int32 column ) override; + virtual OUString SAL_CALL getTableName( sal_Int32 column ) override; + virtual OUString SAL_CALL getCatalogName( sal_Int32 column ) override; + virtual sal_Int32 SAL_CALL getColumnType( sal_Int32 column ) override; + virtual OUString SAL_CALL getColumnTypeName( sal_Int32 column ) override; + virtual sal_Bool SAL_CALL isReadOnly( sal_Int32 column ) override; + virtual sal_Bool SAL_CALL isWritable( sal_Int32 column ) override; + virtual sal_Bool SAL_CALL isDefinitelyWritable( sal_Int32 column ) override; + virtual OUString SAL_CALL getColumnServiceName( sal_Int32 column ) override; + }; + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MRESULTSETMETADATA_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MStatement.cxx b/connectivity/source/drivers/mork/MStatement.cxx new file mode 100644 index 000000000..bd153afa6 --- /dev/null +++ b/connectivity/source/drivers/mork/MStatement.cxx @@ -0,0 +1,471 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include <tools/diagnose_ex.h> +#include <sal/log.hxx> +#include <cppuhelper/queryinterface.hxx> +#include <cppuhelper/typeprovider.hxx> +#include <comphelper/processfactory.hxx> +#include <connectivity/dbexception.hxx> + +#include <algorithm> + +#include "MDriver.hxx" +#include "MStatement.hxx" +#include <sqlbison.hxx> +#include "MResultSet.hxx" + +#include <strings.hrc> + +static ::osl::Mutex m_ThreadMutex; + +using namespace ::comphelper; +using namespace connectivity::mork; +using namespace connectivity; + +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; +using namespace com::sun::star::beans; +using namespace com::sun::star::sdbc; +using namespace com::sun::star::container; +using namespace com::sun::star::io; +using namespace com::sun::star::util; + + +OStatement::OStatement( OConnection* _pConnection) : OCommonStatement( _pConnection) +{ +} + +OCommonStatement::OCommonStatement(OConnection* _pConnection ) + :OCommonStatement_IBASE(m_aMutex) + ,OPropertySetHelper(OCommonStatement_IBASE::rBHelper) + ,m_xDBMetaData (_pConnection->getMetaData()) + ,m_pTable(nullptr) + ,m_pConnection(_pConnection) + ,m_aParser( comphelper::getComponentContext(_pConnection->getDriver()->getFactory()) ) + ,m_pSQLIterator( std::make_shared<OSQLParseTreeIterator>( _pConnection, _pConnection->createCatalog()->getTables(), m_aParser ) ) +{ +} + + +OCommonStatement::~OCommonStatement() +{ +} + + +void OCommonStatement::disposing() +{ + ::osl::MutexGuard aGuard(m_aMutex); + + clearWarnings(); + clearCachedResultSet(); + + m_pConnection.clear(); + + m_pSQLIterator->dispose(); + m_pParseTree.reset(); + + OCommonStatement_IBASE::disposing(); +} + +Any SAL_CALL OCommonStatement::queryInterface( const Type & rType ) +{ + Any aRet = OCommonStatement_IBASE::queryInterface(rType); + if(!aRet.hasValue()) + aRet = OPropertySetHelper::queryInterface(rType); + return aRet; +} + +Sequence< Type > SAL_CALL OCommonStatement::getTypes( ) +{ + ::cppu::OTypeCollection aTypes( cppu::UnoType<XMultiPropertySet>::get(), + cppu::UnoType<XFastPropertySet>::get(), + cppu::UnoType<XPropertySet>::get()); + + return ::comphelper::concatSequences(aTypes.getTypes(),OCommonStatement_IBASE::getTypes()); +} + +void SAL_CALL OCommonStatement::close( ) +{ + { + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + } + dispose(); +} + +OCommonStatement::StatementType OCommonStatement::parseSql( const OUString& sql , bool bAdjusted) +{ + OUString aErr; + + m_pParseTree = m_aParser.parseTree(aErr,sql); + + if(m_pParseTree) + { + m_pSQLIterator->setParseTree(m_pParseTree.get()); + m_pSQLIterator->traverseAll(); + const OSQLTables& rTabs = m_pSQLIterator->getTables(); + + if (rTabs.empty()) + { + getOwnConnection()->throwSQLException( STR_QUERY_AT_LEAST_ONE_TABLES, *this ); + } + + Reference<XIndexAccess> xNames; + switch(m_pSQLIterator->getStatementType()) + { + case OSQLStatementType::Select: + + // at this moment we support only one table per select statement + + OSL_ENSURE( !rTabs.empty(), "Need a Table"); + + m_pTable = static_cast< OTable* > (rTabs.begin()->second.get()); + m_xColNames = m_pTable->getColumns(); + xNames.set(m_xColNames,UNO_QUERY); + // set the binding of the resultrow + m_aRow = new OValueVector(xNames->getCount()); + (*m_aRow)[0].setBound(true); + std::for_each(m_aRow->begin()+1,m_aRow->end(),TSetBound(false)); + // create the column mapping + createColumnMapping(); + + analyseSQL(); + return eSelect; + + case OSQLStatementType::CreateTable: + return eCreateTable; + + default: + break; + } + } + else if(!bAdjusted) //Our sql parser does not support a statement like "create table foo" + // So we append ("E-mail" varchar) to the last of it to make it work + { + return parseSql(sql + "(""E-mail"" character)", true); + } + + getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this ); + OSL_FAIL( "OCommonStatement::parseSql: unreachable!" ); + return eSelect; + +} + +Reference< XResultSet > OCommonStatement::impl_executeCurrentQuery() +{ + clearCachedResultSet(); + + ::rtl::Reference pResult( new OResultSet( this, m_pSQLIterator ) ); + initializeResultSet( pResult.get() ); + + pResult->executeQuery(); + cacheResultSet( pResult ); // only cache if we survived the execution + + return pResult.get(); + +} + + +void OCommonStatement::initializeResultSet( OResultSet* _pResult ) +{ + ENSURE_OR_THROW( _pResult, "invalid result set" ); + + _pResult->setColumnMapping(m_aColMapping); + _pResult->setOrderByColumns(m_aOrderbyColumnNumber); + _pResult->setOrderByAscending(m_aOrderbyAscending); + _pResult->setBindingRow(m_aRow); + _pResult->setTable(m_pTable); +} + + +void OCommonStatement::clearCachedResultSet() +{ + Reference< XResultSet > xResultSet( m_xResultSet.get(), UNO_QUERY ); + if ( !xResultSet.is() ) + return; + + Reference< XCloseable >( xResultSet, UNO_QUERY_THROW )->close(); + + m_xResultSet.clear(); +} + + +void OCommonStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult ) +{ + ENSURE_OR_THROW( _pResult.is(), "invalid result set" ); + m_xResultSet = Reference< XResultSet >( _pResult.get() ); +} + + +sal_Bool SAL_CALL OCommonStatement::execute( const OUString& sql ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + Reference< XResultSet > xRS = executeQuery( sql ); + // returns true when a resultset is available + return xRS.is(); +} + + +Reference< XResultSet > SAL_CALL OCommonStatement::executeQuery( const OUString& sql ) +{ + ::osl::MutexGuard aGuard( m_ThreadMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + // parse the statement + StatementType eStatementType = parseSql( sql ); + if ( eStatementType != eSelect ) + return nullptr; + + return impl_executeCurrentQuery(); +} + + +Reference< XConnection > SAL_CALL OCommonStatement::getConnection( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + // just return our connection here + return Reference< XConnection >(m_pConnection.get()); +} + +Any SAL_CALL OStatement::queryInterface( const Type & rType ) +{ + Any aRet = ::cppu::queryInterface(rType,static_cast< XServiceInfo*> (this)); + if(!aRet.hasValue()) + aRet = OCommonStatement::queryInterface(rType); + return aRet; +} + +sal_Int32 SAL_CALL OCommonStatement::executeUpdate( const OUString& /*sql*/ ) +{ + ::dbtools::throwFeatureNotImplementedSQLException( "XStatement::executeUpdate", *this ); + return 0; + +} + +Any SAL_CALL OCommonStatement::getWarnings( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + return makeAny(m_aLastWarning); +} + + +void SAL_CALL OCommonStatement::clearWarnings( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed); + + + m_aLastWarning = SQLWarning(); +} + +::cppu::IPropertyArrayHelper* OCommonStatement::createArrayHelper( ) const +{ + // this properties are define by the service resultset + // they must in alphabetic order + Sequence< Property > aProps(9); + Property* pProperties = aProps.getArray(); + sal_Int32 nPos = 0; + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CURSORNAME), + PROPERTY_ID_CURSORNAME, cppu::UnoType<OUString>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ESCAPEPROCESSING), + PROPERTY_ID_ESCAPEPROCESSING, cppu::UnoType<bool>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION), + PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE), + PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXFIELDSIZE), + PROPERTY_ID_MAXFIELDSIZE, cppu::UnoType<sal_Int32>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_MAXROWS), + PROPERTY_ID_MAXROWS, cppu::UnoType<sal_Int32>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_QUERYTIMEOUT), + PROPERTY_ID_QUERYTIMEOUT, cppu::UnoType<sal_Int32>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY), + PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), 0); + pProperties[nPos++] = css::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE), + PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), 0); + + return new ::cppu::OPropertyArrayHelper(aProps); +} + + +::cppu::IPropertyArrayHelper & OCommonStatement::getInfoHelper() +{ + return *getArrayHelper(); +} + +sal_Bool OCommonStatement::convertFastPropertyValue( + Any & /*rConvertedValue*/, + Any & /*rOldValue*/, + sal_Int32 /*nHandle*/, + const Any& /*rValue*/ ) +{ + // here we have to try to convert + return false; +} + +void OCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& /*rValue*/) +{ + // set the value to whatever is necessary + switch(nHandle) + { + case PROPERTY_ID_QUERYTIMEOUT: + case PROPERTY_ID_MAXFIELDSIZE: + case PROPERTY_ID_MAXROWS: + case PROPERTY_ID_RESULTSETCONCURRENCY: + case PROPERTY_ID_RESULTSETTYPE: + case PROPERTY_ID_FETCHDIRECTION: + case PROPERTY_ID_FETCHSIZE: + case PROPERTY_ID_ESCAPEPROCESSING: + default: + ; + } +} + +void OCommonStatement::getFastPropertyValue(Any& /*rValue*/,sal_Int32 nHandle) const +{ + switch(nHandle) + { + case PROPERTY_ID_QUERYTIMEOUT: + case PROPERTY_ID_MAXFIELDSIZE: + case PROPERTY_ID_MAXROWS: + case PROPERTY_ID_RESULTSETCONCURRENCY: + case PROPERTY_ID_RESULTSETTYPE: + case PROPERTY_ID_FETCHDIRECTION: + case PROPERTY_ID_FETCHSIZE: + case PROPERTY_ID_ESCAPEPROCESSING: + default: + ; + } +} + +IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.OStatement","com.sun.star.sdbc.Statement"); + +void SAL_CALL OCommonStatement::acquire() throw() +{ + OCommonStatement_IBASE::acquire(); +} + +void SAL_CALL OCommonStatement::release() throw() +{ + OCommonStatement_IBASE::release(); +} + +void SAL_CALL OStatement::acquire() throw() +{ + OCommonStatement::acquire(); +} + +void SAL_CALL OStatement::release() throw() +{ + OCommonStatement::release(); +} + +Reference< css::beans::XPropertySetInfo > SAL_CALL OCommonStatement::getPropertySetInfo( ) +{ + return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); +} + +void OCommonStatement::createColumnMapping() +{ + size_t i; + + // initialize the column index map (mapping select columns to table columns) + ::rtl::Reference<connectivity::OSQLColumns> xColumns = m_pSQLIterator->getSelectColumns(); + m_aColMapping.resize(xColumns->size() + 1); + for (i=0; i<m_aColMapping.size(); ++i) + m_aColMapping[i] = static_cast<sal_Int32>(i); + + Reference<XIndexAccess> xNames(m_xColNames,UNO_QUERY); + // now check which columns are bound +#if OSL_DEBUG_LEVEL > 0 + for ( i = 0; i < m_aColMapping.size(); i++ ) + SAL_INFO( + "connectivity.mork", + "BEFORE Mapped: " << i << " -> " << m_aColMapping[i]); +#endif + OResultSet::setBoundedColumns(m_aRow,xColumns,xNames,true,m_xDBMetaData,m_aColMapping); +#if OSL_DEBUG_LEVEL > 0 + for ( i = 0; i < m_aColMapping.size(); i++ ) + SAL_INFO( + "connectivity.mork", + "AFTER Mapped: " << i << " -> " << m_aColMapping[i]); +#endif +} + + +void OCommonStatement::analyseSQL() +{ + const OSQLParseNode* pOrderbyClause = m_pSQLIterator->getOrderTree(); + if(!pOrderbyClause) + return; + + OSQLParseNode * pOrderingSpecCommalist = pOrderbyClause->getChild(2); + OSL_ENSURE(SQL_ISRULE(pOrderingSpecCommalist,ordering_spec_commalist),"OResultSet: Error in Parse Tree"); + + for (size_t m = 0; m < pOrderingSpecCommalist->count(); m++) + { + OSQLParseNode * pOrderingSpec = pOrderingSpecCommalist->getChild(m); + OSL_ENSURE(SQL_ISRULE(pOrderingSpec,ordering_spec),"OResultSet: Error in Parse Tree"); + OSL_ENSURE(pOrderingSpec->count() == 2,"OResultSet: Error in Parse Tree"); + + OSQLParseNode * pColumnRef = pOrderingSpec->getChild(0); + if(!SQL_ISRULE(pColumnRef,column_ref)) + { + throw SQLException(); + } + OSQLParseNode * pAscendingDescending = pOrderingSpec->getChild(1); + setOrderbyColumn(pColumnRef,pAscendingDescending); + } +} + +void OCommonStatement::setOrderbyColumn(OSQLParseNode const * pColumnRef, + OSQLParseNode const * pAscendingDescending) +{ + OUString aColumnName; + if (pColumnRef->count() == 1) + aColumnName = pColumnRef->getChild(0)->getTokenValue(); + else if (pColumnRef->count() == 3) + { + pColumnRef->getChild(2)->parseNodeToStr( aColumnName, getOwnConnection(), nullptr, false, false ); + } + else + { + throw SQLException(); + } + + Reference<XColumnLocate> xColLocate(m_xColNames,UNO_QUERY); + if(!xColLocate.is()) + return; + + m_aOrderbyColumnNumber.push_back(xColLocate->findColumn(aColumnName)); + + // Ascending or Descending? + m_aOrderbyAscending.push_back(SQL_ISTOKEN(pAscendingDescending,DESC) ? TAscendingOrder::DESC : TAscendingOrder::ASC); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MStatement.hxx b/connectivity/source/drivers/mork/MStatement.hxx new file mode 100644 index 000000000..3cd7113a8 --- /dev/null +++ b/connectivity/source/drivers/mork/MStatement.hxx @@ -0,0 +1,184 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MSTATEMENT_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MSTATEMENT_HXX + +#include <comphelper/proparrhlp.hxx> +#include <connectivity/sqliterator.hxx> +#include <connectivity/sqlparse.hxx> +#include <com/sun/star/sdbc/SQLWarning.hpp> +#include <TSortIndex.hxx> +#include "MTable.hxx" + +#include <memory> + +namespace connectivity +{ + namespace mork + { + class OResultSet; + + typedef ::cppu::WeakComponentImplHelper< css::sdbc::XStatement, + css::sdbc::XWarningsSupplier, + css::sdbc::XCloseable> OCommonStatement_IBASE; + + + //************ Class: OCommonStatement + // is a base class for the normal statement and for the prepared statement + + class OCommonStatement; + + class OCommonStatement :public cppu::BaseMutex + ,public OCommonStatement_IBASE + ,public ::cppu::OPropertySetHelper + ,public ::comphelper::OPropertyArrayUsageHelper< OCommonStatement > + { + private: + css::sdbc::SQLWarning m_aLastWarning; + + protected: + css::uno::WeakReference< css::sdbc::XResultSet > m_xResultSet; + css::uno::Reference< css::sdbc::XDatabaseMetaData> m_xDBMetaData; + css::uno::Reference< css::container::XNameAccess> m_xColNames; // table columns + + // for this Statement + + OTable* m_pTable; + rtl::Reference<OConnection> m_pConnection; // The owning Connection object + + OValueRow m_aRow; + + connectivity::OSQLParser m_aParser; + std::shared_ptr< ::connectivity::OSQLParseTreeIterator > + m_pSQLIterator; + + std::unique_ptr<connectivity::OSQLParseNode> m_pParseTree; + + std::vector<sal_Int32> m_aColMapping; + std::vector<sal_Int32> m_aOrderbyColumnNumber; + std::vector<TAscendingOrder> m_aOrderbyAscending; + + protected: + + // OPropertyArrayUsageHelper + virtual ::cppu::IPropertyArrayHelper* createArrayHelper( ) const override; + // OPropertySetHelper + virtual ::cppu::IPropertyArrayHelper & SAL_CALL getInfoHelper() override; + virtual sal_Bool SAL_CALL convertFastPropertyValue( + css::uno::Any & rConvertedValue, + css::uno::Any & rOldValue, + sal_Int32 nHandle, + const css::uno::Any& rValue ) override; + virtual void SAL_CALL setFastPropertyValue_NoBroadcast( + sal_Int32 nHandle, + const css::uno::Any& rValue) override; + virtual void SAL_CALL getFastPropertyValue( + css::uno::Any& rValue, + sal_Int32 nHandle) const override; + virtual ~OCommonStatement() override; + + protected: + + // Driver Internal Methods + + enum StatementType { eSelect, eCreateTable }; + /** called to do the parsing of a to-be-executed SQL statement, and set all members as needed + + @throws css::sdbc::SQLException + @throws css::uno::RuntimeException + */ + virtual StatementType + parseSql( const OUString& sql , bool bAdjusted = false); + /** called to initialize a result set, according to a previously parsed SQL statement + */ + virtual void initializeResultSet( OResultSet* _pResult ); + /** called when a possible cached instance of our last result set should be cleared + */ + virtual void clearCachedResultSet(); + /** caches a result set which has just been created by an execution of an SQL statement + */ + virtual void cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult ); + + + /** executes the current query (the one which has been passed to the last parseSql call) + */ + css::uno::Reference< css::sdbc::XResultSet > + impl_executeCurrentQuery(); + + void createColumnMapping(); + void analyseSQL(); + void setOrderbyColumn( connectivity::OSQLParseNode const * pColumnRef, + connectivity::OSQLParseNode const * pAscendingDescending); + + public: + // other methods + OConnection* getOwnConnection() const { return m_pConnection.get(); } + + explicit OCommonStatement(OConnection* _pConnection ); + using OCommonStatement_IBASE::operator css::uno::Reference< css::uno::XInterface >; + + // OComponentHelper + virtual void SAL_CALL disposing() override; + + // XInterface + virtual void SAL_CALL release() throw() override; + virtual void SAL_CALL acquire() throw() override; + // XInterface + virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + //XTypeProvider + virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes( ) override; + + // XPropertySet + virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo( ) override; + // XStatement + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL executeQuery( const OUString& sql ) override ; + virtual sal_Int32 SAL_CALL executeUpdate( const OUString& sql ) override ; + virtual sal_Bool SAL_CALL execute( const OUString& sql ) override ; + virtual css::uno::Reference< css::sdbc::XConnection > SAL_CALL getConnection( ) override ; + // XWarningsSupplier + virtual css::uno::Any SAL_CALL getWarnings( ) override; + virtual void SAL_CALL clearWarnings( ) override; + // XCloseable + virtual void SAL_CALL close( ) override; + + protected: + using OPropertySetHelper::getFastPropertyValue; + }; + + class OStatement : public OCommonStatement, + public css::lang::XServiceInfo + { + protected: + virtual ~OStatement() override {} + public: + // a constructor, for when the object needs to be returned: + explicit OStatement( OConnection* _pConnection); + DECLARE_SERVICE_INFO(); + + virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + virtual void SAL_CALL acquire() throw() override; + virtual void SAL_CALL release() throw() override; + }; + } +} + +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MSTATEMENT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MTable.cxx b/connectivity/source/drivers/mork/MTable.cxx new file mode 100644 index 000000000..76db19fc6 --- /dev/null +++ b/connectivity/source/drivers/mork/MTable.cxx @@ -0,0 +1,57 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include "MTable.hxx" +#include "MColumns.hxx" +#include <connectivity/TKeys.hxx> +#include <connectivity/TIndexes.hxx> + + +using namespace connectivity::mork; +using namespace connectivity; + + +OTable::OTable( sdbcx::OCollection* _pTables, OConnection* _pConnection, + const OUString& Name, const OUString& Type, const OUString& Description ) + :OTable_Base(_pTables, _pConnection, true, Name, Type, Description ) + ,m_pConnection( _pConnection ) +{ + construct(); +} + + +sdbcx::OCollection* OTable::createColumns( const ::std::vector< OUString>& _rNames ) +{ + return new OColumns( this, m_aMutex, _rNames ); +} + + +sdbcx::OCollection* OTable::createKeys(const ::std::vector< OUString>& _rNames) +{ + return new OKeysHelper( this, m_aMutex, _rNames ); +} + + +sdbcx::OCollection* OTable::createIndexes(const ::std::vector< OUString>& _rNames) +{ + return new OIndexesHelper( this, m_aMutex, _rNames ); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MTable.hxx b/connectivity/source/drivers/mork/MTable.hxx new file mode 100644 index 000000000..7cbe216be --- /dev/null +++ b/connectivity/source/drivers/mork/MTable.hxx @@ -0,0 +1,61 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MTABLE_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MTABLE_HXX + +#include <connectivity/TTableHelper.hxx> +#include "MConnection.hxx" + +namespace connectivity +{ + namespace mork + { + typedef ::connectivity::OTableHelper OTable_Base; + + class OTable : public OTable_Base + { + OConnection* m_pConnection; + + public: + OTable( sdbcx::OCollection* _pTables, + OConnection* _pConnection, + const OUString& Name, + const OUString& Type, + const OUString& Description ); + + OConnection* getConnection() { return m_pConnection;} + + static bool isReadOnly() { return false; } + + const OUString& getTableName() const { return m_Name; } + const OUString& getSchema() const { return m_SchemaName; } + + // OTableHelper overridables + virtual sdbcx::OCollection* createColumns( const ::std::vector< OUString>& _rNames ) override; + virtual sdbcx::OCollection* createKeys(const ::std::vector< OUString>& _rNames) override; + virtual sdbcx::OCollection* createIndexes(const ::std::vector< OUString>& _rNames) override; + private: + using OTable_Base::getConnection; + }; + } +} +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MTABLE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MTables.cxx b/connectivity/source/drivers/mork/MTables.cxx new file mode 100644 index 000000000..f1f169e2a --- /dev/null +++ b/connectivity/source/drivers/mork/MTables.cxx @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include "MTables.hxx" +#include "MTable.hxx" +#include "MCatalog.hxx" +#include <comphelper/types.hxx> + +#include <com/sun/star/sdbc/XRow.hpp> + +using namespace connectivity; +using namespace connectivity::mork; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::sdbc; + +sdbcx::ObjectType OTables::createObject(const OUString& _rName) +{ + OUString aName,aSchema; + aSchema = "%"; + aName = _rName; + + Sequence< OUString > aTypes { "%" }; + + Reference< XResultSet > xResult = m_xMetaData->getTables(Any(),aSchema,aName,aTypes); + + sdbcx::ObjectType xRet; + if(xResult.is()) + { + Reference< XRow > xRow(xResult,UNO_QUERY); + if(xResult->next()) // there can be only one table with this name + { + OTable* pRet = new OTable( this, static_cast<OCatalog&>(m_rParent).getConnection(), + aName,xRow->getString(4),xRow->getString(5)); + xRet = pRet; + } + } + ::comphelper::disposeComponent(xResult); + + return xRet; +} + +void OTables::impl_refresh( ) +{ + static_cast<OCatalog&>(m_rParent).refreshTables(); +} + +void OTables::disposing() +{ + m_xMetaData.clear(); + OCollection::disposing(); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MTables.hxx b/connectivity/source/drivers/mork/MTables.hxx new file mode 100644 index 000000000..ac3730f9a --- /dev/null +++ b/connectivity/source/drivers/mork/MTables.hxx @@ -0,0 +1,47 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MTABLES_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MTABLES_HXX + +#include <connectivity/sdbcx/VCollection.hxx> +#include <com/sun/star/sdbc/XDatabaseMetaData.hpp> +namespace connectivity +{ + namespace mork + { + class OTables : public sdbcx::OCollection + { + css::uno::Reference< css::sdbc::XDatabaseMetaData > m_xMetaData; + protected: + virtual sdbcx::ObjectType createObject(const OUString& _rName) override; + virtual void impl_refresh() override; + public: + OTables(const css::uno::Reference< css::sdbc::XDatabaseMetaData >& _rMetaData,::cppu::OWeakObject& _rParent, ::osl::Mutex& _rMutex, + const ::std::vector< OUString> &_rVector) : sdbcx::OCollection(_rParent, true, _rMutex, _rVector) + ,m_xMetaData(_rMetaData) + {} + + // only the name is identical to ::cppu::OComponentHelper + virtual void disposing() override; + }; + } +} +#endif // INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MTABLES_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MorkParser.cxx b/connectivity/source/drivers/mork/MorkParser.cxx new file mode 100644 index 000000000..188f8e6fb --- /dev/null +++ b/connectivity/source/drivers/mork/MorkParser.cxx @@ -0,0 +1,757 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2006, ScalingWeb.com + * All rights reserved. + * + * Redistribution and use of this software in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the + * following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * * Neither the name of ScalingWeb.com nor the names of its + * contributors may be used to endorse or promote products + * derived from this software without specific prior + * written permission of ScalingWeb.com. + + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "MorkParser.hxx" +#include <boost/io/ios_state.hpp> +#include <stdlib.h> +#include <string> +#include <string.h> +#include <fstream> +#include <iostream> + +std::string const g_Empty = ""; + +const char * const MorkDictColumnMeta = "<(a=c)>"; + +static const int defaultScope_ = 0x80; + +MorkParser::MorkParser() : + columns_(), + values_(), + mork_(), + currentCells_(nullptr), + error_(NoError), + morkData_(), + morkPos_(0), + nextAddValueId_(0x7fffffff), + defaultTableId_(1), + nowParsing_(NP::Values) +{ +} + +bool MorkParser::open( const std::string &path ) +{ + initVars(); + std::string line; + std::ifstream infile(path.c_str(), std::ios_base::in); + if(!infile.is_open()) + { + error_ = FailedToOpen; + return false; + } + + while (getline(infile, line, '\n')) + { + morkData_.append(line); + morkData_.append("\n"); + } + + // Parse mork + return parse(); +} + +void MorkParser::initVars() +{ + error_ = NoError; + morkPos_ = 0; + nowParsing_ = NP::Values; + currentCells_ = nullptr; + nextAddValueId_ = 0x7fffffff; +} + +bool MorkParser::parse() +{ + bool Result = true; + + // Run over mork chars and parse each term + char cur = nextChar(); + + while ( Result && cur ) + { + if ( !isWhiteSpace( cur ) ) + { + // Figure out what a term + switch ( cur ) + { + case '<': + // Dict + Result = parseDict(); + break; + case '/': + // Comment + Result = parseComment(); + break; + case '{': + Result = parseTable(); + // Table + break; + case '[': + Result = parseRow( 0, 0 ); + // Row + break; + case '@': + parseGroup(); + // Group + break; + default: + error_ = DefectedFormat; + Result = false; + break; + } + } + + // Get next char + cur = nextChar(); + } + + return Result; +} + +bool MorkParser::isWhiteSpace( char c ) +{ + switch ( c ) + { + case ' ': + case '\t': + case '\r': + case '\n': + case '\f': + return true; + default: + return false; + } +} + +inline char MorkParser::nextChar() +{ + char cur = 0; + + + if ( morkPos_ < morkData_.length() ) + { + cur = morkData_[ morkPos_ ]; + morkPos_++; + } + + if ( !cur ) + { + cur = 0; + } + + return cur; +} + +bool MorkParser::parseDict() +{ + char cur = nextChar(); + bool Result = true; + nowParsing_ = NP::Values; + + while ( Result && cur != '>' && cur ) + { + if ( !isWhiteSpace( cur ) ) + { + switch ( cur ) + { + case '<': + { + + if ( morkData_.substr( morkPos_ - 1, strlen( MorkDictColumnMeta ) ) == MorkDictColumnMeta ) + { + nowParsing_ = NP::Columns; + morkPos_ += strlen( MorkDictColumnMeta ) - 1; + } + + + break; + } + case '(': + Result = parseCell(); + break; + case '/': + Result = parseComment(); + break; + + } + } + + cur = nextChar(); + } + + return Result; +} + +inline bool MorkParser::parseComment() +{ + char cur = nextChar(); + if ( '/' != cur ) return false; + + while ( cur != '\r' && cur != '\n' && cur ) + { + cur = nextChar(); + } + + return true; +} + +bool MorkParser::parseCell() +{ + bool Result = true; + bool bValueOid = false; + bool bColumn = true; + int Corners = 0; + + // Column = Value + std::string Column; + std::string Text; + Column.reserve( 4 ); + Text.reserve( 32 ); + + char cur = nextChar(); + + // Process cell start with column (bColumn == true) + while ( Result && cur != ')' && cur ) + { + switch ( cur ) + { + case '^': + // Oids + Corners++; + if ( 1 == Corners ) + { + } + else if ( 2 == Corners ) + { + bColumn = false; + bValueOid = true; + } + else + { + Text += cur; + } + + break; + case '=': + // From column to value + if ( bColumn ) + { + bColumn = false; + } + else + { + Text += cur; + } + break; + case '\\': + { + // Get next two chars + char NextChar= nextChar(); + if ( '\r' != NextChar && '\n' != NextChar ) + { + Text += NextChar; + } + else + { + (void)nextChar(); + } + } + break; + case '$': + { + // Get next two chars + std::string HexChar; + HexChar += nextChar(); + HexChar += nextChar(); + Text += static_cast<char>(strtoul(HexChar.c_str(), nullptr, 16)); + } + break; + default: + // Just a char + if ( bColumn ) + { + Column += cur; + } + else + { + Text += cur; + } + break; + } + + cur = nextChar(); + } + + // Apply column and text + int ColumnId = strtoul(Column.c_str(), nullptr, 16); + + if ( NP::Rows != nowParsing_ ) + { + // Dicts + if ( !Text.empty() ) + { + if ( nowParsing_ == NP::Columns ) + { + columns_[ ColumnId ] = Text; + } + else + { + values_[ ColumnId ] = Text; + } + } + } + else + { + if ( !Text.empty() ) + { + // Rows + //int ValueId = string( Text.c_str() ).toInt( 0, 16 ); + int ValueId = strtoul(Text.c_str(), nullptr, 16); + + if ( bValueOid ) + { + ( *currentCells_ )[ ColumnId ] = ValueId; + } + else + { + nextAddValueId_--; + values_[ nextAddValueId_ ] = Text; + ( *currentCells_ )[ ColumnId ] = nextAddValueId_; + } + } + } + + return Result; +} + +bool MorkParser::parseTable() +{ + bool Result = true; + std::string TextId; + int Id = 0, Scope = 0; + + char cur = nextChar(); + + // Get id + while ( cur != '{' && cur != '[' && cur != '}' && cur ) + { + if ( !isWhiteSpace( cur ) ) + { + TextId += cur; + } + + cur = nextChar(); + } + + parseScopeId( TextId, &Id, &Scope ); + + // Parse the table + while ( Result && cur != '}' && cur ) + { + if ( !isWhiteSpace( cur ) ) + { + switch ( cur ) + { + case '{': + parseMeta( '}' ); + break; + case '[': + Result = parseRow( Id, Scope ); + break; + case '-': + case '+': + break; + default: + { + std::string JustId; + while ( !isWhiteSpace( cur ) && cur ) + { + JustId += cur; + cur = nextChar(); + + if ( cur == '}' ) + { + return Result; + } + } + + int JustIdNum = 0, JustScopeNum = 0; + parseScopeId( JustId, &JustIdNum, &JustScopeNum ); + + setCurrentRow( Scope, Id, JustScopeNum, JustIdNum ); + } + break; + } + } + + cur = nextChar(); + } + + return Result; +} + +void MorkParser::parseScopeId( const std::string &TextId, int *Id, int *Scope ) +{ + int Pos = 0; + + if ( ( Pos = TextId.find( ':' ) ) >= 0 ) + { + std::string tId = TextId.substr( 0, Pos ); + std::string tSc = TextId.substr( Pos + 1, TextId.length() - Pos ); + + if ( tSc.length() > 1 && '^' == tSc[ 0 ] ) + { + // Delete '^' + tSc.erase( 0, 1 ); + } + + *Id = strtoul(tId.c_str(), nullptr, 16); + + *Scope = strtoul(tSc.c_str(), nullptr, 16); + } + else + { + *Id = strtoul(TextId.c_str(), nullptr, 16); + } +} + +inline void MorkParser::setCurrentRow( int TableScope, int TableId, int RowScope, int RowId ) +{ + if ( !RowScope ) + { + RowScope = defaultScope_; + } + + if ( !TableScope ) + { + TableScope = defaultScope_; + } + + // 01.08.2012 davido + // TableId 0 is wrong here. + // Straying rows (rows that defined outside the table) belong to the default scope and table is the last was seen: 1:^80 + // (at least i read so the specification) + if (TableId) + { + defaultTableId_ = TableId; + } + + if (!TableId) + { + TableId = defaultTableId_; + } + + currentCells_ = &( mork_.map[ abs( TableScope ) ].map[ abs( TableId ) ].map[ abs( RowScope ) ].map[ abs( RowId ) ] ); +} + +bool MorkParser::parseRow( int TableId, int TableScope ) +{ + bool Result = true; + std::string TextId; + int Id = 0, Scope = 0; + nowParsing_ = NP::Rows; + + char cur = nextChar(); + + // Get id + while ( cur != '(' && cur != ']' && cur != '[' && cur ) + { + if ( !isWhiteSpace( cur ) ) + { + TextId += cur; + } + + cur = nextChar(); + } + + parseScopeId( TextId, &Id, &Scope ); + setCurrentRow( TableScope, TableId, Scope, Id ); + + // Parse the row + while ( Result && cur != ']' && cur ) + { + if ( !isWhiteSpace( cur ) ) + { + switch ( cur ) + { + case '(': + Result = parseCell(); + break; + case '[': + parseMeta( ']' ); + break; + default: + Result = false; + break; + } + } + + cur = nextChar(); + } + + return Result; +} + +void MorkParser::parseGroup() +{ + parseMeta( '@' ); +} + +void MorkParser::parseMeta( char c ) +{ + char cur = nextChar(); + + while ( cur != c && cur ) + { + cur = nextChar(); + } +} + +MorkTableMap *MorkParser::getTables( int TableScope ) +{ + TableScopeMap::Map::iterator iter = mork_.map.find( TableScope ); + + if ( iter == mork_.map.end() ) + { + return nullptr; + } + + return &iter->second; +} + +MorkRowMap *MorkParser::getRows( int RowScope, RowScopeMap *table ) +{ + RowScopeMap::Map::iterator iter = table->map.find( RowScope ); + + if ( iter == table->map.end() ) + { + return nullptr; + } + + return &iter->second; +} + +std::string const &MorkParser::getValue( int oid ) +{ + MorkDict::iterator foundIter = values_.find( oid ); + + if ( values_.end() == foundIter ) + { + return g_Empty; + } + + return foundIter->second; +} + +std::string const &MorkParser::getColumn( int oid ) +{ + MorkDict::iterator foundIter = columns_.find( oid ); + + if ( columns_.end() == foundIter ) + { + return g_Empty; + } + + return foundIter->second; +} + +void MorkParser::retrieveLists(std::set<std::string>& lists) +{ +#ifdef VERBOSE + boost::io::ios_all_saver ias(std::cout); + std::cout << std::hex << std::uppercase; +#endif + + MorkTableMap* tables = getTables(defaultScope_); + if (!tables) return; + for (auto& rTable : tables->map) + { +#ifdef VERBOSE + std::cout << "\t Table:" + << ( ( int ) rTable.first < 0 ? "-" : " " ) + << rTable.first << std::endl; +#endif + MorkRowMap* rows = getRows( 0x81/*defaultListScope*/, &rTable.second ); + if (!rows) return; + for ( const auto& rRow : rows->map ) + { +#ifdef VERBOSE + std::cout << "\t\t\t Row Id:" + << ( ( int ) rRow.first < 0 ? "-" : " ") + << rRow.first << std::endl; + std::cout << "\t\t\t\t Cells:\r\n"; +#endif + // Get cells + MorkCells::const_iterator cellsIter = rRow.second.find(0xC1); + if (cellsIter != rRow.second.end()) + lists.insert(getValue( cellsIter->second )); + } + } +} + +void MorkParser::getRecordKeysForListTable(std::string const & listName, std::set<int>& records) +{ +#ifdef VERBOSE + boost::io::ios_all_saver ias(std::cout); + std::cout << std::hex << std::uppercase; +#endif + + MorkTableMap* tables = getTables(defaultScope_); + if (!tables) return; + for (auto& rTable : tables->map) + { +#ifdef VERBOSE + std::cout << "\t Table:" + << ( ( int ) rTable.first < 0 ? "-" : " " ) + << rTable.first << std::endl; +#endif + MorkRowMap* rows = getRows( 0x81, &rTable.second ); + if (!rows) return; + for ( const auto& rRow : rows->map ) + { +#ifdef VERBOSE + std::cout << "\t\t\t Row Id:" + << ( ( int ) rRow.first < 0 ? "-" : " ") + << rRow.first << std::endl; + std::cout << "\t\t\t\t Cells:\r\n"; +#endif + // Get cells + bool isListFound = false; + for ( const auto& [rColumnId, rValueId] : rRow.second ) + { + if (isListFound) + { + if (rColumnId >= 0xC7) + { + std::string value = getValue(rValueId); + int id = strtoul(value.c_str(), nullptr, 16); + records.insert(id); + } + } + else if ((rColumnId == 0xC1) && + listName == getValue( rValueId )) + { + isListFound = true; + } + } + + } + } +} + +void MorkParser::dump() +{ + boost::io::ios_all_saver ias(std::cout); + std::cout << std::hex << std::uppercase; + + std::cout << "Column Dict:\r\n"; + std::cout << "=============================================\r\n\r\n"; + + //// columns dict + for ( const auto& [rColumnId, rText] : columns_ ) + { + std::cout << rColumnId + << " : " + << rText + << std::endl; + } + + //// values dict + std::cout << "\r\nValues Dict:\r\n"; + std::cout << "=============================================\r\n\r\n"; + + for ( const auto& [rValueId, rText] : values_ ) + { + if (rValueId >= nextAddValueId_) { + continue; + } + + std::cout << rValueId + << " : " + << rText + << "\r\n"; + } + + std::cout << std::endl << "Data:" << std::endl; + std::cout << "=============================================" + << std::endl << std::endl; + + //// Mork data + for ( const auto& [rTableScopeId, rTableScope] : mork_.map ) + { + std::cout << "\r\n Scope:" << rTableScopeId << std::endl; + + for ( const auto& [rTableId, rTable] : rTableScope.map ) + { + std::cout << "\t Table:" + << ( rTableId < 0 ? "-" : " " ) + << rTableId << std::endl; + + for (const auto& [rRowScopeId, rRowScope] : rTable.map) + { + std::cout << "\t\t RowScope:" + << rRowScopeId << std::endl; + + for (const auto& [rRowId, rRow] : rRowScope.map) + { + std::cout << "\t\t\t Row Id:" + << (rRowId < 0 ? "-" : " ") + << rRowId << std::endl; + std::cout << "\t\t\t\t Cells:" << std::endl; + + for (const auto& [rColumnId, rValueId] : rRow) + { + // Write ids + std::cout << "\t\t\t\t\t" + << rColumnId + << " : " + << rValueId + << " => "; + + MorkDict::const_iterator FoundIter = values_.find( rValueId ); + if ( FoundIter != values_.end() ) + { + // Write string values + std::cout << columns_[ rColumnId ].c_str() + << " : " + << FoundIter->second.c_str() + << std::endl; + } + } + } + } + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/MorkParser.hxx b/connectivity/source/drivers/mork/MorkParser.hxx new file mode 100644 index 000000000..d16fc417d --- /dev/null +++ b/connectivity/source/drivers/mork/MorkParser.hxx @@ -0,0 +1,152 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2006, ScalingWeb.com + * All rights reserved. + * + * Redistribution and use of this software in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above + * copyright notice, this list of conditions and the + * following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the + * following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * * Neither the name of ScalingWeb.com nor the names of its + * contributors may be used to endorse or promote products + * derived from this software without specific prior + * written permission of ScalingWeb.com. + + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MORKPARSER_HXX +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_MORKPARSER_HXX + +#include <rtl/ustring.hxx> + +#include <string> +#include <map> +#include <set> +#include <vector> + +#include "dllapi.h" + +// Types + +typedef std::map< int, std::string > MorkDict; +typedef std::map< int, int > MorkCells; // ColumnId : ValueId +struct MorkRowMap { typedef std::map< int, MorkCells > Map; Map map; }; // Row id +struct RowScopeMap { typedef std::map< int, MorkRowMap > Map; Map map; }; // Row scope +struct MorkTableMap { typedef std::map< int, RowScopeMap > Map; Map map; }; // Table id +struct TableScopeMap { typedef std::map< int, MorkTableMap > Map; Map map; }; // Table Scope + +// Error codes +enum MorkErrors +{ + NoError = 0, + FailedToOpen, + DefectedFormat +}; + + +/// Class MorkParser + +class LO_DLLPUBLIC_MORK MorkParser final +{ +public: + + explicit MorkParser(); + + /// Open and parse mork file + + bool open( const std::string &path ); + + /// Returns all tables of specified scope + + MorkTableMap *getTables( int tableScope ); + + /// Returns all rows under specified scope + + static MorkRowMap *getRows( int rowScope, RowScopeMap *table ); + + /// Return value of specified value oid + + std::string const &getValue( int oid ); + + /// Return value of specified column oid + + std::string const &getColumn( int oid ); + + void retrieveLists(std::set<std::string>& lists); + void getRecordKeysForListTable(std::string const & listName, std::set<int>& records); + + void dump(); + + // All lists + std::vector<OUString> lists_; + +private: // Members + + void initVars(); + + static bool isWhiteSpace( char c ); + char nextChar(); + + static void parseScopeId( const std::string &TextId, int *Id, int *Scope ); + void setCurrentRow( int TableScope, int TableId, int RowScope, int RowId ); + + // Parse methods + bool parse(); + bool parseDict(); + bool parseComment(); + bool parseCell(); + bool parseTable(); + void parseMeta( char c ); + bool parseRow( int TableId, int TableScope ); + void parseGroup(); + +private: // Data + + // Columns in mork means value names + MorkDict columns_; + MorkDict values_; + + // All mork file data + TableScopeMap mork_; + MorkCells *currentCells_; + + // Error status of last operation + MorkErrors error_; + + // All Mork data + std::string morkData_; + + + unsigned morkPos_; + int nextAddValueId_; + int defaultTableId_; + + // Indicates entity is being parsed + enum class NP { Columns, Values, Rows } nowParsing_; + + MorkParser(const MorkParser &) = delete; + MorkParser &operator=(const MorkParser &) = delete; + +}; + +#endif // __MorkParser_h__ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/README b/connectivity/source/drivers/mork/README new file mode 100644 index 000000000..0d4207b0c --- /dev/null +++ b/connectivity/source/drivers/mork/README @@ -0,0 +1,41 @@ +Mork Format Parsing Library +============================= + +Description +----------- + +Cross Platform Mozilla Mork format reader. + + +Compilation +------------ + +g++ -o MorkParser main.cpp MorkParser.cpp + + +License +------- + +This program is licensed under permissive BSD license. +See the license.txt file for more information. + + +Date: October 16th, 2007 + +Project Maintainers: + Yuriy Soroka + ysoroka@scalingweb.com + + http://www.scalingweb.com/ + +Thanks +------------- +Thanks to Petr Stejskal <stejsky@volny.cz> who helped with porting this code from Qt to STL. + + +How you can help +---------------- + + Comments, patches, bug reports are welcome. + + diff --git a/connectivity/source/drivers/mork/dllapi.h b/connectivity/source/drivers/mork/dllapi.h new file mode 100644 index 000000000..adf269107 --- /dev/null +++ b/connectivity/source/drivers/mork/dllapi.h @@ -0,0 +1,25 @@ + +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_DLLAPI_H +#define INCLUDED_CONNECTIVITY_SOURCE_DRIVERS_MORK_DLLAPI_H + +#include <sal/config.h> +#include <sal/types.h> + +#if defined LO_DLLIMPLEMENTATION_MORK +#define LO_DLLPUBLIC_MORK SAL_DLLPUBLIC_EXPORT +#else +#define LO_DLLPUBLIC_MORK SAL_DLLPUBLIC_IMPORT +#endif + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/drivers/mork/license.txt b/connectivity/source/drivers/mork/license.txt new file mode 100644 index 000000000..3e41befc7 --- /dev/null +++ b/connectivity/source/drivers/mork/license.txt @@ -0,0 +1,31 @@ +Software License Agreement (BSD License) + +Copyright (c) 2006, ScalingWeb.com +All rights reserved. + +Redistribution and use of this software in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of ScalingWeb.com nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of ScalingWeb.com. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/connectivity/source/drivers/mork/mork.component b/connectivity/source/drivers/mork/mork.component new file mode 100644 index 000000000..1eeb6affb --- /dev/null +++ b/connectivity/source/drivers/mork/mork.component @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * +--> + +<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@" + xmlns="http://openoffice.org/2010/uno-components"> + <implementation name="com.sun.star.comp.sdbc.MorkDriver" + constructor="com_sun_star_comp_sdbc_MorkDriver_get_implementation"> + <service name="com.sun.star.sdbc.Driver"/> + </implementation> +</component> diff --git a/connectivity/source/drivers/mork/mork_helper.cxx b/connectivity/source/drivers/mork/mork_helper.cxx new file mode 100644 index 000000000..4cb11864f --- /dev/null +++ b/connectivity/source/drivers/mork/mork_helper.cxx @@ -0,0 +1,54 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ + +#include "MorkParser.hxx" +#include <iostream> +#include <sal/log.hxx> + +static bool openAddressBook(const std::string& path) +{ + MorkParser mork; + // Open and parse mork file + if (!mork.open(path)) + { + return false; + } + + const int defaultScope = 0x80; + MorkTableMap *Tables = mork.getTables( defaultScope ); + if ( Tables ) + { + // Iterate all tables + for (auto const& table : Tables->map) + { + if ( 0 == table.first ) continue; + SAL_INFO("connectivity.mork", "table->first : " << table.first); + std::string column = mork.getColumn( table.first ); + std::string value = mork.getValue( table.first ); + SAL_INFO("connectivity.mork", "table.column : " << column); + SAL_INFO("connectivity.mork", "table.value : " << value); + } + } + + mork.dump(); + + return true; +} + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + std::cerr << "Usage: " << argv[0] << " <path-to>/abook.mab" << std::endl; + std::cerr << "Example: " << argv[0] << " /home/johndoe/.thunderbird/m0tpqlky.default/abook.mab" << std::endl; + + return 1; + } + + OString aOString(argv[1]); + SAL_INFO("connectivity.mork", "abook.mab: " << aOString); + openAddressBook(aOString.getStr()); + + return 0; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |