summaryrefslogtreecommitdiffstats
path: root/connectivity/source/drivers/mork/MResultSet.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--connectivity/source/drivers/mork/MResultSet.cxx1710
1 files changed, 1710 insertions, 0 deletions
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: */