/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_connectivity.hxx"

#include <stdio.h>
#include <osl/diagnose.h>
#include "odbc/OStatement.hxx"
#include "odbc/OConnection.hxx"
#include "odbc/OResultSet.hxx"
#include <comphelper/property.hxx>
#include "odbc/OTools.hxx"
#include <comphelper/uno3.hxx>
#include <osl/thread.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 "diagnose_ex.h"
#include <algorithm>
#include "resource/common_res.hrc"
#include "connectivity/dbexception.hxx"

using namespace ::comphelper;

#define THROW_SQL(x) \
	OTools::ThrowException(m_pConnection,x,m_aStatementHandle,SQL_HANDLE_STMT,*this)

#if OSL_DEBUG_LEVEL > 1
#define DEBUG_THROW					\
	try									\
	{									\
		THROW_SQL(nRetCode);			\
	}									\
	catch(SQLException&)				\
	{									\
		OSL_ENSURE(0,"Exception in odbc catched"); \
	}
#endif



using namespace connectivity::odbc;
//------------------------------------------------------------------------------
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;
//------------------------------------------------------------------------------
OStatement_Base::OStatement_Base(OConnection* _pConnection )
	:OStatement_BASE(m_aMutex)
	,OPropertySetHelper(OStatement_BASE::rBHelper)
	,m_pConnection(_pConnection)
    ,m_aStatementHandle(SQL_NULL_HANDLE)
	,m_pRowStatusArray(0)
    ,rBHelper(OStatement_BASE::rBHelper)
{
	osl_incrementInterlockedCount( &m_refCount );
	m_pConnection->acquire();
	m_aStatementHandle = m_pConnection->createStatementHandle();

	//setMaxFieldSize(0);
    // Don't do this. By ODBC spec, "0" is the default for the SQL_ATTR_MAX_LENGTH attribute. We once introduced
    // this line since an PostgreSQL ODBC driver had a default other than 0. However, current drivers (at least 8.3
    // and later) have a proper default of 0, so there should be no need anymore.
    // On the other hand, the NotesSQL driver (IBM's ODBC driver for the Lotus Notes series) wrongly interprets
    // "0" as "0", whereas the ODBC spec says it should in fact mean "unlimited".
    // So, removing this line seems to be the best option for now.
    // If we ever again encounter a ODBC driver which needs this option, then we should introduce a data source
    // setting for it, instead of unconditionally doing it.

	osl_decrementInterlockedCount( &m_refCount );
}
// -----------------------------------------------------------------------------
OStatement_Base::~OStatement_Base()
{
	OSL_ENSURE(!m_aStatementHandle,"Sohould ne null here!");
}
//------------------------------------------------------------------------------
void OStatement_Base::disposeResultSet()
{
	// free the cursor if alive
	Reference< XComponent > xComp(m_xResultSet.get(), UNO_QUERY);
	if (xComp.is())
		xComp->dispose();
	m_xResultSet = Reference< XResultSet>();
}
// -----------------------------------------------------------------------------
void SAL_CALL OStatement_Base::disposing(void)
{
	::osl::MutexGuard aGuard(m_aMutex);

	disposeResultSet();
	::comphelper::disposeComponent(m_xGeneratedStatement);

	OSL_ENSURE(m_aStatementHandle,"OStatement_BASE2::disposing: StatementHandle is null!");
	if (m_pConnection)
	{
		m_pConnection->freeStatementHandle(m_aStatementHandle);
		m_pConnection->release();
		m_pConnection = NULL;
	}
	OSL_ENSURE(!m_aStatementHandle,"Sohould ne null here!");

	OStatement_BASE::disposing();
}
//------------------------------------------------------------------------------
void OStatement_BASE2::disposing()
{
	::osl::MutexGuard aGuard(m_aMutex);

	dispose_ChildImpl();
	OStatement_Base::disposing();
}
//-----------------------------------------------------------------------------
void SAL_CALL OStatement_BASE2::release() throw()
{
	relase_ChildImpl();
}
//-----------------------------------------------------------------------------
Any SAL_CALL OStatement_Base::queryInterface( const Type & rType ) throw(RuntimeException)
{
	if ( m_pConnection && !m_pConnection->isAutoRetrievingEnabled() && rType == ::getCppuType( (const Reference< XGeneratedResultSet > *)0 ) )
		return Any();
	Any aRet = OStatement_BASE::queryInterface(rType);
	return aRet.hasValue() ? aRet : OPropertySetHelper::queryInterface(rType);
}
// -------------------------------------------------------------------------
Sequence< Type > SAL_CALL OStatement_Base::getTypes(  ) throw(RuntimeException)
{
	::cppu::OTypeCollection aTypes(	::getCppuType( (const Reference< XMultiPropertySet > *)0 ),
									::getCppuType( (const Reference< XFastPropertySet > *)0 ),
									::getCppuType( (const Reference< XPropertySet > *)0 ));
	Sequence< Type > aOldTypes = OStatement_BASE::getTypes();
	if ( m_pConnection && !m_pConnection->isAutoRetrievingEnabled() )
	{
		::std::remove(aOldTypes.getArray(),aOldTypes.getArray() + aOldTypes.getLength(),
						::getCppuType( (const Reference< XGeneratedResultSet > *)0 ));
		aOldTypes.realloc(aOldTypes.getLength() - 1);
	}

	return ::comphelper::concatSequences(aTypes.getTypes(),aOldTypes);
}
// -------------------------------------------------------------------------
Reference< XResultSet > SAL_CALL OStatement_Base::getGeneratedValues(  ) throw (SQLException, RuntimeException)
{
	OSL_ENSURE(	m_pConnection && m_pConnection->isAutoRetrievingEnabled(),"Illegal call here. isAutoRetrievingEnabled is false!");
	Reference< XResultSet > xRes;
	if ( m_pConnection )
	{
		::rtl::OUString sStmt = m_pConnection->getTransformedGeneratedStatement(m_sSqlStatement);
		if ( sStmt.getLength() )
		{
			::comphelper::disposeComponent(m_xGeneratedStatement);
			m_xGeneratedStatement = m_pConnection->createStatement();
			xRes = m_xGeneratedStatement->executeQuery(sStmt);
		}
	}
	return xRes;
}
// -----------------------------------------------------------------------------
void SAL_CALL OStatement_Base::cancel(  ) throw(RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);

	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	OTools::ThrowException(m_pConnection,N3SQLCancel(m_aStatementHandle),m_aStatementHandle,SQL_HANDLE_STMT,*this);
}
// -------------------------------------------------------------------------

void SAL_CALL OStatement_Base::close(  ) throw(SQLException, RuntimeException)
{
	{
		::osl::MutexGuard aGuard( m_aMutex );
		checkDisposed(OStatement_BASE::rBHelper.bDisposed);

	}
	dispose();
}
// -------------------------------------------------------------------------

void SAL_CALL OStatement::clearBatch(  ) throw(SQLException, RuntimeException)
{

}
// -------------------------------------------------------------------------

void OStatement_Base::reset() throw (SQLException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	clearWarnings ();

	if (m_xResultSet.get().is())
	{
		clearMyResultSet();
	}
	if(m_aStatementHandle)
	{
		THROW_SQL(N3SQLFreeStmt(m_aStatementHandle, SQL_CLOSE));
	}
}
//--------------------------------------------------------------------
// clearMyResultSet
// If a ResultSet was created for this Statement, close it
//--------------------------------------------------------------------

void OStatement_Base::clearMyResultSet () throw (SQLException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);

    try
    {
	    Reference<XCloseable> xCloseable;
	    if ( ::comphelper::query_interface( m_xResultSet.get(), xCloseable ) )
		    xCloseable->close();
    }
    catch( const DisposedException& ) { }

    m_xResultSet = Reference< XResultSet >();
}
//--------------------------------------------------------------------
SQLLEN OStatement_Base::getRowCount () throw( SQLException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	SQLLEN numRows = 0;

	try {
		THROW_SQL(N3SQLRowCount(m_aStatementHandle,&numRows));
	}
	catch (SQLException&)
	{
	}
	return numRows;
}
//--------------------------------------------------------------------
// lockIfNecessary
// If the given SQL statement contains a 'FOR UPDATE' clause, change
// the concurrency to lock so that the row can then be updated.  Returns
// true if the concurrency has been changed
//--------------------------------------------------------------------

sal_Bool OStatement_Base::lockIfNecessary (const ::rtl::OUString& sql) throw( SQLException)
{
	sal_Bool rc = sal_False;

	// First, convert the statement to upper case

	::rtl::OUString sqlStatement = sql.toAsciiUpperCase ();

	// Now, look for the FOR UPDATE keywords.  If there is any extra white
	// space between the FOR and UPDATE, this will fail.

	sal_Int32 index = sqlStatement.indexOf(::rtl::OUString::createFromAscii(" FOR UPDATE"));

	// We found it.  Change our concurrency level to ensure that the
	// row can be updated.

	if (index > 0)
	{
		OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
		try
		{
			SQLINTEGER nLock = SQL_CONCUR_LOCK;
			THROW_SQL(N3SQLSetStmtAttr(m_aStatementHandle, SQL_CONCURRENCY,(SQLPOINTER)nLock,SQL_IS_UINTEGER));
		}
		catch (SQLWarning& warn)
		{
			// Catch any warnings and place on the warning stack
			setWarning (warn);
		}
		rc = sal_True;
	}

	return rc;
}
//--------------------------------------------------------------------
// setWarning
// Sets the warning
//--------------------------------------------------------------------

void OStatement_Base::setWarning (const	SQLWarning &ex) throw( SQLException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	m_aLastWarning = ex;
}

//--------------------------------------------------------------------
// getColumnCount
// Return the number of columns in the ResultSet
//--------------------------------------------------------------------

sal_Int32 OStatement_Base::getColumnCount () throw( SQLException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	sal_Int16	numCols = 0;
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");

	try {
		THROW_SQL(N3SQLNumResultCols(m_aStatementHandle,&numCols));
	}
	catch (SQLException&)
	{
	}
	return numCols;
}
// -------------------------------------------------------------------------

sal_Bool SAL_CALL OStatement_Base::execute( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);
	m_sSqlStatement = sql;


	::rtl::OString aSql(::rtl::OUStringToOString(sql,getOwnConnection()->getTextEncoding()));

	sal_Bool hasResultSet = sal_False;
	SQLWarning aWarning;

	// Reset the statement handle and warning

	reset();

	// Check for a 'FOR UPDATE' statement.  If present, change
	// the concurrency to lock

	lockIfNecessary (sql);

	// Call SQLExecDirect
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");

	try {
		THROW_SQL(N3SQLExecDirect(m_aStatementHandle, (SDB_ODBC_CHAR*)aSql.getStr(),aSql.getLength()));
	}
	catch (SQLWarning& ex) {

		// Save pointer to warning and save with ResultSet
		// object once it is created.

		aWarning = ex;
	}

	// Now determine if there is a result set associated with
	// the SQL statement that was executed.  Get the column
	// count, and if it is not zero, there is a result set.

	if (getColumnCount () > 0)
	{
		hasResultSet = sal_True;
	}

	return hasResultSet;
}
//--------------------------------------------------------------------
// getResultSet
// getResultSet returns the current result as a ResultSet.  It
// returns NULL if the current result is not a ResultSet.
//--------------------------------------------------------------------
Reference< XResultSet > OStatement_Base::getResultSet (sal_Bool checkCount) throw( SQLException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	if (m_xResultSet.get().is())  // if resultset already retrieved,
	{
		// throw exception to avoid sequence error
        ::dbtools::throwFunctionSequenceException(*this,Any());
	}

	OResultSet* pRs = NULL;
	sal_Int32 numCols = 1;

	// If we already know we have result columns, checkCount
	// is false.  This is an optimization to prevent unneeded
	// calls to getColumnCount

	if (checkCount)
		numCols = getColumnCount ();

	// Only return a result set if there are result columns

	if (numCols > 0)
	{
		OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
		pRs = createResulSet();
		pRs->construct();

		// Save a copy of our last result set
		// Changed to save copy at getResultSet.
		//m_xResultSet = rs;
	}
	else
		clearMyResultSet ();

	return pRs;
}
//--------------------------------------------------------------------
// getStmtOption
// Invoke SQLGetStmtOption with the given option.
//--------------------------------------------------------------------

sal_Int32 OStatement_Base::getStmtOption (short fOption) const
{
	SQLLEN	result = 0;
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	N3SQLGetStmtAttr(m_aStatementHandle, fOption,&result,SQL_IS_INTEGER,NULL);
	return result;
}
// -------------------------------------------------------------------------

Reference< XResultSet > SAL_CALL OStatement_Base::executeQuery( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	Reference< XResultSet > xRS = NULL;

	// Execute the statement.  If execute returns true, a result
	// set exists.

	if (execute (sql))
	{
		xRS = getResultSet (sal_False);
		m_xResultSet = xRS;
	}
	else
	{
		// No ResultSet was produced.  Raise an exception
		m_pConnection->throwGenericSQLException(STR_NO_RESULTSET,*this);
	}
	return xRS;
}
// -------------------------------------------------------------------------

Reference< XConnection > SAL_CALL OStatement_Base::getConnection(  ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);

	return (Reference< XConnection >)m_pConnection;
}
// -------------------------------------------------------------------------

Any SAL_CALL OStatement::queryInterface( const Type & rType ) throw(RuntimeException)
{
	Any aRet = ::cppu::queryInterface(rType,static_cast< XBatchExecution*> (this));
	return aRet.hasValue() ? aRet : OStatement_Base::queryInterface(rType);
}
// -------------------------------------------------------------------------

void SAL_CALL OStatement::addBatch( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	m_aBatchList.push_back(sql);
}
// -------------------------------------------------------------------------
Sequence< sal_Int32 > SAL_CALL OStatement::executeBatch(  ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	::rtl::OString aBatchSql;
	sal_Int32 nLen = 0;
	for(::std::list< ::rtl::OUString>::const_iterator i=m_aBatchList.begin();i != m_aBatchList.end();++i,++nLen)
	{
		aBatchSql += ::rtl::OUStringToOString(*i,getOwnConnection()->getTextEncoding());
		aBatchSql += ";";
	}

	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	THROW_SQL(N3SQLExecDirect(m_aStatementHandle, (SDB_ODBC_CHAR*)aBatchSql.getStr(),aBatchSql.getLength()));

	Sequence< sal_Int32 > aRet(nLen);
	sal_Int32* pArray = aRet.getArray();
	for(sal_Int32 j=0;j<nLen;++j)
	{
		SQLRETURN nError = N3SQLMoreResults(m_aStatementHandle);
		if(nError == SQL_SUCCESS)
		{
			SQLLEN nRowCount=0;
			N3SQLRowCount(m_aStatementHandle,&nRowCount);
			pArray[j] = nRowCount;
		}
	}
	return aRet;
}
// -------------------------------------------------------------------------


sal_Int32 SAL_CALL OStatement_Base::executeUpdate( const ::rtl::OUString& sql ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	sal_Int32 numRows = -1;

	// Execute the statement.  If execute returns false, a
	// row count exists.

	if (!execute (sql)) {
		numRows = getUpdateCount();
	}
	else {

		// No update count was produced (a ResultSet was).  Raise
		// an exception

        ::connectivity::SharedResources aResources;
        const ::rtl::OUString sError( aResources.getResourceString(STR_NO_ROWCOUNT));
		throw SQLException (sError,	*this,::rtl::OUString(),0,Any());
	}
	return numRows;

}
// -------------------------------------------------------------------------

Reference< XResultSet > SAL_CALL OStatement_Base::getResultSet(  ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	m_xResultSet = getResultSet(sal_True);
	return m_xResultSet;
}
// -------------------------------------------------------------------------

sal_Int32 SAL_CALL OStatement_Base::getUpdateCount(  ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	sal_Int32 rowCount = -1;

	// Only return a row count for SQL statements that did not
	// return a result set.

	if (getColumnCount () == 0)
		rowCount = getRowCount ();

	return rowCount;
}
// -------------------------------------------------------------------------

sal_Bool SAL_CALL OStatement_Base::getMoreResults(  ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	SQLWarning	warning;
	sal_Bool hasResultSet = sal_False;

	// clear previous warnings

	clearWarnings ();

	// Call SQLMoreResults
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");

	try {
		hasResultSet = N3SQLMoreResults(m_aStatementHandle) == SQL_SUCCESS;
	}
	catch (SQLWarning &ex) {

		// Save pointer to warning and save with ResultSet
		// object once it is created.

		warning = ex;
	}

	// There are more results (it may not be a result set, though)

	if (hasResultSet)
	{

		// Now determine if there is a result set associated
		// with the SQL statement that was executed.  Get the
		// column count, and if it is zero, there is not a
		// result set.

		if (getColumnCount () == 0)
			hasResultSet = sal_False;
	}

	// Set the warning for the statement, if one was generated

	setWarning (warning);

	// Return the result set indicator

	return hasResultSet;
}
// -------------------------------------------------------------------------

// -------------------------------------------------------------------------
Any SAL_CALL OStatement_Base::getWarnings(  ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	return makeAny(m_aLastWarning);
}
// -------------------------------------------------------------------------

// -------------------------------------------------------------------------
void SAL_CALL OStatement_Base::clearWarnings(  ) throw(SQLException, RuntimeException)
{
	::osl::MutexGuard aGuard( m_aMutex );
	checkDisposed(OStatement_BASE::rBHelper.bDisposed);


	m_aLastWarning = SQLWarning();
}
// -------------------------------------------------------------------------
//------------------------------------------------------------------------------
sal_Int32 OStatement_Base::getQueryTimeOut() const
{
	return getStmtOption(SQL_ATTR_QUERY_TIMEOUT);
}
//------------------------------------------------------------------------------
sal_Int32 OStatement_Base::getMaxRows() const
{
	return getStmtOption(SQL_ATTR_MAX_ROWS);
}
//------------------------------------------------------------------------------
sal_Int32 OStatement_Base::getResultSetConcurrency() const
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	sal_uInt32 nValue;
	SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CONCURRENCY,&nValue,SQL_IS_UINTEGER,0);
    OSL_UNUSED( nRetCode );
	if(nValue == SQL_CONCUR_READ_ONLY)
		nValue = ResultSetConcurrency::READ_ONLY;
	else
		nValue = ResultSetConcurrency::UPDATABLE;
	return nValue;
}
//------------------------------------------------------------------------------
sal_Int32 OStatement_Base::getResultSetType() const
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	sal_uInt32 nValue = SQL_CURSOR_FORWARD_ONLY;
	SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SENSITIVITY,&nValue,SQL_IS_UINTEGER,0);
	nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_TYPE,&nValue,SQL_IS_UINTEGER,0);
	switch(nValue)
	{
		case SQL_CURSOR_FORWARD_ONLY:
			nValue = ResultSetType::FORWARD_ONLY;
			break;
		case SQL_CURSOR_KEYSET_DRIVEN:
		case SQL_CURSOR_STATIC:
			nValue = ResultSetType::SCROLL_INSENSITIVE;
			break;
		case SQL_CURSOR_DYNAMIC:
			nValue = ResultSetType::SCROLL_SENSITIVE;
			break;
	}

	return nValue;
}
//------------------------------------------------------------------------------
sal_Int32 OStatement_Base::getFetchDirection() const
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	sal_uInt32 nValue = 0;
	SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SCROLLABLE,&nValue,SQL_IS_UINTEGER,0);
    OSL_UNUSED( nRetCode );

	switch(nValue)
	{
		case SQL_SCROLLABLE:
			nValue = FetchDirection::REVERSE;
			break;
		default:
			nValue = FetchDirection::FORWARD;
			break;
	}

	return nValue;
}
//------------------------------------------------------------------------------
sal_Int32 OStatement_Base::getFetchSize() const
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	sal_uInt32 nValue;
	SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_ARRAY_SIZE,&nValue,SQL_IS_UINTEGER,0);
    OSL_UNUSED( nRetCode );
	return nValue;
}
//------------------------------------------------------------------------------
sal_Int32 OStatement_Base::getMaxFieldSize() const
{
	return getStmtOption(SQL_ATTR_MAX_LENGTH);
}
//------------------------------------------------------------------------------
::rtl::OUString OStatement_Base::getCursorName() const
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	SQLCHAR pName[258];
	SQLSMALLINT nRealLen = 0;
	SQLRETURN nRetCode = N3SQLGetCursorName(m_aStatementHandle,(SQLCHAR*)pName,256,&nRealLen);
    OSL_UNUSED( nRetCode );
	return ::rtl::OUString::createFromAscii((const char*)pName);
}
//------------------------------------------------------------------------------
void OStatement_Base::setQueryTimeOut(sal_Int32 seconds)
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_QUERY_TIMEOUT,(SQLPOINTER)seconds,SQL_IS_UINTEGER);
    OSL_UNUSED( nRetCode );
}
//------------------------------------------------------------------------------
void OStatement_Base::setMaxRows(sal_Int32 _par0)
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_MAX_ROWS, (SQLPOINTER)_par0,SQL_IS_UINTEGER);
    OSL_UNUSED( nRetCode );
}
//------------------------------------------------------------------------------
void OStatement_Base::setResultSetConcurrency(sal_Int32 _par0)
{
	SQLINTEGER nSet;
	if(_par0 == ResultSetConcurrency::READ_ONLY)
		nSet = SQL_CONCUR_READ_ONLY;
	else
		nSet = SQL_CONCUR_VALUES;

	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CONCURRENCY,(SQLPOINTER)nSet,SQL_IS_UINTEGER);

}
//------------------------------------------------------------------------------
void OStatement_Base::setResultSetType(sal_Int32 _par0)
{

	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_ROW_BIND_TYPE,(SQLPOINTER)SQL_BIND_BY_COLUMN,SQL_IS_UINTEGER);
    OSL_UNUSED( nRetCode );

	sal_Bool bUseBookmark = isUsingBookmarks();
    SQLUINTEGER nSet( SQL_UNSPECIFIED );
	switch(_par0)
	{
		case ResultSetType::FORWARD_ONLY:
			nSet = 	SQL_UNSPECIFIED;
			break;
		case ResultSetType::SCROLL_INSENSITIVE:
			nSet = 	SQL_INSENSITIVE;
			N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_TYPE,(SQLPOINTER)SQL_CURSOR_KEYSET_DRIVEN,SQL_IS_UINTEGER);
			break;
		case ResultSetType::SCROLL_SENSITIVE:
			if(bUseBookmark)
			{
				SQLUINTEGER nCurProp = getCursorProperties(SQL_CURSOR_DYNAMIC,sal_True);
				if((nCurProp & SQL_CA1_BOOKMARK) != SQL_CA1_BOOKMARK) // check if bookmark for this type isn't supported
				{ // we have to test the next one
					nCurProp = getCursorProperties(SQL_CURSOR_KEYSET_DRIVEN,sal_True);
					sal_Bool bNotBookmarks = ((nCurProp & SQL_CA1_BOOKMARK) != SQL_CA1_BOOKMARK);
					nCurProp = getCursorProperties(SQL_CURSOR_KEYSET_DRIVEN,sal_False);
					nSet = SQL_CURSOR_KEYSET_DRIVEN;
					if(	bNotBookmarks ||
						((nCurProp & SQL_CA2_SENSITIVITY_DELETIONS) != SQL_CA2_SENSITIVITY_DELETIONS) ||
						((nCurProp & SQL_CA2_SENSITIVITY_ADDITIONS) != SQL_CA2_SENSITIVITY_ADDITIONS))
					{
						// bookmarks for keyset isn't supported so reset bookmark setting
						setUsingBookmarks(sal_False);
						nSet = SQL_CURSOR_DYNAMIC;
					}
				}
				else
					nSet = SQL_CURSOR_DYNAMIC;
			}
			else
				nSet = SQL_CURSOR_DYNAMIC;
			if(N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_TYPE,(SQLPOINTER)nSet,SQL_IS_UINTEGER) != SQL_SUCCESS)
			{
				nSet = SQL_CURSOR_KEYSET_DRIVEN;
				N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_TYPE,(SQLPOINTER)nSet,SQL_IS_UINTEGER);
			}
			nSet = 	SQL_SENSITIVE;
			break;
        default:
            OSL_ENSURE( false, "OStatement_Base::setResultSetType: invalid result set type!" );
            break;
	}


	N3SQLSetStmtAttr(m_aStatementHandle, SQL_ATTR_CURSOR_SENSITIVITY,(SQLPOINTER)nSet,SQL_IS_UINTEGER);
}
//------------------------------------------------------------------------------
void OStatement_Base::setEscapeProcessing( const sal_Bool _bEscapeProc )
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
    SQLUINTEGER nEscapeProc( _bEscapeProc ? SQL_NOSCAN_OFF : SQL_NOSCAN_ON );
	SQLRETURN nRetCode = N3SQLSetStmtAttr( m_aStatementHandle, SQL_ATTR_NOSCAN, (SQLPOINTER)nEscapeProc, SQL_IS_UINTEGER );
    (void)nRetCode;
}

//------------------------------------------------------------------------------
void OStatement_Base::setFetchDirection(sal_Int32 _par0)
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	sal_Int32 nCursType = 0;
	SQLRETURN nRetCode	= SQL_SUCCESS;
	if(_par0 == FetchDirection::FORWARD)
	{
		nCursType = SQL_NONSCROLLABLE;
		nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SCROLLABLE,(SQLPOINTER)nCursType,SQL_IS_UINTEGER);
	}
	else if(_par0 == FetchDirection::REVERSE)
	{
		nCursType = SQL_SCROLLABLE;
		nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_CURSOR_SCROLLABLE,(SQLPOINTER)nCursType,SQL_IS_UINTEGER);
	}
    OSL_UNUSED( nRetCode );
}
//------------------------------------------------------------------------------
void OStatement_Base::setFetchSize(sal_Int32 _par0)
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	OSL_ENSURE(_par0>0,"Illegal fetch size!");
	if ( _par0 > 0 )
	{

		SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_ARRAY_SIZE,(SQLPOINTER)_par0,SQL_IS_UINTEGER);

		delete m_pRowStatusArray;
		m_pRowStatusArray = new SQLUSMALLINT[_par0];
		nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_ROW_STATUS_PTR,m_pRowStatusArray,SQL_IS_POINTER);
	}
}
//------------------------------------------------------------------------------
void OStatement_Base::setMaxFieldSize(sal_Int32 _par0)
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_MAX_LENGTH,(SQLPOINTER)_par0,SQL_IS_UINTEGER);
}
//------------------------------------------------------------------------------
void OStatement_Base::setCursorName(const ::rtl::OUString &_par0)
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	::rtl::OString aName(::rtl::OUStringToOString(_par0,getOwnConnection()->getTextEncoding()));
	N3SQLSetCursorName(m_aStatementHandle,(SDB_ODBC_CHAR*)aName.getStr(),(SQLSMALLINT)aName.getLength());
}
// -------------------------------------------------------------------------
sal_Bool OStatement_Base::isUsingBookmarks() const
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	sal_uInt32 nValue = SQL_UB_OFF;
	SQLRETURN nRetCode = N3SQLGetStmtAttr(m_aStatementHandle,SQL_ATTR_USE_BOOKMARKS,&nValue,SQL_IS_UINTEGER,NULL);
    OSL_UNUSED( nRetCode );
	return nValue != SQL_UB_OFF;
}
// -------------------------------------------------------------------------
sal_Bool OStatement_Base::getEscapeProcessing() const
{
	OSL_ENSURE( m_aStatementHandle, "StatementHandle is null!" );
	sal_uInt32 nValue = SQL_NOSCAN_OFF;
	SQLRETURN nRetCode = N3SQLGetStmtAttr( m_aStatementHandle, SQL_ATTR_NOSCAN, &nValue, SQL_IS_UINTEGER, NULL );
    (void)nRetCode;
	return nValue == SQL_NOSCAN_OFF;
}
// -------------------------------------------------------------------------
void OStatement_Base::setUsingBookmarks(sal_Bool _bUseBookmark)
{
	OSL_ENSURE(m_aStatementHandle,"StatementHandle is null!");
	sal_uInt32 nValue = _bUseBookmark ? SQL_UB_VARIABLE : SQL_UB_OFF;
    SQLRETURN nRetCode = N3SQLSetStmtAttr(m_aStatementHandle,SQL_ATTR_USE_BOOKMARKS,(SQLPOINTER)nValue,SQL_IS_UINTEGER);
    OSL_UNUSED( nRetCode );
}
// -------------------------------------------------------------------------
::cppu::IPropertyArrayHelper* OStatement_Base::createArrayHelper( ) const
{
	Sequence< Property > aProps(10);
	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);
	DECL_BOOL_PROP0(USEBOOKMARKS);

	return new ::cppu::OPropertyArrayHelper(aProps);
}

// -------------------------------------------------------------------------
::cppu::IPropertyArrayHelper & OStatement_Base::getInfoHelper()
{
	return *const_cast<OStatement_Base*>(this)->getArrayHelper();
}
// -------------------------------------------------------------------------
sal_Bool OStatement_Base::convertFastPropertyValue(
							Any & rConvertedValue,
							Any & rOldValue,
							sal_Int32 nHandle,
							const Any& rValue )
								throw (::com::sun::star::lang::IllegalArgumentException)
{
	sal_Bool bConverted = sal_False;
	try
	{
		switch(nHandle)
		{
			case PROPERTY_ID_QUERYTIMEOUT:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getQueryTimeOut());
				break;

			case PROPERTY_ID_MAXFIELDSIZE:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getMaxFieldSize());
				break;

			case PROPERTY_ID_MAXROWS:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getMaxRows());
				break;

			case PROPERTY_ID_CURSORNAME:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getCursorName());
				break;

			case PROPERTY_ID_RESULTSETCONCURRENCY:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetConcurrency());
				break;

			case PROPERTY_ID_RESULTSETTYPE:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getResultSetType());
				break;

			case PROPERTY_ID_FETCHDIRECTION:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
				break;

			case PROPERTY_ID_FETCHSIZE:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
				break;

			case PROPERTY_ID_USEBOOKMARKS:
				bConverted = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, isUsingBookmarks());
				break;

			case PROPERTY_ID_ESCAPEPROCESSING:
				bConverted = ::comphelper::tryPropertyValue( rConvertedValue, rOldValue, rValue, getEscapeProcessing() );
				break;

		}
	}
	catch(const SQLException&)
	{
		//	throw Exception(e.Message,*this);
	}
	return bConverted;
}
// -------------------------------------------------------------------------
void OStatement_Base::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
{
	try
	{
		switch(nHandle)
		{
			case PROPERTY_ID_QUERYTIMEOUT:
				setQueryTimeOut(comphelper::getINT32(rValue));
				break;
			case PROPERTY_ID_MAXFIELDSIZE:
				setMaxFieldSize(comphelper::getINT32(rValue));
				break;
			case PROPERTY_ID_MAXROWS:
				setMaxRows(comphelper::getINT32(rValue));
				break;
			case PROPERTY_ID_CURSORNAME:
				setCursorName(comphelper::getString(rValue));
				break;
			case PROPERTY_ID_RESULTSETCONCURRENCY:
				setResultSetConcurrency(comphelper::getINT32(rValue));
				break;
			case PROPERTY_ID_RESULTSETTYPE:
				setResultSetType(comphelper::getINT32(rValue));
				break;
			case PROPERTY_ID_FETCHDIRECTION:
				setFetchDirection(comphelper::getINT32(rValue));
				break;
			case PROPERTY_ID_FETCHSIZE:
				setFetchSize(comphelper::getINT32(rValue));
				break;
			case PROPERTY_ID_USEBOOKMARKS:
				setUsingBookmarks(comphelper::getBOOL(rValue));
				break;
            case PROPERTY_ID_ESCAPEPROCESSING:
                setEscapeProcessing( ::comphelper::getBOOL( rValue ) );
                break;
            default:
                OSL_ENSURE( false, "OStatement_Base::setFastPropertyValue_NoBroadcast: what property?" );
                break;
		}
	}
	catch(const SQLException& )
	{
		//	throw Exception(e.Message,*this);
	}
}
// -------------------------------------------------------------------------
void OStatement_Base::getFastPropertyValue(Any& rValue,sal_Int32 nHandle) const
{
	switch(nHandle)
	{
		case PROPERTY_ID_QUERYTIMEOUT:
			rValue <<= getQueryTimeOut();
			break;
		case PROPERTY_ID_MAXFIELDSIZE:
			rValue <<= getMaxFieldSize();
			break;
		case PROPERTY_ID_MAXROWS:
			rValue <<= getMaxRows();
			break;
		case PROPERTY_ID_CURSORNAME:
			rValue <<= getCursorName();
			break;
		case PROPERTY_ID_RESULTSETCONCURRENCY:
			rValue <<= getResultSetConcurrency();
			break;
		case PROPERTY_ID_RESULTSETTYPE:
			rValue <<= getResultSetType();
			break;
		case PROPERTY_ID_FETCHDIRECTION:
			rValue <<= getFetchDirection();
			break;
		case PROPERTY_ID_FETCHSIZE:
			rValue <<= getFetchSize();
			break;
		case PROPERTY_ID_USEBOOKMARKS:
			rValue <<= isUsingBookmarks();
			break;
        case PROPERTY_ID_ESCAPEPROCESSING:
            rValue <<= getEscapeProcessing();
            break;
        default:
            OSL_ENSURE( false, "OStatement_Base::getFastPropertyValue: what property?" );
            break;
	}
}
// -------------------------------------------------------------------------
IMPLEMENT_SERVICE_INFO(OStatement,"com.sun.star.sdbcx.OStatement","com.sun.star.sdbc.Statement");
// -----------------------------------------------------------------------------
void SAL_CALL OStatement_Base::acquire() throw()
{
	OStatement_BASE::acquire();
}
// -----------------------------------------------------------------------------
void SAL_CALL OStatement_Base::release() throw()
{
	OStatement_BASE::release();
}
// -----------------------------------------------------------------------------
void SAL_CALL OStatement::acquire() throw()
{
	OStatement_BASE2::acquire();
}
// -----------------------------------------------------------------------------
void SAL_CALL OStatement::release() throw()
{
	OStatement_BASE2::release();
}
// -----------------------------------------------------------------------------
OResultSet* OStatement_Base::createResulSet()
{
	return new OResultSet(m_aStatementHandle,this);
}
// -----------------------------------------------------------------------------
Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OStatement_Base::getPropertySetInfo(  ) throw(RuntimeException)
{
	return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
}
// -----------------------------------------------------------------------------
SQLUINTEGER OStatement_Base::getCursorProperties(SQLINTEGER _nCursorType,sal_Bool bFirst)
{
	SQLUINTEGER nValueLen = 0;
	try
	{
		SQLUSMALLINT nAskFor = SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2;
		if(SQL_CURSOR_KEYSET_DRIVEN == _nCursorType)
			nAskFor = bFirst ? SQL_KEYSET_CURSOR_ATTRIBUTES1 : SQL_KEYSET_CURSOR_ATTRIBUTES2;
		else if(SQL_CURSOR_STATIC  == _nCursorType)
			nAskFor = bFirst ? SQL_STATIC_CURSOR_ATTRIBUTES1 : SQL_STATIC_CURSOR_ATTRIBUTES2;
		else if(SQL_CURSOR_FORWARD_ONLY == _nCursorType)
			nAskFor = bFirst ? SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1 : SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2;
		else if(SQL_CURSOR_DYNAMIC == _nCursorType)
			nAskFor = bFirst ? SQL_DYNAMIC_CURSOR_ATTRIBUTES1 : SQL_DYNAMIC_CURSOR_ATTRIBUTES2;


		OTools::GetInfo(getOwnConnection(),getConnectionHandle(),nAskFor,nValueLen,NULL);
	}
	catch(Exception&)
	{ // we don't want our result destroy here
		nValueLen = 0;
	}
	return nValueLen;
}
// -----------------------------------------------------------------------------