LCOV - code coverage report
Current view: top level - libreoffice/connectivity/source/drivers/mork - MResultSet.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 279 787 35.5 %
Date: 2012-12-27 Functions: 31 118 26.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <com/sun/star/sdbc/DataType.hpp>
      21             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      22             : #include <comphelper/property.hxx>
      23             : #include <comphelper/sequence.hxx>
      24             : #include <cppuhelper/typeprovider.hxx>
      25             : #include <comphelper/extract.hxx>
      26             : #include <com/sun/star/lang/DisposedException.hpp>
      27             : #include <com/sun/star/sdbc/ResultSetType.hpp>
      28             : #include <com/sun/star/sdbc/FetchDirection.hpp>
      29             : #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
      30             : #include <comphelper/types.hxx>
      31             : #include <connectivity/dbexception.hxx>
      32             : #include <connectivity/dbtools.hxx>
      33             : 
      34             : #include <TSortIndex.hxx>
      35             : #include <rtl/string.hxx>
      36             : #include <vector>
      37             : #include <algorithm>
      38             : #include "MResultSet.hxx"
      39             : #include "MResultSetMetaData.hxx"
      40             : #include "FDatabaseMetaDataResultSet.hxx"
      41             : 
      42             : #include "resource/mork_res.hrc"
      43             : #include "resource/common_res.hrc"
      44             : 
      45             : #if OSL_DEBUG_LEVEL > 0
      46             : # define OUtoCStr( x ) ( ::rtl::OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
      47             : #else /* OSL_DEBUG_LEVEL */
      48             : # define OUtoCStr( x ) ("dummy")
      49             : #endif /* OSL_DEBUG_LEVEL */
      50             : 
      51             : using namespace ::comphelper;
      52             : using namespace connectivity;
      53             : using namespace connectivity::mork;
      54             : using namespace ::cppu;
      55             : using namespace com::sun::star::uno;
      56             : using namespace com::sun::star::lang;
      57             : using namespace com::sun::star::beans;
      58             : using namespace com::sun::star::sdbc;
      59             : using namespace com::sun::star::container;
      60             : using namespace com::sun::star::io;
      61             : using namespace com::sun::star::util;
      62             : 
      63             : //------------------------------------------------------------------------------
      64             : //  IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.OResultSet","com.sun.star.sdbc.ResultSet");
      65           0 : ::rtl::OUString SAL_CALL OResultSet::getImplementationName(  ) throw ( RuntimeException)    \
      66             : {
      67           0 :     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbcx.mork.ResultSet"));
      68             : }
      69             : // -------------------------------------------------------------------------
      70           0 :  Sequence< ::rtl::OUString > SAL_CALL OResultSet::getSupportedServiceNames(  ) throw( RuntimeException)
      71             : {
      72           0 :     ::com::sun::star::uno::Sequence< ::rtl::OUString > aSupported(2);
      73           0 :     aSupported[0] = OUString("com.sun.star.sdbc.ResultSet");
      74           0 :     aSupported[1] = OUString("com.sun.star.sdbcx.ResultSet");
      75           0 :     return aSupported;
      76             : }
      77             : // -------------------------------------------------------------------------
      78           0 : sal_Bool SAL_CALL OResultSet::supportsService( const ::rtl::OUString& _rServiceName ) throw( RuntimeException)
      79             : {
      80           0 :     Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
      81           0 :     const ::rtl::OUString* pSupported = aSupported.getConstArray();
      82           0 :     const ::rtl::OUString* pEnd = pSupported + aSupported.getLength();
      83           0 :     for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported)
      84             :         ;
      85             : 
      86           0 :     return pSupported != pEnd;
      87             : }
      88             : 
      89             : // -------------------------------------------------------------------------
      90           2 : OResultSet::OResultSet(OCommonStatement* pStmt, const ::boost::shared_ptr< connectivity::OSQLParseTreeIterator >& _pSQLIterator )
      91             :     : OResultSet_BASE(m_aMutex)
      92             :     ,OPropertySetHelper(OResultSet_BASE::rBHelper)
      93             :     ,m_pStatement(pStmt)
      94             :     ,m_xStatement(*pStmt)
      95             :     ,m_xMetaData(NULL)
      96             :     ,m_nRowPos(0)
      97             :     ,m_nOldRowPos(0)
      98             :     ,m_nFetchSize(0)
      99             :     ,m_nResultSetType(ResultSetType::SCROLL_INSENSITIVE)
     100             :     ,m_nFetchDirection(FetchDirection::FORWARD)
     101             :     ,m_nResultSetConcurrency(ResultSetConcurrency::UPDATABLE)
     102             :     ,m_pSQLIterator( _pSQLIterator )
     103           2 :     ,m_pParseTree( _pSQLIterator->getParseTree() )
     104           2 :     ,m_aQueryHelper(pStmt->getOwnConnection()->getColumnAlias())
     105             :     ,m_pTable(NULL)
     106             :     ,m_CurrentRowCount(0)
     107             :     ,m_nParamIndex(0)
     108             :     ,m_bIsAlwaysFalseQuery(sal_False)
     109             :     ,m_pKeySet(NULL)
     110             :     ,m_nNewRow(0)
     111             :     ,m_nUpdatedRow(0)
     112             :     ,m_RowStates(0)
     113           6 :     ,m_bIsReadOnly(-1)
     114             : {
     115             : 
     116             :     //m_aQuery.setMaxNrOfReturns(pStmt->getOwnConnection()->getMaxResultRecords());
     117           2 : }
     118             : // -------------------------------------------------------------------------
     119           0 : OResultSet::~OResultSet()
     120             : {
     121           0 : }
     122             : 
     123             : // -------------------------------------------------------------------------
     124           0 : void OResultSet::disposing(void)
     125             : {
     126           0 :     OPropertySetHelper::disposing();
     127             : 
     128           0 :     ::osl::MutexGuard aGuard(m_aMutex);
     129             : 
     130           0 :     m_xStatement.clear();
     131           0 :     m_xMetaData.clear();
     132           0 :     m_pParseTree    = NULL;
     133           0 :     m_xColumns = NULL;
     134           0 :     m_xParamColumns = NULL;
     135           0 :     m_pKeySet       = NULL;
     136           0 :     if(m_pTable)
     137             :     {
     138           0 :         m_pTable->release();
     139           0 :         m_pTable = NULL;
     140           0 :     }
     141           0 : }
     142             : // -------------------------------------------------------------------------
     143           4 : Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeException)
     144             : {
     145           4 :     Any aRet = OPropertySetHelper::queryInterface(rType);
     146           4 :     if(!aRet.hasValue())
     147           4 :         aRet = OResultSet_BASE::queryInterface(rType);
     148           4 :     return aRet;
     149             : }
     150             : // -------------------------------------------------------------------------
     151           0 :  Sequence<  Type > SAL_CALL OResultSet::getTypes(  ) throw( RuntimeException)
     152             : {
     153           0 :     OTypeCollection aTypes( ::getCppuType( (const  Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
     154           0 :                                                 ::getCppuType( (const  Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ),
     155           0 :                                                 ::getCppuType( (const  Reference< ::com::sun::star::beans::XPropertySet > *)0 ));
     156             : 
     157           0 :     return ::comphelper::concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes());
     158             : }
     159             : // -------------------------------------------------------------------------
     160          14 : void OResultSet::methodEntry()
     161             : {
     162          14 :     checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
     163          14 :     if ( !m_pTable )
     164             :     {
     165             :         OSL_FAIL( "OResultSet::methodEntry: looks like we're disposed, but how is this possible?" );
     166           0 :         throw DisposedException( ::rtl::OUString(), *this );
     167             :     }
     168          14 : }
     169             : 
     170             : // -------------------------------------------------------------------------
     171           0 : sal_Int32 SAL_CALL OResultSet::findColumn( const ::rtl::OUString& columnName ) throw(SQLException, RuntimeException)
     172             : {
     173           0 :     ResultSetEntryGuard aGuard( *this );
     174             : 
     175             :     // find the first column with the name columnName
     176           0 :     Reference< XResultSetMetaData > xMeta = getMetaData();
     177           0 :     sal_Int32 nLen = xMeta->getColumnCount();
     178           0 :     sal_Int32 i = 1;
     179           0 :     for(;i<=nLen;++i)
     180           0 :         if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
     181           0 :                 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
     182           0 :             break;
     183           0 :     return i;
     184             : }
     185             : // -------------------------------------------------------------------------
     186           0 : Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     187             : {
     188           0 :     return NULL;
     189             : }
     190             : // -------------------------------------------------------------------------
     191           0 : Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     192             : {
     193           0 :     return NULL;
     194             : }
     195             : 
     196             : // -------------------------------------------------------------------------
     197           0 : sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     198             : {
     199           0 :     ResultSetEntryGuard aGuard( *this );
     200           0 :     m_bWasNull = sal_True;
     201           0 :     return sal_False;
     202             : }
     203             : // -------------------------------------------------------------------------
     204             : 
     205           0 : sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     206             : {
     207           0 :     ResultSetEntryGuard aGuard( *this );
     208           0 :     return 0;
     209             : }
     210             : // -------------------------------------------------------------------------
     211             : 
     212           0 : Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     213             : {
     214           0 :     ResultSetEntryGuard aGuard( *this );
     215           0 :     return Sequence< sal_Int8 >();
     216             : }
     217             : // -------------------------------------------------------------------------
     218             : 
     219           0 : Date SAL_CALL OResultSet::getDate( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     220             : {
     221           0 :     ResultSetEntryGuard aGuard( *this );
     222           0 :     return Date();
     223             : }
     224             : // -------------------------------------------------------------------------
     225             : 
     226           0 : double SAL_CALL OResultSet::getDouble( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     227             : {
     228           0 :     ResultSetEntryGuard aGuard( *this );
     229           0 :     return 0.0;
     230             : }
     231             : // -------------------------------------------------------------------------
     232             : 
     233           0 : float SAL_CALL OResultSet::getFloat( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     234             : {
     235           0 :     ResultSetEntryGuard aGuard( *this );
     236           0 :     return 0;
     237             : }
     238             : // -------------------------------------------------------------------------
     239             : 
     240           0 : sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     241             : {
     242           0 :     ResultSetEntryGuard aGuard( *this );
     243           0 :     return 0;
     244             : }
     245             : 
     246             : // -------------------------------------------------------------------------
     247           0 : sal_Int32 SAL_CALL OResultSet::getRow(  ) throw(SQLException, RuntimeException)
     248             : {
     249           0 :     ResultSetEntryGuard aGuard( *this );
     250             : 
     251             :     OSL_TRACE("In/Out: OResultSet::getRow, return = %u", m_nRowPos );
     252           0 :     return m_nRowPos;
     253             : }
     254             : // -------------------------------------------------------------------------
     255             : 
     256           0 : sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     257             : {
     258           0 :     ResultSetEntryGuard aGuard( *this );
     259           0 :     return sal_Int64();
     260             : }
     261             : // -------------------------------------------------------------------------
     262             : 
     263           0 : Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData(  ) throw(SQLException, RuntimeException)
     264             : {
     265           0 :     ResultSetEntryGuard aGuard( *this );
     266             : 
     267           0 :     if(!m_xMetaData.is())
     268             :         m_xMetaData = new OResultSetMetaData(
     269           0 :         m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,determineReadOnly());
     270           0 :     return m_xMetaData;
     271             : }
     272             : // -------------------------------------------------------------------------
     273           0 : Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     274             : {
     275           0 :     return NULL;
     276             : }
     277             : 
     278             : // -------------------------------------------------------------------------
     279             : 
     280           0 : Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     281             : {
     282           0 :     return NULL;
     283             : }
     284             : // -------------------------------------------------------------------------
     285           0 : Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     286             : {
     287           0 :     return NULL;
     288             : }
     289             : // -------------------------------------------------------------------------
     290             : 
     291           0 : Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     292             : {
     293           0 :     return NULL;
     294             : }
     295             : // -------------------------------------------------------------------------
     296             : 
     297           0 : Any SAL_CALL OResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
     298             : {
     299           0 :     return Any();
     300             : }
     301             : // -------------------------------------------------------------------------
     302             : 
     303           0 : sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     304             : {
     305           0 :     return 0;
     306             : }
     307             : // -------------------------------------------------------------------------
     308             : 
     309           4 : void OResultSet::checkIndex(sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException)
     310             : {
     311           4 :     if(columnIndex <= 0 || columnIndex > (sal_Int32)m_xColumns->get().size())
     312           0 :         ::dbtools::throwInvalidIndexException(*this);
     313           4 : }
     314             : // -------------------------------------------------------------------------
     315           6 : sal_uInt32 OResultSet::currentRowCount()
     316             : {
     317           6 :     if ( m_bIsAlwaysFalseQuery )
     318           0 :         return 0;
     319             :     //return 0;//m_aQuery.getRealRowCount() - deletedCount();
     320             :     // new implementation
     321           6 :     return m_aQueryHelper.getResultCount();
     322             : }
     323             : 
     324             : // -------------------------------------------------------------------------
     325             : 
     326           5 : sal_Bool OResultSet::fetchCurrentRow( ) throw(SQLException, RuntimeException)
     327             : {
     328             :     OSL_TRACE("fetchCurrentRow, m_nRowPos = %u", m_nRowPos );
     329           5 :     return fetchRow(getCurrentCardNumber());
     330             : }
     331             : 
     332             : // -------------------------------------------------------------------------
     333           0 : sal_Bool OResultSet::pushCard(sal_uInt32 /*cardNumber*/) throw(SQLException, RuntimeException)
     334             : {
     335             :     SAL_INFO("connectivity.mork", "=> OResultSet::pushCard()" );
     336           0 :     return sal_True;
     337             : /*
     338             :     if (cardNumber == 0)
     339             :         return sal_True;
     340             :     // Check whether we are storing the updated row
     341             :     if ( (m_aRow->get())[0].isNull() || (sal_Int32)(m_aRow->get())[0] != (sal_Int32)cardNumber )
     342             :         return sal_False;
     343             : 
     344             :     sal_Int32 nCount = m_aColumnNames.getLength();
     345             :     m_aQuery.setRowStates(cardNumber,m_RowStates);
     346             :     for( sal_Int32 i = 1; i <= nCount; i++ )
     347             :     {
     348             :         if ( (m_aRow->get())[i].isBound() )
     349             :         {
     350             :             //
     351             :             // Everything in the addressbook is a string!
     352             :             //
     353             :             if ( !m_aQuery.setRowValue( (m_aRow->get())[i], cardNumber, m_aColumnNames[i-1], DataType::VARCHAR ))
     354             :             {
     355             :                 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
     356             :             }
     357             :         }
     358             :     }
     359             :     return sal_True;
     360             : */
     361             : }
     362             : // -------------------------------------------------------------------------
     363          19 : sal_Bool OResultSet::fetchRow(sal_Int32 cardNumber,sal_Bool bForceReload) throw(SQLException, RuntimeException)
     364             : {
     365             :     SAL_INFO("connectivity.mork", "=> OResultSet::fetchRow()" );
     366             : 
     367             :     OSL_TRACE("fetchRow, cardNumber = %u", cardNumber );
     368          19 :     if (!bForceReload)
     369             :     {
     370             :         // Check whether we've already fetched the row...
     371          19 :         if ( !(m_aRow->get())[0].isNull() && (sal_Int32)(m_aRow->get())[0] == (sal_Int32)cardNumber )
     372           5 :             return sal_True;
     373             :         //Check whether the old row has been changed
     374          14 :         if (cardNumber == m_nUpdatedRow)
     375             :         {
     376             :             //write back the changes first
     377           0 :             if (!pushCard(cardNumber))  //error write back the changes
     378           0 :                 throw SQLException();
     379             :         }
     380             :     }
     381             : //    else
     382             : //        m_aQuery.resyncRow(cardNumber);
     383             : 
     384          14 :     if ( validRow( cardNumber ) == sal_False )
     385           0 :         return sal_False;
     386             : 
     387          14 :     (m_aRow->get())[0] = (sal_Int32)cardNumber;
     388          14 :     sal_Int32 nCount = m_aColumnNames.getLength();
     389             :     //m_RowStates = m_aQuery.getRowStates(cardNumber);
     390         532 :     for( sal_Int32 i = 1; i <= nCount; i++ )
     391             :     {
     392         518 :         if ( (m_aRow->get())[i].isBound() )
     393             :         {
     394             :             //
     395             :             // Everything in the addressbook is a string!
     396             :             //
     397          14 :             if ( !m_aQueryHelper.getRowValue( (m_aRow->get())[i], cardNumber, m_aColumnNames[i-1], DataType::VARCHAR ))
     398             :             {
     399           0 :                 m_pStatement->getOwnConnection()->throwSQLException( m_aQueryHelper.getError(), *this );
     400             :             }
     401             :         }
     402             :     }
     403          14 :     return sal_True;
     404             : 
     405             : }
     406             : // -------------------------------------------------------------------------
     407             : 
     408          14 : const ORowSetValue& OResultSet::getValue(sal_Int32 cardNumber, sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
     409             : {
     410          14 :     if ( fetchRow( cardNumber ) == sal_False )
     411             :     {
     412             :         OSL_FAIL("fetchRow() returned False" );
     413           0 :         m_bWasNull = sal_True;
     414           0 :         return *ODatabaseMetaDataResultSet::getEmptyValue();
     415             :     }
     416             : 
     417          14 :     m_bWasNull = (m_aRow->get())[columnIndex].isNull();
     418          14 :     return (m_aRow->get())[columnIndex];
     419             : 
     420             : }
     421             : // -------------------------------------------------------------------------
     422             : 
     423             : 
     424           4 : ::rtl::OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
     425             : {
     426           4 :     ResultSetEntryGuard aGuard( *this );
     427             : 
     428             :     OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
     429             :     OSL_ENSURE(columnIndex <= (sal_Int32)m_xColumns->get().size(), "Trying to access invalid columns number");
     430           4 :     checkIndex( columnIndex );
     431             : 
     432             :     // If this query was sorted then we should have a valid KeySet, so use it
     433           4 :     return getValue(getCurrentCardNumber(), mapColumn( columnIndex ) );
     434             : 
     435             : }
     436             : // -------------------------------------------------------------------------
     437             : 
     438           0 : Time SAL_CALL OResultSet::getTime( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     439             : {
     440           0 :     ResultSetEntryGuard aGuard( *this );
     441           0 :     return Time();
     442             : }
     443             : // -------------------------------------------------------------------------
     444             : 
     445             : 
     446           0 : DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
     447             : {
     448           0 :     ResultSetEntryGuard aGuard( *this );
     449           0 :     return DateTime();
     450             : }
     451             : // -------------------------------------------------------------------------
     452             : 
     453           0 : sal_Bool SAL_CALL OResultSet::isBeforeFirst(  ) throw(SQLException, RuntimeException)
     454             : {
     455           0 :     ResultSetEntryGuard aGuard( *this );
     456             : 
     457             :     // here you have to implement your movements
     458             :     // return true means there is no data
     459             :     OSL_TRACE("In/Out: OResultSet::isBeforeFirst" );
     460           0 :     return( m_nRowPos < 1 );
     461             : }
     462             : // -------------------------------------------------------------------------
     463           0 : sal_Bool SAL_CALL OResultSet::isAfterLast(  ) throw(SQLException, RuntimeException)
     464             : {
     465             :     SAL_WARN("connectivity.mork", "OResultSet::isAfterLast() NOT IMPLEMENTED!");
     466           0 :     ResultSetEntryGuard aGuard( *this );
     467             : 
     468             :     OSL_TRACE("In/Out: OResultSet::isAfterLast" );
     469             : //    return sal_True;
     470           0 :     return m_nRowPos > currentRowCount() && m_aQueryHelper.queryComplete();
     471             : }
     472             : // -------------------------------------------------------------------------
     473           0 : sal_Bool SAL_CALL OResultSet::isFirst(  ) throw(SQLException, RuntimeException)
     474             : {
     475           0 :     ResultSetEntryGuard aGuard( *this );
     476             : 
     477             :     OSL_TRACE("In/Out: OResultSet::isFirst" );
     478           0 :     return m_nRowPos == 1;
     479             : }
     480             : // -------------------------------------------------------------------------
     481           0 : sal_Bool SAL_CALL OResultSet::isLast(  ) throw(SQLException, RuntimeException)
     482             : {
     483             :     SAL_WARN("connectivity.mork", "OResultSet::isLast() NOT IMPLEMENTED!");
     484           0 :     ResultSetEntryGuard aGuard( *this );
     485             : 
     486             :     OSL_TRACE("In/Out: OResultSet::isLast" );
     487             : //    return sal_True;
     488           0 :     return m_nRowPos == currentRowCount() && m_aQueryHelper.queryComplete();
     489             : }
     490             : // -------------------------------------------------------------------------
     491           1 : void SAL_CALL OResultSet::beforeFirst(  ) throw(SQLException, RuntimeException)
     492             : {
     493           1 :     ResultSetEntryGuard aGuard( *this );
     494             : 
     495             :     // move before the first row so that isBeforeFirst returns false
     496             :     OSL_TRACE("In/Out: OResultSet::beforeFirst" );
     497           1 :     if ( first() )
     498           1 :         previous();
     499           1 : }
     500             : // -------------------------------------------------------------------------
     501           0 : void SAL_CALL OResultSet::afterLast(  ) throw(SQLException, RuntimeException)
     502             : {
     503           0 :     ResultSetEntryGuard aGuard( *this );
     504             :     OSL_TRACE("In/Out: OResultSet::afterLast" );
     505             : 
     506           0 :     if(last())
     507           0 :         next();
     508           0 : }
     509             : // -------------------------------------------------------------------------
     510             : 
     511           0 : void SAL_CALL OResultSet::close() throw(SQLException, RuntimeException)
     512             : {
     513             :     OSL_TRACE("In/Out: OResultSet::close" );
     514           0 :     dispose();
     515           0 : }
     516             : // -------------------------------------------------------------------------
     517             : 
     518           3 : sal_Bool SAL_CALL OResultSet::first(  ) throw(SQLException, RuntimeException)
     519             : {
     520             :     OSL_TRACE("In/Out: OResultSet::first" );
     521           3 :     return seekRow( FIRST_POS );
     522             : }
     523             : // -------------------------------------------------------------------------
     524             : 
     525           1 : sal_Bool SAL_CALL OResultSet::last(  ) throw(SQLException, RuntimeException)
     526             : {
     527             :     OSL_TRACE("In/Out: OResultSet::last" );
     528           1 :     return seekRow( LAST_POS );
     529             : }
     530             : // -------------------------------------------------------------------------
     531           0 : sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row ) throw(SQLException, RuntimeException)
     532             : {
     533             :     OSL_TRACE("In/Out: OResultSet::absolute" );
     534           0 :     return seekRow( ABSOLUTE_POS, row );
     535             : }
     536             : // -------------------------------------------------------------------------
     537           0 : sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row ) throw(SQLException, RuntimeException)
     538             : {
     539             :     OSL_TRACE("In/Out: OResultSet::relative" );
     540           0 :     return seekRow( RELATIVE_POS, row );
     541             : }
     542             : // -------------------------------------------------------------------------
     543           1 : sal_Bool SAL_CALL OResultSet::previous(  ) throw(SQLException, RuntimeException)
     544             : {
     545           1 :     ResultSetEntryGuard aGuard( *this );
     546             :     OSL_TRACE("In/Out: OResultSet::previous" );
     547           1 :     return seekRow( PRIOR_POS );
     548             : }
     549             : // -------------------------------------------------------------------------
     550           0 : Reference< XInterface > SAL_CALL OResultSet::getStatement(  ) throw(SQLException, RuntimeException)
     551             : {
     552           0 :     ResultSetEntryGuard aGuard( *this );
     553             : 
     554             :     OSL_TRACE("In/Out: OResultSet::getStatement" );
     555           0 :     return m_xStatement;
     556             : }
     557             : // -------------------------------------------------------------------------
     558             : 
     559           0 : sal_Bool SAL_CALL OResultSet::rowDeleted(  ) throw(SQLException, RuntimeException)
     560             : {
     561             :     SAL_WARN("connectivity.mork", "OResultSet::rowDeleted() NOT IMPLEMENTED!");
     562           0 :     ResultSetEntryGuard aGuard( *this );
     563             :     OSL_TRACE("In/Out: OResultSet::rowDeleted, m_RowStates=%u",m_RowStates );
     564           0 :     return sal_True;//return ((m_RowStates & RowStates_Deleted) == RowStates_Deleted) ;
     565             : }
     566             : // -------------------------------------------------------------------------
     567           0 : sal_Bool SAL_CALL OResultSet::rowInserted(  ) throw(SQLException, RuntimeException)
     568             : {
     569             :     SAL_WARN("connectivity.mork", "OResultSet::rowInserted() NOT IMPLEMENTED!");
     570           0 :     ResultSetEntryGuard aGuard( *this );
     571             :     OSL_TRACE("In/Out: OResultSet::rowInserted,m_RowStates=%u",m_RowStates );
     572           0 :     return sal_True;//return ((m_RowStates & RowStates_Inserted) == RowStates_Inserted);
     573             : }
     574             : // -------------------------------------------------------------------------
     575           0 : sal_Bool SAL_CALL OResultSet::rowUpdated(  ) throw(SQLException, RuntimeException)
     576             : {
     577             :     SAL_WARN("connectivity.mork", "OResultSet::rowUpdated() NOT IMPLEMENTED!");
     578           0 :     ResultSetEntryGuard aGuard( *this );
     579             :     OSL_TRACE("In/Out: OResultSet::rowUpdated,m_RowStates=%u",m_RowStates );
     580           0 :     return sal_True;// return ((m_RowStates & RowStates_Updated) == RowStates_Updated) ;
     581             : }
     582             : // -------------------------------------------------------------------------
     583             : 
     584           1 : sal_Bool SAL_CALL OResultSet::next(  ) throw(SQLException, RuntimeException)
     585             : {
     586           1 :     return seekRow( NEXT_POS );
     587             : }
     588             : // -------------------------------------------------------------------------
     589             : 
     590           0 : sal_Bool SAL_CALL OResultSet::wasNull(  ) throw(SQLException, RuntimeException)
     591             : {
     592           0 :     ResultSetEntryGuard aGuard( *this );
     593             : 
     594           0 :     return m_bWasNull;
     595             : }
     596             : // -------------------------------------------------------------------------
     597             : 
     598           0 : void SAL_CALL OResultSet::cancel(  ) throw(RuntimeException)
     599             : {
     600           0 :     ResultSetEntryGuard aGuard( *this );
     601           0 :     OSL_TRACE("In/Out: OResultSet::cancel" );
     602             : 
     603           0 : }
     604             : // -------------------------------------------------------------------------
     605           0 : void SAL_CALL OResultSet::clearWarnings(  ) throw(SQLException, RuntimeException)
     606             : {
     607             :     OSL_TRACE("In/Out: OResultSet::clearWarnings" );
     608           0 : }
     609             : // -------------------------------------------------------------------------
     610           0 : Any SAL_CALL OResultSet::getWarnings(  ) throw(SQLException, RuntimeException)
     611             : {
     612             :     OSL_TRACE("In/Out: OResultSet::getWarnings" );
     613           0 :     return Any();
     614             : }
     615             : // -------------------------------------------------------------------------
     616           0 : void SAL_CALL OResultSet::refreshRow(  ) throw(SQLException, RuntimeException)
     617             : {
     618             :     OSL_TRACE("In/Out: OResultSet::refreshRow" );
     619           0 :     if (fetchRow(getCurrentCardNumber(),sal_True)) {
     620             :         //force fetch current row will cause we lose all change to the current row
     621           0 :         m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_REFRESH_ROW, *this );
     622             :     }
     623           0 : }
     624             : // -------------------------------------------------------------------------
     625           0 : IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
     626             : {
     627           0 :     Sequence< Property > aProps(5);
     628           0 :     Property* pProperties = aProps.getArray();
     629           0 :     sal_Int32 nPos = 0;
     630           0 :     DECL_PROP0(FETCHDIRECTION,          sal_Int32);
     631           0 :     DECL_PROP0(FETCHSIZE,               sal_Int32);
     632           0 :      DECL_BOOL_PROP1IMPL(ISBOOKMARKABLE) PropertyAttribute::READONLY);
     633           0 :     DECL_PROP1IMPL(RESULTSETCONCURRENCY,sal_Int32) PropertyAttribute::READONLY);
     634           0 :     DECL_PROP1IMPL(RESULTSETTYPE,       sal_Int32) PropertyAttribute::READONLY);
     635             : 
     636           0 :     return new OPropertyArrayHelper(aProps);
     637             : }
     638             : // -------------------------------------------------------------------------
     639           0 : IPropertyArrayHelper & OResultSet::getInfoHelper()
     640             : {
     641           0 :     return *const_cast<OResultSet*>(this)->getArrayHelper();
     642             : }
     643             : // -------------------------------------------------------------------------
     644           0 : sal_Bool OResultSet::convertFastPropertyValue(
     645             :                             Any & /*rConvertedValue*/,
     646             :                             Any & /*rOldValue*/,
     647             :                             sal_Int32 nHandle,
     648             :                             const Any& /*rValue*/ )
     649             :                                 throw (::com::sun::star::lang::IllegalArgumentException)
     650             : {
     651             :     OSL_FAIL( "OResultSet::convertFastPropertyValue: not implemented!" );
     652           0 :     switch(nHandle)
     653             :     {
     654             :         case PROPERTY_ID_ISBOOKMARKABLE:
     655             :         case PROPERTY_ID_RESULTSETCONCURRENCY:
     656             :         case PROPERTY_ID_RESULTSETTYPE:
     657           0 :             throw ::com::sun::star::lang::IllegalArgumentException();
     658             :         case PROPERTY_ID_FETCHDIRECTION:
     659             :         case PROPERTY_ID_FETCHSIZE:
     660             :         default:
     661             :             ;
     662             :     }
     663           0 :     return sal_False;
     664             : }
     665             : // -------------------------------------------------------------------------
     666           0 : void OResultSet::setFastPropertyValue_NoBroadcast(
     667             :                                 sal_Int32 nHandle,
     668             :                                 const Any& /*rValue*/
     669             :                                                  )
     670             :                                                  throw (Exception)
     671             : {
     672             :     OSL_FAIL( "OResultSet::setFastPropertyValue_NoBroadcast: not implemented!" );
     673           0 :     switch(nHandle)
     674             :     {
     675             :         case PROPERTY_ID_ISBOOKMARKABLE:
     676             :         case PROPERTY_ID_RESULTSETCONCURRENCY:
     677             :         case PROPERTY_ID_RESULTSETTYPE:
     678           0 :             throw Exception();
     679             :         case PROPERTY_ID_FETCHDIRECTION:
     680           0 :             break;
     681             :         case PROPERTY_ID_FETCHSIZE:
     682           0 :             break;
     683             :         default:
     684             :             ;
     685             :     }
     686           0 : }
     687             : // -------------------------------------------------------------------------
     688           0 : void OResultSet::getFastPropertyValue(
     689             :                                 Any& rValue,
     690             :                                 sal_Int32 nHandle
     691             :                                      ) const
     692             : {
     693           0 :     switch(nHandle)
     694             :     {
     695             :         case PROPERTY_ID_RESULTSETCONCURRENCY:
     696           0 :             rValue <<= (sal_Int32)m_nResultSetConcurrency;
     697           0 :             break;
     698             :         case PROPERTY_ID_RESULTSETTYPE:
     699           0 :             rValue <<= m_nResultSetType;
     700           0 :             break;
     701             :         case PROPERTY_ID_FETCHDIRECTION:
     702           0 :             rValue <<= m_nFetchDirection;
     703           0 :             break;
     704             :         case PROPERTY_ID_FETCHSIZE:
     705           0 :             rValue <<= m_nFetchSize;
     706           0 :             break;
     707             :         case PROPERTY_ID_ISBOOKMARKABLE:
     708           0 :             const_cast< OResultSet* >( this )->determineReadOnly();
     709           0 :             rValue <<= !m_bIsReadOnly;
     710           0 :          break;
     711             :     }
     712           0 : }
     713             : // -----------------------------------------------------------------------------
     714          16 : void SAL_CALL OResultSet::acquire() throw()
     715             : {
     716          16 :     OResultSet_BASE::acquire();
     717          16 : }
     718             : // -----------------------------------------------------------------------------
     719          14 : void SAL_CALL OResultSet::release() throw()
     720             : {
     721          14 :     OResultSet_BASE::release();
     722          14 : }
     723             : // -----------------------------------------------------------------------------
     724           0 : ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
     725             : {
     726           0 :     return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
     727             : }
     728             : 
     729             : // -------------------------------------------------------------------------
     730           0 : void OResultSet::parseParameter( const OSQLParseNode* pNode, rtl::OUString& rMatchString )
     731             : {
     732             :     OSL_ENSURE(pNode->count() > 0,"Error parsing parameter in Parse Tree");
     733           0 :     OSQLParseNode *pMark = pNode->getChild(0);
     734             : 
     735             :     // Initialize to empty string
     736           0 :     rMatchString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(""));
     737             : 
     738           0 :     rtl::OUString aParameterName;
     739           0 :     if (SQL_ISPUNCTUATION(pMark,"?")) {
     740           0 :         aParameterName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("?"));
     741             :     }
     742           0 :     else if (SQL_ISPUNCTUATION(pMark,":")) {
     743           0 :         aParameterName = pNode->getChild(1)->getTokenValue();
     744             :     }
     745             :     // XXX - Now we know name, what's value????
     746           0 :     m_nParamIndex ++;
     747             :     OSL_TRACE("Parameter name [%d]: %s", m_nParamIndex,OUtoCStr(aParameterName) );
     748             : 
     749           0 :     if ( m_aParameterRow.is() ) {
     750             :         OSL_ENSURE( m_nParamIndex < (sal_Int32)m_aParameterRow->get().size() + 1, "More parameters than values found" );
     751           0 :         rMatchString = (m_aParameterRow->get())[(sal_uInt16)m_nParamIndex];
     752             : #if OSL_DEBUG_LEVEL > 0
     753             :         OSL_TRACE("Prop Value       : %s", OUtoCStr( rMatchString ) );
     754             : #endif
     755           0 :     }
     756             : #if OSL_DEBUG_LEVEL > 0
     757             :     else {
     758             :         OSL_TRACE("Prop Value       : Invalid ParameterRow!" );
     759             :     }
     760             : #endif
     761           0 : }
     762             : 
     763           2 : void OResultSet::analyseWhereClause( const OSQLParseNode*                 parseTree,
     764             :                                      MQueryExpression                     &queryExpression)
     765             : {
     766           2 :     ::rtl::OUString         columnName;
     767           2 :     MQueryOp::cond_type     op( MQueryOp::Is );
     768           2 :     ::rtl::OUString         matchString;
     769             : 
     770           2 :     if ( parseTree == NULL )
     771           2 :         return;
     772             : 
     773           2 :     if ( m_pSQLIterator->getParseTree() != NULL ) {
     774           2 :         ::rtl::Reference<OSQLColumns> xColumns = m_pSQLIterator->getParameters();
     775           2 :         if(xColumns.is())
     776             :         {
     777           2 :             ::rtl::OUString aColName, aParameterValue;
     778           2 :             OSQLColumns::Vector::iterator aIter = xColumns->get().begin();
     779           2 :             sal_Int32 i = 1;
     780           2 :             for(;aIter != xColumns->get().end();++aIter)
     781             :             {
     782           0 :                 (*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
     783             :                 OSL_TRACE("Prop Column Name : %s", OUtoCStr( aColName ) );
     784           0 :                 if ( m_aParameterRow.is() ) {
     785           0 :                     aParameterValue = (m_aParameterRow->get())[(sal_uInt16)i];
     786             : #if OSL_DEBUG_LEVEL > 0
     787             :                     OSL_TRACE("Prop Value       : %s", OUtoCStr( aParameterValue ) );
     788             : #endif
     789             :                 }
     790             : #if OSL_DEBUG_LEVEL > 0
     791             :                 else {
     792             :                     OSL_TRACE("Prop Value       : Invalid ParameterRow!" );
     793             :                 }
     794             : #endif
     795           0 :                 i++;
     796           2 :             }
     797           2 :         }
     798             : 
     799             :     }
     800             : 
     801           2 :     if ( SQL_ISRULE(parseTree,where_clause) )
     802             :     {
     803             :         OSL_TRACE("analyseSQL : Got WHERE clause");
     804             :         // Reset Parameter Counter
     805           1 :         resetParameters();
     806           1 :         analyseWhereClause( parseTree->getChild( 1 ), queryExpression );
     807             :     }
     808           1 :     else if ( parseTree->count() == 3 &&                         // Handle ()'s
     809           0 :         SQL_ISPUNCTUATION(parseTree->getChild(0),"(") &&
     810           0 :         SQL_ISPUNCTUATION(parseTree->getChild(2),")"))
     811             :     {
     812             : 
     813             :         OSL_TRACE("analyseSQL : Got Punctuation ()");
     814           0 :         MQueryExpression *subExpression = new MQueryExpression();
     815           0 :         analyseWhereClause( parseTree->getChild( 1 ), *subExpression );
     816           0 :         queryExpression.getExpressions().push_back( subExpression );
     817             :     }
     818           1 :     else if ((SQL_ISRULE(parseTree,search_condition) || (SQL_ISRULE(parseTree,boolean_term)))
     819           0 :              && parseTree->count() == 3)                   // Handle AND/OR
     820             :     {
     821             : 
     822             :         OSL_TRACE("analyseSQL : Got AND/OR clause");
     823             : 
     824             :         // TODO - Need to take care or AND, for now match is always OR
     825           0 :         analyseWhereClause( parseTree->getChild( 0 ), queryExpression );
     826           0 :         analyseWhereClause( parseTree->getChild( 2 ), queryExpression );
     827             : 
     828           0 :         if (SQL_ISTOKEN(parseTree->getChild(1),OR)) {         // OR-Operator
     829           0 :             queryExpression.setExpressionCondition( MQueryExpression::OR );
     830             :         }
     831           0 :         else if (SQL_ISTOKEN(parseTree->getChild(1),AND)) {  // AND-Operator
     832           0 :             queryExpression.setExpressionCondition( MQueryExpression::AND );
     833             :         }
     834             :         else {
     835             :             OSL_FAIL("analyseSQL: Error in Parse Tree");
     836             :         }
     837             :     }
     838           1 :     else if (SQL_ISRULE(parseTree,comparison_predicate))
     839             :     {
     840             :         OSL_ENSURE(parseTree->count() == 3, "Error parsing COMPARE predicate");
     841           0 :         if (!(SQL_ISRULE(parseTree->getChild(0),column_ref) ||
     842           0 :           parseTree->getChild(2)->getNodeType() == SQL_NODE_STRING ||
     843           0 :           parseTree->getChild(2)->getNodeType() == SQL_NODE_INTNUM ||
     844           0 :           parseTree->getChild(2)->getNodeType() == SQL_NODE_APPROXNUM ||
     845           0 :           SQL_ISTOKEN(parseTree->getChild(2),TRUE) ||
     846           0 :           SQL_ISTOKEN(parseTree->getChild(2),FALSE) ||
     847           0 :           SQL_ISRULE(parseTree->getChild(2),parameter) ||
     848             :           // odbc date
     849           0 :           (SQL_ISRULE(parseTree->getChild(2),set_fct_spec) && SQL_ISPUNCTUATION(parseTree->getChild(2)->getChild(0),"{"))))
     850             :         {
     851           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
     852             :         }
     853             : 
     854           0 :         OSQLParseNode *pPrec = parseTree->getChild(1);
     855           0 :         if (pPrec->getNodeType() == SQL_NODE_EQUAL)
     856           0 :             op = MQueryOp::Is;
     857           0 :         else if (pPrec->getNodeType() == SQL_NODE_NOTEQUAL)
     858           0 :             op = MQueryOp::IsNot;
     859             : 
     860           0 :         ::rtl::OUString sTableRange;
     861           0 :         if(SQL_ISRULE(parseTree->getChild(0),column_ref))
     862           0 :             m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange);
     863           0 :         else if(parseTree->getChild(0)->isToken())
     864           0 :             columnName = parseTree->getChild(0)->getTokenValue();
     865             : 
     866           0 :         if ( SQL_ISRULE(parseTree->getChild(2),parameter) ) {
     867           0 :             parseParameter( parseTree->getChild(2), matchString );
     868             :         }
     869             :         else {
     870           0 :             matchString = parseTree->getChild(2)->getTokenValue();
     871             :         }
     872             : 
     873           0 :         if ( columnName.compareToAscii("0") ==0 && op == MQueryOp::Is &&
     874           0 :              matchString.compareToAscii("1") == 0 ) {
     875             :             OSL_TRACE("Query always evaluates to FALSE");
     876           0 :             m_bIsAlwaysFalseQuery = sal_True;
     877             :         }
     878           0 :         queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op, matchString ));
     879             :     }
     880           1 :     else if (SQL_ISRULE(parseTree,like_predicate))
     881             :     {
     882             :         OSL_ENSURE(parseTree->count() == 2, "Error parsing LIKE predicate");
     883             : 
     884             :         OSL_TRACE("analyseSQL : Got LIKE rule");
     885             : 
     886           1 :         if ( !(SQL_ISRULE(parseTree->getChild(0), column_ref)) )
     887             :         {
     888           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_COLUMN, *this );
     889             :         }
     890             : 
     891             : 
     892             :         OSQLParseNode *pColumn;
     893             :         OSQLParseNode *pAtom;
     894             :         OSQLParseNode *pOptEscape;
     895           1 :         const OSQLParseNode* pPart2 = parseTree->getChild(1);
     896           1 :         pColumn     = parseTree->getChild(0);                        // Match Item
     897           1 :         pAtom       = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-2));     // Match String
     898           1 :         pOptEscape  = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-1));     // Opt Escape Rule
     899             :         (void)pOptEscape;
     900           1 :         const bool bNot = SQL_ISTOKEN(pPart2->getChild(0), NOT);
     901             : 
     902           2 :         if (!(pAtom->getNodeType() == SQL_NODE_STRING ||
     903           0 :               pAtom->getNodeType() == SQL_NODE_NAME ||
     904           0 :               SQL_ISRULE(pAtom,parameter) ||
     905           0 :               ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQL_NODE_NAME ) ||
     906           0 :               ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQL_NODE_STRING )
     907           1 :               ) )
     908             :         {
     909             :             OSL_TRACE("analyseSQL : pAtom->count() = %d", pAtom->count() );
     910             : 
     911           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_STRING, *this );
     912             :         }
     913             : 
     914           1 :         const sal_Unicode WILDCARD = '%';
     915           1 :         const sal_Unicode ALT_WILDCARD = '*';
     916           1 :         const sal_Unicode MATCHCHAR = '_';
     917             : 
     918           1 :         ::rtl::OUString sTableRange;
     919           1 :         if(SQL_ISRULE(pColumn,column_ref))
     920           1 :             m_pSQLIterator->getColumnRange(pColumn,columnName,sTableRange);
     921             : 
     922             :         OSL_TRACE("ColumnName = %s", OUtoCStr( columnName ) );
     923             : 
     924           1 :         if ( SQL_ISRULE(pAtom,parameter) ) {
     925           0 :             parseParameter( pAtom, matchString );
     926             :             // Replace all '*' with '%' : UI Usually does this but not with
     927             :             // Parameters for some reason.
     928           0 :             matchString = matchString.replace( ALT_WILDCARD, WILDCARD );
     929             :         }
     930             :         else
     931             :         {
     932           1 :             matchString = pAtom->getTokenValue();
     933             :         }
     934             : 
     935             :         // Determine where '%' character is...
     936             : 
     937           1 :         if ( matchString.equals( ::rtl::OUString::valueOf( WILDCARD ) ) )
     938             :         {
     939             :             // String containing only a '%' and nothing else
     940           0 :             op = MQueryOp::Exists;
     941             :             // Will be ignored for Exists case, but clear anyway.
     942           0 :             matchString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(""));
     943             :         }
     944           1 :         else if ( matchString.indexOf ( WILDCARD ) == -1 &&
     945           0 :              matchString.indexOf ( MATCHCHAR ) == -1 )
     946             :         {
     947             :             // Simple string , eg. "to match"
     948           0 :             if ( bNot )
     949           0 :                 op = MQueryOp::DoesNotContain;
     950             :             else
     951           0 :                 op = MQueryOp::Contains;
     952             :         }
     953           2 :         else if (  matchString.indexOf ( WILDCARD ) == 0
     954           1 :                    && matchString.lastIndexOf ( WILDCARD ) == matchString.getLength() -1
     955           0 :                    && matchString.indexOf ( WILDCARD, 1 ) == matchString.lastIndexOf ( WILDCARD )
     956           0 :                    && matchString.indexOf( MATCHCHAR ) == -1
     957             :                  )
     958             :         {
     959             :             // Relatively simple "%string%" - ie, contains...
     960             :             // Cut '%'  from front and rear
     961           0 :             matchString = matchString.replaceAt( 0, 1, rtl::OUString() );
     962           0 :             matchString = matchString.replaceAt( matchString.getLength() -1 , 1, rtl::OUString() );
     963             : 
     964           0 :             if (bNot)
     965           0 :                 op = MQueryOp::DoesNotContain;
     966             :             else
     967           0 :                 op = MQueryOp::Contains;
     968             :         }
     969           1 :         else if ( bNot )
     970             :         {
     971             :             // We currently can't handle a 'NOT LIKE' when there are '%' or
     972             :             // '_' dispersed throughout
     973           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_NOT_LIKE_TOO_COMPLEX, *this );
     974             :         }
     975             :         else
     976             :         {
     977           2 :             if ( (matchString.indexOf ( WILDCARD ) == matchString.lastIndexOf ( WILDCARD ))
     978           1 :                   && matchString.indexOf( MATCHCHAR ) == -1
     979             :                 )
     980             :             {
     981             :                 // One occurrence of '%' - no '_' matches...
     982           1 :                 if ( matchString.indexOf ( WILDCARD ) == 0 )
     983             :                 {
     984           1 :                     op = MQueryOp::EndsWith;
     985           1 :                     matchString = matchString.replaceAt( 0, 1, rtl::OUString());
     986             :                 }
     987           0 :                 else if ( matchString.indexOf ( WILDCARD ) == matchString.getLength() -1 )
     988             :                 {
     989           0 :                     op = MQueryOp::BeginsWith;
     990           0 :                     matchString = matchString.replaceAt( matchString.getLength() -1 , 1, rtl::OUString() );
     991             :                 }
     992             :                 else
     993             :                 {
     994           0 :                     sal_Int32 pos = matchString.indexOf ( WILDCARD );
     995           0 :                     matchString = matchString.replaceAt( pos, 1,::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".*")) );
     996           0 :                     op = MQueryOp::RegExp;
     997             :                 }
     998             : 
     999             :             }
    1000             :             else
    1001             :             {
    1002             :                 // Most Complex, need to use an RE
    1003           0 :                 sal_Int32 pos = matchString.indexOf ( WILDCARD );
    1004           0 :                 while ( (pos = matchString.indexOf ( WILDCARD )) != -1 )
    1005             :                 {
    1006           0 :                     matchString = matchString.replaceAt( pos, 1, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".*")) );
    1007             :                 }
    1008             : 
    1009           0 :                 pos = matchString.indexOf ( MATCHCHAR );
    1010           0 :                 while ( (pos = matchString.indexOf( MATCHCHAR )) != -1 )
    1011             :                 {
    1012           0 :                     matchString = matchString.replaceAt( pos, 1, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".")) );
    1013             :                 }
    1014             : 
    1015           0 :                 op = MQueryOp::RegExp;
    1016             :             }
    1017             :         }
    1018             : 
    1019           1 :         queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op, matchString ));
    1020             :     }
    1021           0 :     else if (SQL_ISRULE(parseTree,test_for_null))
    1022             :     {
    1023             :         OSL_ENSURE(parseTree->count() == 2,"Error in ParseTree");
    1024           0 :         const OSQLParseNode* pPart2 = parseTree->getChild(1);
    1025             :         OSL_ENSURE(SQL_ISTOKEN(pPart2->getChild(0),IS),"Error in ParseTree");
    1026             : 
    1027           0 :         if (!SQL_ISRULE(parseTree->getChild(0),column_ref))
    1028             :         {
    1029           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_IS_NULL_COLUMN, *this );
    1030             :         }
    1031             : 
    1032           0 :         if (SQL_ISTOKEN(pPart2->getChild(1),NOT))
    1033             :         {
    1034           0 :             op = MQueryOp::Exists;
    1035             :         }
    1036             :         else
    1037             :         {
    1038           0 :             op = MQueryOp::DoesNotExist;
    1039             :         }
    1040             : 
    1041           0 :         ::rtl::OUString sTableRange;
    1042           0 :         m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange);
    1043             : 
    1044           0 :         queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op ));
    1045             :     }
    1046             :     else
    1047             :     {
    1048             :         OSL_TRACE( "Unexpected statement!!!" );
    1049             : 
    1050           0 :         m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
    1051           2 :     }
    1052             : }
    1053             : 
    1054             : // -----------------------------------------------------------------------------
    1055             : 
    1056           2 : void OResultSet::fillRowData()
    1057             :     throw( ::com::sun::star::sdbc::SQLException )
    1058             : {
    1059             :     OSL_ENSURE( m_pStatement, "Require a statement" );
    1060             : 
    1061           2 :     MQueryExpression queryExpression;
    1062             : 
    1063           2 :     OConnection* xConnection = static_cast<OConnection*>(m_pStatement->getConnection().get());
    1064           2 :     m_xColumns = m_pSQLIterator->getSelectColumns();
    1065             : 
    1066             :     OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
    1067             : 
    1068           2 :     OSQLColumns::Vector::const_iterator aIter = m_xColumns->get().begin();
    1069           2 :     const ::rtl::OUString sProprtyName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
    1070           2 :     ::rtl::OUString sName;
    1071           2 :     m_aAttributeStrings.clear();
    1072           2 :     m_aAttributeStrings.reserve(m_xColumns->get().size());
    1073           4 :     for (sal_Int32 i = 1; aIter != m_xColumns->get().end();++aIter, i++)
    1074             :     {
    1075           2 :         (*aIter)->getPropertyValue(sProprtyName) >>= sName;
    1076             : #if OSL_DEBUG_LEVEL > 0
    1077             :         OSL_TRACE("Query Columns : (%d) %s", i, OUtoCStr(sName) );
    1078             : #endif
    1079           2 :         m_aAttributeStrings.push_back( sName );
    1080             :     }
    1081             : 
    1082             :     // Generate Match Conditions for Query
    1083           2 :     const OSQLParseNode*  pParseTree = m_pSQLIterator->getWhereTree();
    1084             : 
    1085           2 :     m_bIsAlwaysFalseQuery = sal_False;
    1086           2 :     if ( pParseTree != NULL )
    1087             :     {
    1088             :         // Extract required info
    1089             : 
    1090             :         OSL_TRACE("\tHave a Where Clause");
    1091             : 
    1092           1 :         analyseWhereClause( pParseTree, queryExpression );
    1093             :     }
    1094             :     // If the query is a 0=1 then set Row count to 0 and return
    1095           2 :     if ( m_bIsAlwaysFalseQuery )
    1096             :     {
    1097           0 :         m_bIsReadOnly = 1;
    1098           2 :         return;
    1099             :     }
    1100             : 
    1101           2 :     m_aQueryHelper.setExpression( queryExpression );
    1102             : 
    1103           2 :     rtl::OUString aStr(  m_pTable->getName() );
    1104           2 :     m_aQueryHelper.setAddressbook( aStr );
    1105             : 
    1106           2 :     sal_Int32 rv = m_aQueryHelper.executeQuery(xConnection);
    1107           2 :     if ( rv == -1 ) {
    1108           0 :         m_pStatement->getOwnConnection()->throwSQLException( STR_ERR_EXECUTING_QUERY, *this );
    1109             :     }
    1110             : 
    1111           2 :     if (m_aQueryHelper.hadError())
    1112             :     {
    1113           0 :         m_pStatement->getOwnConnection()->throwSQLException( m_aQueryHelper.getError(), *this );
    1114             :     }
    1115             : 
    1116             :     //determine whether the address book is readonly
    1117           2 :     determineReadOnly();
    1118             : 
    1119             : #if OSL_DEBUG_LEVEL > 0
    1120             :     OSL_TRACE( "executeQuery returned %d", rv );
    1121             : 
    1122             :     OSL_TRACE( "\tOUT OResultSet::fillRowData()" );
    1123             : #endif
    1124             : }
    1125             : 
    1126             : // -----------------------------------------------------------------------------
    1127           0 : static sal_Bool matchRow( OValueRow& row1, OValueRow& row2 )
    1128             : {
    1129           0 :     OValueVector::Vector::iterator row1Iter = row1->get().begin();
    1130           0 :     OValueVector::Vector::iterator row2Iter = row2->get().begin();
    1131           0 :     for ( ++row1Iter,++row2Iter; // the first column is the bookmark column
    1132           0 :           row1Iter != row1->get().end(); ++row1Iter,++row2Iter)
    1133             :     {
    1134           0 :         if ( row1Iter->isBound())
    1135             :         {
    1136             :             // Compare values, if at anytime there's a mismatch return false
    1137           0 :             if ( !( (*row1Iter) == (*row2Iter) ) )
    1138           0 :                 return sal_False;
    1139             :         }
    1140             :     }
    1141             : 
    1142             :     // If we get to here the rows match
    1143           0 :     return sal_True;
    1144             : }
    1145             : 
    1146           0 : sal_Int32 OResultSet::getRowForCardNumber(sal_Int32 nCardNum)
    1147             : {
    1148             :     OSL_TRACE("In/Out: OResultSet::getRowForCardNumber, nCardNum = %u", nCardNum );
    1149             : 
    1150           0 :     if ( m_pKeySet.is() )
    1151             :     {
    1152             :         sal_Int32  nPos;
    1153           0 :         for(nPos=0;nPos < (sal_Int32)m_pKeySet->get().size();nPos++)
    1154             :         {
    1155           0 :             if (nCardNum == (m_pKeySet->get())[nPos])
    1156             :             {
    1157             :                 OSL_TRACE("In/Out: OResultSet::getRowForCardNumber, return = %u", nPos+1 );
    1158           0 :                 return nPos+1;
    1159             :             }
    1160             :         }
    1161             :     }
    1162             : 
    1163           0 :     m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this );
    1164             : 
    1165           0 :     return 0;
    1166             : }
    1167             : 
    1168             : // -----------------------------------------------------------------------------
    1169           2 : void SAL_CALL OResultSet::executeQuery() throw( ::com::sun::star::sdbc::SQLException,
    1170             :                                                 ::com::sun::star::uno::RuntimeException)
    1171             : {
    1172           2 :     ResultSetEntryGuard aGuard( *this );
    1173             : 
    1174             :     OSL_ENSURE( m_pTable, "Need a Table object");
    1175           2 :     if(!m_pTable)
    1176             :     {
    1177           0 :         const OSQLTables& xTabs = m_pSQLIterator->getTables();
    1178           0 :         if ((xTabs.begin() == xTabs.end()) || !xTabs.begin()->second.is())
    1179           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
    1180             : 
    1181           0 :         m_pTable = static_cast< OTable* > ((xTabs.begin()->second).get());
    1182             : 
    1183             :     }
    1184             : 
    1185           2 :     m_nRowPos = 0;
    1186             : 
    1187           2 :     fillRowData();
    1188             : 
    1189             :     OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
    1190             : 
    1191           2 :     switch( m_pSQLIterator->getStatementType() )
    1192             :     {
    1193             :         case SQL_STATEMENT_SELECT:
    1194             :         {
    1195           2 :             if(m_bIsAlwaysFalseQuery) {
    1196           0 :                 break;
    1197             :             }
    1198           2 :             else if(isCount())
    1199             :             {
    1200           0 :                 m_pStatement->getOwnConnection()->throwSQLException( STR_NO_COUNT_SUPPORT, *this );
    1201             :             }
    1202             :             else
    1203             :             {
    1204           2 :                 sal_Bool bDistinct = sal_False;
    1205           2 :                 OSQLParseNode *pDistinct = m_pParseTree->getChild(1);
    1206           2 :                 if (pDistinct && pDistinct->getTokenID() == SQL_TOKEN_DISTINCT)
    1207             :                 {
    1208           0 :                     if(!IsSorted())
    1209             :                     {
    1210           0 :                         m_aOrderbyColumnNumber.push_back(m_aColMapping[1]);
    1211           0 :                         m_aOrderbyAscending.push_back(SQL_DESC);
    1212             :                     }
    1213           0 :                     bDistinct = sal_True;
    1214             :                 }
    1215             : 
    1216           2 :                 OSortIndex::TKeyTypeVector eKeyType(m_aOrderbyColumnNumber.size());
    1217           2 :                 ::std::vector<sal_Int32>::iterator aOrderByIter = m_aOrderbyColumnNumber.begin();
    1218           3 :                 for ( ::std::vector<sal_Int16>::size_type i = 0; aOrderByIter != m_aOrderbyColumnNumber.end(); ++aOrderByIter,++i)
    1219             :                 {
    1220             :                     OSL_ENSURE((sal_Int32)m_aRow->get().size() > *aOrderByIter,"Invalid Index");
    1221           1 :                     switch ((m_aRow->get().begin()+*aOrderByIter)->getTypeKind())
    1222             :                     {
    1223             :                     case DataType::CHAR:
    1224             :                         case DataType::VARCHAR:
    1225           1 :                             eKeyType[i] = SQL_ORDERBYKEY_STRING;
    1226           1 :                             break;
    1227             : 
    1228             :                         case DataType::OTHER:
    1229             :                         case DataType::TINYINT:
    1230             :                         case DataType::SMALLINT:
    1231             :                         case DataType::INTEGER:
    1232             :                         case DataType::DECIMAL:
    1233             :                         case DataType::NUMERIC:
    1234             :                         case DataType::REAL:
    1235             :                         case DataType::DOUBLE:
    1236             :                         case DataType::DATE:
    1237             :                         case DataType::TIME:
    1238             :                         case DataType::TIMESTAMP:
    1239             :                         case DataType::BIT:
    1240           0 :                             eKeyType[i] = SQL_ORDERBYKEY_DOUBLE;
    1241           0 :                             break;
    1242             : 
    1243             :                     // Other types aren't implemented (so they are always FALSE)
    1244             :                         default:
    1245           0 :                             eKeyType[i] = SQL_ORDERBYKEY_NONE;
    1246             :                             OSL_FAIL("MResultSet::executeQuery: Order By Data Type not implemented");
    1247           0 :                             break;
    1248             :                     }
    1249             :                 }
    1250             : 
    1251           2 :                 if (IsSorted())
    1252             :                 {
    1253             :                     // Implement Sorting
    1254             : 
    1255             :                     // So that we can sort we need to wait until the executed
    1256             :                     // query to the mozilla addressbooks has returned all
    1257             :                     // values.
    1258             : 
    1259             :                     OSL_TRACE("Query is to be sorted");
    1260             : 
    1261             :                     OSL_ENSURE( m_aQueryHelper.queryComplete(), "Query not complete!!");
    1262             : 
    1263           1 :                     m_pSortIndex = new OSortIndex(eKeyType,m_aOrderbyAscending);
    1264             : 
    1265             :                     OSL_TRACE("OrderbyColumnNumber->size() = %d",m_aOrderbyColumnNumber.size());
    1266             : #if OSL_DEBUG_LEVEL > 0
    1267             :                     for ( ::std::vector<sal_Int32>::size_type i = 0; i < m_aColMapping.size(); i++ )
    1268             :                         OSL_TRACE("Mapped: %d -> %d", i, m_aColMapping[i] );
    1269             : #endif
    1270          11 :                     for ( sal_Int32 nRow = 1; nRow <= m_aQueryHelper.getResultCount(); nRow++ ) {
    1271             : 
    1272          10 :                         OKeyValue* pKeyValue = OKeyValue::createKeyValue((nRow));
    1273             : 
    1274          10 :                         ::std::vector<sal_Int32>::iterator aIter = m_aOrderbyColumnNumber.begin();
    1275          20 :                         for (;aIter != m_aOrderbyColumnNumber.end(); ++aIter)
    1276             :                         {
    1277          10 :                             const ORowSetValue& value = getValue(nRow, *aIter);
    1278             : 
    1279             :                             OSL_TRACE( "Adding Value: (%d,%d) : %s", nRow, *aIter,OUtoCStr( value ));
    1280             : 
    1281          10 :                             pKeyValue->pushKey(new ORowSetValueDecorator(value));
    1282             :                         }
    1283             : 
    1284          10 :                         m_pSortIndex->AddKeyValue( pKeyValue );
    1285             :                     }
    1286             : 
    1287           1 :                     m_pKeySet = m_pSortIndex->CreateKeySet();
    1288           1 :                     m_CurrentRowCount = static_cast<sal_Int32>(m_pKeySet->get().size());
    1289             : #if OSL_DEBUG_LEVEL > 0
    1290             :                     for( OKeySet::Vector::size_type i = 0; i < m_pKeySet->get().size(); i++ )
    1291             :                         OSL_TRACE("Sorted: %d -> %d", i, (m_pKeySet->get())[i] );
    1292             : #endif
    1293             : 
    1294           1 :                     m_pSortIndex = NULL;
    1295           1 :                     beforeFirst(); // Go back to start
    1296             :                 }
    1297             :                 else  //we always need m_pKeySet now
    1298           1 :                     m_pKeySet = new OKeySet();
    1299             : 
    1300             :                 // Handle the DISTINCT case
    1301           2 :                 if ( bDistinct && m_pKeySet.is() )
    1302             :                 {
    1303           0 :                     OValueRow aSearchRow = new OValueVector( m_aRow->get().size() );
    1304             : 
    1305           0 :                     for( OKeySet::Vector::size_type i = 0; i < m_pKeySet->get().size(); i++ )
    1306             :                     {
    1307           0 :                         fetchRow( (m_pKeySet->get())[i] );        // Fills m_aRow
    1308           0 :                         if ( matchRow( m_aRow, aSearchRow ) )
    1309             :                         {
    1310           0 :                             (m_pKeySet->get())[i] = 0;   // Marker for later to be removed
    1311             :                         }
    1312             :                         else
    1313             :                         {
    1314             :                             // They don't match, so it's not a duplicate.
    1315             :                             // Use the current Row as the next one to match against
    1316           0 :                             *aSearchRow = *m_aRow;
    1317             :                         }
    1318             :                     }
    1319             :                     // Now remove any keys marked with a 0
    1320           0 :                     m_pKeySet->get().erase(::std::remove_if(m_pKeySet->get().begin(),m_pKeySet->get().end()
    1321             :                                     ,::std::bind2nd(::std::equal_to<sal_Int32>(),0))
    1322           0 :                                      ,m_pKeySet->get().end());
    1323             : 
    1324           2 :                 }
    1325             :             }
    1326           2 :         }   break;
    1327             : 
    1328             :         case SQL_STATEMENT_UPDATE:
    1329             :         case SQL_STATEMENT_DELETE:
    1330             :         case SQL_STATEMENT_INSERT:
    1331           0 :             break;
    1332             :         default:
    1333           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_STMT_TYPE_NOT_SUPPORTED, *this );
    1334           0 :             break;
    1335           2 :     }
    1336           2 : }
    1337             : 
    1338             : // -----------------------------------------------------------------------------
    1339             : 
    1340             : 
    1341           4 : void OResultSet::setBoundedColumns(const OValueRow& _rRow,
    1342             :                                    const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns,
    1343             :                                    const Reference<XIndexAccess>& _xNames,
    1344             :                                    sal_Bool _bSetColumnMapping,
    1345             :                                    const Reference<XDatabaseMetaData>& _xMetaData,
    1346             :                                    ::std::vector<sal_Int32>& _rColMapping)
    1347             : {
    1348           4 :     ::comphelper::UStringMixEqual aCase(_xMetaData->supportsMixedCaseQuotedIdentifiers());
    1349             : 
    1350           4 :     Reference<XPropertySet> xTableColumn;
    1351           4 :     ::rtl::OUString sTableColumnName, sSelectColumnRealName;
    1352             : 
    1353           4 :     const ::rtl::OUString sName     = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
    1354           4 :     const ::rtl::OUString sRealName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME);
    1355             : 
    1356           4 :     ::std::vector< ::rtl::OUString> aColumnNames;
    1357           4 :     aColumnNames.reserve(_rxColumns->get().size());
    1358           4 :     OValueVector::Vector::iterator aRowIter = _rRow->get().begin()+1;
    1359         456 :     for (sal_Int32 i=0; // the first column is the bookmark column
    1360         304 :          aRowIter != _rRow->get().end();
    1361             :             ++i, ++aRowIter
    1362             :         )
    1363             :     {
    1364             :         try
    1365             :         {
    1366             :             // get the table column and it's name
    1367         148 :             _xNames->getByIndex(i) >>= xTableColumn;
    1368             :             OSL_ENSURE(xTableColumn.is(), "OResultSet::setBoundedColumns: invalid table column!");
    1369         148 :             if (xTableColumn.is())
    1370         148 :                 xTableColumn->getPropertyValue(sName) >>= sTableColumnName;
    1371             :             else
    1372           0 :                 sTableColumnName = ::rtl::OUString();
    1373             : 
    1374             :             // look if we have such a select column
    1375             :             // TODO: would like to have a O(log n) search here ...
    1376         148 :             sal_Int32 nColumnPos = 0;
    1377         666 :             for (   OSQLColumns::Vector::iterator aIter = _rxColumns->get().begin();
    1378         444 :                     aIter != _rxColumns->get().end();
    1379             :                     ++aIter,++nColumnPos
    1380             :                 )
    1381             :             {
    1382          74 :                 if ( nColumnPos < (sal_Int32)aColumnNames.size() )
    1383          72 :                     sSelectColumnRealName = aColumnNames[nColumnPos];
    1384             :                 else
    1385             :                 {
    1386           2 :                     if((*aIter)->getPropertySetInfo()->hasPropertyByName(sRealName))
    1387           2 :                         (*aIter)->getPropertyValue(sRealName) >>= sSelectColumnRealName;
    1388             :                     else
    1389           0 :                         (*aIter)->getPropertyValue(sName) >>= sSelectColumnRealName;
    1390           2 :                     aColumnNames.push_back(sSelectColumnRealName);
    1391             :                 }
    1392             : 
    1393          74 :                 if (aCase(sTableColumnName, sSelectColumnRealName))
    1394             :                 {
    1395           2 :                     if(_bSetColumnMapping)
    1396             :                     {
    1397           2 :                         sal_Int32 nSelectColumnPos = static_cast<sal_Int32>(aIter - _rxColumns->get().begin() + 1);
    1398             :                             // the getXXX methods are 1-based ...
    1399           2 :                         sal_Int32 nTableColumnPos = i + 1;
    1400             :                             // get first table column is the bookmark column
    1401             :                             // ...
    1402             : #if OSL_DEBUG_LEVEL > 0
    1403             :                         OSL_TRACE("Set Col Mapping: %d -> %d", nSelectColumnPos, nTableColumnPos );
    1404             : #endif
    1405           2 :                         _rColMapping[nSelectColumnPos] = nTableColumnPos;
    1406             :                     }
    1407             : 
    1408           2 :                     aRowIter->setBound(sal_True);
    1409           2 :                     aRowIter->setTypeKind(DataType::VARCHAR);
    1410             :                 }
    1411             :             }
    1412             :         }
    1413           0 :         catch (Exception&)
    1414             :         {
    1415             :             OSL_FAIL("OResultSet::setBoundedColumns: caught an Exception!");
    1416             :         }
    1417           4 :     }
    1418           4 : }
    1419             : 
    1420             : 
    1421             : // -----------------------------------------------------------------------------
    1422           2 : sal_Bool OResultSet::isCount() const
    1423             : {
    1424             :     return (m_pParseTree &&
    1425           2 :             m_pParseTree->count() > 2                                                       &&
    1426           4 :             SQL_ISRULE(m_pParseTree->getChild(2),scalar_exp_commalist)                      &&
    1427           4 :             SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0),derived_column)               &&
    1428           4 :             SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0)->getChild(0),general_set_fct) &&
    1429           0 :             m_pParseTree->getChild(2)->getChild(0)->getChild(0)->count() == 4
    1430          16 :             );
    1431             : }
    1432             : 
    1433             : // -----------------------------------------------------------------------------
    1434             : //
    1435             : // Check for valid row in m_aQuery
    1436             : //
    1437          14 : sal_Bool OResultSet::validRow( sal_uInt32 nRow)
    1438             : {
    1439          14 :     sal_Int32  nNumberOfRecords = m_aQueryHelper.getResultCount();
    1440             : 
    1441          28 :     while ( nRow > (sal_uInt32)nNumberOfRecords && !m_aQueryHelper.queryComplete() ) {
    1442             : #if OSL_DEBUG_LEVEL > 0
    1443             :             OSL_TRACE("validRow: waiting...");
    1444             : #endif
    1445           0 :             if (m_aQueryHelper.checkRowAvailable( nRow ) == sal_False)
    1446             :             {
    1447             :                 OSL_TRACE("validRow(%u): return False", nRow);
    1448           0 :                 return sal_False;
    1449             :             }
    1450             : 
    1451           0 :             if ( m_aQueryHelper.hadError() )
    1452             :             {
    1453           0 :                 m_pStatement->getOwnConnection()->throwSQLException( m_aQueryHelper.getError(), *this );
    1454             :             }
    1455             : 
    1456           0 :             nNumberOfRecords = m_aQueryHelper.getResultCount();
    1457             :     }
    1458             : 
    1459          14 :     if (( nRow == 0 ) ||
    1460           0 :         ( nRow > (sal_uInt32)nNumberOfRecords && m_aQueryHelper.queryComplete()) ){
    1461             :         OSL_TRACE("validRow(%u): return False", nRow);
    1462           0 :         return sal_False;
    1463             :     }
    1464             : #if OSL_DEBUG_LEVEL > 0
    1465             :     OSL_TRACE("validRow(%u): return True", nRow);
    1466             : #endif
    1467             : 
    1468          14 :     return sal_True;
    1469             : }
    1470           5 : sal_Bool OResultSet::fillKeySet(sal_Int32 nMaxCardNumber)
    1471             : {
    1472           5 :     impl_ensureKeySet();
    1473           5 :     if (m_CurrentRowCount < nMaxCardNumber)
    1474             :     {
    1475             :         sal_Int32   nKeyValue;
    1476           1 :         if ( (sal_Int32)m_pKeySet->get().capacity() < nMaxCardNumber )
    1477           1 :             m_pKeySet->get().reserve(nMaxCardNumber + 20 );
    1478             : 
    1479           2 :         for (nKeyValue = m_CurrentRowCount+1; nKeyValue  <= nMaxCardNumber; nKeyValue ++)
    1480           1 :             m_pKeySet->get().push_back( nKeyValue );
    1481           1 :         m_CurrentRowCount = nMaxCardNumber;
    1482             :     }
    1483           5 :     return sal_True;
    1484             : }
    1485             : 
    1486           2 : sal_Int32 OResultSet::deletedCount()
    1487             : {
    1488           2 :     impl_ensureKeySet();
    1489           2 :     return m_CurrentRowCount - static_cast<sal_Int32>(m_pKeySet->get().size());
    1490             : 
    1491             : }
    1492             : // -----------------------------------------------------------------------------
    1493           6 : sal_Bool OResultSet::seekRow( eRowPosition pos, sal_Int32 nOffset )
    1494             : {
    1495             :     SAL_INFO("connectivity.mork", "=> OResultSet::seekRow()" );
    1496             : 
    1497           6 :     ResultSetEntryGuard aGuard( *this );
    1498           6 :     if ( !m_pKeySet.is() )
    1499           0 :         m_pStatement->getOwnConnection()->throwSQLException( STR_ILLEGAL_MOVEMENT, *this );
    1500             : 
    1501           6 :     sal_Int32  nNumberOfRecords = m_aQueryHelper.getResultCount();
    1502           6 :     sal_Int32  nRetrivedRows = currentRowCount();
    1503           6 :     sal_Int32  nCurPos = m_nRowPos;
    1504             : 
    1505             :     OSL_TRACE("seekRow: nCurPos = %d", nCurPos );
    1506           6 :     switch( pos ) {
    1507             :         case NEXT_POS:
    1508             :             OSL_TRACE("seekRow: NEXT");
    1509           1 :             nCurPos++;
    1510           1 :             break;
    1511             :         case PRIOR_POS:
    1512             :             OSL_TRACE("seekRow: PRIOR");
    1513           1 :             if ( nCurPos > 0 )
    1514           1 :                 nCurPos--;
    1515           1 :             break;
    1516             : 
    1517             :         case FIRST_POS:
    1518             :             OSL_TRACE("seekRow: FIRST");
    1519           3 :             nCurPos = 1;
    1520           3 :             break;
    1521             : 
    1522             :         case LAST_POS:
    1523             :             OSL_TRACE("seekRow: LAST");
    1524           1 :             nCurPos = nRetrivedRows;
    1525           1 :             break;
    1526             :         case ABSOLUTE_POS:
    1527             :             OSL_TRACE("seekRow: ABSOLUTE : %d", nOffset);
    1528           0 :             nCurPos = nOffset;
    1529           0 :             break;
    1530             :         case RELATIVE_POS:
    1531             :             OSL_TRACE("seekRow: RELATIVE : %d", nOffset);
    1532           0 :             nCurPos += sal_uInt32( nOffset );
    1533           0 :             break;
    1534             :     }
    1535             : 
    1536           6 :     if ( nCurPos <= 0 ) {
    1537           1 :         m_nRowPos = 0;
    1538             :         OSL_TRACE("seekRow: return False, m_nRowPos = %u", m_nRowPos );
    1539           1 :         return sal_False;
    1540             :     }
    1541           5 :     sal_Int32 nCurCard = nCurPos;
    1542           5 :     if ( nCurPos < (sal_Int32)m_pKeySet->get().size() ) //The requested row is exist in m_pKeySet, so we just use it
    1543             :     {
    1544           3 :         nCurCard = (m_pKeySet->get())[nCurPos-1];
    1545             :     }
    1546             :     else    //The requested row has not been retrived until now. We should get the right card for it.
    1547           2 :         nCurCard = nCurPos + deletedCount();
    1548             : 
    1549           5 :     if ( nCurCard > nNumberOfRecords) {
    1550           0 :         fillKeySet(nNumberOfRecords);
    1551           0 :         m_nRowPos = static_cast<sal_uInt32>(m_pKeySet->get().size() + 1);
    1552             :         OSL_TRACE("seekRow: return False, m_nRowPos = %u", m_nRowPos );
    1553           0 :         return sal_False;
    1554             :     }
    1555             :     //Insert new retrived items for later use
    1556           5 :     fillKeySet(nNumberOfRecords);
    1557           5 :     m_nRowPos = (sal_uInt32)nCurPos;
    1558             :     OSL_TRACE("seekRow: return True, m_nRowPos = %u", m_nRowPos );
    1559           5 :     fetchCurrentRow();
    1560           5 :     return sal_True;
    1561             : }
    1562             : // -----------------------------------------------------------------------------
    1563           2 : void OResultSet::setColumnMapping(const ::std::vector<sal_Int32>& _aColumnMapping)
    1564             : {
    1565           2 :     m_aColMapping = _aColumnMapping;
    1566             : #if OSL_DEBUG_LEVEL > 0
    1567             :     for ( sal_uInt32 i = 0; i < m_aColMapping.size(); i++ )
    1568             :         OSL_TRACE("Set Mapped: %d -> %d", i, m_aColMapping[i] );
    1569             : #endif
    1570           2 : }
    1571             : // -----------------------------------------------------------------------------
    1572             : 
    1573           0 : ::com::sun::star::uno::Any OResultSet::getBookmark(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1574             : {
    1575             :     OSL_TRACE("getBookmark, m_nRowPos = %u", m_nRowPos );
    1576           0 :     ResultSetEntryGuard aGuard( *this );
    1577           0 :     if ( fetchCurrentRow() == sal_False ) {
    1578           0 :         m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
    1579             :     }
    1580             : 
    1581             :     OSL_ENSURE((!m_aRow->isDeleted()),"getBookmark called for deleted row");
    1582           0 :     return makeAny((sal_Int32)(m_aRow->get())[0]);
    1583             : }
    1584           0 : sal_Bool  OResultSet::moveToBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1585             : {
    1586           0 :     ResultSetEntryGuard aGuard( *this );
    1587             :     OSL_TRACE("moveToBookmark, bookmark = %u", comphelper::getINT32(bookmark) );
    1588           0 :     sal_Int32 nCardNum = comphelper::getINT32(bookmark);
    1589           0 :     m_nRowPos = getRowForCardNumber(nCardNum);
    1590           0 :     fetchCurrentRow();
    1591           0 :     return sal_True;
    1592             : }
    1593           0 : sal_Bool  OResultSet::moveRelativeToBookmark( const ::com::sun::star::uno::Any& bookmark, sal_Int32 rows ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1594             : {
    1595           0 :     ResultSetEntryGuard aGuard( *this );
    1596             :     OSL_TRACE("moveRelativeToBookmark, bookmark = %u rows= %u", comphelper::getINT32(bookmark),rows );
    1597           0 :     sal_Int32 nCardNum = comphelper::getINT32(bookmark);
    1598           0 :     m_nRowPos = getRowForCardNumber(nCardNum);
    1599           0 :     return seekRow(RELATIVE_POS,rows );
    1600             : }
    1601           0 : sal_Int32 OResultSet::compareBookmarks( const ::com::sun::star::uno::Any& lhs, const ::com::sun::star::uno::Any& rhs ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1602             : {
    1603           0 :     ResultSetEntryGuard aGuard( *this );
    1604             :     OSL_TRACE("compareBookmarks, m_nRowPos = %u", m_nRowPos );
    1605           0 :         sal_Int32 nFirst=0;
    1606           0 :         sal_Int32 nSecond=0;
    1607           0 :         sal_Int32 nResult=0;
    1608             : 
    1609           0 :         if ( !( lhs >>= nFirst ) || !( rhs >>= nSecond ) ) {
    1610           0 :             m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this );
    1611             :         }
    1612             : 
    1613           0 :     if(nFirst < nSecond)
    1614           0 :          nResult = -1;
    1615           0 :     else if(nFirst > nSecond)
    1616           0 :          nResult = 1;
    1617             :     else
    1618           0 :          nResult = 0;
    1619             : 
    1620           0 :     return  nResult;
    1621             : }
    1622           0 : sal_Bool OResultSet::hasOrderedBookmarks(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1623             : {
    1624           0 :     ResultSetEntryGuard aGuard( *this );
    1625             :     OSL_TRACE("hasOrderedBookmarks, m_nRowPos = %u", m_nRowPos );
    1626           0 :     return sal_True;
    1627             : }
    1628           0 : sal_Int32 OResultSet::hashBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1629             : {
    1630           0 :     ResultSetEntryGuard aGuard( *this );
    1631             :     OSL_TRACE("hashBookmark, m_nRowPos = %u", m_nRowPos );
    1632           0 :     return  comphelper::getINT32(bookmark);
    1633             : }
    1634             : 
    1635           9 : sal_Int32 OResultSet::getCurrentCardNumber()
    1636             : {
    1637           9 :     if ( ( m_nRowPos == 0 ) || !m_pKeySet.is() )
    1638           0 :         return 0;
    1639           9 :     if (m_pKeySet->get().size() < m_nRowPos)
    1640           0 :         return 0;
    1641           9 :     return (m_pKeySet->get())[m_nRowPos-1];
    1642             : }
    1643           0 : void OResultSet::checkPendingUpdate() throw(SQLException, RuntimeException)
    1644             : {
    1645             :     OSL_FAIL( "OResultSet::checkPendingUpdate() not implemented" );
    1646             : /*
    1647             :     OSL_TRACE("checkPendingUpdate, m_nRowPos = %u", m_nRowPos );
    1648             :     const sal_Int32 nCurrentRow = getCurrentCardNumber();
    1649             : 
    1650             :     if ((m_nNewRow && nCurrentRow != m_nNewRow)
    1651             :         || ( m_nUpdatedRow && m_nUpdatedRow != nCurrentRow))
    1652             :     {
    1653             :         const ::rtl::OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
    1654             :                 STR_COMMIT_ROW,
    1655             :                 "$position$", ::rtl::OUString::valueOf(nCurrentRow)
    1656             :              ) );
    1657             :         ::dbtools::throwGenericSQLException(sError,*this);
    1658             :     }
    1659             : */
    1660             : 
    1661           0 : }
    1662           0 : void OResultSet::updateValue(sal_Int32 columnIndex ,const ORowSetValue& x) throw(SQLException, RuntimeException)
    1663             : {
    1664             :     OSL_TRACE("updateValue, m_nRowPos = %u", m_nRowPos );
    1665           0 :     ResultSetEntryGuard aGuard( *this );
    1666           0 :     if ( fetchCurrentRow() == sal_False ) {
    1667           0 :         m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
    1668             :     }
    1669             : 
    1670           0 :     checkPendingUpdate();
    1671             : 
    1672           0 :     checkIndex(columnIndex );
    1673           0 :     columnIndex = mapColumn(columnIndex);
    1674             : 
    1675           0 :     (m_aRow->get())[columnIndex].setBound(sal_True);
    1676           0 :     (m_aRow->get())[columnIndex] = x;
    1677           0 :     m_nUpdatedRow = getCurrentCardNumber();
    1678             : //    m_RowStates = m_RowStates | RowStates_Updated;
    1679           0 : }
    1680             : // -----------------------------------------------------------------------------
    1681             : 
    1682           0 : void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
    1683             : {
    1684             :     OSL_TRACE("updateNull, m_nRowPos = %u", m_nRowPos );
    1685           0 :     ResultSetEntryGuard aGuard( *this );
    1686           0 :     if ( fetchCurrentRow() == sal_False )
    1687           0 :         m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
    1688             : 
    1689           0 :     checkPendingUpdate();
    1690           0 :     checkIndex(columnIndex );
    1691           0 :     columnIndex = mapColumn(columnIndex);
    1692             : 
    1693           0 :     (m_aRow->get())[columnIndex].setBound(sal_True);
    1694           0 :     (m_aRow->get())[columnIndex].setNull();
    1695           0 :     m_nUpdatedRow = getCurrentCardNumber();
    1696             : //    m_RowStates = m_RowStates | RowStates_Updated;
    1697           0 : }
    1698             : // -------------------------------------------------------------------------
    1699             : 
    1700           0 : void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) throw(SQLException, RuntimeException)
    1701             : {
    1702           0 :     updateValue(columnIndex,x);
    1703           0 : }
    1704             : // -------------------------------------------------------------------------
    1705           0 : void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
    1706             : {
    1707           0 :     updateValue(columnIndex,x);
    1708           0 : }
    1709             : // -------------------------------------------------------------------------
    1710             : 
    1711           0 : void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
    1712             : {
    1713           0 :     updateValue(columnIndex,x);
    1714           0 : }
    1715             : // -------------------------------------------------------------------------
    1716           0 : void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
    1717             : {
    1718           0 :     updateValue(columnIndex,x);
    1719           0 : }
    1720             : // -------------------------------------------------------------------------
    1721           0 : void SAL_CALL OResultSet::updateLong( sal_Int32 /*columnIndex*/, sal_Int64 /*x*/ ) throw(SQLException, RuntimeException)
    1722             : {
    1723           0 :     ::dbtools::throwFeatureNotImplementedException( "XRowUpdate::updateLong", *this );
    1724           0 : }
    1725             : // -----------------------------------------------------------------------
    1726           0 : void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x ) throw(SQLException, RuntimeException)
    1727             : {
    1728           0 :     updateValue(columnIndex,x);
    1729           0 : }
    1730             : // -------------------------------------------------------------------------
    1731             : 
    1732           0 : void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x ) throw(SQLException, RuntimeException)
    1733             : {
    1734           0 :     updateValue(columnIndex,x);
    1735           0 : }
    1736             : // -------------------------------------------------------------------------
    1737           0 : void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
    1738             : {
    1739           0 :     updateValue(columnIndex,x);
    1740           0 : }
    1741             : // -------------------------------------------------------------------------
    1742           0 : void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
    1743             : {
    1744           0 :     updateValue(columnIndex,x);
    1745           0 : }
    1746             : // -------------------------------------------------------------------------
    1747           0 : void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException)
    1748             : {
    1749           0 :     updateValue(columnIndex,x);
    1750           0 : }
    1751             : // -------------------------------------------------------------------------
    1752             : 
    1753           0 : void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException)
    1754             : {
    1755           0 :     updateValue(columnIndex,x);
    1756           0 : }
    1757             : // -------------------------------------------------------------------------
    1758             : 
    1759           0 : void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException)
    1760             : {
    1761           0 :     updateValue(columnIndex,x);
    1762           0 : }
    1763             : // -------------------------------------------------------------------------
    1764             : 
    1765           0 : void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
    1766             : {
    1767           0 :     ResultSetEntryGuard aGuard( *this );
    1768             : 
    1769           0 :     if(!x.is())
    1770           0 :         ::dbtools::throwFunctionSequenceException(*this);
    1771             : 
    1772           0 :     Sequence<sal_Int8> aSeq;
    1773           0 :     x->readBytes(aSeq,length);
    1774           0 :     updateValue(columnIndex,aSeq);
    1775           0 : }
    1776             : // -------------------------------------------------------------------------
    1777           0 : void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
    1778             : {
    1779           0 :     updateBinaryStream(columnIndex,x,length);
    1780           0 : }
    1781             : // -------------------------------------------------------------------------
    1782           0 : void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) throw(SQLException, RuntimeException)
    1783             : {
    1784           0 :     if (!::dbtools::implUpdateObject(this, columnIndex, x))
    1785             :     {
    1786           0 :         const ::rtl::OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
    1787             :                 STR_COLUMN_NOT_UPDATEABLE,
    1788             :                 "$position$", ::rtl::OUString::valueOf(columnIndex)
    1789           0 :              ) );
    1790           0 :         ::dbtools::throwGenericSQLException(sError,*this);
    1791             :     } // if (!::dbtools::implUpdateObject(this, columnIndex, x))
    1792           0 :  }
    1793             : // -------------------------------------------------------------------------
    1794             : 
    1795           0 : void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
    1796             : {
    1797           0 :     if (!::dbtools::implUpdateObject(this, columnIndex, x))
    1798             :     {
    1799           0 :         const ::rtl::OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
    1800             :                 STR_COLUMN_NOT_UPDATEABLE,
    1801             :                 "$position$", ::rtl::OUString::valueOf(columnIndex)
    1802           0 :              ) );
    1803           0 :         ::dbtools::throwGenericSQLException(sError,*this);
    1804             :     }
    1805           0 : }
    1806             : 
    1807             : // XResultSetUpdate
    1808             : // -------------------------------------------------------------------------
    1809           0 : void SAL_CALL OResultSet::insertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1810             : {
    1811           0 :     ResultSetEntryGuard aGuard( *this );
    1812             :     OSL_TRACE("insertRow in, m_nRowPos = %u", m_nRowPos );
    1813             : //    m_RowStates = RowStates_Inserted;
    1814           0 :     updateRow();
    1815           0 :     m_nOldRowPos = 0;
    1816           0 :     m_nNewRow = 0;
    1817             :     //m_aQueryHelper.setRowStates(getCurrentCardNumber(),m_RowStates);
    1818           0 :     OSL_TRACE("insertRow out, m_nRowPos = %u", m_nRowPos );
    1819           0 : }
    1820             : // -------------------------------------------------------------------------
    1821           0 : void SAL_CALL OResultSet::updateRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1822             : {
    1823             :     OSL_FAIL( "OResultSet::updateRow(  ) not implemented" );
    1824           0 : }
    1825             : // -------------------------------------------------------------------------
    1826           0 : void SAL_CALL OResultSet::deleteRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1827             : {
    1828             :     OSL_FAIL( "OResultSet::deleteRow(  ) not implemented" );
    1829           0 : }
    1830             : // -------------------------------------------------------------------------
    1831           0 : void SAL_CALL OResultSet::cancelRowUpdates(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1832             : {
    1833             :     OSL_FAIL( "OResultSet::cancelRowUpdates(  ) not implemented" );
    1834           0 : }
    1835             : // -------------------------------------------------------------------------
    1836           0 : void SAL_CALL OResultSet::moveToInsertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1837             : {
    1838             :     OSL_FAIL( "OResultSet::moveToInsertRow(  ) not implemented" );
    1839           0 : }
    1840             : // -------------------------------------------------------------------------
    1841           0 : void SAL_CALL OResultSet::moveToCurrentRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
    1842             : {
    1843           0 :     ResultSetEntryGuard aGuard( *this );
    1844             :     OSL_TRACE("moveToCurrentRow, m_nRowPos = %u", m_nRowPos );
    1845           0 :     if (rowInserted())
    1846             :     {
    1847           0 :         m_nRowPos = m_nOldRowPos;
    1848           0 :         fetchCurrentRow();
    1849           0 :     }
    1850           0 : }
    1851             : 
    1852           2 : sal_Bool OResultSet::determineReadOnly()
    1853             : {
    1854             : //    OSL_FAIL( "OResultSet::determineReadOnly(  ) not implemented" );
    1855             : 
    1856           2 :     if (m_bIsReadOnly == -1)
    1857             :     {
    1858           2 :         m_bIsReadOnly = sal_True;
    1859             : //        OConnection* xConnection = static_cast<OConnection*>(m_pStatement->getConnection().get());
    1860             : //        m_bIsReadOnly = !m_aQueryHelper.isWritable(xConnection) || m_bIsAlwaysFalseQuery;
    1861             :     }
    1862             : 
    1863           2 :     return m_bIsReadOnly != 0;
    1864             : }
    1865             : 
    1866           2 : void OResultSet::setTable(OTable* _rTable)
    1867             : {
    1868             :     OSL_TRACE("In : setTable");
    1869           2 :     m_pTable = _rTable;
    1870           2 :     m_pTable->acquire();
    1871           2 :     m_xTableColumns = m_pTable->getColumns();
    1872           2 :     if(m_xTableColumns.is())
    1873           2 :         m_aColumnNames = m_xTableColumns->getElementNames();
    1874             :     OSL_TRACE("Out : setTable");
    1875           2 : }
    1876             : 
    1877           2 : void OResultSet::setOrderByColumns(const ::std::vector<sal_Int32>& _aColumnOrderBy)
    1878             : {
    1879           2 :     m_aOrderbyColumnNumber = _aColumnOrderBy;
    1880           2 : }
    1881             : 
    1882           2 : void OResultSet::setOrderByAscending(const ::std::vector<TAscendingOrder>& _aOrderbyAsc)
    1883             : {
    1884           2 :     m_aOrderbyAscending = _aOrderbyAsc;
    1885           2 : }
    1886           0 : Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows( const Sequence< Any >& /*rows*/ ) throw(SQLException, RuntimeException)
    1887             : {
    1888           0 :     ::dbtools::throwFeatureNotImplementedException( "XDeleteRows::deleteRows", *this );
    1889           0 :     return Sequence< sal_Int32 >();
    1890             : };
    1891             : 
    1892             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10