mork driver: add Statement stuff

Change-Id: I7c7aab568dce21c87b9925fd599ab381e6d9885f

12 files changed, 4192 insertions, 3 deletions

diff --git a/connectivity/Library_mork.mk b/connectivity/Library_mork.mk
index 5d90b009e54d..7066342dc389 100644
--- a/connectivity/Library_mork.mk
+++ b/connectivity/Library_mork.mk
@@ -21,11 +21,12 @@ $(eval $(call gb_Library_set_include,mork,\
 ))
 
 $(eval $(call gb_Library_use_libraries,mork, \
+    comphelper \
     cppu \
     cppuhelper \
+    dbtools \
     sal \
     salhelper \
-    dbtools \
     $(gb_STDLIBS) \
 ))
 
@@ -40,6 +41,10 @@ $(eval $(call gb_Library_add_exception_objects,mork, \
     connectivity/source/drivers/mork/MConnection \
     connectivity/source/drivers/mork/MDatabaseMetaData \
     connectivity/source/drivers/mork/MDatabaseMetaDataHelper \
+    connectivity/source/drivers/mork/MStatement \
+    connectivity/source/drivers/mork/MResultSet \
+    connectivity/source/drivers/mork/MResultSetMetaData \
+    connectivity/source/drivers/mork/MPreparedStatement \
     connectivity/source/drivers/mork/MServices \
 ))
 
diff --git a/connectivity/source/drivers/mork/MConnection.cxx b/connectivity/source/drivers/mork/MConnection.cxx
index a40673423fb6..8dedf5e680b3 100644
--- a/connectivity/source/drivers/mork/MConnection.cxx
+++ b/connectivity/source/drivers/mork/MConnection.cxx
@@ -12,7 +12,7 @@
 #include "MConnection.hxx"
 #include "MDriver.hxx"
 #include "MDatabaseMetaData.hxx"
-
+#include "MPreparedStatement.hxx"
 #include "MorkParser.hxx"
 
 #include <connectivity/dbcharset.hxx>
@@ -164,12 +164,21 @@ Reference< XStatement > SAL_CALL OConnection::createStatement(  ) throw(SQLExcep
 Reference< XPreparedStatement > SAL_CALL OConnection::prepareStatement( const ::rtl::OUString& _sSql ) throw(SQLException, RuntimeException)
 {
     SAL_INFO("connectivity.mork", "=> OConnection::prepareStatement()" );
+    SAL_INFO("connectivity.mork", "OConnection::prepareStatement( " << _sSql << " )");
 
     OSL_UNUSED( _sSql );
     ::osl::MutexGuard aGuard( m_aMutex );
     checkDisposed(OConnection_BASE::rBHelper.bDisposed);
 
-    SAL_INFO("connectivity.mork", "OConnection::prepareStatement( " << _sSql << " )");
+    // the pre
+    // create a statement
+    // the statement can only be executed more than once
+    OPreparedStatement* pPrepared = new OPreparedStatement(this,_sSql);
+    Reference< XPreparedStatement > xReturn = pPrepared;
+    pPrepared->lateInit();
+
+    m_aStatements.push_back(WeakReferenceHelper(xReturn));
+
     return NULL;
 }
 // --------------------------------------------------------------------------------
diff --git a/connectivity/source/drivers/mork/MConnection.hxx b/connectivity/source/drivers/mork/MConnection.hxx
index 9194a87177b5..9f6b862d1b65 100644
--- a/connectivity/source/drivers/mork/MConnection.hxx
+++ b/connectivity/source/drivers/mork/MConnection.hxx
@@ -61,6 +61,8 @@ namespace connectivity
             virtual void construct( const ::rtl::OUString& url,const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& info) throw(::com::sun::star::sdbc::SQLException);
             OConnection(MorkDriver* const driver);
             virtual ~OConnection();
+
+            MorkDriver* getDriver() {return m_pDriver;};
             MorkParser* getMorkParser() {return m_pMork;};
             void closeAllStatements () throw( ::com::sun::star::sdbc::SQLException);
 
diff --git a/connectivity/source/drivers/mork/MPreparedStatement.cxx b/connectivity/source/drivers/mork/MPreparedStatement.cxx
new file mode 100644
index 000000000000..c34de94576e1
--- /dev/null
+++ b/connectivity/source/drivers/mork/MPreparedStatement.cxx
@@ -0,0 +1,529 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <stdio.h>
+#include <osl/diagnose.h>
+#include "connectivity/sdbcx/VColumn.hxx"
+#include "MPreparedStatement.hxx"
+#include <com/sun/star/sdbc/DataType.hpp>
+#include "MResultSetMetaData.hxx"
+#include <cppuhelper/typeprovider.hxx>
+#include <comphelper/sequence.hxx>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include "connectivity/dbexception.hxx"
+#include "connectivity/dbtools.hxx"
+#include <comphelper/types.hxx>
+#include <com/sun/star/sdbc/ColumnValue.hpp>
+#include "diagnose_ex.h"
+
+#if OSL_DEBUG_LEVEL > 0
+# define OUtoCStr( x ) ( ::rtl::OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
+#else /* OSL_DEBUG_LEVEL */
+# define OUtoCStr( x ) ("dummy")
+#endif /* OSL_DEBUG_LEVEL */
+
+using namespace ::comphelper;
+using namespace connectivity;
+using namespace connectivity::mork;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::sdbc;
+using namespace com::sun::star::sdbcx;
+using namespace com::sun::star::container;
+using namespace com::sun::star::io;
+using namespace com::sun::star::util;
+
+IMPLEMENT_SERVICE_INFO(OPreparedStatement,"com.sun.star.sdbcx.mork.PreparedStatement","com.sun.star.sdbc.PreparedStatement");
+
+
+OPreparedStatement::OPreparedStatement( OConnection* _pConnection,const ::rtl::OUString& sql)
+    :OCommonStatement(_pConnection)
+    ,m_nNumParams(0)
+    ,m_sSqlStatement(sql)
+    ,m_bPrepared(sal_False)
+    ,m_pResultSet()
+{
+}
+// -----------------------------------------------------------------------------
+OPreparedStatement::~OPreparedStatement()
+{
+}
+// -----------------------------------------------------------------------------
+void OPreparedStatement::lateInit()
+{
+    if ( eSelect != parseSql( m_sSqlStatement ) )
+        throw SQLException();
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OPreparedStatement::disposing()
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    OCommonStatement::disposing();
+
+    m_xMetaData.clear();
+    if(m_aParameterRow.is())
+    {
+        m_aParameterRow->get().clear();
+        m_aParameterRow = NULL;
+    }
+    m_xParamColumns = NULL;
+}
+// -----------------------------------------------------------------------------
+
+OCommonStatement::StatementType OPreparedStatement::parseSql( const ::rtl::OUString& sql , sal_Bool bAdjusted )
+    throw ( ::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException )
+{
+    SAL_INFO("connectivity.mork", "=> OPreparedStatement::parseSql()" );
+
+    StatementType eStatementType = OCommonStatement::parseSql( sql, bAdjusted );
+    if ( eStatementType != eSelect )
+        return eStatementType;
+
+    m_xParamColumns = new OSQLColumns();
+
+    // describe all parameters need for the resultset
+    describeParameter();
+
+    Reference<XIndexAccess> xNames(m_xColNames,UNO_QUERY);
+    OResultSet::setBoundedColumns( m_aRow, m_xParamColumns, xNames, sal_False, m_xDBMetaData, m_aColMapping );
+
+    return eStatementType;
+}
+
+// -----------------------------------------------------------------------------
+void OPreparedStatement::initializeResultSet( OResultSet* _pResult )
+{
+    OCommonStatement::initializeResultSet( _pResult );
+    _pResult->setParameterColumns( m_xParamColumns );
+    _pResult->setParameterRow( m_aParameterRow );
+}
+
+// -----------------------------------------------------------------------------
+void OPreparedStatement::clearCachedResultSet()
+{
+    OCommonStatement::clearCachedResultSet();
+    m_pResultSet.clear();
+    m_xMetaData.clear();
+}
+// -----------------------------------------------------------------------------
+void OPreparedStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult )
+{
+    OCommonStatement::cacheResultSet( _pResult );
+    OSL_PRECOND( m_pResultSet == NULL, "OPreparedStatement::parseSql: you should call clearCachedResultSet before!" );
+    m_pResultSet = _pResult;
+}
+
+// -----------------------------------------------------------------------------
+void SAL_CALL OPreparedStatement::acquire() throw()
+{
+    OCommonStatement::acquire();
+}
+// -----------------------------------------------------------------------------
+void SAL_CALL OPreparedStatement::release() throw()
+{
+    OCommonStatement::release();
+}
+// -----------------------------------------------------------------------------
+Any SAL_CALL OPreparedStatement::queryInterface( const Type & rType ) throw(RuntimeException)
+{
+    Any aRet = OCommonStatement::queryInterface(rType);
+    if(!aRet.hasValue())
+        aRet = OPreparedStatement_BASE::queryInterface(rType);
+    return aRet;
+}
+// -------------------------------------------------------------------------
+::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL OPreparedStatement::getTypes(  ) throw(::com::sun::star::uno::RuntimeException)
+{
+    return ::comphelper::concatSequences(OPreparedStatement_BASE::getTypes(),OCommonStatement::getTypes());
+}
+// -------------------------------------------------------------------------
+
+Reference< XResultSetMetaData > SAL_CALL OPreparedStatement::getMetaData(  ) throw(SQLException, RuntimeException)
+{
+    SAL_INFO("connectivity.mork", "=> OPreparedStatement::getMetaData()" );
+
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    sal_Bool bReadOnly = sal_True;
+    if ( m_pResultSet.is() )
+        bReadOnly = m_pResultSet->determineReadOnly();
+    // if we do not have a result set, then we have not been executed, yet. In this case, assuming readonly=true is
+    // okay, /me thinks.
+
+    if ( !m_xMetaData.is() )
+        m_xMetaData = new OResultSetMetaData( m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,bReadOnly );
+
+    return m_xMetaData;
+}
+
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OPreparedStatement::execute(  ) throw(SQLException, RuntimeException)
+{
+    SAL_INFO("connectivity.mork", "=> OPreparedStatement::execute()" );
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    Reference< XResultSet> xResult = executeQuery();
+    return xResult.is();
+}
+// -------------------------------------------------------------------------
+
+sal_Int32 SAL_CALL OPreparedStatement::executeUpdate(  ) throw(SQLException, RuntimeException)
+{
+    SAL_INFO("connectivity.mork", "=> OPreparedStatement::executeUpdate()" );
+
+    ::dbtools::throwFeatureNotImplementedException( "XStatement::executeUpdate", *this );
+    return 0;
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setString( sal_Int32 parameterIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    OSL_TRACE("prepStmt::setString( %s )", OUtoCStr( x ) );
+    setParameter( parameterIndex, x );
+}
+// -------------------------------------------------------------------------
+
+Reference< XConnection > SAL_CALL OPreparedStatement::getConnection(  ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    return (Reference< XConnection >)m_pConnection;
+}
+// -------------------------------------------------------------------------
+
+Reference< XResultSet > SAL_CALL OPreparedStatement::executeQuery(  ) throw(SQLException, RuntimeException)
+{
+    SAL_INFO("connectivity.mork", "=> OPreparedStatement::executeQuery()" );
+
+    ::osl::MutexGuard aGuard( m_aMutex );
+    OSL_TRACE("In: OPreparedStatement::executeQuery" );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    // our statement has already been parsed in lateInit, no need to do all this (potentially expensive)
+    // stuff again. Just execute.
+    return impl_executeCurrentQuery();
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setBoolean( sal_Int32 /*parameterIndex*/, sal_Bool /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setBoolean", *this );
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OPreparedStatement::setByte( sal_Int32 /*parameterIndex*/, sal_Int8 /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setByte", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setDate( sal_Int32 /*parameterIndex*/, const Date& /*aData*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setDate", *this );
+}
+// -------------------------------------------------------------------------
+
+
+void SAL_CALL OPreparedStatement::setTime( sal_Int32 /*parameterIndex*/, const Time& /*aVal*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setTime", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setTimestamp( sal_Int32 /*parameterIndex*/, const DateTime& /*aVal*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setTimestamp", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setDouble( sal_Int32 /*parameterIndex*/, double /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setDouble", *this );
+}
+
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setFloat( sal_Int32 /*parameterIndex*/, float /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setFloat", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setInt( sal_Int32 /*parameterIndex*/, sal_Int32 /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setInt", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setLong( sal_Int32 /*parameterIndex*/, sal_Int64 /*aVal*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setLong", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setNull( sal_Int32 parameterIndex, sal_Int32 /*sqlType*/ ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    checkAndResizeParameters(parameterIndex);
+
+    (m_aParameterRow->get())[parameterIndex].setNull();
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setClob( sal_Int32 /*parameterIndex*/, const Reference< XClob >& /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setClob", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setBlob( sal_Int32 /*parameterIndex*/, const Reference< XBlob >& /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setBlob", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setArray( sal_Int32 /*parameterIndex*/, const Reference< XArray >& /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setArray", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setRef( sal_Int32 /*parameterIndex*/, const Reference< XRef >& /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setRef", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setObjectWithInfo( sal_Int32 /*parameterIndex*/, const Any& /*x*/, sal_Int32 /*sqlType*/, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setObjectWithInfo", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& /*typeName*/ ) throw(SQLException, RuntimeException)
+{
+    setNull(parameterIndex,sqlType);
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setObject( sal_Int32 parameterIndex, const Any& x ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::implSetObject(this,parameterIndex,x);
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setShort( sal_Int32 /*parameterIndex*/, sal_Int16 /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setShort", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setBytes( sal_Int32 /*parameterIndex*/, const Sequence< sal_Int8 >& /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setBytes", *this );
+}
+// -------------------------------------------------------------------------
+
+
+void SAL_CALL OPreparedStatement::setCharacterStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setCharacterStream", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::setBinaryStream( sal_Int32 /*parameterIndex*/, const Reference< ::com::sun::star::io::XInputStream >& /*x*/, sal_Int32 /*length*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XParameters::setBinaryStream", *this );
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OPreparedStatement::clearParameters(  ) throw(SQLException, RuntimeException)
+{
+}
+// -------------------------------------------------------------------------
+void OPreparedStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
+{
+    switch(nHandle)
+    {
+        case PROPERTY_ID_RESULTSETCONCURRENCY:
+            break;
+        case PROPERTY_ID_RESULTSETTYPE:
+            break;
+        case PROPERTY_ID_FETCHDIRECTION:
+            break;
+        case PROPERTY_ID_USEBOOKMARKS:
+            break;
+        default:
+            OCommonStatement::setFastPropertyValue_NoBroadcast(nHandle,rValue);
+    }
+}
+
+// -----------------------------------------------------------------------------
+void OPreparedStatement::checkAndResizeParameters(sal_Int32 parameterIndex)
+{
+    ::connectivity::checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    if ( !m_aParameterRow.is() ) {
+        m_aParameterRow = new OValueVector();
+        m_aParameterRow->get().push_back(sal_Int32(0));
+    }
+
+    if ((sal_Int32)(m_aParameterRow->get()).size() <= parameterIndex)
+        (m_aParameterRow->get()).resize(parameterIndex+1);
+}
+// -----------------------------------------------------------------------------
+void OPreparedStatement::setParameter(sal_Int32 parameterIndex, const
+ORowSetValue& x)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkAndResizeParameters(parameterIndex);
+
+    OSL_TRACE("setParameter( %d, '%s')", parameterIndex, OUtoCStr(x) );
+    (m_aParameterRow->get())[parameterIndex] = x;
+}
+
+//------------------------------------------------------------------
+size_t OPreparedStatement::AddParameter(OSQLParseNode * pParameter, const Reference<XPropertySet>& _xCol)
+{
+    OSL_UNUSED( pParameter );
+    // Count of the newly added Parameters
+    size_t nParameter = m_xParamColumns->get().size()+1;
+
+    OSL_ENSURE(SQL_ISRULE(pParameter,parameter),"OResultSet::AddParameter: Argument is not a Parameter");
+    OSL_ENSURE(pParameter->count() > 0,"OResultSet: error in parse tree");
+#if OSL_DEBUG_LEVEL > 0
+    OSQLParseNode * pMark = pParameter->getChild(0);
+    OSL_UNUSED( pMark );
+#endif
+
+    ::rtl::OUString sParameterName;
+
+    // set up Parameter-Column:
+    sal_Int32 eType = DataType::VARCHAR;
+    sal_uInt32 nPrecision = 255;
+    sal_Int32 nScale = 0;
+    sal_Int32 nNullable = ColumnValue::NULLABLE;
+
+    if (_xCol.is())
+    {
+        // Type, Precision, Scale ... utilize the selected Columns,
+        // then this Column will get the value assigned or with this
+        // Column will the value be compared.
+        eType = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)));
+        nPrecision = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)));
+        nScale = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE)));
+        nNullable = getINT32(_xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE)));
+        _xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sParameterName;
+    }
+
+    Reference<XPropertySet> xParaColumn = new connectivity::sdbcx::OColumn(sParameterName
+                                                    ,::rtl::OUString()
+                                                    ,::rtl::OUString()
+                                                    ,::rtl::OUString()
+                                                    ,nNullable
+                                                    ,nPrecision
+                                                    ,nScale
+                                                    ,eType
+                                                    ,sal_False
+                                                    ,sal_False
+                                                    ,sal_False
+                                                    ,m_pSQLIterator->isCaseSensitive());
+    m_xParamColumns->get().push_back(xParaColumn);
+    return nParameter;
+}
+// -----------------------------------------------------------------------------
+void OPreparedStatement::describeColumn(OSQLParseNode*
+_pParameter,OSQLParseNode* _pNode,const OSQLTable& _xTable)
+{
+    Reference<XPropertySet> xProp;
+    if(SQL_ISRULE(_pNode,column_ref))
+    {
+        ::rtl::OUString sColumnName,sTableRange;
+        m_pSQLIterator->getColumnRange(_pNode,sColumnName,sTableRange);
+        if(!sColumnName.isEmpty())
+        {
+            Reference<XNameAccess> xNameAccess = _xTable->getColumns();
+            if(xNameAccess->hasByName(sColumnName))
+                xNameAccess->getByName(sColumnName) >>= xProp;
+            AddParameter(_pParameter,xProp);
+        }
+    }
+    //  else
+        //  AddParameter(_pParameter,xProp);
+}
+// -------------------------------------------------------------------------
+void OPreparedStatement::describeParameter()
+{
+    ::std::vector< OSQLParseNode*> aParseNodes;
+    scanParameter(m_pParseTree,aParseNodes);
+    if(!aParseNodes.empty())
+    {
+        m_xParamColumns = new OSQLColumns();
+        const OSQLTables& xTabs = m_pSQLIterator->getTables();
+        if(xTabs.size())
+        {
+            OSQLTable xTable = xTabs.begin()->second;
+            ::std::vector< OSQLParseNode*>::const_iterator aIter =
+aParseNodes.begin();
+            for (;aIter != aParseNodes.end();++aIter )
+            {
+                describeColumn(*aIter,(*aIter)->getParent()->getChild(0),xTable);
+            }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+void OPreparedStatement::scanParameter(OSQLParseNode* pParseNode,::std::vector< OSQLParseNode*>& _rParaNodes)
+{
+    OSL_ENSURE(pParseNode != NULL,"OResultSet: internal error: invalid ParseNode");
+
+    // Parameter Name-Row found?
+    if (SQL_ISRULE(pParseNode,parameter))
+    {
+        OSL_ENSURE(pParseNode->count() >= 1,"OResultSet: Faulty Parse Tree");
+        OSL_ENSURE(pParseNode->getChild(0)->getNodeType() == SQL_NODE_PUNCTUATION,"OResultSet: Faulty Parse Tree");
+
+        _rParaNodes.push_back(pParseNode);
+        // further search isn't necessary
+        return;
+    }
+
+    // Search on in Parse Tree
+    for (sal_uInt32 i = 0; i < pParseNode->count(); i++)
+        scanParameter(pParseNode->getChild(i),_rParaNodes);
+}
+// -----------------------------------------------------------------------------
+::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet > SAL_CALL OPreparedStatement::getResultSet(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    return NULL;
+}
+// -----------------------------------------------------------------------------
+sal_Int32 SAL_CALL OPreparedStatement::getUpdateCount(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    return 0;
+}
+// -----------------------------------------------------------------------------
+sal_Bool SAL_CALL OPreparedStatement::getMoreResults(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    return sal_False;
+}
+// -----------------------------------------------------------------------------
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MPreparedStatement.hxx b/connectivity/source/drivers/mork/MPreparedStatement.hxx
new file mode 100644
index 000000000000..0c38cbacb78b
--- /dev/null
+++ b/connectivity/source/drivers/mork/MPreparedStatement.hxx
@@ -0,0 +1,156 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef CONNECTIVITY_SPREPAREDSTATEMENT_HXX
+#define CONNECTIVITY_SPREPAREDSTATEMENT_HXX
+
+#include "MResultSet.hxx"
+#include "MStatement.hxx"
+#include <com/sun/star/sdbc/XPreparedStatement.hpp>
+#include <com/sun/star/sdbc/XParameters.hpp>
+#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <com/sun/star/sdbc/XMultipleResults.hpp>
+#include <cppuhelper/compbase5.hxx>
+
+namespace connectivity
+{
+    namespace mork
+    {
+
+        typedef ::cppu::ImplHelper5<    ::com::sun::star::sdbc::XPreparedStatement,
+                                        ::com::sun::star::sdbc::XParameters,
+                                        ::com::sun::star::sdbc::XResultSetMetaDataSupplier,
+                                        ::com::sun::star::sdbc::XMultipleResults,
+                                        ::com::sun::star::lang::XServiceInfo> OPreparedStatement_BASE;
+
+        class OPreparedStatement :  public  OCommonStatement,
+                                    public  OPreparedStatement_BASE
+        {
+        protected:
+            struct Parameter
+            {
+                ::com::sun::star::uno::Any  aValue;
+                sal_Int32                   nDataType;
+
+                Parameter(const ::com::sun::star::uno::Any& rValue,
+                          sal_Int32                         rDataType) : aValue(rValue),nDataType(rDataType)
+                {
+                }
+
+            };
+
+            ::std::vector< Parameter>       m_aParameters;
+            //====================================================================
+            // Data attributes
+            //====================================================================
+            sal_Int32                       m_nNumParams; // Number of parameter markers for the prepared statement
+
+            ::rtl::OUString                             m_sSqlStatement;
+            ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSetMetaData >  m_xMetaData;
+            sal_Bool                                    m_bPrepared;
+            ::rtl::Reference< OResultSet >              m_pResultSet;
+            ::rtl::Reference<connectivity::OSQLColumns> m_xParamColumns;    // the parameter columns
+            OValueRow                                   m_aParameterRow;
+
+        protected:
+            virtual void SAL_CALL setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,
+                                                                   const ::com::sun::star::uno::Any& rValue)
+                                                                        throw (::com::sun::star::uno::Exception);
+            virtual ~OPreparedStatement();
+
+            virtual void SAL_CALL disposing();
+
+            // OCommonStatement overridables
+            virtual StatementType
+                            parseSql( const ::rtl::OUString& sql , sal_Bool bAdjusted = sal_False) throw ( ::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException );
+            virtual void    initializeResultSet( OResultSet* _pResult );
+            virtual void    clearCachedResultSet();
+            virtual void    cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult );
+
+
+            void checkAndResizeParameters(sal_Int32 parameterIndex);
+            void setParameter(sal_Int32 parameterIndex, const ORowSetValue& x);
+
+            size_t AddParameter(connectivity::OSQLParseNode * pParameter,
+                                const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet>& _xCol);
+            void scanParameter(OSQLParseNode* pParseNode,::std::vector< OSQLParseNode*>& _rParaNodes);
+            void describeColumn(OSQLParseNode* _pParameter,OSQLParseNode* _pNode,const OSQLTable& _xTable);
+            void describeParameter();
+
+        public:
+            DECLARE_SERVICE_INFO();
+            // A ctor need for returning the object
+            OPreparedStatement( OConnection* _pConnection,const ::rtl::OUString& sql);
+            void lateInit();
+
+            //XInterface
+            virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL acquire() throw();
+            virtual void SAL_CALL release() throw();
+            //XTypeProvider
+            virtual ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes(  ) throw(::com::sun::star::uno::RuntimeException);
+
+            // XPreparedStatement
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet > SAL_CALL executeQuery(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int32 SAL_CALL executeUpdate(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL execute(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection > SAL_CALL getConnection(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XParameters
+            virtual void SAL_CALL setNull( sal_Int32 parameterIndex, sal_Int32 sqlType ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setObjectNull( sal_Int32 parameterIndex, sal_Int32 sqlType, const ::rtl::OUString& typeName ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setBoolean( sal_Int32 parameterIndex, sal_Bool x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setByte( sal_Int32 parameterIndex, sal_Int8 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setShort( sal_Int32 parameterIndex, sal_Int16 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setInt( sal_Int32 parameterIndex, sal_Int32 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setLong( sal_Int32 parameterIndex, sal_Int64 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setFloat( sal_Int32 parameterIndex, float x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setDouble( sal_Int32 parameterIndex, double x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setString( sal_Int32 parameterIndex, const ::rtl::OUString& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setBytes( sal_Int32 parameterIndex, const ::com::sun::star::uno::Sequence< sal_Int8 >& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setDate( sal_Int32 parameterIndex, const ::com::sun::star::util::Date& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setTime( sal_Int32 parameterIndex, const ::com::sun::star::util::Time& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setTimestamp( sal_Int32 parameterIndex, const ::com::sun::star::util::DateTime& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setBinaryStream( sal_Int32 parameterIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setCharacterStream( sal_Int32 parameterIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setObject( sal_Int32 parameterIndex, const ::com::sun::star::uno::Any& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setObjectWithInfo( sal_Int32 parameterIndex, const ::com::sun::star::uno::Any& x, sal_Int32 targetSqlType, sal_Int32 scale ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setRef( sal_Int32 parameterIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XRef >& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setBlob( sal_Int32 parameterIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XBlob >& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setClob( sal_Int32 parameterIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XClob >& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL setArray( sal_Int32 parameterIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XArray >& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL clearParameters(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XResultSetMetaDataSupplier
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSetMetaData > SAL_CALL getMetaData(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XMultipleResults
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet > SAL_CALL getResultSet(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int32 SAL_CALL getUpdateCount(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL getMoreResults(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+
+        public:
+            using OCommonStatement::executeQuery;
+            using OCommonStatement::executeUpdate;
+            using OCommonStatement::execute;
+        protected:
+            using OPropertySetHelper::getFastPropertyValue;
+        };
+    }
+}
+#endif // CONNECTIVITY_SPREPAREDSTATEMENT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MResultSet.cxx b/connectivity/source/drivers/mork/MResultSet.cxx
new file mode 100644
index 000000000000..c150cf1ac59d
--- /dev/null
+++ b/connectivity/source/drivers/mork/MResultSet.cxx
@@ -0,0 +1,2023 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/sdbc/DataType.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <comphelper/property.hxx>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/typeprovider.hxx>
+#include <comphelper/extract.hxx>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/sdbc/ResultSetType.hpp>
+#include <com/sun/star/sdbc/FetchDirection.hpp>
+#include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
+#include <comphelper/types.hxx>
+#include <connectivity/dbexception.hxx>
+#include <connectivity/dbtools.hxx>
+
+#include <TSortIndex.hxx>
+#include <rtl/string.hxx>
+#include <vector>
+#include <algorithm>
+#include "MResultSet.hxx"
+#include "MResultSetMetaData.hxx"
+#include "FDatabaseMetaDataResultSet.hxx"
+#include "resource/common_res.hrc"
+
+#if OSL_DEBUG_LEVEL > 0
+# define OUtoCStr( x ) ( ::rtl::OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
+#else /* OSL_DEBUG_LEVEL */
+# define OUtoCStr( x ) ("dummy")
+#endif /* OSL_DEBUG_LEVEL */
+
+using namespace ::comphelper;
+using namespace connectivity;
+using namespace connectivity::mork;
+using namespace ::cppu;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::sdbc;
+using namespace com::sun::star::container;
+using namespace com::sun::star::io;
+using namespace com::sun::star::util;
+
+//------------------------------------------------------------------------------
+//  IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.OResultSet","com.sun.star.sdbc.ResultSet");
+::rtl::OUString SAL_CALL OResultSet::getImplementationName(  ) throw ( RuntimeException)    \
+{
+    return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbcx.mork.ResultSet"));
+}
+// -------------------------------------------------------------------------
+ Sequence< ::rtl::OUString > SAL_CALL OResultSet::getSupportedServiceNames(  ) throw( RuntimeException)
+{
+    ::com::sun::star::uno::Sequence< ::rtl::OUString > aSupported(2);
+    aSupported[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbc.ResultSet"));
+    aSupported[1] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbcx.ResultSet"));
+    return aSupported;
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::supportsService( const ::rtl::OUString& _rServiceName ) throw( RuntimeException)
+{
+    Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
+    const ::rtl::OUString* pSupported = aSupported.getConstArray();
+    const ::rtl::OUString* pEnd = pSupported + aSupported.getLength();
+    for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported)
+        ;
+
+    return pSupported != pEnd;
+}
+
+// -------------------------------------------------------------------------
+OResultSet::OResultSet(OCommonStatement* pStmt, const ::boost::shared_ptr< connectivity::OSQLParseTreeIterator >& _pSQLIterator )
+    : OResultSet_BASE(m_aMutex)
+    ,OPropertySetHelper(OResultSet_BASE::rBHelper)
+    ,m_pStatement(pStmt)
+    ,m_xStatement(*pStmt)
+    ,m_xMetaData(NULL)
+    ,m_nRowPos(0)
+    ,m_nOldRowPos(0)
+    ,m_nFetchSize(0)
+    ,m_nResultSetType(ResultSetType::SCROLL_INSENSITIVE)
+    ,m_nFetchDirection(FetchDirection::FORWARD)
+    ,m_nResultSetConcurrency(ResultSetConcurrency::UPDATABLE)
+    ,m_pSQLIterator( _pSQLIterator )
+    ,m_pParseTree( _pSQLIterator->getParseTree() )
+      // TODO
+      //,m_aQuery( pStmt->getOwnConnection()->getColumnAlias() )
+    ,m_pTable(NULL)
+    ,m_CurrentRowCount(0)
+    ,m_nParamIndex(0)
+    ,m_bIsAlwaysFalseQuery(sal_False)
+    ,m_pKeySet(NULL)
+    ,m_nNewRow(0)
+    ,m_nUpdatedRow(0)
+    ,m_RowStates(0)
+    ,m_bIsReadOnly(-1)
+{
+
+    //m_aQuery.setMaxNrOfReturns(pStmt->getOwnConnection()->getMaxResultRecords());
+}
+// -------------------------------------------------------------------------
+OResultSet::~OResultSet()
+{
+}
+
+// -------------------------------------------------------------------------
+void OResultSet::disposing(void)
+{
+    OPropertySetHelper::disposing();
+
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    m_xStatement.clear();
+    m_xMetaData.clear();
+    m_pParseTree    = NULL;
+    m_xColumns = NULL;
+    m_xParamColumns = NULL;
+    m_pKeySet       = NULL;
+    if(m_pTable)
+    {
+        m_pTable->release();
+        m_pTable = NULL;
+    }
+}
+// -------------------------------------------------------------------------
+Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeException)
+{
+    Any aRet = OPropertySetHelper::queryInterface(rType);
+    if(!aRet.hasValue())
+        aRet = OResultSet_BASE::queryInterface(rType);
+    return aRet;
+}
+// -------------------------------------------------------------------------
+ Sequence<  Type > SAL_CALL OResultSet::getTypes(  ) throw( RuntimeException)
+{
+    OTypeCollection aTypes( ::getCppuType( (const  Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
+                                                ::getCppuType( (const  Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ),
+                                                ::getCppuType( (const  Reference< ::com::sun::star::beans::XPropertySet > *)0 ));
+
+    return ::comphelper::concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes());
+}
+// -------------------------------------------------------------------------
+void OResultSet::methodEntry()
+{
+    checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
+    if ( !m_pTable )
+    {
+        OSL_FAIL( "OResultSet::methodEntry: looks like we're disposed, but how is this possible?" );
+        throw DisposedException( ::rtl::OUString(), *this );
+    }
+}
+
+// -------------------------------------------------------------------------
+sal_Int32 SAL_CALL OResultSet::findColumn( const ::rtl::OUString& columnName ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    // find the first column with the name columnName
+    Reference< XResultSetMetaData > xMeta = getMetaData();
+    sal_Int32 nLen = xMeta->getColumnCount();
+    sal_Int32 i = 1;
+    for(;i<=nLen;++i)
+        if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
+                columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
+            break;
+    return i;
+}
+// -------------------------------------------------------------------------
+Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    return NULL;
+}
+// -------------------------------------------------------------------------
+Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    return NULL;
+}
+
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    m_bWasNull = sal_True;
+    return sal_False;
+}
+// -------------------------------------------------------------------------
+
+sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return 0;
+}
+// -------------------------------------------------------------------------
+
+Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return Sequence< sal_Int8 >();
+}
+// -------------------------------------------------------------------------
+
+Date SAL_CALL OResultSet::getDate( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return Date();
+}
+// -------------------------------------------------------------------------
+
+double SAL_CALL OResultSet::getDouble( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return 0.0;
+}
+// -------------------------------------------------------------------------
+
+float SAL_CALL OResultSet::getFloat( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return 0;
+}
+// -------------------------------------------------------------------------
+
+sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return 0;
+}
+
+// -------------------------------------------------------------------------
+sal_Int32 SAL_CALL OResultSet::getRow(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    OSL_TRACE("In/Out: OResultSet::getRow, return = %u", m_nRowPos );
+    return m_nRowPos;
+}
+// -------------------------------------------------------------------------
+
+sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return sal_Int64();
+}
+// -------------------------------------------------------------------------
+
+Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    if(!m_xMetaData.is())
+        m_xMetaData = new OResultSetMetaData(
+        m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,determineReadOnly());
+    return m_xMetaData;
+}
+// -------------------------------------------------------------------------
+Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    return NULL;
+}
+
+// -------------------------------------------------------------------------
+
+Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    return NULL;
+}
+// -------------------------------------------------------------------------
+Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    return NULL;
+}
+// -------------------------------------------------------------------------
+
+Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    return NULL;
+}
+// -------------------------------------------------------------------------
+
+Any SAL_CALL OResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
+{
+    return Any();
+}
+// -------------------------------------------------------------------------
+
+sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    return 0;
+}
+// -------------------------------------------------------------------------
+
+void OResultSet::checkIndex(sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException)
+{
+    if(columnIndex <= 0 || columnIndex > (sal_Int32)m_xColumns->get().size())
+        ::dbtools::throwInvalidIndexException(*this);
+}
+// -------------------------------------------------------------------------
+sal_uInt32  OResultSet::currentRowCount()
+{
+    if ( m_bIsAlwaysFalseQuery )
+        return 0;
+    return 0;//m_aQuery.getRealRowCount() - deletedCount();
+}
+
+// -------------------------------------------------------------------------
+
+sal_Bool OResultSet::fetchCurrentRow( ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("fetchCurrentRow, m_nRowPos = %u", m_nRowPos );
+    return fetchRow(getCurrentCardNumber());
+}
+
+// -------------------------------------------------------------------------
+sal_Bool OResultSet::pushCard(sal_uInt32 /*cardNumber*/) throw(SQLException, RuntimeException)
+{
+    SAL_WARN("connectivity.mork", "OResultSet::pushCard() NOT IMPLEMENTED!");
+    return sal_True;
+/*
+    if (cardNumber == 0)
+        return sal_True;
+    // Check whether we are storing the updated row
+    if ( (m_aRow->get())[0].isNull() || (sal_Int32)(m_aRow->get())[0] != (sal_Int32)cardNumber )
+        return sal_False;
+
+    sal_Int32 nCount = m_aColumnNames.getLength();
+    m_aQuery.setRowStates(cardNumber,m_RowStates);
+    for( sal_Int32 i = 1; i <= nCount; i++ )
+    {
+        if ( (m_aRow->get())[i].isBound() )
+        {
+            //
+            // Everything in the addressbook is a string!
+            //
+            if ( !m_aQuery.setRowValue( (m_aRow->get())[i], cardNumber, m_aColumnNames[i-1], DataType::VARCHAR ))
+            {
+                m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
+            }
+        }
+    }
+    return sal_True;
+*/
+}
+// -------------------------------------------------------------------------
+sal_Bool OResultSet::fetchRow(sal_Int32 /*cardNumber*/,sal_Bool /*bForceReload*/) throw(SQLException, RuntimeException)
+{
+    SAL_WARN("connectivity.mork", "OResultSet::fetchRow() NOT IMPLEMENTED!");
+    return sal_True;
+/*
+    OSL_TRACE("fetchRow, cardNumber = %u", cardNumber );
+    if (!bForceReload)
+    {
+        // Check whether we've already fetched the row...
+        if ( !(m_aRow->get())[0].isNull() && (sal_Int32)(m_aRow->get())[0] == (sal_Int32)cardNumber )
+            return sal_True;
+        //Check whether the old row has been changed
+        if (cardNumber == m_nUpdatedRow)
+        {
+            //write back the changes first
+            if (!pushCard(cardNumber))  //error write back the changes
+                throw SQLException();
+        }
+    }
+    else
+        m_aQuery.resyncRow(cardNumber);
+
+    if ( validRow( cardNumber ) == sal_False )
+        return sal_False;
+
+    (m_aRow->get())[0] = (sal_Int32)cardNumber;
+    sal_Int32 nCount = m_aColumnNames.getLength();
+    m_RowStates = m_aQuery.getRowStates(cardNumber);
+    for( sal_Int32 i = 1; i <= nCount; i++ )
+    {
+        if ( (m_aRow->get())[i].isBound() )
+        {
+            //
+            // Everything in the addressbook is a string!
+            //
+            if ( !m_aQuery.getRowValue( (m_aRow->get())[i], cardNumber, m_aColumnNames[i-1], DataType::VARCHAR ))
+            {
+                m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
+            }
+        }
+    }
+    return sal_True;
+*/
+}
+// -------------------------------------------------------------------------
+
+const ORowSetValue& OResultSet::getValue(sal_Int32 cardNumber, sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
+{
+    if ( fetchRow( cardNumber ) == sal_False )
+    {
+        OSL_FAIL("fetchRow() returned False" );
+        m_bWasNull = sal_True;
+        return *ODatabaseMetaDataResultSet::getEmptyValue();
+    }
+
+    m_bWasNull = (m_aRow->get())[columnIndex].isNull();
+    return (m_aRow->get())[columnIndex];
+
+}
+// -------------------------------------------------------------------------
+
+
+::rtl::OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
+    OSL_ENSURE(columnIndex <= (sal_Int32)m_xColumns->get().size(), "Trying to access invalid columns number");
+    checkIndex( columnIndex );
+
+    // If this query was sorted then we should have a valid KeySet, so use it
+    return getValue(getCurrentCardNumber(), mapColumn( columnIndex ) );
+
+}
+// -------------------------------------------------------------------------
+
+Time SAL_CALL OResultSet::getTime( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return Time();
+}
+// -------------------------------------------------------------------------
+
+
+DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    return DateTime();
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSet::isBeforeFirst(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    // here you have to implement your movements
+    // return true means there is no data
+    OSL_TRACE("In/Out: OResultSet::isBeforeFirst" );
+    return( m_nRowPos < 1 );
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::isAfterLast(  ) throw(SQLException, RuntimeException)
+{
+    SAL_WARN("connectivity.mork", "OResultSet::isAfterLast() NOT IMPLEMENTED!");
+    ResultSetEntryGuard aGuard( *this );
+
+    OSL_TRACE("In/Out: OResultSet::isAfterLast" );
+    return sal_True;
+//    return m_nRowPos > currentRowCount() && m_aQuery.queryComplete();
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::isFirst(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    OSL_TRACE("In/Out: OResultSet::isFirst" );
+    return m_nRowPos == 1;
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::isLast(  ) throw(SQLException, RuntimeException)
+{
+    SAL_WARN("connectivity.mork", "OResultSet::isLast() NOT IMPLEMENTED!");
+    ResultSetEntryGuard aGuard( *this );
+
+    OSL_TRACE("In/Out: OResultSet::isLast" );
+    return sal_True;
+//    return m_nRowPos == currentRowCount() && m_aQuery.queryComplete();
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::beforeFirst(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    // move before the first row so that isBeforeFirst returns false
+    OSL_TRACE("In/Out: OResultSet::beforeFirst" );
+    if ( first() )
+        previous();
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::afterLast(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("In/Out: OResultSet::afterLast" );
+
+    if(last())
+        next();
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::close(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("In/Out: OResultSet::close" );
+    dispose();
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSet::first(  ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("In/Out: OResultSet::first" );
+    return seekRow( FIRST_POS );
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSet::last(  ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("In/Out: OResultSet::last" );
+    return seekRow( LAST_POS );
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("In/Out: OResultSet::absolute" );
+    return seekRow( ABSOLUTE_POS, row );
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("In/Out: OResultSet::relative" );
+    return seekRow( RELATIVE_POS, row );
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::previous(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("In/Out: OResultSet::previous" );
+    return seekRow( PRIOR_POS );
+}
+// -------------------------------------------------------------------------
+Reference< XInterface > SAL_CALL OResultSet::getStatement(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    OSL_TRACE("In/Out: OResultSet::getStatement" );
+    return m_xStatement;
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSet::rowDeleted(  ) throw(SQLException, RuntimeException)
+{
+    SAL_WARN("connectivity.mork", "OResultSet::rowDeleted() NOT IMPLEMENTED!");
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("In/Out: OResultSet::rowDeleted, m_RowStates=%u",m_RowStates );
+    return sal_True;//return ((m_RowStates & RowStates_Deleted) == RowStates_Deleted) ;
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::rowInserted(  ) throw(SQLException, RuntimeException)
+{
+    SAL_WARN("connectivity.mork", "OResultSet::rowInserted() NOT IMPLEMENTED!");
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("In/Out: OResultSet::rowInserted,m_RowStates=%u",m_RowStates );
+    return sal_True;//return ((m_RowStates & RowStates_Inserted) == RowStates_Inserted);
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSet::rowUpdated(  ) throw(SQLException, RuntimeException)
+{
+    SAL_WARN("connectivity.mork", "OResultSet::rowUpdated() NOT IMPLEMENTED!");
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("In/Out: OResultSet::rowUpdated,m_RowStates=%u",m_RowStates );
+    return sal_True;// return ((m_RowStates & RowStates_Updated) == RowStates_Updated) ;
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSet::next(  ) throw(SQLException, RuntimeException)
+{
+    return seekRow( NEXT_POS );
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSet::wasNull(  ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    return m_bWasNull;
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::cancel(  ) throw(RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("In/Out: OResultSet::cancel" );
+
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::clearWarnings(  ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("In/Out: OResultSet::clearWarnings" );
+}
+// -------------------------------------------------------------------------
+Any SAL_CALL OResultSet::getWarnings(  ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("In/Out: OResultSet::getWarnings" );
+    return Any();
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::refreshRow(  ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("In/Out: OResultSet::refreshRow" );
+    if (fetchRow(getCurrentCardNumber(),sal_True)) {
+        //force fetch current row will cause we lose all change to the current row
+        //m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_REFRESH_ROW, *this );
+        SAL_WARN("connectivity.mork", "OResultSet::refreshRow(): STR_ERROR_REFRESH_ROW!");
+    }
+}
+// -------------------------------------------------------------------------
+IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
+{
+    Sequence< Property > aProps(5);
+    Property* pProperties = aProps.getArray();
+    sal_Int32 nPos = 0;
+    DECL_PROP0(FETCHDIRECTION,          sal_Int32);
+    DECL_PROP0(FETCHSIZE,               sal_Int32);
+     DECL_BOOL_PROP1IMPL(ISBOOKMARKABLE) PropertyAttribute::READONLY);
+    DECL_PROP1IMPL(RESULTSETCONCURRENCY,sal_Int32) PropertyAttribute::READONLY);
+    DECL_PROP1IMPL(RESULTSETTYPE,       sal_Int32) PropertyAttribute::READONLY);
+
+    return new OPropertyArrayHelper(aProps);
+}
+// -------------------------------------------------------------------------
+IPropertyArrayHelper & OResultSet::getInfoHelper()
+{
+    return *const_cast<OResultSet*>(this)->getArrayHelper();
+}
+// -------------------------------------------------------------------------
+sal_Bool OResultSet::convertFastPropertyValue(
+                            Any & /*rConvertedValue*/,
+                            Any & /*rOldValue*/,
+                            sal_Int32 nHandle,
+                            const Any& /*rValue*/ )
+                                throw (::com::sun::star::lang::IllegalArgumentException)
+{
+    OSL_FAIL( "OResultSet::convertFastPropertyValue: not implemented!" );
+    switch(nHandle)
+    {
+        case PROPERTY_ID_ISBOOKMARKABLE:
+        case PROPERTY_ID_RESULTSETCONCURRENCY:
+        case PROPERTY_ID_RESULTSETTYPE:
+            throw ::com::sun::star::lang::IllegalArgumentException();
+        case PROPERTY_ID_FETCHDIRECTION:
+        case PROPERTY_ID_FETCHSIZE:
+        default:
+            ;
+    }
+    return sal_False;
+}
+// -------------------------------------------------------------------------
+void OResultSet::setFastPropertyValue_NoBroadcast(
+                                sal_Int32 nHandle,
+                                const Any& /*rValue*/
+                                                 )
+                                                 throw (Exception)
+{
+    OSL_FAIL( "OResultSet::setFastPropertyValue_NoBroadcast: not implemented!" );
+    switch(nHandle)
+    {
+        case PROPERTY_ID_ISBOOKMARKABLE:
+        case PROPERTY_ID_RESULTSETCONCURRENCY:
+        case PROPERTY_ID_RESULTSETTYPE:
+            throw Exception();
+        case PROPERTY_ID_FETCHDIRECTION:
+            break;
+        case PROPERTY_ID_FETCHSIZE:
+            break;
+        default:
+            ;
+    }
+}
+// -------------------------------------------------------------------------
+void OResultSet::getFastPropertyValue(
+                                Any& rValue,
+                                sal_Int32 nHandle
+                                     ) const
+{
+    switch(nHandle)
+    {
+        case PROPERTY_ID_RESULTSETCONCURRENCY:
+            rValue <<= (sal_Int32)m_nResultSetConcurrency;
+            break;
+        case PROPERTY_ID_RESULTSETTYPE:
+            rValue <<= m_nResultSetType;
+            break;
+        case PROPERTY_ID_FETCHDIRECTION:
+            rValue <<= m_nFetchDirection;
+            break;
+        case PROPERTY_ID_FETCHSIZE:
+            rValue <<= m_nFetchSize;
+            break;
+        case PROPERTY_ID_ISBOOKMARKABLE:
+            const_cast< OResultSet* >( this )->determineReadOnly();
+            rValue <<= !m_bIsReadOnly;
+         break;
+    }
+}
+// -----------------------------------------------------------------------------
+void SAL_CALL OResultSet::acquire() throw()
+{
+    OResultSet_BASE::acquire();
+}
+// -----------------------------------------------------------------------------
+void SAL_CALL OResultSet::release() throw()
+{
+    OResultSet_BASE::release();
+}
+// -----------------------------------------------------------------------------
+::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
+{
+    return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
+}
+
+// -------------------------------------------------------------------------
+void OResultSet::parseParameter( const OSQLParseNode* pNode, rtl::OUString& rMatchString )
+{
+    OSL_ENSURE(pNode->count() > 0,"Error parsing parameter in Parse Tree");
+    OSQLParseNode *pMark = pNode->getChild(0);
+
+    // Initialize to empty string
+    rMatchString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(""));
+
+    rtl::OUString aParameterName;
+    if (SQL_ISPUNCTUATION(pMark,"?")) {
+        aParameterName = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("?"));
+    }
+    else if (SQL_ISPUNCTUATION(pMark,":")) {
+        aParameterName = pNode->getChild(1)->getTokenValue();
+    }
+    // XXX - Now we know name, what's value????
+    m_nParamIndex ++;
+    OSL_TRACE("Parameter name [%d]: %s", m_nParamIndex,OUtoCStr(aParameterName) );
+
+    if ( m_aParameterRow.is() ) {
+        OSL_ENSURE( m_nParamIndex < (sal_Int32)m_aParameterRow->get().size() + 1, "More parameters than values found" );
+        rMatchString = (m_aParameterRow->get())[(sal_uInt16)m_nParamIndex];
+#if OSL_DEBUG_LEVEL > 0
+        OSL_TRACE("Prop Value       : %s", OUtoCStr( rMatchString ) );
+#endif
+    }
+#if OSL_DEBUG_LEVEL > 0
+    else {
+        OSL_TRACE("Prop Value       : Invalid ParameterRow!" );
+    }
+#endif
+}
+
+#if 0
+void OResultSet::analyseWhereClause( const OSQLParseNode*                 parseTree,
+                                     MQueryExpression                     &queryExpression)
+{
+    ::rtl::OUString         columnName;
+    MQueryOp::cond_type     op( MQueryOp::Is );
+    ::rtl::OUString         matchString;
+
+    if ( parseTree == NULL )
+        return;
+
+    if ( m_pSQLIterator->getParseTree() != NULL ) {
+        ::rtl::Reference<OSQLColumns> xColumns = m_pSQLIterator->getParameters();
+        if(xColumns.is())
+        {
+            ::rtl::OUString aColName, aParameterValue;
+            OSQLColumns::Vector::iterator aIter = xColumns->get().begin();
+            sal_Int32 i = 1;
+            for(;aIter != xColumns->get().end();++aIter)
+            {
+                (*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
+                OSL_TRACE("Prop Column Name : %s", OUtoCStr( aColName ) );
+                if ( m_aParameterRow.is() ) {
+                    aParameterValue = (m_aParameterRow->get())[(sal_uInt16)i];
+#if OSL_DEBUG_LEVEL > 0
+                    OSL_TRACE("Prop Value       : %s", OUtoCStr( aParameterValue ) );
+#endif
+                }
+#if OSL_DEBUG_LEVEL > 0
+                else {
+                    OSL_TRACE("Prop Value       : Invalid ParameterRow!" );
+                }
+#endif
+                i++;
+            }
+        }
+
+    }
+
+    if ( SQL_ISRULE(parseTree,where_clause) )
+    {
+        OSL_TRACE("analyseSQL : Got WHERE clause");
+        // Reset Parameter Counter
+        resetParameters();
+        analyseWhereClause( parseTree->getChild( 1 ), queryExpression );
+    }
+    else if ( parseTree->count() == 3 &&                         // Handle ()'s
+        SQL_ISPUNCTUATION(parseTree->getChild(0),"(") &&
+        SQL_ISPUNCTUATION(parseTree->getChild(2),")"))
+    {
+
+        OSL_TRACE("analyseSQL : Got Punctuation ()");
+        MQueryExpression *subExpression = new MQueryExpression();
+        analyseWhereClause( parseTree->getChild( 1 ), *subExpression );
+        queryExpression.getExpressions().push_back( subExpression );
+    }
+    else if ((SQL_ISRULE(parseTree,search_condition) || (SQL_ISRULE(parseTree,boolean_term)))
+             && parseTree->count() == 3)                   // Handle AND/OR
+    {
+
+        OSL_TRACE("analyseSQL : Got AND/OR clause");
+
+        // TODO - Need to take care or AND, for now match is always OR
+        analyseWhereClause( parseTree->getChild( 0 ), queryExpression );
+        analyseWhereClause( parseTree->getChild( 2 ), queryExpression );
+
+        if (SQL_ISTOKEN(parseTree->getChild(1),OR)) {         // OR-Operator
+            queryExpression.setExpressionCondition( MQueryExpression::OR );
+        }
+        else if (SQL_ISTOKEN(parseTree->getChild(1),AND)) {  // AND-Operator
+            queryExpression.setExpressionCondition( MQueryExpression::AND );
+        }
+        else {
+            OSL_FAIL("analyseSQL: Error in Parse Tree");
+        }
+    }
+    else if (SQL_ISRULE(parseTree,comparison_predicate))
+    {
+        OSL_ENSURE(parseTree->count() == 3, "Error parsing COMPARE predicate");
+        if (!(SQL_ISRULE(parseTree->getChild(0),column_ref) ||
+          parseTree->getChild(2)->getNodeType() == SQL_NODE_STRING ||
+          parseTree->getChild(2)->getNodeType() == SQL_NODE_INTNUM ||
+          parseTree->getChild(2)->getNodeType() == SQL_NODE_APPROXNUM ||
+          SQL_ISTOKEN(parseTree->getChild(2),TRUE) ||
+          SQL_ISTOKEN(parseTree->getChild(2),FALSE) ||
+          SQL_ISRULE(parseTree->getChild(2),parameter) ||
+          // odbc date
+          (SQL_ISRULE(parseTree->getChild(2),set_fct_spec) && SQL_ISPUNCTUATION(parseTree->getChild(2)->getChild(0),"{"))))
+        {
+            m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
+        }
+
+        OSQLParseNode *pPrec = parseTree->getChild(1);
+        if (pPrec->getNodeType() == SQL_NODE_EQUAL)
+            op = MQueryOp::Is;
+        else if (pPrec->getNodeType() == SQL_NODE_NOTEQUAL)
+            op = MQueryOp::IsNot;
+
+        ::rtl::OUString sTableRange;
+        if(SQL_ISRULE(parseTree->getChild(0),column_ref))
+            m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange);
+        else if(parseTree->getChild(0)->isToken())
+            columnName = parseTree->getChild(0)->getTokenValue();
+
+        if ( SQL_ISRULE(parseTree->getChild(2),parameter) ) {
+            parseParameter( parseTree->getChild(2), matchString );
+        }
+        else {
+            matchString = parseTree->getChild(2)->getTokenValue();
+        }
+
+        if ( columnName.compareToAscii("0") ==0 && op == MQueryOp::Is &&
+             matchString.compareToAscii("1") == 0 ) {
+            OSL_TRACE("Query always evaluates to FALSE");
+            m_bIsAlwaysFalseQuery = sal_True;
+        }
+        queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op, matchString ));
+    }
+    else if (SQL_ISRULE(parseTree,like_predicate))
+    {
+        OSL_ENSURE(parseTree->count() == 2, "Error parsing LIKE predicate");
+
+        OSL_TRACE("analyseSQL : Got LIKE rule");
+
+        if ( !(SQL_ISRULE(parseTree->getChild(0), column_ref)) )
+        {
+            m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_COLUMN, *this );
+        }
+
+
+        OSQLParseNode *pColumn;
+        OSQLParseNode *pAtom;
+        OSQLParseNode *pOptEscape;
+        const OSQLParseNode* pPart2 = parseTree->getChild(1);
+        pColumn     = parseTree->getChild(0);                        // Match Item
+        pAtom       = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-2));     // Match String
+        pOptEscape  = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-1));     // Opt Escape Rule
+        (void)pOptEscape;
+        const bool bNot = SQL_ISTOKEN(pPart2->getChild(0), NOT);
+
+        if (!(pAtom->getNodeType() == SQL_NODE_STRING ||
+              pAtom->getNodeType() == SQL_NODE_NAME ||
+              SQL_ISRULE(pAtom,parameter) ||
+              ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQL_NODE_NAME ) ||
+              ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQL_NODE_STRING )
+              ) )
+        {
+            OSL_TRACE("analyseSQL : pAtom->count() = %d", pAtom->count() );
+
+            m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_STRING, *this );
+        }
+
+        const sal_Unicode WILDCARD = '%';
+        const sal_Unicode ALT_WILDCARD = '*';
+        const sal_Unicode MATCHCHAR = '_';
+
+        ::rtl::OUString sTableRange;
+        if(SQL_ISRULE(pColumn,column_ref))
+            m_pSQLIterator->getColumnRange(pColumn,columnName,sTableRange);
+
+        OSL_TRACE("ColumnName = %s", OUtoCStr( columnName ) );
+
+        if ( SQL_ISRULE(pAtom,parameter) ) {
+            parseParameter( pAtom, matchString );
+            // Replace all '*' with '%' : UI Usually does this but not with
+            // Parameters for some reason.
+            matchString = matchString.replace( ALT_WILDCARD, WILDCARD );
+        }
+        else
+        {
+            matchString = pAtom->getTokenValue();
+        }
+
+        // Determine where '%' character is...
+
+        if ( matchString.equals( ::rtl::OUString::valueOf( WILDCARD ) ) )
+        {
+            // String containing only a '%' and nothing else
+            op = MQueryOp::Exists;
+            // Will be ignored for Exists case, but clear anyway.
+            matchString = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(""));
+        }
+        else if ( matchString.indexOf ( WILDCARD ) == -1 &&
+             matchString.indexOf ( MATCHCHAR ) == -1 )
+        {
+            // Simple string , eg. "to match"
+            if ( bNot )
+                op = MQueryOp::DoesNotContain;
+            else
+                op = MQueryOp::Contains;
+        }
+        else if (  matchString.indexOf ( WILDCARD ) == 0
+                   && matchString.lastIndexOf ( WILDCARD ) == matchString.getLength() -1
+                   && matchString.indexOf ( WILDCARD, 1 ) == matchString.lastIndexOf ( WILDCARD )
+                   && matchString.indexOf( MATCHCHAR ) == -1
+                 )
+        {
+            // Relatively simple "%string%" - ie, contains...
+            // Cut '%'  from front and rear
+            matchString = matchString.replaceAt( 0, 1, rtl::OUString() );
+            matchString = matchString.replaceAt( matchString.getLength() -1 , 1, rtl::OUString() );
+
+            if (bNot)
+                op = MQueryOp::DoesNotContain;
+            else
+                op = MQueryOp::Contains;
+        }
+        else if ( bNot )
+        {
+            // We currently can't handle a 'NOT LIKE' when there are '%' or
+            // '_' dispersed throughout
+            m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_NOT_LIKE_TOO_COMPLEX, *this );
+        }
+        else
+        {
+            if ( (matchString.indexOf ( WILDCARD ) == matchString.lastIndexOf ( WILDCARD ))
+                  && matchString.indexOf( MATCHCHAR ) == -1
+                )
+            {
+                // One occurrence of '%' - no '_' matches...
+                if ( matchString.indexOf ( WILDCARD ) == 0 )
+                {
+                    op = MQueryOp::EndsWith;
+                    matchString = matchString.replaceAt( 0, 1, rtl::OUString());
+                }
+                else if ( matchString.indexOf ( WILDCARD ) == matchString.getLength() -1 )
+                {
+                    op = MQueryOp::BeginsWith;
+                    matchString = matchString.replaceAt( matchString.getLength() -1 , 1, rtl::OUString() );
+                }
+                else
+                {
+                    sal_Int32 pos = matchString.indexOf ( WILDCARD );
+                    matchString = matchString.replaceAt( pos, 1,::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".*")) );
+                    op = MQueryOp::RegExp;
+                }
+
+            }
+            else
+            {
+                // Most Complex, need to use an RE
+                sal_Int32 pos = matchString.indexOf ( WILDCARD );
+                while ( (pos = matchString.indexOf ( WILDCARD )) != -1 )
+                {
+                    matchString = matchString.replaceAt( pos, 1, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".*")) );
+                }
+
+                pos = matchString.indexOf ( MATCHCHAR );
+                while ( (pos = matchString.indexOf( MATCHCHAR )) != -1 )
+                {
+                    matchString = matchString.replaceAt( pos, 1, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".")) );
+                }
+
+                op = MQueryOp::RegExp;
+            }
+        }
+
+        queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op, matchString ));
+    }
+    else if (SQL_ISRULE(parseTree,test_for_null))
+    {
+        OSL_ENSURE(parseTree->count() == 2,"Error in ParseTree");
+        const OSQLParseNode* pPart2 = parseTree->getChild(1);
+        OSL_ENSURE(SQL_ISTOKEN(pPart2->getChild(0),IS),"Error in ParseTree");
+
+        if (!SQL_ISRULE(parseTree->getChild(0),column_ref))
+        {
+            m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_IS_NULL_COLUMN, *this );
+        }
+
+        if (SQL_ISTOKEN(pPart2->getChild(1),NOT))
+        {
+            op = MQueryOp::Exists;
+        }
+        else
+            op = MQueryOp::DoesNotExist;
+
+        ::rtl::OUString sTableRange;
+        m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange);
+
+        queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op ));
+    }
+    else
+    {
+        OSL_TRACE( "Unexpected statement!!!" );
+
+        m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
+    }
+}
+#endif
+
+// -----------------------------------------------------------------------------
+
+void OResultSet::fillRowData()
+    throw( ::com::sun::star::sdbc::SQLException )
+{
+    OSL_FAIL( "OResultSet::fillRowData() not implemented!" );
+/*
+    OSL_ENSURE( m_pStatement, "Require a statement" );
+
+    MQueryExpression queryExpression;
+
+    OConnection* xConnection = static_cast<OConnection*>(m_pStatement->getConnection().get());
+    m_xColumns = m_pSQLIterator->getSelectColumns();
+
+    OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
+
+    OSQLColumns::Vector::const_iterator aIter = m_xColumns->get().begin();
+    const ::rtl::OUString sProprtyName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
+    ::rtl::OUString sName;
+    m_aAttributeStrings.clear();
+    m_aAttributeStrings.reserve(m_xColumns->get().size());
+    for (sal_Int32 i = 1; aIter != m_xColumns->get().end();++aIter, i++)
+    {
+        (*aIter)->getPropertyValue(sProprtyName) >>= sName;
+#if OSL_DEBUG_LEVEL > 0
+        OSL_TRACE("Query Columns : (%d) %s", i, OUtoCStr(sName) );
+#endif
+        m_aAttributeStrings.push_back( sName );
+    }
+
+
+    // Generate Match Conditions for Query
+    const OSQLParseNode*  pParseTree = m_pSQLIterator->getWhereTree();
+
+    // const OSQLParseNode*  pParseTree = NULL;
+
+    m_bIsAlwaysFalseQuery = sal_False;
+    if ( pParseTree != NULL )
+    {
+        // Extract required info
+
+        OSL_TRACE("\tHave a Where Clause");
+
+        analyseWhereClause( pParseTree, queryExpression );
+    }
+    else
+    {
+        OSL_TRACE("\tDon't have a Where Clause");
+
+        MQueryExpression::ExprVector    eVector;
+
+        // LDAP does not allow a query without restriction, so we add a dummy
+        // for PrimaryEmail
+        // For other types we stick to the old behaviour of using
+        // card:nsIAbCard.
+        OSL_ENSURE(m_pStatement, "Cannot determine Parent Statement");
+        ::rtl::OUString aStr;
+        if (xConnection->isLDAP())
+            aStr = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("PrimaryEmail"));
+        else
+            aStr = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("card:nsIAbCard"));
+        eVector.push_back( new MQueryExpressionString(aStr, MQueryOp::Exists) );
+
+        queryExpression.setExpressions( eVector );
+    }
+
+    // If the query is a 0=1 then set Row count to 0 and return
+    if ( m_bIsAlwaysFalseQuery )
+    {
+        m_bIsReadOnly = 1;
+        return;
+    }
+
+    m_aQuery.setExpression( queryExpression );
+
+    rtl::OUString aStr(  m_pTable->getName() );
+    m_aQuery.setAddressbook( aStr );
+
+    sal_Int32 rv = m_aQuery.executeQuery(xConnection);
+    if ( rv == -1 ) {
+        m_pStatement->getOwnConnection()->throwSQLException( STR_ERR_EXECUTING_QUERY, *this );
+    }
+    //determine whether the address book is readonly
+    determineReadOnly();
+
+#if OSL_DEBUG_LEVEL > 0
+    OSL_TRACE( "executeQuery returned %d", rv );
+
+    OSL_TRACE( "\tOUT OResultSet::fillRowData()" );
+#endif
+*/
+}
+
+#if 0
+// -----------------------------------------------------------------------------
+static sal_Bool matchRow( OValueRow& row1, OValueRow& row2 )
+{
+    OValueVector::Vector::iterator row1Iter = row1->get().begin();
+    OValueVector::Vector::iterator row2Iter = row2->get().begin();
+    for ( ++row1Iter,++row2Iter; // the first column is the bookmark column
+          row1Iter != row1->get().end(); ++row1Iter,++row2Iter)
+    {
+        if ( row1Iter->isBound())
+        {
+            // Compare values, if at anytime there's a mismatch return false
+            if ( !( (*row1Iter) == (*row2Iter) ) )
+                return sal_False;
+        }
+    }
+
+    // If we get to here the rows match
+    return sal_True;
+}
+#endif
+
+sal_Int32 OResultSet::getRowForCardNumber(sal_Int32 nCardNum)
+{
+    OSL_TRACE("In/Out: OResultSet::getRowForCardNumber, nCardNum = %u", nCardNum );
+
+    if ( m_pKeySet.is() )
+    {
+        sal_Int32  nPos;
+        for(nPos=0;nPos < (sal_Int32)m_pKeySet->get().size();nPos++)
+        {
+            if (nCardNum == (m_pKeySet->get())[nPos])
+            {
+                OSL_TRACE("In/Out: OResultSet::getRowForCardNumber, return = %u", nPos+1 );
+                return nPos+1;
+            }
+        }
+    }
+
+    // TODO
+    //m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this );
+    OSL_FAIL( "STR_INVALID_BOOKMARK!" );
+
+    return 0;
+}
+
+// -----------------------------------------------------------------------------
+void SAL_CALL OResultSet::executeQuery() throw( ::com::sun::star::sdbc::SQLException,
+                                                ::com::sun::star::uno::RuntimeException)
+{
+    OSL_FAIL( "OResultSet::executeQuery() not implemented" );
+/*
+    ResultSetEntryGuard aGuard( *this );
+
+    OSL_ENSURE( m_pTable, "Need a Table object");
+    if(!m_pTable)
+    {
+        const OSQLTables& xTabs = m_pSQLIterator->getTables();
+        if ((xTabs.begin() == xTabs.end()) || !xTabs.begin()->second.is()) {
+            OSL_FAIL( " STR_QUERY_TOO_COMPLEX!" );
+//            m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
+        }
+
+        m_pTable = static_cast< OTable* > ((xTabs.begin()->second).get());
+
+    }
+
+    m_nRowPos = 0;
+
+    fillRowData();
+
+    OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
+
+    switch( m_pSQLIterator->getStatementType() )
+    {
+        case SQL_STATEMENT_SELECT:
+        {
+            if(m_bIsAlwaysFalseQuery) {
+                break;
+            }
+            else if(isCount())
+            {
+                OSL_FAIL( "STR_NO_COUNT_SUPPORT!" );
+                //m_pStatement->getOwnConnection()->throwSQLException( STR_NO_COUNT_SUPPORT, *this );
+            }
+            else
+            {
+                sal_Bool bDistinct = sal_False;
+                OSQLParseNode *pDistinct = m_pParseTree->getChild(1);
+                if (pDistinct && pDistinct->getTokenID() == SQL_TOKEN_DISTINCT)
+                {
+                    if(!IsSorted())
+                    {
+                        m_aOrderbyColumnNumber.push_back(m_aColMapping[1]);
+                        m_aOrderbyAscending.push_back(SQL_DESC);
+                    }
+                    bDistinct = sal_True;
+                }
+
+                OSortIndex::TKeyTypeVector eKeyType(m_aOrderbyColumnNumber.size());
+                ::std::vector<sal_Int32>::iterator aOrderByIter = m_aOrderbyColumnNumber.begin();
+                for ( ::std::vector<sal_Int16>::size_type i = 0; aOrderByIter != m_aOrderbyColumnNumber.end(); ++aOrderByIter,++i)
+                {
+                    OSL_ENSURE((sal_Int32)m_aRow->get().size() > *aOrderByIter,"Invalid Index");
+                    switch ((m_aRow->get().begin()+*aOrderByIter)->getTypeKind())
+                    {
+                    case DataType::CHAR:
+                        case DataType::VARCHAR:
+                            eKeyType[i] = SQL_ORDERBYKEY_STRING;
+                            break;
+
+                        case DataType::OTHER:
+                        case DataType::TINYINT:
+                        case DataType::SMALLINT:
+                        case DataType::INTEGER:
+                        case DataType::DECIMAL:
+                        case DataType::NUMERIC:
+                        case DataType::REAL:
+                        case DataType::DOUBLE:
+                        case DataType::DATE:
+                        case DataType::TIME:
+                        case DataType::TIMESTAMP:
+                        case DataType::BIT:
+                            eKeyType[i] = SQL_ORDERBYKEY_DOUBLE;
+                            break;
+
+                    // Other types aren't implemented (so they are always FALSE)
+                        default:
+                            eKeyType[i] = SQL_ORDERBYKEY_NONE;
+                            OSL_FAIL("MResultSet::executeQuery: Order By Data Type not implemented");
+                            break;
+                    }
+                }
+
+                if (IsSorted())
+                {
+                    // Implement Sorting
+
+                    // So that we can sort we need to wait until the executed
+                    // query to the mozilla addressbooks has returned all
+                    // values.
+
+                    OSL_TRACE("Query is to be sorted");
+                    if( ! m_aQuery.queryComplete() )
+                        if ( !m_aQuery.waitForQueryComplete() )
+                        {
+                            m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
+                        }
+
+                    OSL_ENSURE( m_aQuery.queryComplete(), "Query not complete!!");
+
+                    m_pSortIndex = new OSortIndex(eKeyType,m_aOrderbyAscending);
+
+                    OSL_TRACE("OrderbyColumnNumber->size() = %d",m_aOrderbyColumnNumber.size());
+#if OSL_DEBUG_LEVEL > 0
+                    for ( ::std::vector<sal_Int32>::size_type i = 0; i < m_aColMapping.size(); i++ )
+                        OSL_TRACE("Mapped: %d -> %d", i, m_aColMapping[i] );
+#endif
+                    for ( sal_Int32 nRow = 1; nRow <= m_aQuery.getRowCount(); nRow++ ) {
+
+                        OKeyValue* pKeyValue = OKeyValue::createKeyValue((nRow));
+
+                        ::std::vector<sal_Int32>::iterator aIter = m_aOrderbyColumnNumber.begin();
+                        for (;aIter != m_aOrderbyColumnNumber.end(); ++aIter)
+                        {
+                            const ORowSetValue& value = getValue(nRow, *aIter);
+
+                            OSL_TRACE( "Adding Value: (%d,%d) : %s", nRow, *aIter,OUtoCStr( value ));
+
+                            pKeyValue->pushKey(new ORowSetValueDecorator(value));
+                        }
+
+                        m_pSortIndex->AddKeyValue( pKeyValue );
+                    }
+
+                    m_pKeySet = m_pSortIndex->CreateKeySet();
+                    m_CurrentRowCount = static_cast<sal_Int32>(m_pKeySet->get().size());
+#if OSL_DEBUG_LEVEL > 0
+                    for( OKeySet::Vector::size_type i = 0; i < m_pKeySet->get().size(); i++ )
+                        OSL_TRACE("Sorted: %d -> %d", i, (m_pKeySet->get())[i] );
+#endif
+
+                    m_pSortIndex = NULL;
+                    beforeFirst(); // Go back to start
+                }
+                else  //we always need m_pKeySet now
+                    m_pKeySet = new OKeySet();
+
+                // Handle the DISTINCT case
+                if ( bDistinct && m_pKeySet.is() )
+                {
+                    OValueRow aSearchRow = new OValueVector( m_aRow->get().size() );
+
+                    for( OKeySet::Vector::size_type i = 0; i < m_pKeySet->get().size(); i++ )
+                    {
+                        fetchRow( (m_pKeySet->get())[i] );        // Fills m_aRow
+                        if ( matchRow( m_aRow, aSearchRow ) )
+                        {
+                            (m_pKeySet->get())[i] = 0;   // Marker for later to be removed
+                        }
+                        else
+                        {
+                            // They don't match, so it's not a duplicate.
+                            // Use the current Row as the next one to match against
+                            *aSearchRow = *m_aRow;
+                        }
+                    }
+                    // Now remove any keys marked with a 0
+                    m_pKeySet->get().erase(::std::remove_if(m_pKeySet->get().begin(),m_pKeySet->get().end()
+                                    ,::std::bind2nd(::std::equal_to<sal_Int32>(),0))
+                                     ,m_pKeySet->get().end());
+
+                }
+            }
+        }   break;
+
+        case SQL_STATEMENT_UPDATE:
+        case SQL_STATEMENT_DELETE:
+        case SQL_STATEMENT_INSERT:
+            break;
+        default:
+            m_pStatement->getOwnConnection()->throwSQLException( STR_STMT_TYPE_NOT_SUPPORTED, *this );
+            break;
+    }
+*/
+}
+
+// -----------------------------------------------------------------------------
+
+void OResultSet::setBoundedColumns(const OValueRow& _rRow,
+                                   const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns,
+                                   const Reference<XIndexAccess>& _xNames,
+                                   sal_Bool _bSetColumnMapping,
+                                   const Reference<XDatabaseMetaData>& _xMetaData,
+                                   ::std::vector<sal_Int32>& _rColMapping)
+{
+    ::comphelper::UStringMixEqual aCase(_xMetaData->supportsMixedCaseQuotedIdentifiers());
+
+    Reference<XPropertySet> xTableColumn;
+    ::rtl::OUString sTableColumnName, sSelectColumnRealName;
+
+    const ::rtl::OUString sName     = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
+    const ::rtl::OUString sRealName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME);
+
+    ::std::vector< ::rtl::OUString> aColumnNames;
+    aColumnNames.reserve(_rxColumns->get().size());
+    OValueVector::Vector::iterator aRowIter = _rRow->get().begin()+1;
+    for (sal_Int32 i=0; // the first column is the bookmark column
+         aRowIter != _rRow->get().end();
+            ++i, ++aRowIter
+        )
+    {
+        try
+        {
+            // get the table column and it's name
+            _xNames->getByIndex(i) >>= xTableColumn;
+            OSL_ENSURE(xTableColumn.is(), "OResultSet::setBoundedColumns: invalid table column!");
+            if (xTableColumn.is())
+                xTableColumn->getPropertyValue(sName) >>= sTableColumnName;
+            else
+                sTableColumnName = ::rtl::OUString();
+
+            // look if we have such a select column
+            // TODO: would like to have a O(log n) search here ...
+            sal_Int32 nColumnPos = 0;
+            for (   OSQLColumns::Vector::iterator aIter = _rxColumns->get().begin();
+                    aIter != _rxColumns->get().end();
+                    ++aIter,++nColumnPos
+                )
+            {
+                if ( nColumnPos < (sal_Int32)aColumnNames.size() )
+                    sSelectColumnRealName = aColumnNames[nColumnPos];
+                else
+                {
+                    if((*aIter)->getPropertySetInfo()->hasPropertyByName(sRealName))
+                        (*aIter)->getPropertyValue(sRealName) >>= sSelectColumnRealName;
+                    else
+                        (*aIter)->getPropertyValue(sName) >>= sSelectColumnRealName;
+                    aColumnNames.push_back(sSelectColumnRealName);
+                }
+
+                if (aCase(sTableColumnName, sSelectColumnRealName))
+                {
+                    if(_bSetColumnMapping)
+                    {
+                        sal_Int32 nSelectColumnPos = static_cast<sal_Int32>(aIter - _rxColumns->get().begin() + 1);
+                            // the getXXX methods are 1-based ...
+                        sal_Int32 nTableColumnPos = i + 1;
+                            // get first table column is the bookmark column
+                            // ...
+#if OSL_DEBUG_LEVEL > 0
+                        OSL_TRACE("Set Col Mapping: %d -> %d", nSelectColumnPos, nTableColumnPos );
+#endif
+                        _rColMapping[nSelectColumnPos] = nTableColumnPos;
+                    }
+
+                    aRowIter->setBound(sal_True);
+                    aRowIter->setTypeKind(DataType::VARCHAR);
+                }
+            }
+        }
+        catch (Exception&)
+        {
+            OSL_FAIL("OResultSet::setBoundedColumns: caught an Exception!");
+        }
+    }
+}
+
+
+// -----------------------------------------------------------------------------
+sal_Bool OResultSet::isCount() const
+{
+    return (m_pParseTree &&
+            m_pParseTree->count() > 2                                                       &&
+            SQL_ISRULE(m_pParseTree->getChild(2),scalar_exp_commalist)                      &&
+            SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0),derived_column)               &&
+            SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0)->getChild(0),general_set_fct) &&
+            m_pParseTree->getChild(2)->getChild(0)->getChild(0)->count() == 4
+            );
+}
+
+// -----------------------------------------------------------------------------
+//
+// Check for valid row in m_aQuery
+//
+sal_Bool OResultSet::validRow( sal_uInt32 /*nRow*/ )
+{
+    OSL_FAIL( "OResultSet::validRow() is not implemented" );
+
+/*
+    sal_Int32  nNumberOfRecords = m_aQuery.getRealRowCount();
+
+    while ( nRow > (sal_uInt32)nNumberOfRecords && !m_aQuery.queryComplete() ) {
+#if OSL_DEBUG_LEVEL > 0
+            OSL_TRACE("validRow: waiting...");
+#endif
+            m_aQuery.checkRowAvailable( nRow );
+            if ( m_aQuery.hadError() )
+            {
+                m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
+            }
+            nNumberOfRecords = m_aQuery.getRealRowCount();
+    }
+
+    if (( nRow == 0 ) ||
+        ( nRow > (sal_uInt32)nNumberOfRecords && m_aQuery.queryComplete()) ){
+        OSL_TRACE("validRow(%u): return False", nRow);
+        return sal_False;
+    }
+#if OSL_DEBUG_LEVEL > 0
+    OSL_TRACE("validRow(%u): return True", nRow);
+#endif
+*/
+    return sal_True;
+}
+sal_Bool OResultSet::fillKeySet(sal_Int32 nMaxCardNumber)
+{
+    impl_ensureKeySet();
+    if (m_CurrentRowCount < nMaxCardNumber)
+    {
+        sal_Int32   nKeyValue;
+        if ( (sal_Int32)m_pKeySet->get().capacity() < nMaxCardNumber )
+            m_pKeySet->get().reserve(nMaxCardNumber + 20 );
+
+        for (nKeyValue = m_CurrentRowCount+1; nKeyValue  <= nMaxCardNumber; nKeyValue ++)
+            m_pKeySet->get().push_back( nKeyValue );
+        m_CurrentRowCount = nMaxCardNumber;
+    }
+    return sal_True;
+}
+
+sal_Int32 OResultSet::deletedCount()
+{
+    impl_ensureKeySet();
+    return m_CurrentRowCount - static_cast<sal_Int32>(m_pKeySet->get().size());
+
+}
+// -----------------------------------------------------------------------------
+sal_Bool OResultSet::seekRow( eRowPosition /*pos*/, sal_Int32 /*nOffset*/ )
+{
+    OSL_FAIL( "OResultSet::seekRow() not omplemented" );
+/*
+    ResultSetEntryGuard aGuard( *this );
+    if ( !m_pKeySet.is() )
+        OSL_FAIL( "OResultSet::STR_ILLEGAL_MOVEMENT" );
+//        m_pStatement->getOwnConnection()->throwSQLException( STR_ILLEGAL_MOVEMENT, *this );
+
+    sal_Int32  nNumberOfRecords = m_aQuery.getRealRowCount();
+    sal_Int32  nRetrivedRows = currentRowCount();
+    sal_Int32  nCurPos = m_nRowPos;
+
+    OSL_TRACE("seekRow: nCurPos = %d", nCurPos );
+    switch( pos ) {
+        case NEXT_POS:
+            OSL_TRACE("seekRow: NEXT");
+            nCurPos++;
+            break;
+        case PRIOR_POS:
+            OSL_TRACE("seekRow: PRIOR");
+            if ( nCurPos > 0 )
+                nCurPos--;
+            break;
+
+        case FIRST_POS:
+            OSL_TRACE("seekRow: FIRST");
+            nCurPos = 1;
+            break;
+
+        case LAST_POS:
+            OSL_TRACE("seekRow: LAST");
+            nCurPos = nRetrivedRows;
+            break;
+        case ABSOLUTE_POS:
+            OSL_TRACE("seekRow: ABSOLUTE : %d", nOffset);
+            nCurPos = nOffset;
+            break;
+        case RELATIVE_POS:
+            OSL_TRACE("seekRow: RELATIVE : %d", nOffset);
+            nCurPos += sal_uInt32( nOffset );
+            break;
+    }
+
+    if ( nCurPos <= 0 ) {
+        m_nRowPos = 0;
+        OSL_TRACE("seekRow: return False, m_nRowPos = %u", m_nRowPos );
+        return sal_False;
+    }
+    sal_Int32 nCurCard = nCurPos;
+    if ( nCurPos < (sal_Int32)m_pKeySet->get().size() ) //The requested row is exist in m_pKeySet, so we just use it
+    {
+        nCurCard = (m_pKeySet->get())[nCurPos-1];
+    }
+    else    //The requested row has not been retrived until now. We should get the right card for it.
+        nCurCard = nCurPos + deletedCount();
+
+    while ( nCurCard > nNumberOfRecords && !m_aQuery.queryComplete() ) {
+            m_aQuery.checkRowAvailable( nCurCard );
+            if ( m_aQuery.hadError() )
+            {
+                m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
+            }
+            nNumberOfRecords = m_aQuery.getRealRowCount();
+    }
+
+    if ( nCurCard > nNumberOfRecords && m_aQuery.queryComplete()) {
+        fillKeySet(nNumberOfRecords);
+        m_nRowPos = static_cast<sal_uInt32>(m_pKeySet->get().size() + 1);
+        OSL_TRACE("seekRow: return False, m_nRowPos = %u", m_nRowPos );
+        return sal_False;
+    }
+    //Insert new retrived items for later use
+    fillKeySet(nNumberOfRecords);
+    m_nRowPos = (sal_uInt32)nCurPos;
+    OSL_TRACE("seekRow: return True, m_nRowPos = %u", m_nRowPos );
+    fetchCurrentRow();
+*/
+    return sal_True;
+}
+// -----------------------------------------------------------------------------
+void OResultSet::setColumnMapping(const ::std::vector<sal_Int32>& _aColumnMapping)
+{
+    m_aColMapping = _aColumnMapping;
+#if OSL_DEBUG_LEVEL > 0
+    for ( sal_uInt32 i = 0; i < m_aColMapping.size(); i++ )
+        OSL_TRACE("Set Mapped: %d -> %d", i, m_aColMapping[i] );
+#endif
+}
+// -----------------------------------------------------------------------------
+
+::com::sun::star::uno::Any OResultSet::getBookmark(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    OSL_TRACE("getBookmark, m_nRowPos = %u", m_nRowPos );
+    ResultSetEntryGuard aGuard( *this );
+    if ( fetchCurrentRow() == sal_False ) {
+//        m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
+        OSL_FAIL( "STR_ERROR_GET_ROW" );
+    }
+
+    OSL_ENSURE((!m_aRow->isDeleted()),"getBookmark called for deleted row");
+    return makeAny((sal_Int32)(m_aRow->get())[0]);
+}
+sal_Bool  OResultSet::moveToBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("moveToBookmark, bookmark = %u", comphelper::getINT32(bookmark) );
+    sal_Int32 nCardNum = comphelper::getINT32(bookmark);
+    m_nRowPos = getRowForCardNumber(nCardNum);
+    fetchCurrentRow();
+    return sal_True;
+}
+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)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("moveRelativeToBookmark, bookmark = %u rows= %u", comphelper::getINT32(bookmark),rows );
+    sal_Int32 nCardNum = comphelper::getINT32(bookmark);
+    m_nRowPos = getRowForCardNumber(nCardNum);
+    return seekRow(RELATIVE_POS,rows );
+}
+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)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("compareBookmarks, m_nRowPos = %u", m_nRowPos );
+        sal_Int32 nFirst=0;
+        sal_Int32 nSecond=0;
+        sal_Int32 nResult=0;
+
+        if ( !( lhs >>= nFirst ) || !( rhs >>= nSecond ) ) {
+            OSL_FAIL( "STR_INVALID_BOOKMARK" );
+//            m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this );
+        }
+
+    if(nFirst < nSecond)
+         nResult = -1;
+    else if(nFirst > nSecond)
+         nResult = 1;
+    else
+         nResult = 0;
+
+    return  nResult;
+}
+sal_Bool OResultSet::hasOrderedBookmarks(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("hasOrderedBookmarks, m_nRowPos = %u", m_nRowPos );
+    return sal_True;
+}
+sal_Int32 OResultSet::hashBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("hashBookmark, m_nRowPos = %u", m_nRowPos );
+    return  comphelper::getINT32(bookmark);
+}
+
+sal_Int32 OResultSet::getCurrentCardNumber()
+{
+    if ( ( m_nRowPos == 0 ) || !m_pKeySet.is() )
+        return 0;
+    if (m_pKeySet->get().size() < m_nRowPos)
+        return 0;
+    return (m_pKeySet->get())[m_nRowPos-1];
+}
+void OResultSet::checkPendingUpdate() throw(SQLException, RuntimeException)
+{
+    OSL_FAIL( "OResultSet::checkPendingUpdate() not implemented" );
+/*
+    OSL_TRACE("checkPendingUpdate, m_nRowPos = %u", m_nRowPos );
+    const sal_Int32 nCurrentRow = getCurrentCardNumber();
+
+    if ((m_nNewRow && nCurrentRow != m_nNewRow)
+        || ( m_nUpdatedRow && m_nUpdatedRow != nCurrentRow))
+    {
+        const ::rtl::OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
+                STR_COMMIT_ROW,
+                "$position$", ::rtl::OUString::valueOf(nCurrentRow)
+             ) );
+        ::dbtools::throwGenericSQLException(sError,*this);
+    }
+*/
+
+}
+void OResultSet::updateValue(sal_Int32 columnIndex ,const ORowSetValue& x) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("updateValue, m_nRowPos = %u", m_nRowPos );
+    ResultSetEntryGuard aGuard( *this );
+    if ( fetchCurrentRow() == sal_False ) {
+        //m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
+        OSL_FAIL( "STR_ERROR_GET_ROW" );
+    }
+
+    checkPendingUpdate();
+
+    checkIndex(columnIndex );
+    columnIndex = mapColumn(columnIndex);
+
+    (m_aRow->get())[columnIndex].setBound(sal_True);
+    (m_aRow->get())[columnIndex] = x;
+    m_nUpdatedRow = getCurrentCardNumber();
+//    m_RowStates = m_RowStates | RowStates_Updated;
+}
+// -----------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
+{
+    OSL_TRACE("updateNull, m_nRowPos = %u", m_nRowPos );
+    ResultSetEntryGuard aGuard( *this );
+    if ( fetchCurrentRow() == sal_False )
+//        m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
+        OSL_FAIL( "STR_ERROR_GET_ROW" );
+
+
+    checkPendingUpdate();
+    checkIndex(columnIndex );
+    columnIndex = mapColumn(columnIndex);
+
+    (m_aRow->get())[columnIndex].setBound(sal_True);
+    (m_aRow->get())[columnIndex].setNull();
+    m_nUpdatedRow = getCurrentCardNumber();
+//    m_RowStates = m_RowStates | RowStates_Updated;
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateLong( sal_Int32 /*columnIndex*/, sal_Int64 /*x*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XRowUpdate::updateLong", *this );
+}
+// -----------------------------------------------------------------------
+void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const ::rtl::OUString& x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException)
+{
+    updateValue(columnIndex,x);
+}
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+
+    if(!x.is())
+        ::dbtools::throwFunctionSequenceException(*this);
+
+    Sequence<sal_Int8> aSeq;
+    x->readBytes(aSeq,length);
+    updateValue(columnIndex,aSeq);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
+{
+    updateBinaryStream(columnIndex,x,length);
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) throw(SQLException, RuntimeException)
+{
+    if (!::dbtools::implUpdateObject(this, columnIndex, x))
+    {
+        const ::rtl::OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
+                STR_COLUMN_NOT_UPDATEABLE,
+                "$position$", ::rtl::OUString::valueOf(columnIndex)
+             ) );
+        ::dbtools::throwGenericSQLException(sError,*this);
+    } // if (!::dbtools::implUpdateObject(this, columnIndex, x))
+ }
+// -------------------------------------------------------------------------
+
+void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
+{
+    if (!::dbtools::implUpdateObject(this, columnIndex, x))
+    {
+        const ::rtl::OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
+                STR_COLUMN_NOT_UPDATEABLE,
+                "$position$", ::rtl::OUString::valueOf(columnIndex)
+             ) );
+        ::dbtools::throwGenericSQLException(sError,*this);
+    }
+}
+
+// XResultSetUpdate
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::insertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("insertRow in, m_nRowPos = %u", m_nRowPos );
+//    m_RowStates = RowStates_Inserted;
+    updateRow();
+    m_nOldRowPos = 0;
+    m_nNewRow = 0;
+    //m_aQuery.setRowStates(getCurrentCardNumber(),m_RowStates);
+    OSL_TRACE("insertRow out, m_nRowPos = %u", m_nRowPos );
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::updateRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    OSL_FAIL( "OResultSet::updateRow(  ) not implemented" );
+#if 0
+    OSL_TRACE("updateRow in, m_nRowPos = %u", m_nRowPos );
+    ResultSetEntryGuard aGuard( *this );
+    impl_ensureKeySet();
+
+    if (!m_nRowPos || m_pKeySet->get().size() < m_nRowPos )
+    {
+        OSL_FAIL( "STR_INVALID_ROW_UPDATE" );
+//        m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_ROW_UPDATE, *this );
+    }
+
+    const sal_Int32 nCurrentCard = getCurrentCardNumber();
+
+    if (!pushCard(nCurrentCard))
+    {
+        m_RowStates = RowStates_Error;
+        m_pStatement->getOwnConnection()->throwSQLException( STR_ROW_CAN_NOT_SAVE, *this );
+    }
+
+    if (!m_aQuery.commitRow(nCurrentCard))
+    {
+        m_RowStates = RowStates_Error;
+        m_nUpdatedRow = 0;
+        m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
+    }
+
+    m_nUpdatedRow = 0;
+    fetchCurrentRow();
+    OSL_TRACE("updateRow out, m_nRowPos = %u", m_nRowPos );
+#endif
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::deleteRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    OSL_FAIL( "OResultSet::deleteRow(  ) not implemented" );
+#if 0
+    OSL_TRACE("deleteRow, m_nRowPos = %u", m_nRowPos );
+    ResultSetEntryGuard aGuard( *this );
+    if (rowDeleted())
+        m_pStatement->getOwnConnection()->throwSQLException( STR_ROW_ALREADY_DELETED, *this );
+
+    const sal_Int32 nCurrentRow = getCurrentCardNumber();
+    //fetchRow(nCurrentRow);
+    if (!nCurrentRow)
+        m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
+
+    sal_Bool m_bRowDeleted = ( m_aQuery.deleteRow( nCurrentRow ) > 0 );
+    if (!m_bRowDeleted)
+        m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
+
+    m_aQuery.setRowStates(nCurrentRow,RowStates_Deleted);
+    m_pKeySet->get().erase(m_pKeySet->get().begin() + m_nRowPos -1);
+    m_RowStates = RowStates_Deleted;
+    OSL_TRACE("deleteRow out, m_nRowPos = %u", m_nRowPos );
+#endif
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::cancelRowUpdates(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    OSL_FAIL( "OResultSet::cancelRowUpdates(  ) not implemented" );
+#if 0
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("cancelRowUpdates, m_nRowPos = %u", m_nRowPos );
+    if (fetchRow(getCurrentCardNumber(),sal_True))  //force fetch current row will cause we lose all change to the current row
+        m_pStatement->getOwnConnection()->throwSQLException( STR_CAN_NOT_CANCEL_ROW_UPDATE, *this );
+#endif
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::moveToInsertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    OSL_FAIL( "OResultSet::moveToInsertRow(  ) not implemented" );
+#if 0
+    OSL_TRACE("moveToInsertRow in, m_nRowPos = %u", m_nRowPos );
+    ResultSetEntryGuard aGuard( *this );
+    m_nOldRowPos = m_nRowPos;
+
+    if (!m_nNewRow) //no new row now, insert one
+    {
+        checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
+        checkPendingUpdate();
+        if (rowUpdated())
+        {
+            if (m_nRowPos && !pushCard(getCurrentCardNumber()))
+                throw SQLException();
+        }
+        m_nNewRow = m_aQuery.createNewCard();
+        if (!m_nNewRow)
+            m_pStatement->getOwnConnection()->throwSQLException( STR_CAN_NOT_CREATE_ROW, *this );
+
+        m_RowStates = RowStates_Normal;
+        fillKeySet(m_nNewRow);
+    }
+    else
+        m_nUpdatedRow = 0;
+
+    m_nRowPos = static_cast<sal_uInt32>(m_pKeySet->get().size());
+    fetchCurrentRow();
+    OSL_TRACE("moveToInsertRow out, m_nRowPos = %u", m_nRowPos );
+#endif
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OResultSet::moveToCurrentRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    ResultSetEntryGuard aGuard( *this );
+    OSL_TRACE("moveToCurrentRow, m_nRowPos = %u", m_nRowPos );
+    if (rowInserted())
+    {
+        m_nRowPos = m_nOldRowPos;
+        fetchCurrentRow();
+    }
+}
+
+sal_Bool OResultSet::determineReadOnly()
+{
+    OSL_FAIL( "OResultSet::determineReadOnly(  ) not implemented" );
+
+    if (m_bIsReadOnly == -1)
+    {
+//        OConnection* xConnection = static_cast<OConnection*>(m_pStatement->getConnection().get());
+//        m_bIsReadOnly = !m_aQuery.isWritable(xConnection) || m_bIsAlwaysFalseQuery;
+    }
+
+    return m_bIsReadOnly != 0;
+}
+
+void OResultSet::setTable(OTable* _rTable)
+{
+    OSL_TRACE("In : setTable");
+    m_pTable = _rTable;
+    m_pTable->acquire();
+    m_xTableColumns = m_pTable->getColumns();
+    if(m_xTableColumns.is())
+        m_aColumnNames = m_xTableColumns->getElementNames();
+    OSL_TRACE("Out : setTable");
+}
+
+void OResultSet::setOrderByColumns(const ::std::vector<sal_Int32>& _aColumnOrderBy)
+{
+    m_aOrderbyColumnNumber = _aColumnOrderBy;
+}
+
+void OResultSet::setOrderByAscending(const ::std::vector<TAscendingOrder>& _aOrderbyAsc)
+{
+    m_aOrderbyAscending = _aOrderbyAsc;
+}
+Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows( const Sequence< Any >& /*rows*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XDeleteRows::deleteRows", *this );
+    return Sequence< sal_Int32 >();
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MResultSet.hxx b/connectivity/source/drivers/mork/MResultSet.hxx
new file mode 100644
index 000000000000..8f8245cc160f
--- /dev/null
+++ b/connectivity/source/drivers/mork/MResultSet.hxx
@@ -0,0 +1,357 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef CONNECTIVITY_SRESULTSET_HXX
+#define CONNECTIVITY_SRESULTSET_HXX
+
+#include <com/sun/star/sdbc/XResultSet.hpp>
+#include <com/sun/star/sdbc/XRow.hpp>
+#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
+#include <com/sun/star/sdbc/XCloseable.hpp>
+#include <com/sun/star/sdbc/XColumnLocate.hpp>
+#include <com/sun/star/util/XCancellable.hpp>
+#include <com/sun/star/sdbc/XWarningsSupplier.hpp>
+#include <com/sun/star/sdbc/XResultSetUpdate.hpp>
+#include <com/sun/star/sdbcx/XRowLocate.hpp>
+#include <com/sun/star/sdbcx/XDeleteRows.hpp>
+#include <com/sun/star/sdbc/XRowUpdate.hpp>
+#include <cppuhelper/compbase12.hxx>
+#include <comphelper/proparrhlp.hxx>
+#include "MStatement.hxx"
+#include "connectivity/CommonTools.hxx"
+#include "connectivity/FValue.hxx"
+#include "connectivity/sqliterator.hxx"
+#include "TSortIndex.hxx"
+
+namespace connectivity
+{
+    namespace mork
+    {
+
+        /*
+        **  java_sql_ResultSet
+        */
+        typedef ::cppu::WeakComponentImplHelper12<      ::com::sun::star::sdbc::XResultSet,
+                                                        ::com::sun::star::sdbc::XRow,
+                                                        ::com::sun::star::sdbc::XResultSetMetaDataSupplier,
+                                                        ::com::sun::star::util::XCancellable,
+                                                        ::com::sun::star::sdbc::XWarningsSupplier,
+                                                        ::com::sun::star::sdbc::XCloseable,
+                                                        ::com::sun::star::sdbc::XColumnLocate,
+                                                        ::com::sun::star::sdbc::XResultSetUpdate,
+                                                        ::com::sun::star::sdbc::XRowUpdate,
+                                                        ::com::sun::star::sdbcx::XRowLocate,
+                                                        ::com::sun::star::sdbcx::XDeleteRows,
+                                                        ::com::sun::star::lang::XServiceInfo> OResultSet_BASE;
+
+
+        typedef sal_Int64 TVoidPtr;
+        typedef ::std::allocator< TVoidPtr >    TVoidAlloc;
+        typedef ::std::vector<TVoidPtr>         TVoidVector;
+
+        class OResultSet :  public  comphelper::OBaseMutex,
+                            public  OResultSet_BASE,
+                            public  ::cppu::OPropertySetHelper,
+                            public  ::comphelper::OPropertyArrayUsageHelper<OResultSet>
+        {
+        protected:
+            OCommonStatement*                           m_pStatement;
+            ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface>            m_xStatement;
+            ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSetMetaData>   m_xMetaData;
+            sal_uInt32                                  m_nRowPos;
+            sal_uInt32                                  m_nOldRowPos;
+            sal_Bool                                    m_bWasNull;
+            sal_Int32                                   m_nFetchSize;
+            sal_Int32                                   m_nResultSetType;
+            sal_Int32                                   m_nFetchDirection;
+            sal_Int32                                   m_nResultSetConcurrency;
+
+
+
+            ::boost::shared_ptr< ::connectivity::OSQLParseTreeIterator >
+                                                        m_pSQLIterator;
+            const connectivity::OSQLParseNode*          m_pParseTree;
+
+            // OPropertyArrayUsageHelper
+            virtual ::cppu::IPropertyArrayHelper* createArrayHelper( ) const;
+            // OPropertySetHelper
+            virtual ::cppu::IPropertyArrayHelper & SAL_CALL getInfoHelper();
+
+            virtual sal_Bool SAL_CALL convertFastPropertyValue(
+                                ::com::sun::star::uno::Any & rConvertedValue,
+                                ::com::sun::star::uno::Any & rOldValue,
+                                sal_Int32 nHandle,
+                                const ::com::sun::star::uno::Any& rValue )
+                                    throw (::com::sun::star::lang::IllegalArgumentException);
+            virtual void SAL_CALL setFastPropertyValue_NoBroadcast(
+                                    sal_Int32 nHandle,
+                                    const ::com::sun::star::uno::Any& rValue
+                                     )
+                                     throw (::com::sun::star::uno::Exception);
+            virtual void SAL_CALL getFastPropertyValue(
+                                    ::com::sun::star::uno::Any& rValue,
+                                    sal_Int32 nHandle
+                                         ) const;
+
+            // you can't delete objects of this type
+            virtual ~OResultSet();
+        public:
+            DECLARE_SERVICE_INFO();
+
+            OResultSet(OCommonStatement* pStmt, const ::boost::shared_ptr< ::connectivity::OSQLParseTreeIterator >& _pSQLIterator );
+
+
+            ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > operator *()
+            {
+                return ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(*(OResultSet_BASE*)this);
+            }
+
+            // ::cppu::OComponentHelper
+            virtual void SAL_CALL disposing(void);
+            // XInterface
+            virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL acquire() throw();
+            virtual void SAL_CALL release() throw();
+            //XTypeProvider
+            virtual ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes(  ) throw(::com::sun::star::uno::RuntimeException);
+            // XPropertySet
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException);
+            // XResultSet
+            virtual sal_Bool SAL_CALL next(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL isBeforeFirst(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL isAfterLast(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL isFirst(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL isLast(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL beforeFirst(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL afterLast(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL first(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL last(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int32 SAL_CALL getRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL absolute( sal_Int32 row ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL relative( sal_Int32 rows ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL previous(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL refreshRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL rowUpdated(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL rowInserted(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL rowDeleted(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL getStatement(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XRow
+            virtual sal_Bool SAL_CALL wasNull(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::rtl::OUString SAL_CALL getString( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL getBoolean( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int8 SAL_CALL getByte( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int16 SAL_CALL getShort( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int32 SAL_CALL getInt( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int64 SAL_CALL getLong( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual float SAL_CALL getFloat( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual double SAL_CALL getDouble( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getBytes( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::util::Date SAL_CALL getDate( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::util::Time SAL_CALL getTime( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::util::DateTime SAL_CALL getTimestamp( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > SAL_CALL getBinaryStream( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > SAL_CALL getCharacterStream( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Any SAL_CALL getObject( sal_Int32 columnIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >& typeMap ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XRef > SAL_CALL getRef( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XBlob > SAL_CALL getBlob( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XClob > SAL_CALL getClob( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XArray > SAL_CALL getArray( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XResultSetMetaDataSupplier
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSetMetaData > SAL_CALL getMetaData(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XCancellable
+            virtual void SAL_CALL cancel(  ) throw(::com::sun::star::uno::RuntimeException);
+            // XCloseable
+            virtual void SAL_CALL close(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XWarningsSupplier
+            virtual ::com::sun::star::uno::Any SAL_CALL getWarnings(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL clearWarnings(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XColumnLocate
+            virtual sal_Int32 SAL_CALL findColumn( const ::rtl::OUString& columnName ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+
+            // XResultSetUpdate
+            virtual void SAL_CALL insertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL deleteRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL cancelRowUpdates(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL moveToInsertRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL moveToCurrentRow(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XRowUpdate
+            virtual void SAL_CALL updateNull( sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateBoolean( sal_Int32 columnIndex, sal_Bool x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateLong( sal_Int32 columnIndex, sal_Int64 x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateFloat( sal_Int32 columnIndex, float x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateDouble( sal_Int32 columnIndex, double x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateString( sal_Int32 columnIndex, const ::rtl::OUString& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateBytes( sal_Int32 columnIndex, const ::com::sun::star::uno::Sequence< sal_Int8 >& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateDate( sal_Int32 columnIndex, const ::com::sun::star::util::Date& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateTime( sal_Int32 columnIndex, const ::com::sun::star::util::Time& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateTimestamp( sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateBinaryStream( sal_Int32 columnIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateCharacterStream( sal_Int32 columnIndex, const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateObject( sal_Int32 columnIndex, const ::com::sun::star::uno::Any& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL updateNumericObject( sal_Int32 columnIndex, const ::com::sun::star::uno::Any& x, sal_Int32 scale ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XRowLocate
+            virtual ::com::sun::star::uno::Any SAL_CALL getBookmark(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL moveToBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL moveRelativeToBookmark( const ::com::sun::star::uno::Any& bookmark, sal_Int32 rows ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int32 SAL_CALL compareBookmarks( const ::com::sun::star::uno::Any& first, const ::com::sun::star::uno::Any& second ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Bool SAL_CALL hasOrderedBookmarks(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual sal_Int32 SAL_CALL hashBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XDeleteRows
+            virtual ::com::sun::star::uno::Sequence< sal_Int32 > SAL_CALL deleteRows( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& rows ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+
+protected:
+            //MQuery                   m_aQuery;
+            OTable*                  m_pTable;
+            sal_Int32                   m_CurrentRowCount;
+            ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >
+                                     m_xTableColumns;
+
+            ::std::vector<sal_Int32> m_aColMapping; // pos 0 is unused so we don't have to decrement 1 everytime
+            ::std::vector<sal_Int32> m_aOrderbyColumnNumber;
+            ::std::vector<TAscendingOrder>  m_aOrderbyAscending;
+            ::com::sun::star::uno::Sequence< ::rtl::OUString> m_aColumnNames;
+            OValueRow                m_aRow;
+            OValueRow                m_aParameterRow;
+            ::std::vector< ::rtl::OUString> m_aAttributeStrings;
+            sal_Int32                m_nParamIndex;
+            sal_Bool                 m_bIsAlwaysFalseQuery;
+            ::rtl::Reference<OKeySet>     m_pKeySet;
+            OSortIndex*              m_pSortIndex;
+            sal_Int32                 m_nNewRow;        //inserted row
+            sal_Int32                     m_nUpdatedRow;    //updated row
+            sal_Int32                 m_RowStates;
+            sal_Int32                     m_bIsReadOnly;
+            inline void resetParameters() { m_nParamIndex = 0; }
+
+            ::rtl::Reference<connectivity::OSQLColumns>  m_xColumns; // this are the select columns
+            ::rtl::Reference<connectivity::OSQLColumns>  m_xParamColumns;
+
+            void parseParameter( const OSQLParseNode* pNode, rtl::OUString& rMatchString );
+            void fillRowData() throw( ::com::sun::star::sdbc::SQLException );
+//            void analyseWhereClause( const OSQLParseNode*                 parseTree,
+//                                     MQueryExpression                    &queryExpression);
+
+            sal_Bool isCount() const;
+
+            // XXX sal_Bool IsSorted() const { return !m_aOrderbyColumnNumber.empty() && m_aOrderbyColumnNumber[0] != STRING_NOTFOUND ;}
+            sal_Bool IsSorted() const { return !m_aOrderbyColumnNumber.empty(); }
+
+            enum eRowPosition {
+                NEXT_POS, PRIOR_POS, FIRST_POS, LAST_POS, ABSOLUTE_POS, RELATIVE_POS
+            };
+
+            sal_uInt32  currentRowCount();
+
+            sal_Bool fetchRow(sal_Int32 rowIndex,sal_Bool bForceReload=sal_False) throw( ::com::sun::star::sdbc::SQLException,
+                                                          ::com::sun::star::uno::RuntimeException);
+            sal_Bool fetchCurrentRow() throw( ::com::sun::star::sdbc::SQLException,
+                                                          ::com::sun::star::uno::RuntimeException);
+            sal_Bool pushCard(sal_uInt32 rowIndex) throw( ::com::sun::star::sdbc::SQLException,
+                                                          ::com::sun::star::uno::RuntimeException);
+            sal_Bool validRow( sal_uInt32 nRow );
+            sal_Bool seekRow( eRowPosition pos, sal_Int32 nOffset = 0 );
+            sal_Int32 deletedCount();
+            sal_Bool fillKeySet(sal_Int32 nMaxCardNumber);  //When we get new rows, fill the m_pKeySet items for them
+            sal_Int32 getRowForCardNumber(sal_Int32 nCardNum);
+            const ORowSetValue& getValue(sal_Int32 rowIndex, sal_Int32 columnIndex)
+                throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+
+            void updateValue(sal_Int32 columnIndex,const ORowSetValue& x ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            void checkPendingUpdate() throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            sal_Int32 getCurrentCardNumber();
+
+public:
+             sal_Bool determineReadOnly();
+            // MozAddressbook Specific methods
+            void SAL_CALL executeQuery() throw( ::com::sun::star::sdbc::SQLException,
+                                                ::com::sun::star::uno::RuntimeException);
+
+            void setTable(OTable* _rTable);
+
+            void setParameterRow(const OValueRow& _rParaRow)
+                      { m_aParameterRow = _rParaRow; }
+
+            void setParameterColumns(const ::rtl::Reference<connectivity::OSQLColumns>& _xParamColumns)
+                      { m_xParamColumns = _xParamColumns; }
+
+            void setBindingRow(const OValueRow& _aRow)
+                      { m_aRow = _aRow; }
+
+            void setColumnMapping(const ::std::vector<sal_Int32>& _aColumnMapping);
+
+            void setOrderByColumns(const ::std::vector<sal_Int32>& _aColumnOrderBy);
+
+            void setOrderByAscending(const ::std::vector<TAscendingOrder>& _aOrderbyAsc);
+
+            inline sal_Int32 mapColumn(sal_Int32 column);
+
+            void checkIndex(sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException);
+
+            static void setBoundedColumns(
+                const OValueRow& _rRow,
+                const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns,
+                const ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexAccess>& _xNames,
+                sal_Bool _bSetColumnMapping,
+                const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XDatabaseMetaData>& _xMetaData,
+                ::std::vector<sal_Int32>& _rColMapping);
+
+            ::osl::Mutex&   getMutex() { return m_aMutex; }
+            void            methodEntry();
+
+            private:
+                inline void impl_ensureKeySet()
+                {
+                    if ( !m_pKeySet.is() )
+                        m_pKeySet = new OKeySet();
+                }
+
+        protected:
+            using OPropertySetHelper::getFastPropertyValue;
+        };
+
+        inline sal_Int32 OResultSet::mapColumn(sal_Int32 column)
+        {
+            sal_Int32   map = column;
+
+            OSL_ENSURE(column > 0, "OResultSet::mapColumn: invalid column index!");
+                // the first column (index 0) is for convenience only. The
+                // first real select column is no 1.
+            if ((column > 0) && (column < (sal_Int32)m_aColMapping.size()))
+                map = m_aColMapping[column];
+
+            return map;
+        }
+
+        class ResultSetEntryGuard : public ::osl::MutexGuard
+        {
+        public:
+            ResultSetEntryGuard( OResultSet& _rRS ) : ::osl::MutexGuard( _rRS.getMutex() )
+            {
+                _rRS.methodEntry();
+            }
+        };
+
+    }
+}
+#endif // CONNECTIVITY_SRESULTSET_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MResultSetMetaData.cxx b/connectivity/source/drivers/mork/MResultSetMetaData.cxx
new file mode 100644
index 000000000000..581e9305a2c9
--- /dev/null
+++ b/connectivity/source/drivers/mork/MResultSetMetaData.cxx
@@ -0,0 +1,205 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "connectivity/dbexception.hxx"
+#include "connectivity/dbtools.hxx"
+#include <comphelper/types.hxx>
+#include <comphelper/extract.hxx>
+#include <cppuhelper/typeprovider.hxx>
+#include <tools/diagnose_ex.h>
+#include "MResultSetMetaData.hxx"
+#include <com/sun/star/sdbc/DataType.hpp>
+
+using namespace connectivity::mork;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::sdbc;
+using namespace com::sun::star::beans;
+using namespace ::dbtools;
+using namespace ::comphelper;
+
+// -------------------------------------------------------------------------
+OResultSetMetaData::~OResultSetMetaData()
+{
+   m_xColumns = NULL;
+}
+
+// -----------------------------------------------------------------------------
+void OResultSetMetaData::checkColumnIndex(sal_Int32 column)  throw(SQLException, RuntimeException)
+{
+    if(column <= 0 || column > (sal_Int32)(sal_Int32)m_xColumns->get().size())
+        throwInvalidIndexException(*this);
+}
+// -------------------------------------------------------------------------
+sal_Int32 SAL_CALL OResultSetMetaData::getColumnDisplaySize( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    return getPrecision(column);
+}
+// -------------------------------------------------------------------------
+
+sal_Int32 SAL_CALL OResultSetMetaData::getColumnType( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return DataType::VARCHAR; // at the moment there exists only this type
+}
+// -------------------------------------------------------------------------
+
+sal_Int32 SAL_CALL OResultSetMetaData::getColumnCount(  ) throw(SQLException, RuntimeException)
+{
+    return static_cast<sal_Int32>((m_xColumns->get()).size());
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSetMetaData::isCaseSensitive( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return sal_False;
+}
+// -------------------------------------------------------------------------
+
+::rtl::OUString SAL_CALL OResultSetMetaData::getSchemaName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return ::rtl::OUString();
+}
+// -------------------------------------------------------------------------
+
+::rtl::OUString SAL_CALL OResultSetMetaData::getColumnName( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    checkColumnIndex(column);
+
+    ::rtl::OUString sColumnName;
+    try
+    {
+        Reference< XPropertySet > xColumnProps( (m_xColumns->get())[column-1], UNO_QUERY_THROW );
+        OSL_VERIFY( xColumnProps->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_NAME ) ) >>= sColumnName );
+    }
+    catch( const Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION();
+    }
+    return sColumnName;
+}
+// -------------------------------------------------------------------------
+::rtl::OUString SAL_CALL OResultSetMetaData::getTableName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return m_aTableName;
+}
+// -------------------------------------------------------------------------
+::rtl::OUString SAL_CALL OResultSetMetaData::getCatalogName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return ::rtl::OUString();
+}
+// -------------------------------------------------------------------------
+::rtl::OUString SAL_CALL OResultSetMetaData::getColumnTypeName( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    checkColumnIndex(column);
+    return getString((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME)));
+}
+// -------------------------------------------------------------------------
+::rtl::OUString SAL_CALL OResultSetMetaData::getColumnLabel( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    return getColumnName(column);
+}
+// -------------------------------------------------------------------------
+::rtl::OUString SAL_CALL OResultSetMetaData::getColumnServiceName( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return ::rtl::OUString();
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSetMetaData::isCurrency( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    checkColumnIndex(column);
+    return getBOOL((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)));
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSetMetaData::isAutoIncrement( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return sal_False;
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSetMetaData::isSigned( sal_Int32 /*column*/ ) throw(SQLException, RuntimeException)
+{
+    return sal_False;
+}
+// -------------------------------------------------------------------------
+sal_Int32 SAL_CALL OResultSetMetaData::getPrecision( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    checkColumnIndex(column);
+    return getINT32((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)));
+}
+// -------------------------------------------------------------------------
+sal_Int32 SAL_CALL OResultSetMetaData::getScale( sal_Int32 column ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
+{
+    checkColumnIndex(column);
+    return getINT32((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE)));
+}
+// -------------------------------------------------------------------------
+
+sal_Int32 SAL_CALL OResultSetMetaData::isNullable( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    checkColumnIndex(column);
+    return getINT32((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE)));
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSetMetaData::isSearchable( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    ::rtl::OUString sColumnName( getColumnName( column ) );
+
+    if ( !m_pTable || !m_pTable->getConnection() )
+    {
+        OSL_FAIL( "OResultSetMetaData::isSearchable: suspicious: called without table or connection!" );
+        return sal_False;
+    }
+
+#if 0
+    if ( m_pTable->getConnection()->isLDAP() )
+    {
+        const OColumnAlias& aAliases( m_pTable->getConnection()->getColumnAlias() );
+        if ( !aAliases.isColumnSearchable( sColumnName ) )
+            return sal_False;
+    }
+#endif
+
+    return sal_True;
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSetMetaData::isReadOnly( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    checkColumnIndex(column);
+    sal_Bool bReadOnly = (m_xColumns->get())[column-1]->getPropertySetInfo()->hasPropertyByName(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FUNCTION)) &&
+        ::cppu::any2bool((m_xColumns->get())[column-1]->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FUNCTION)));
+
+    return m_bReadOnly || bReadOnly || m_pTable->isReadOnly();
+}
+// -------------------------------------------------------------------------
+
+sal_Bool SAL_CALL OResultSetMetaData::isDefinitelyWritable( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    return !isReadOnly(column);
+}
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OResultSetMetaData::isWritable( sal_Int32 column ) throw(SQLException, RuntimeException)
+{
+    return !isReadOnly(column);
+}
+// -------------------------------------------------------------------------
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MStatement.cxx b/connectivity/source/drivers/mork/MStatement.cxx
new file mode 100644
index 000000000000..dbbb78bc36bd
--- /dev/null
+++ b/connectivity/source/drivers/mork/MStatement.cxx
@@ -0,0 +1,559 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <stdio.h>
+#include <osl/diagnose.h>
+#include <comphelper/property.hxx>
+#include <comphelper/uno3.hxx>
+#include <osl/thread.h>
+#include <tools/diagnose_ex.h>
+#include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
+#include <com/sun/star/sdbc/ResultSetType.hpp>
+#include <com/sun/star/sdbc/FetchDirection.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/typeprovider.hxx>
+#include <comphelper/extract.hxx>
+#include <comphelper/types.hxx>
+#include <connectivity/dbexception.hxx>
+#include <com/sun/star/container/XIndexAccess.hpp>
+
+#include <algorithm>
+
+#include "diagnose_ex.h"
+#include "MDriver.hxx"
+#include "MStatement.hxx"
+#include "MConnection.hxx"
+#include "MResultSet.hxx"
+#include "MDatabaseMetaData.hxx"
+
+#if OSL_DEBUG_LEVEL > 0
+# define OUtoCStr( x ) ( ::rtl::OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
+#else /* OSL_DEBUG_LEVEL */
+# define OUtoCStr( x ) ("dummy")
+#endif /* OSL_DEBUG_LEVEL */
+
+static ::osl::Mutex m_ThreadMutex;
+
+using namespace ::comphelper;
+using namespace connectivity::mork;
+using namespace connectivity;
+//------------------------------------------------------------------------------
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::sdbc;
+using namespace com::sun::star::container;
+using namespace com::sun::star::io;
+using namespace com::sun::star::util;
+//------------------------------------------------------------------------------
+OCommonStatement::OCommonStatement(OConnection* _pConnection )
+    :OCommonStatement_IBASE(m_aMutex)
+    ,OPropertySetHelper(OCommonStatement_IBASE::rBHelper)
+    ,OCommonStatement_SBASE((::cppu::OWeakObject*)_pConnection, this)
+    ,m_xDBMetaData(_pConnection->getMetaData())
+    ,m_pTable(NULL)
+    ,m_pConnection(_pConnection)
+    ,m_aParser(NULL)//_pConnection->getDriver()->getMSFactory())
+     // TODO
+    ,m_pSQLIterator( new OSQLParseTreeIterator( _pConnection, NULL/*_pConnection->createCatalog()->getTables()*/, m_aParser, NULL ) )
+    ,m_pParseTree(NULL)
+    ,rBHelper(OCommonStatement_IBASE::rBHelper)
+{
+    m_pConnection->acquire();
+    OSL_TRACE("In/Out: OCommonStatement::OCommonStatement" );
+}
+// -----------------------------------------------------------------------------
+OCommonStatement::~OCommonStatement()
+{
+}
+
+//------------------------------------------------------------------------------
+void OCommonStatement::disposing()
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    clearWarnings();
+    clearCachedResultSet();
+
+    if (m_pConnection)
+        m_pConnection->release();
+    m_pConnection = NULL;
+
+    m_pSQLIterator->dispose();
+
+    dispose_ChildImpl();
+    OCommonStatement_IBASE::disposing();
+}
+//-----------------------------------------------------------------------------
+Any SAL_CALL OCommonStatement::queryInterface( const Type & rType ) throw(RuntimeException)
+{
+    Any aRet = OCommonStatement_IBASE::queryInterface(rType);
+    if(!aRet.hasValue())
+        aRet = OPropertySetHelper::queryInterface(rType);
+    return aRet;
+}
+// -------------------------------------------------------------------------
+Sequence< Type > SAL_CALL OCommonStatement::getTypes(  ) throw(RuntimeException)
+{
+    ::cppu::OTypeCollection aTypes( ::getCppuType( (const Reference< XMultiPropertySet > *)0 ),
+                                    ::getCppuType( (const Reference< XFastPropertySet > *)0 ),
+                                    ::getCppuType( (const Reference< XPropertySet > *)0 ));
+
+    return ::comphelper::concatSequences(aTypes.getTypes(),OCommonStatement_IBASE::getTypes());
+}
+// -------------------------------------------------------------------------
+void SAL_CALL OCommonStatement::close(  ) throw(SQLException, RuntimeException)
+{
+    {
+        ::osl::MutexGuard aGuard( m_aMutex );
+        checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+    }
+    dispose();
+}
+
+
+// -------------------------------------------------------------------------
+void OCommonStatement::createTable( ) throw ( SQLException, RuntimeException )
+{
+/*
+    if(m_pParseTree)
+    {
+        ::rtl::Reference<connectivity::OSQLColumns> xCreateColumn;
+        if (m_pSQLIterator->getStatementType() == SQL_STATEMENT_CREATE_TABLE)
+        {
+            const OSQLTables& xTabs = m_pSQLIterator->getTables();
+            OSL_ENSURE( !xTabs.empty(), "Need a Table");
+            ::rtl::OUString ouTableName=xTabs.begin()->first;
+            xCreateColumn     = m_pSQLIterator->getCreateColumns();
+            OSL_ENSURE(xCreateColumn.is(), "Need the Columns!!");
+
+            const OColumnAlias& aColumnAlias = m_pConnection->getColumnAlias();
+
+            OSQLColumns::Vector::const_iterator aIter = xCreateColumn->get().begin();
+            const ::rtl::OUString sProprtyName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
+            ::rtl::OUString sName;
+            for (sal_Int32 i = 1; aIter != xCreateColumn->get().end();++aIter, i++)
+            {
+                (*aIter)->getPropertyValue(sProprtyName) >>= sName;
+                if ( !aColumnAlias.hasAlias( sName ) )
+                {
+
+                    const ::rtl::OUString sError( getOwnConnection()->getResources().getResourceStringWithSubstitution(
+                            STR_INVALID_COLUMNNAME,
+                            "$columnname$", sName
+                         ) );
+                    ::dbtools::throwGenericSQLException(sError,*this);
+                }
+            }
+            MDatabaseMetaDataHelper     _aDbHelper;
+            if (!_aDbHelper.NewAddressBook(m_pConnection,ouTableName))
+            {
+                getOwnConnection()->throwSQLException( _aDbHelper.getError(), *this );
+            }
+            m_pSQLIterator.reset( new ::connectivity::OSQLParseTreeIterator(
+                m_pConnection, m_pConnection->createCatalog()->getTables(), m_aParser, NULL ) );
+        }
+
+    }
+    else
+        getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
+*/
+}
+// -------------------------------------------------------------------------
+OCommonStatement::StatementType OCommonStatement::parseSql( const ::rtl::OUString& sql , sal_Bool bAdjusted)
+    throw ( SQLException, RuntimeException )
+{
+    ::rtl::OUString aErr;
+
+    m_pParseTree = m_aParser.parseTree(aErr,sql);
+
+#if OSL_DEBUG_LEVEL > 0
+    {
+        const char* str = OUtoCStr(sql);
+        OSL_UNUSED( str );
+        OSL_TRACE("ParseSQL: %s", OUtoCStr( sql ) );
+    }
+#endif // OSL_DEBUG_LEVEL
+
+    if(m_pParseTree)
+    {
+        m_pSQLIterator->setParseTree(m_pParseTree);
+        m_pSQLIterator->traverseAll();
+        const OSQLTables& xTabs = m_pSQLIterator->getTables();
+
+        // TODO
+        SAL_WARN("connectivity.mork", "STR_QUERY_AT_LEAST_ONE_TABLES!");
+        // if(xTabs.empty())
+        //    getOwnConnection()->throwSQLException( STR_QUERY_AT_LEAST_ONE_TABLES, *this );
+
+#if OSL_DEBUG_LEVEL > 0
+        OSQLTables::const_iterator citer;
+        for( citer = xTabs.begin(); citer != xTabs.end(); ++citer ) {
+            OSL_TRACE("SELECT Table : %s", OUtoCStr(citer->first) );
+        }
+#endif
+
+        Reference<XIndexAccess> xNames;
+        switch(m_pSQLIterator->getStatementType())
+        {
+        case SQL_STATEMENT_SELECT:
+
+            // at this moment we support only one table per select statement
+
+            OSL_ENSURE( xTabs.begin() != xTabs.end(), "Need a Table");
+
+            m_pTable = static_cast< OTable* > (xTabs.begin()->second.get());
+            m_xColNames     = m_pTable->getColumns();
+            xNames = Reference<XIndexAccess>(m_xColNames,UNO_QUERY);
+            // set the binding of the resultrow
+            m_aRow          = new OValueVector(xNames->getCount());
+            (m_aRow->get())[0].setBound(sal_True);
+            ::std::for_each(m_aRow->get().begin()+1,m_aRow->get().end(),TSetBound(sal_False));
+            // create the column mapping
+            createColumnMapping();
+
+            analyseSQL();
+            return eSelect;
+
+        case SQL_STATEMENT_CREATE_TABLE:
+            createTable();
+            return eCreateTable;
+
+        default:
+            break;
+        }
+    }
+    else if(!bAdjusted) //Our sql parser does not support a statement like "create table foo"
+                        // So we append ("E-mail" varchar) to the last of it to make it work
+    {
+        return parseSql(sql + ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("(""E-mail"" caracter)")),sal_True);
+    }
+
+    // TODO:
+    SAL_WARN("connectivity.mork", "STR_QUERY_TOO_COMPLEX!");
+    //getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
+    OSL_FAIL( "OCommonStatement::parseSql: unreachable!" );
+    return eSelect;
+
+}
+// -------------------------------------------------------------------------
+Reference< XResultSet > OCommonStatement::impl_executeCurrentQuery()
+{
+    clearCachedResultSet();
+
+    ::rtl::Reference< OResultSet > pResult( new OResultSet( this, m_pSQLIterator ) );
+    initializeResultSet( pResult.get() );
+
+    pResult->executeQuery();
+    cacheResultSet( pResult );  // only cache if we survived the execution
+
+    return pResult.get();
+
+}
+
+// -------------------------------------------------------------------------
+void OCommonStatement::initializeResultSet( OResultSet* _pResult )
+{
+    ENSURE_OR_THROW( _pResult, "invalid result set" );
+
+    _pResult->setColumnMapping(m_aColMapping);
+    _pResult->setOrderByColumns(m_aOrderbyColumnNumber);
+    _pResult->setOrderByAscending(m_aOrderbyAscending);
+    _pResult->setBindingRow(m_aRow);
+    _pResult->setTable(m_pTable);
+}
+
+// -------------------------------------------------------------------------
+void OCommonStatement::clearCachedResultSet()
+{
+    Reference< XResultSet > xResultSet( m_xResultSet.get(), UNO_QUERY );
+    if ( !xResultSet.is() )
+        return;
+
+    try
+    {
+        Reference< XCloseable > xCloseable( xResultSet, UNO_QUERY_THROW );
+        xCloseable->close();
+    }
+    catch( const DisposedException& )
+    {
+        DBG_UNHANDLED_EXCEPTION();
+    }
+
+    m_xResultSet = Reference< XResultSet >();
+}
+
+// -------------------------------------------------------------------------
+void OCommonStatement::cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult )
+{
+    ENSURE_OR_THROW( _pResult.is(), "invalid result set" );
+    m_xResultSet = Reference< XResultSet >( _pResult.get() );
+}
+
+// -------------------------------------------------------------------------
+sal_Bool SAL_CALL OCommonStatement::execute( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    OSL_TRACE("Statement::execute( %s )", OUtoCStr( sql ) );
+
+    Reference< XResultSet > xRS = executeQuery( sql );
+    // returns true when a resultset is available
+    return xRS.is();
+}
+// -------------------------------------------------------------------------
+
+Reference< XResultSet > SAL_CALL OCommonStatement::executeQuery( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_ThreadMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    OSL_TRACE("Statement::executeQuery( %s )", OUtoCStr( sql ) );
+
+    // parse the statement
+    StatementType eStatementType = parseSql( sql );
+    if ( eStatementType != eSelect )
+        return NULL;
+
+    return impl_executeCurrentQuery();
+}
+// -------------------------------------------------------------------------
+
+Reference< XConnection > SAL_CALL OCommonStatement::getConnection(  ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    // just return our connection here
+    return (Reference< XConnection >)m_pConnection;
+}
+// -----------------------------------------------------------------------------
+Any SAL_CALL OStatement::queryInterface( const Type & rType ) throw(RuntimeException)
+{
+    Any aRet = ::cppu::queryInterface(rType,static_cast< XServiceInfo*> (this));
+    if(!aRet.hasValue())
+        aRet = OCommonStatement::queryInterface(rType);
+    return aRet;
+}
+// -------------------------------------------------------------------------
+sal_Int32 SAL_CALL OCommonStatement::executeUpdate( const ::rtl::OUString& /*sql*/ ) throw(SQLException, RuntimeException)
+{
+    ::dbtools::throwFeatureNotImplementedException( "XStatement::executeUpdate", *this );
+    return 0;
+
+}
+// -------------------------------------------------------------------------
+Any SAL_CALL OCommonStatement::getWarnings(  ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+    return makeAny(m_aLastWarning);
+}
+// -------------------------------------------------------------------------
+
+// -------------------------------------------------------------------------
+void SAL_CALL OCommonStatement::clearWarnings(  ) throw(SQLException, RuntimeException)
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OCommonStatement_IBASE::rBHelper.bDisposed);
+
+
+    m_aLastWarning = SQLWarning();
+}
+// -------------------------------------------------------------------------
+::cppu::IPropertyArrayHelper* OCommonStatement::createArrayHelper( ) const
+{
+    // this properties are define by the service resultset
+    // they must in alphabetic order
+    Sequence< Property > aProps(9);
+    Property* pProperties = aProps.getArray();
+    sal_Int32 nPos = 0;
+    DECL_PROP0(CURSORNAME,  ::rtl::OUString);
+    DECL_BOOL_PROP0(ESCAPEPROCESSING);
+    DECL_PROP0(FETCHDIRECTION,sal_Int32);
+    DECL_PROP0(FETCHSIZE,   sal_Int32);
+    DECL_PROP0(MAXFIELDSIZE,sal_Int32);
+    DECL_PROP0(MAXROWS,     sal_Int32);
+    DECL_PROP0(QUERYTIMEOUT,sal_Int32);
+    DECL_PROP0(RESULTSETCONCURRENCY,sal_Int32);
+    DECL_PROP0(RESULTSETTYPE,sal_Int32);
+
+    return new ::cppu::OPropertyArrayHelper(aProps);
+}
+
+// -------------------------------------------------------------------------
+::cppu::IPropertyArrayHelper & OCommonStatement::getInfoHelper()
+{
+    return *const_cast<OCommonStatement*>(this)->getArrayHelper();
+}
+// -------------------------------------------------------------------------
+sal_Bool OCommonStatement::convertFastPropertyValue(
+                            Any & /*rConvertedValue*/,
+                            Any & /*rOldValue*/,
+                            sal_Int32 /*nHandle*/,
+                            const Any& /*rValue*/ )
+                                throw (::com::sun::star::lang::IllegalArgumentException)
+{
+    sal_Bool bConverted = sal_False;
+    // here we have to try to convert
+    return bConverted;
+}
+// -------------------------------------------------------------------------
+void OCommonStatement::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& /*rValue*/) throw (Exception)
+{
+    // set the value to whatever is necessary
+    switch(nHandle)
+    {
+        case PROPERTY_ID_QUERYTIMEOUT:
+        case PROPERTY_ID_MAXFIELDSIZE:
+        case PROPERTY_ID_MAXROWS:
+        case PROPERTY_ID_RESULTSETCONCURRENCY:
+        case PROPERTY_ID_RESULTSETTYPE:
+        case PROPERTY_ID_FETCHDIRECTION:
+        case PROPERTY_ID_FETCHSIZE:
+        case PROPERTY_ID_ESCAPEPROCESSING:
+        default:
+            ;
+    }
+}
+// -------------------------------------------------------------------------
+void OCommonStatement::getFastPropertyValue(Any& /*rValue*/,sal_Int32 nHandle) const
+{
+    switch(nHandle)
+    {
+        case PROPERTY_ID_QUERYTIMEOUT:
+        case PROPERTY_ID_MAXFIELDSIZE:
+        case PROPERTY_ID_MAXROWS:
+        case PROPERTY_ID_RESULTSETCONCURRENCY:
+        case PROPERTY_ID_RESULTSETTYPE:
+        case PROPERTY_ID_FETCHDIRECTION:
+        case PROPERTY_ID_FETCHSIZE:
+        case PROPERTY_ID_ESCAPEPROCESSING:
+        default:
+            ;
+    }
+}
+// -------------------------------------------------------------------------
+IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.OStatement","com.sun.star.sdbc.Statement");
+// -----------------------------------------------------------------------------
+void SAL_CALL OCommonStatement::acquire() throw()
+{
+    OCommonStatement_IBASE::acquire();
+}
+// -----------------------------------------------------------------------------
+void SAL_CALL OCommonStatement::release() throw()
+{
+    relase_ChildImpl();
+}
+// -----------------------------------------------------------------------------
+void SAL_CALL OStatement::acquire() throw()
+{
+    OCommonStatement::acquire();
+}
+// -----------------------------------------------------------------------------
+void SAL_CALL OStatement::release() throw()
+{
+    OCommonStatement::release();
+}
+// -----------------------------------------------------------------------------
+Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OCommonStatement::getPropertySetInfo(  ) throw(RuntimeException)
+{
+    return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
+}
+// -----------------------------------------------------------------------------
+void OCommonStatement::createColumnMapping()
+{
+    size_t i;
+
+    // initialize the column index map (mapping select columns to table columns)
+    ::rtl::Reference<connectivity::OSQLColumns> xColumns = m_pSQLIterator->getSelectColumns();
+    m_aColMapping.resize(xColumns->get().size() + 1);
+    for (i=0; i<m_aColMapping.size(); ++i)
+        m_aColMapping[i] = static_cast<sal_Int32>(i);
+
+    Reference<XIndexAccess> xNames(m_xColNames,UNO_QUERY);
+    // now check which columns are bound
+#if OSL_DEBUG_LEVEL > 0
+    for ( i = 0; i < m_aColMapping.size(); i++ )
+        OSL_TRACE("BEFORE Mapped: %d -> %d", i, m_aColMapping[i] );
+#endif
+    OResultSet::setBoundedColumns(m_aRow,xColumns,xNames,sal_True,m_xDBMetaData,m_aColMapping);
+#if OSL_DEBUG_LEVEL > 0
+    for ( i = 0; i < m_aColMapping.size(); i++ )
+        OSL_TRACE("AFTER  Mapped: %d -> %d", i, m_aColMapping[i] );
+#endif
+}
+// -----------------------------------------------------------------------------
+
+void OCommonStatement::analyseSQL()
+{
+    const OSQLParseNode* pOrderbyClause = m_pSQLIterator->getOrderTree();
+    if(pOrderbyClause)
+    {
+        OSQLParseNode * pOrderingSpecCommalist = pOrderbyClause->getChild(2);
+        OSL_ENSURE(SQL_ISRULE(pOrderingSpecCommalist,ordering_spec_commalist),"OResultSet: Fehler im Parse Tree");
+
+        for (sal_uInt32 m = 0; m < pOrderingSpecCommalist->count(); m++)
+        {
+            OSQLParseNode * pOrderingSpec = pOrderingSpecCommalist->getChild(m);
+            OSL_ENSURE(SQL_ISRULE(pOrderingSpec,ordering_spec),"OResultSet: Fehler im Parse Tree");
+            OSL_ENSURE(pOrderingSpec->count() == 2,"OResultSet: Fehler im Parse Tree");
+
+            OSQLParseNode * pColumnRef = pOrderingSpec->getChild(0);
+            if(!SQL_ISRULE(pColumnRef,column_ref))
+            {
+                throw SQLException();
+            }
+            OSQLParseNode * pAscendingDescending = pOrderingSpec->getChild(1);
+            setOrderbyColumn(pColumnRef,pAscendingDescending);
+        }
+    }
+}
+//------------------------------------------------------------------
+void OCommonStatement::setOrderbyColumn(    OSQLParseNode* pColumnRef,
+                                        OSQLParseNode* pAscendingDescending)
+{
+    ::rtl::OUString aColumnName;
+    if (pColumnRef->count() == 1)
+        aColumnName = pColumnRef->getChild(0)->getTokenValue();
+    else if (pColumnRef->count() == 3)
+    {
+        pColumnRef->getChild(2)->parseNodeToStr( aColumnName, getOwnConnection(), NULL, sal_False, sal_False );
+    }
+    else
+    {
+        throw SQLException();
+    }
+
+    Reference<XColumnLocate> xColLocate(m_xColNames,UNO_QUERY);
+    if(!xColLocate.is())
+        return;
+
+    m_aOrderbyColumnNumber.push_back(xColLocate->findColumn(aColumnName));
+
+    // Ascending or Descending?
+    m_aOrderbyAscending.push_back((SQL_ISTOKEN(pAscendingDescending,DESC)) ? SQL_DESC : SQL_ASC);
+}
+// -----------------------------------------------------------------------------
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MStatement.hxx b/connectivity/source/drivers/mork/MStatement.hxx
new file mode 100644
index 000000000000..c89cecfd52db
--- /dev/null
+++ b/connectivity/source/drivers/mork/MStatement.hxx
@@ -0,0 +1,202 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef CONNECTIVITY_SSTATEMENT_HXX
+#define CONNECTIVITY_SSTATEMENT_HXX
+
+#include <com/sun/star/sdbc/XStatement.hpp>
+#include <com/sun/star/sdbc/XWarningsSupplier.hpp>
+#include <com/sun/star/sdbc/XBatchExecution.hpp>
+#include <com/sun/star/sdbc/XCloseable.hpp>
+#include <com/sun/star/sdbc/SQLWarning.hpp>
+#include <comphelper/proparrhlp.hxx>
+#include <cppuhelper/compbase3.hxx>
+#include <comphelper/uno3.hxx>
+#include "connectivity/CommonTools.hxx"
+#include <list>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <comphelper/broadcasthelper.hxx>
+#include "connectivity/sqliterator.hxx"
+#include "connectivity/sqlparse.hxx"
+#include <connectivity/FValue.hxx>
+#include "TSortIndex.hxx"
+#include "MConnection.hxx"
+#include "MTable.hxx"
+
+#include <boost/shared_ptr.hpp>
+
+namespace connectivity
+{
+    namespace mork
+    {
+        class OResultSet;
+
+        typedef ::cppu::WeakComponentImplHelper3<   ::com::sun::star::sdbc::XStatement,
+                                                    ::com::sun::star::sdbc::XWarningsSupplier,
+                                                    ::com::sun::star::sdbc::XCloseable> OCommonStatement_IBASE;
+
+        //**************************************************************
+        //************ Class: OCommonStatement
+        // is a base class for the normal statement and for the prepared statement
+        //**************************************************************
+        class OCommonStatement;
+        typedef ::connectivity::OSubComponent< OCommonStatement, OCommonStatement_IBASE >  OCommonStatement_SBASE;
+
+        class OCommonStatement  :public comphelper::OBaseMutex
+                                ,public OCommonStatement_IBASE
+                                ,public ::cppu::OPropertySetHelper
+                                ,public ::comphelper::OPropertyArrayUsageHelper< OCommonStatement >
+                                ,public OCommonStatement_SBASE
+        {
+            friend class ::connectivity::OSubComponent< OCommonStatement, OCommonStatement_IBASE >;
+
+        private:
+            ::com::sun::star::sdbc::SQLWarning                            m_aLastWarning;
+
+        protected:
+            ::com::sun::star::uno::WeakReference< ::com::sun::star::sdbc::XResultSet >   m_xResultSet;
+            ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XDatabaseMetaData> m_xDBMetaData;
+            ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess>  m_xColNames; // table columns
+
+            //  for this Statement
+
+            ::std::list< ::rtl::OUString>               m_aBatchList;
+
+            OTable*                                     m_pTable;
+            OConnection*                                m_pConnection;  // The owning Connection object
+
+            OValueRow                                   m_aRow;
+
+            connectivity::OSQLParser                    m_aParser;
+            ::boost::shared_ptr< ::connectivity::OSQLParseTreeIterator >
+                                                        m_pSQLIterator;
+
+            connectivity::OSQLParseNode*                m_pParseTree;
+
+            ::std::vector<sal_Int32>                    m_aColMapping;
+            ::std::vector<sal_Int32>                    m_aOrderbyColumnNumber;
+            ::std::vector<TAscendingOrder>              m_aOrderbyAscending;
+
+            ::cppu::OBroadcastHelper&                   rBHelper;
+
+        protected:
+
+            // OPropertyArrayUsageHelper
+            virtual ::cppu::IPropertyArrayHelper* createArrayHelper( ) const;
+            // OPropertySetHelper
+            virtual ::cppu::IPropertyArrayHelper & SAL_CALL getInfoHelper();
+            virtual sal_Bool SAL_CALL convertFastPropertyValue(
+                                                                ::com::sun::star::uno::Any & rConvertedValue,
+                                                                ::com::sun::star::uno::Any & rOldValue,
+                                                                sal_Int32 nHandle,
+                                                                const ::com::sun::star::uno::Any& rValue )
+                                                            throw (::com::sun::star::lang::IllegalArgumentException);
+            virtual void SAL_CALL setFastPropertyValue_NoBroadcast(
+                                                                sal_Int32 nHandle,
+                                                                const ::com::sun::star::uno::Any& rValue)   throw (::com::sun::star::uno::Exception);
+            virtual void SAL_CALL getFastPropertyValue(
+                                                                ::com::sun::star::uno::Any& rValue,
+                                                                sal_Int32 nHandle) const;
+            virtual ~OCommonStatement();
+
+        protected:
+            //
+            // Driver Internal Methods
+            //
+            enum StatementType { eSelect, eCreateTable };
+            /** called to do the parsing of a to-be-executed SQL statement, and set all members as needed
+            */
+            virtual StatementType
+                            parseSql( const ::rtl::OUString& sql , sal_Bool bAdjusted = sal_False) throw ( ::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException );
+            /** called to initialize a result set, according to a previously parsed SQL statement
+            */
+            virtual void    initializeResultSet( OResultSet* _pResult );
+            /** called when a possible cached instance of our last result set should be cleared
+            */
+            virtual void    clearCachedResultSet();
+            /** caches a result set which has just been created by an execution of an SQL statement
+            */
+            virtual void    cacheResultSet( const ::rtl::Reference< OResultSet >& _pResult );
+
+
+            /** executes the current query (the one which has been passed to the last parseSql call)
+            */
+            ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet >
+                            impl_executeCurrentQuery();
+
+            void         createColumnMapping();
+            void         analyseSQL();
+            void         setOrderbyColumn( connectivity::OSQLParseNode* pColumnRef,
+                                           connectivity::OSQLParseNode* pAscendingDescending);
+            virtual void createTable(  ) throw (
+                        ::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException );
+
+        public:
+            // other methods
+            OConnection* getOwnConnection() const { return m_pConnection;}
+
+            OCommonStatement(OConnection* _pConnection );
+            using OCommonStatement_IBASE::operator ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >;
+
+            // OComponentHelper
+            virtual void SAL_CALL disposing(void);
+
+            // XInterface
+            virtual void SAL_CALL release() throw();
+            virtual void SAL_CALL acquire() throw();
+            // XInterface
+            virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException);
+            //XTypeProvider
+            virtual ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes(  ) throw(::com::sun::star::uno::RuntimeException);
+
+            // XPropertySet
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException);
+            // XStatement
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet > SAL_CALL executeQuery( const ::rtl::OUString& sql ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException) ;
+            virtual sal_Int32 SAL_CALL executeUpdate( const ::rtl::OUString& sql ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException) ;
+            virtual sal_Bool SAL_CALL execute( const ::rtl::OUString& sql ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException) ;
+            virtual ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XConnection > SAL_CALL getConnection(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException) ;
+            // XWarningsSupplier
+            virtual ::com::sun::star::uno::Any SAL_CALL getWarnings(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL clearWarnings(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+            // XCloseable
+            virtual void SAL_CALL close(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+
+        protected:
+            using OPropertySetHelper::getFastPropertyValue;
+        };
+
+        class OStatement :  public OCommonStatement,
+                            public ::com::sun::star::lang::XServiceInfo
+        {
+        protected:
+            ~OStatement(){}
+        public:
+            // a constructor, for when the object needs to be returned:
+            OStatement( OConnection* _pConnection) : OCommonStatement( _pConnection){}
+            DECLARE_SERVICE_INFO();
+
+            virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException);
+            virtual void SAL_CALL acquire() throw();
+            virtual void SAL_CALL release() throw();
+        };
+    }
+}
+#endif // CONNECTIVITY_SSTATEMENT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MTable.cxx b/connectivity/source/drivers/mork/MTable.cxx
new file mode 100644
index 000000000000..af142fe4210a
--- /dev/null
+++ b/connectivity/source/drivers/mork/MTable.cxx
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "MTable.hxx"
+#include "MTables.hxx"
+#include "MColumns.hxx"
+#include <com/sun/star/sdbc/XRow.hpp>
+#include <com/sun/star/sdbc/XResultSet.hpp>
+#include <com/sun/star/sdbcx/KeyType.hpp>
+#include <com/sun/star/sdbc/KeyRule.hpp>
+#include <cppuhelper/typeprovider.hxx>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/sdbc/ColumnValue.hpp>
+#include <comphelper/sequence.hxx>
+#include <comphelper/extract.hxx>
+#include <comphelper/types.hxx>
+#include "connectivity/dbtools.hxx"
+#include "connectivity/TKeys.hxx"
+#include "connectivity/TIndexes.hxx"
+#include "MCatalog.hxx"
+
+
+using namespace ::comphelper;
+using namespace connectivity::mork;
+using namespace connectivity;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+
+// -------------------------------------------------------------------------
+OTable::OTable( sdbcx::OCollection* _pTables, OConnection* _pConnection,
+                const ::rtl::OUString& _Name, const ::rtl::OUString& _Type, const ::rtl::OUString& _Description )
+    :OTable_Base(_pTables, _pConnection, sal_True, _Name, _Type, _Description )
+    ,m_pConnection( _pConnection )
+{
+    construct();
+}
+
+//--------------------------------------------------------------------------
+sdbcx::OCollection* OTable::createColumns( const TStringVector& _rNames )
+{
+    return new OColumns( this, m_aMutex, _rNames );
+}
+
+//--------------------------------------------------------------------------
+sdbcx::OCollection* OTable::createKeys(const TStringVector& _rNames)
+{
+    return new OKeysHelper( this, m_aMutex, _rNames );
+}
+
+//--------------------------------------------------------------------------
+sdbcx::OCollection* OTable::createIndexes(const TStringVector& _rNames)
+{
+    return new OIndexesHelper( this, m_aMutex, _rNames );
+}
+
+// -----------------------------------------------------------------------------
+
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/mork/MTable.hxx b/connectivity/source/drivers/mork/MTable.hxx
new file mode 100644
index 000000000000..adad779c3b6c
--- /dev/null
+++ b/connectivity/source/drivers/mork/MTable.hxx
@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef _CONNECTIVITY_MOZAB_TABLE_HXX_
+#define _CONNECTIVITY_MOZAB_TABLE_HXX_
+
+#include "connectivity/TTableHelper.hxx"
+#include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
+#include "MConnection.hxx"
+
+namespace connectivity
+{
+    namespace mork
+    {
+        typedef ::connectivity::OTableHelper OTable_Base;
+
+        class OTable :  public OTable_Base
+        {
+            OConnection*    m_pConnection;
+
+        public:
+            OTable( sdbcx::OCollection* _pTables,
+                    OConnection* _pConnection,
+                    const ::rtl::OUString& _Name,
+                    const ::rtl::OUString& _Type,
+                    const ::rtl::OUString& _Description );
+
+            OConnection* getConnection() { return m_pConnection;}
+
+            sal_Bool isReadOnly() const { return sal_False; }
+
+            ::rtl::OUString getTableName() const { return m_Name; }
+            ::rtl::OUString getSchema() const { return m_SchemaName; }
+
+            // OTableHelper overridables
+            virtual sdbcx::OCollection* createColumns( const TStringVector& _rNames );
+            virtual sdbcx::OCollection* createKeys(const TStringVector& _rNames);
+            virtual sdbcx::OCollection* createIndexes(const TStringVector& _rNames);
+        private:
+            using OTable_Base::getConnection;
+        };
+    }
+}
+#endif // _CONNECTIVITY_MOZAB_TABLE_HXX_
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */