/**************************************************************
 * 
 * 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 "connectivity/dbtools.hxx"
#include "connectivity/dbconversion.hxx"
#include "connectivity/dbcharset.hxx"
#include "connectivity/SQLStatementHelper.hxx"
#include <unotools/confignode.hxx>
#include "resource/sharedresources.hxx"
#include "resource/common_res.hrc"
#include <com/sun/star/sdbc/XConnection.hpp>
#include <com/sun/star/sdbc/ColumnValue.hpp>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
#include <com/sun/star/sdbcx/XKeysSupplier.hpp>
#include <com/sun/star/sdbc/XDriverAccess.hpp>
#include <com/sun/star/sdbcx/XDataDefinitionSupplier.hpp>
#include <com/sun/star/sdbcx/Privilege.hpp>
#include <com/sun/star/container/XIndexAccess.hpp>
#include <com/sun/star/container/XEnumerationAccess.hpp>
#include <com/sun/star/sdbc/KeyRule.hpp>
#include <com/sun/star/sdbcx/KeyType.hpp>
#include "TConnection.hxx"
#include "connectivity/sdbcx/VColumn.hxx"
#include <com/sun/star/frame/XModel.hpp>
#include <com/sun/star/container/XChild.hpp>

#include <tools/diagnose_ex.h>
#include <unotools/sharedunocomponent.hxx>
#include <comphelper/configurationhelper.hxx>

//.........................................................................
namespace dbtools
{
//.........................................................................
	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::beans;
	using namespace ::com::sun::star::sdbc;
	using namespace ::com::sun::star::sdbcx;
	using namespace ::com::sun::star::lang;
	using namespace ::com::sun::star::container;
	using namespace ::com::sun::star::frame;
	using namespace connectivity;
	using namespace comphelper;

::rtl::OUString createStandardColumnPart(const Reference< XPropertySet >& xColProp,const Reference< XConnection>& _xConnection,ISQLStatementHelper* _pHelper,const ::rtl::OUString& _sCreatePattern)
{

	Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();

	::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();

	::rtl::OUString sTypeName;
	sal_Int32		nDataType	= 0;
	sal_Int32		nPrecision	= 0;
	sal_Int32		nScale		= 0;

	const ::rtl::OUString sQuoteString = xMetaData->getIdentifierQuoteString();
	::rtl::OUStringBuffer aSql = ::dbtools::quoteName(sQuoteString,::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME))));

	aSql.appendAscii(" ");

	nDataType = nPrecision = nScale = 0;
	sal_Bool bIsAutoIncrement = sal_False;
	xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_TYPENAME))			>>= sTypeName;
	xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_TYPE))				>>= nDataType;
	xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_PRECISION))			>>= nPrecision;
	xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCALE))				>>= nScale;
	xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT))	>>= bIsAutoIncrement;

	// check if the user enter a specific string to create autoincrement values
	::rtl::OUString sAutoIncrementValue;
	Reference<XPropertySetInfo> xPropInfo = xColProp->getPropertySetInfo();
	if ( xPropInfo.is() && xPropInfo->hasPropertyByName(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) )
		xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) >>= sAutoIncrementValue;
	// look if we have to use precisions
	sal_Bool bUseLiteral = sal_False;
	::rtl::OUString sPreFix,sPostFix,sCreateParams;
	{
		Reference<XResultSet> xRes = xMetaData->getTypeInfo();
		if(xRes.is())
		{
			Reference<XRow> xRow(xRes,UNO_QUERY);
			while(xRes->next())
			{
				::rtl::OUString sTypeName2Cmp = xRow->getString(1);
				sal_Int32 nType = xRow->getShort(2);
				sPreFix = xRow->getString (4);
				sPostFix = xRow->getString (5);
				sCreateParams = xRow->getString(6);
				// first identical type will be used if typename is empty
				if ( !sTypeName.getLength() && nType == nDataType )
					sTypeName = sTypeName2Cmp;

				if( sTypeName.equalsIgnoreAsciiCase(sTypeName2Cmp) && nType == nDataType && sCreateParams.getLength() && !xRow->wasNull())
				{
					bUseLiteral = sal_True;
					break;
				}
			}
		}
	}

	sal_Int32 nIndex = 0;
	if ( sAutoIncrementValue.getLength() && (nIndex = sTypeName.indexOf(sAutoIncrementValue)) != -1 )
	{
		sTypeName = sTypeName.replaceAt(nIndex,sTypeName.getLength() - nIndex,::rtl::OUString());
	}

	if ( (nPrecision > 0 || nScale > 0) && bUseLiteral )
	{
		sal_Int32 nParenPos = sTypeName.indexOf('(');
		if ( nParenPos == -1 )
		{
			aSql.append(sTypeName);
			aSql.appendAscii("(");
		}
		else
		{
			aSql.append(sTypeName.copy(0,++nParenPos));
		}

        if ( nPrecision > 0 && nDataType != DataType::TIMESTAMP )
        {
		    aSql.append(nPrecision);
            if ( (nScale > 0) || (_sCreatePattern.getLength() && sCreateParams.indexOf(_sCreatePattern) != -1) )
                aSql.appendAscii(",");
        }
		if ( (nScale > 0) || (_sCreatePattern.getLength() && sCreateParams.indexOf(_sCreatePattern) != -1 ) || nDataType == DataType::TIMESTAMP )
			aSql.append(nScale);

        if ( nParenPos == -1 )
			aSql.appendAscii(")");
		else
		{
			nParenPos = sTypeName.indexOf(')',nParenPos);
			aSql.append(sTypeName.copy(nParenPos));
		}
	}
	else
		aSql.append(sTypeName); // simply add the type name

	::rtl::OUString aDefault = ::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_DEFAULTVALUE)));
	if ( aDefault.getLength() )
    {
		aSql.append(::rtl::OUString::createFromAscii(" DEFAULT ")); 
        aSql.append(sPreFix);
        aSql.append(aDefault);
        aSql.append(sPostFix);
    } // if ( aDefault.getLength() )

	if(::comphelper::getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_ISNULLABLE))) == ColumnValue::NO_NULLS)
		aSql.append(::rtl::OUString::createFromAscii(" NOT NULL"));

	if ( bIsAutoIncrement && sAutoIncrementValue.getLength())
	{
		aSql.appendAscii(" ");
		aSql.append(sAutoIncrementValue);
	}

    if ( _pHelper )
        _pHelper->addComment(xColProp,aSql);

	return aSql.makeStringAndClear();
}
// -----------------------------------------------------------------------------

::rtl::OUString createStandardCreateStatement(const Reference< XPropertySet >& descriptor,const Reference< XConnection>& _xConnection,ISQLStatementHelper* _pHelper,const ::rtl::OUString& _sCreatePattern)
{
	::rtl::OUStringBuffer aSql	= ::rtl::OUString::createFromAscii("CREATE TABLE ");
	::rtl::OUString sCatalog,sSchema,sTable,sComposedName;

	Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
	::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();

	descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME))	>>= sCatalog;
	descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME))	>>= sSchema;
	descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME))			>>= sTable;

	sComposedName = ::dbtools::composeTableName( xMetaData, sCatalog, sSchema, sTable, sal_True, ::dbtools::eInTableDefinitions );
	if ( !sComposedName.getLength() )
		::dbtools::throwFunctionSequenceException(_xConnection);

	aSql.append(sComposedName);
    aSql.append(::rtl::OUString::createFromAscii(" ("));

	// columns
	Reference<XColumnsSupplier> xColumnSup(descriptor,UNO_QUERY);
	Reference<XIndexAccess> xColumns(xColumnSup->getColumns(),UNO_QUERY);
	// check if there are columns
	if(!xColumns.is() || !xColumns->getCount()) 
		::dbtools::throwFunctionSequenceException(_xConnection);

	Reference< XPropertySet > xColProp;

	sal_Int32 nCount = xColumns->getCount();
	for(sal_Int32 i=0;i<nCount;++i)
	{
		if ( (xColumns->getByIndex(i) >>= xColProp) && xColProp.is() )
		{
			aSql.append(createStandardColumnPart(xColProp,_xConnection,_pHelper,_sCreatePattern));
			aSql.appendAscii(",");
		}
	}
	return aSql.makeStringAndClear();
}
namespace
{
	::rtl::OUString generateColumnNames(const Reference<XIndexAccess>& _xColumns,const Reference<XDatabaseMetaData>& _xMetaData)
	{
		::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
		static const ::rtl::OUString sComma(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(",")));
		
		const ::rtl::OUString sQuote(_xMetaData->getIdentifierQuoteString());
		::rtl::OUString sSql = ::rtl::OUString::createFromAscii(" (");
		Reference< XPropertySet > xColProp;

		sal_Int32 nColCount  = _xColumns->getCount();
		for(sal_Int32 i=0;i<nColCount;++i)
		{
			if ( (_xColumns->getByIndex(i) >>= xColProp) && xColProp.is() )
				sSql += ::dbtools::quoteName(sQuote,::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME))))
						+ sComma;
		}

		if ( nColCount )
			sSql = sSql.replaceAt(sSql.getLength()-1,1,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")));
		return sSql;
	}
}
// -----------------------------------------------------------------------------
::rtl::OUString createStandardKeyStatement(const Reference< XPropertySet >& descriptor,const Reference< XConnection>& _xConnection)
{
	Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
	::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();

	::rtl::OUStringBuffer aSql;
	// keys
	Reference<XKeysSupplier> xKeySup(descriptor,UNO_QUERY);
	Reference<XIndexAccess> xKeys = xKeySup->getKeys();
	if ( xKeys.is() )
	{
		Reference< XPropertySet > xColProp;
		Reference<XIndexAccess> xColumns;
		Reference<XColumnsSupplier> xColumnSup;
		::rtl::OUString sCatalog,sSchema,sTable,sComposedName;
		sal_Bool bPKey = sal_False;
		for(sal_Int32 i=0;i<xKeys->getCount();++i)
		{
			if ( (xKeys->getByIndex(i) >>= xColProp) && xColProp.is() )
			{

				sal_Int32 nKeyType		= ::comphelper::getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_TYPE)));

				if ( nKeyType == KeyType::PRIMARY )
				{
					if(bPKey)
						::dbtools::throwFunctionSequenceException(_xConnection);

					bPKey = sal_True;
					xColumnSup = Reference<XColumnsSupplier>(xColProp,UNO_QUERY);
					xColumns = Reference<XIndexAccess>(xColumnSup->getColumns(),UNO_QUERY);
					if(!xColumns.is() || !xColumns->getCount())
						::dbtools::throwFunctionSequenceException(_xConnection);

					const ::rtl::OUString sQuote	 = xMetaData->getIdentifierQuoteString();
					aSql.append(::rtl::OUString::createFromAscii(" PRIMARY KEY "));
					aSql.append(generateColumnNames(xColumns,xMetaData));
				}
				else if(nKeyType == KeyType::UNIQUE)
				{
					xColumnSup = Reference<XColumnsSupplier>(xColProp,UNO_QUERY);
					xColumns = Reference<XIndexAccess>(xColumnSup->getColumns(),UNO_QUERY);
					if(!xColumns.is() || !xColumns->getCount())
						::dbtools::throwFunctionSequenceException(_xConnection);

					const ::rtl::OUString sQuote	 = xMetaData->getIdentifierQuoteString();
					aSql.append(::rtl::OUString::createFromAscii(" UNIQUE "));
					aSql.append(generateColumnNames(xColumns,xMetaData));
				}
				else if(nKeyType == KeyType::FOREIGN)
				{
					sal_Int32 nDeleteRule	= getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_DELETERULE)));

					xColumnSup = Reference<XColumnsSupplier>(xColProp,UNO_QUERY);
					xColumns = Reference<XIndexAccess>(xColumnSup->getColumns(),UNO_QUERY);
					if(!xColumns.is() || !xColumns->getCount())
						::dbtools::throwFunctionSequenceException(_xConnection);

					aSql.append(::rtl::OUString::createFromAscii(" FOREIGN KEY "));
					::rtl::OUString sRefTable = getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_REFERENCEDTABLE)));
					::dbtools::qualifiedNameComponents(xMetaData,
														sRefTable,
														sCatalog, 
														sSchema, 
														sTable,
														::dbtools::eInDataManipulation);
					sComposedName = ::dbtools::composeTableName( xMetaData, sCatalog, sSchema, sTable, sal_True, ::dbtools::eInTableDefinitions );
					

					if ( !sComposedName.getLength() )
						::dbtools::throwFunctionSequenceException(_xConnection);

					aSql.append(generateColumnNames(xColumns,xMetaData));

					switch(nDeleteRule)
					{
						case KeyRule::CASCADE:
							aSql.append(::rtl::OUString::createFromAscii(" ON DELETE CASCADE "));
							break;
						case KeyRule::RESTRICT:
							aSql.append(::rtl::OUString::createFromAscii(" ON DELETE RESTRICT "));
							break;
						case KeyRule::SET_NULL:
							aSql.append(::rtl::OUString::createFromAscii(" ON DELETE SET NULL "));
							break;
						case KeyRule::SET_DEFAULT:
							aSql.append(::rtl::OUString::createFromAscii(" ON DELETE SET DEFAULT "));
							break;
						default:
							;
					}
				}
			}
		}
	}

	if ( aSql.getLength() )
	{
		if ( aSql.charAt(aSql.getLength()-1) == ',' )
			aSql.setCharAt(aSql.getLength()-1,')');
		else
			aSql.appendAscii(")");
	}

	return aSql.makeStringAndClear();

}
// -----------------------------------------------------------------------------
::rtl::OUString createSqlCreateTableStatement(	const Reference< XPropertySet >& descriptor,
												const Reference< XConnection>& _xConnection,
                                                ISQLStatementHelper* _pHelper,
                                                const ::rtl::OUString& _sCreatePattern)
{
	::rtl::OUString aSql = ::dbtools::createStandardCreateStatement(descriptor,_xConnection,_pHelper,_sCreatePattern);
	const ::rtl::OUString sKeyStmt = ::dbtools::createStandardKeyStatement(descriptor,_xConnection);
	if ( sKeyStmt.getLength() )
		aSql += sKeyStmt;
	else
	{
		if ( aSql.lastIndexOf(',') == (aSql.getLength()-1) )
			aSql = aSql.replaceAt(aSql.getLength()-1,1,::rtl::OUString::createFromAscii(")"));
		else
			aSql += ::rtl::OUString::createFromAscii(")");
	}
	return aSql;
}
namespace 
{
	Reference<XPropertySet> lcl_createSDBCXColumn(const Reference<XNameAccess>& _xPrimaryKeyColumns,
										  const Reference<XConnection>& _xConnection,
										  const Any& _aCatalog,
										  const ::rtl::OUString& _aSchema,
										  const ::rtl::OUString& _aTable,
										  const ::rtl::OUString& _rQueryName,
										  const ::rtl::OUString& _rName,
										  sal_Bool _bCase,
										  sal_Bool _bQueryForInfo,
										  sal_Bool _bIsAutoIncrement,
										  sal_Bool _bIsCurrency,
										  sal_Int32 _nDataType)
	{
		Reference<XPropertySet> xProp;
		Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
		Reference< XResultSet > xResult = xMetaData->getColumns(_aCatalog, _aSchema, _aTable, _rQueryName);

		if ( xResult.is() )
		{
			UStringMixEqual aMixCompare(_bCase);
			Reference< XRow > xRow(xResult,UNO_QUERY);
			while( xResult->next() )
			{
				if ( aMixCompare(xRow->getString(4),_rName) )
				{
					sal_Int32		nField5	= xRow->getInt(5);
					::rtl::OUString aField6 = xRow->getString(6);
					sal_Int32		nField7 = xRow->getInt(7)
								,	nField9 = xRow->getInt(9)
								,	nField11= xRow->getInt(11);
					::rtl::OUString sField12 = xRow->getString(12),
                                    sField13 = xRow->getString(13);
					::comphelper::disposeComponent(xRow);

					sal_Bool bAutoIncrement = _bIsAutoIncrement
							,bIsCurrency	= _bIsCurrency;
					if ( _bQueryForInfo )
					{
						const ::rtl::OUString sQuote = xMetaData->getIdentifierQuoteString();
						::rtl::OUString sQuotedName  = ::dbtools::quoteName(sQuote,_rName);
						::rtl::OUString sComposedName;
						sComposedName = composeTableNameForSelect(_xConnection, getString( _aCatalog ), _aSchema, _aTable );

						ColumnInformationMap aInfo(_bCase);
						collectColumnInformation(_xConnection,sComposedName,sQuotedName,aInfo);
						ColumnInformationMap::iterator aIter = aInfo.begin();
						if ( aIter != aInfo.end() )
						{
							bAutoIncrement	= aIter->second.first.first;
							bIsCurrency		= aIter->second.first.second;
							if ( DataType::OTHER == nField5 )
								nField5		= aIter->second.second;
						}
					}
					else if ( DataType::OTHER == nField5 )
						nField5 = _nDataType;
					
					if ( nField11 != ColumnValue::NO_NULLS )
					{
						try
						{
                            if ( _xPrimaryKeyColumns.is() )
                            {
                                if ( _xPrimaryKeyColumns->hasByName(_rName) )
                                    nField11 = ColumnValue::NO_NULLS;
                                
                            }
                            else
                            {
							    Reference< XResultSet > xPKeys = xMetaData->getPrimaryKeys( _aCatalog, _aSchema, _aTable );
                                Reference< XRow > xPKeyRow( xPKeys, UNO_QUERY_THROW );
                                while( xPKeys->next() ) // there can be only one primary key
							    {
                                    ::rtl::OUString sKeyColumn = xPKeyRow->getString(4);
								    if ( aMixCompare(_rName,sKeyColumn) )
								    {
									    nField11 = ColumnValue::NO_NULLS;
									    break;
								    }
							    }
							}
                        }
						catch(SQLException&)
						{
                            OSL_ENSURE( false, "lcl_createSDBCXColumn: caught an exception!" );
						}
					}

					connectivity::sdbcx::OColumn* pRet = new connectivity::sdbcx::OColumn(_rName,
												aField6,
												sField13,
                                                sField12,
												nField11,
												nField7,
												nField9,
												nField5,
												bAutoIncrement,
												sal_False,
												bIsCurrency,
												_bCase);

					xProp = pRet;
					break;
				}
			}
		}

		return xProp;
	}
	//------------------------------------------------------------------
	Reference< XModel> lcl_getXModel(const Reference< XInterface>& _xIface)
	{
		Reference< XInterface > xParent = _xIface;
		Reference< XModel > xModel(xParent,UNO_QUERY);;
		while( xParent.is() && !xModel.is() )
		{
			Reference<XChild> xChild(xParent,UNO_QUERY);
			xParent.set(xChild.is() ? xChild->getParent() : Reference< XInterface >(),UNO_QUERY);
			xModel.set(xParent,UNO_QUERY);
		}
		return xModel;
	}
}
// -----------------------------------------------------------------------------
Reference<XPropertySet> createSDBCXColumn(const Reference<XPropertySet>& _xTable,
										  const Reference<XConnection>& _xConnection,
										  const ::rtl::OUString& _rName,
										  sal_Bool _bCase,
										  sal_Bool _bQueryForInfo,
										  sal_Bool _bIsAutoIncrement,
										  sal_Bool _bIsCurrency,
										  sal_Int32 _nDataType)
{
	Reference<XPropertySet> xProp;
	OSL_ENSURE(_xTable.is(),"Table is NULL!");
	if ( !_xTable.is() )
		return xProp;

	::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
	Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
	Any aCatalog;
	aCatalog = _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME));

	::rtl::OUString aSchema, aTable;
	_xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME))	>>= aSchema;
	_xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME))		>>= aTable;
  
    Reference<XNameAccess> xPrimaryKeyColumns = getPrimaryKeyColumns_throw(_xTable);

	xProp = lcl_createSDBCXColumn(xPrimaryKeyColumns,_xConnection,aCatalog, aSchema, aTable, _rName,_rName,_bCase,_bQueryForInfo,_bIsAutoIncrement,_bIsCurrency,_nDataType);
	if ( !xProp.is() )
	{
		xProp = lcl_createSDBCXColumn(xPrimaryKeyColumns,_xConnection,aCatalog, aSchema, aTable, ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("%")),_rName,_bCase,_bQueryForInfo,_bIsAutoIncrement,_bIsCurrency,_nDataType);
		if ( !xProp.is() )
			xProp = new connectivity::sdbcx::OColumn(_rName,
												::rtl::OUString(),::rtl::OUString(),::rtl::OUString(),
												ColumnValue::NULLABLE_UNKNOWN,
												0,
												0,
												DataType::VARCHAR,
												_bIsAutoIncrement,
												sal_False,
												_bIsCurrency,
												_bCase);

	}

	return xProp;
}

// -----------------------------------------------------------------------------
bool getBooleanDataSourceSetting( const Reference< XConnection >& _rxConnection, const sal_Char* _pAsciiSettingName )
{
    bool bValue( false );
    try
    {
		Reference< XPropertySet> xDataSourceProperties( findDataSource( _rxConnection ), UNO_QUERY );
        OSL_ENSURE( xDataSourceProperties.is(), "::dbtools::getBooleanDataSourceSetting: somebody is using this with a non-SDB-level connection!" );
		if ( xDataSourceProperties.is() )
		{
			Reference< XPropertySet > xSettings(
			    xDataSourceProperties->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Settings") ) ),
                UNO_QUERY_THROW
            );
            OSL_VERIFY( xSettings->getPropertyValue( ::rtl::OUString::createFromAscii( _pAsciiSettingName ) ) >>= bValue );
		}
    }
    catch( const Exception& )
    {
    	DBG_UNHANDLED_EXCEPTION();
    }
    return bValue;
}
// -------------------------------------------------------------------------
bool getDataSourceSetting( const Reference< XInterface >& _xChild, const ::rtl::OUString& _sAsciiSettingsName,
    Any& /* [out] */ _rSettingsValue )
{
    bool bIsPresent = false;
    try
    {
        const Reference< XPropertySet> xDataSourceProperties( findDataSource( _xChild ), UNO_QUERY );
        if ( !xDataSourceProperties.is() )
            return false;

        const Reference< XPropertySet > xSettings(
			    xDataSourceProperties->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Settings") ) ),
                UNO_QUERY_THROW
            );

        _rSettingsValue = xSettings->getPropertyValue( _sAsciiSettingsName );
        bIsPresent = true;
    }
    catch( const Exception& )
    {
	    bIsPresent = false;
    }
    return bIsPresent;
}
// -------------------------------------------------------------------------
bool getDataSourceSetting( const Reference< XInterface >& _rxDataSource, const sal_Char* _pAsciiSettingsName,
    Any& /* [out] */ _rSettingsValue )
{
    ::rtl::OUString sAsciiSettingsName = ::rtl::OUString::createFromAscii(_pAsciiSettingsName);
    return getDataSourceSetting( _rxDataSource, sAsciiSettingsName,_rSettingsValue );
}
// -----------------------------------------------------------------------------
sal_Bool isDataSourcePropertyEnabled(const Reference<XInterface>& _xProp,const ::rtl::OUString& _sProperty,sal_Bool _bDefault)
{
	sal_Bool bEnabled = _bDefault;
	try
	{
		Reference< XPropertySet> xProp(findDataSource(_xProp),UNO_QUERY);
		if ( xProp.is() )
		{
			Sequence< PropertyValue > aInfo;
			xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Info"))) >>= aInfo;
			const PropertyValue* pValue =::std::find_if(aInfo.getConstArray(),
												aInfo.getConstArray() + aInfo.getLength(),
												::std::bind2nd(TPropertyValueEqualFunctor(),_sProperty));
			if ( pValue && pValue != (aInfo.getConstArray() + aInfo.getLength()) )
				pValue->Value >>= bEnabled;
		}
	}
	catch(SQLException&)
	{
        DBG_UNHANDLED_EXCEPTION();
	}
	return bEnabled;
}
// -----------------------------------------------------------------------------
Reference< XTablesSupplier> getDataDefinitionByURLAndConnection(
			const ::rtl::OUString& _rsUrl,
			const Reference< XConnection>& _xConnection,
			const Reference< XMultiServiceFactory>& _rxFactory)
{
	Reference< XTablesSupplier> xTablesSup;
    try
    {
	    Reference< XDriverAccess> xManager(
            _rxFactory->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.sdbc.DriverManager") ),
            UNO_QUERY_THROW );
	    Reference< XDataDefinitionSupplier > xSupp( xManager->getDriverByURL( _rsUrl ), UNO_QUERY );
    	
	    if ( xSupp.is() )
        {
		    xTablesSup = xSupp->getDataDefinitionByConnection( _xConnection );
            OSL_ENSURE(xTablesSup.is(),"No table supplier!");
        }
    }
    catch( const Exception& )
    {
    	DBG_UNHANDLED_EXCEPTION();
    }
	return xTablesSup;
}

// -----------------------------------------------------------------------------
sal_Int32 getTablePrivileges(const Reference< XDatabaseMetaData>& _xMetaData,
							 const ::rtl::OUString& _sCatalog,
							 const ::rtl::OUString& _sSchema,
							 const ::rtl::OUString& _sTable)
{
	OSL_ENSURE(_xMetaData.is(),"Invalid metadata!");
	sal_Int32 nPrivileges = 0;
	try
	{
		Any aVal;
		if(_sCatalog.getLength())
			aVal <<= _sCatalog;
		Reference< XResultSet > xPrivileges = _xMetaData->getTablePrivileges(aVal, _sSchema, _sTable);
		Reference< XRow > xCurrentRow(xPrivileges, UNO_QUERY);

		if ( xCurrentRow.is() )
		{
			::rtl::OUString sUserWorkingFor = _xMetaData->getUserName();
			static const ::rtl::OUString sSELECT	= ::rtl::OUString::createFromAscii("SELECT");
			static const ::rtl::OUString sINSERT	= ::rtl::OUString::createFromAscii("INSERT");
			static const ::rtl::OUString sUPDATE	= ::rtl::OUString::createFromAscii("UPDATE");
			static const ::rtl::OUString sDELETE	= ::rtl::OUString::createFromAscii("DELETE");
			static const ::rtl::OUString sREAD		= ::rtl::OUString::createFromAscii("READ");
			static const ::rtl::OUString sCREATE	= ::rtl::OUString::createFromAscii("CREATE");
			static const ::rtl::OUString sALTER		= ::rtl::OUString::createFromAscii("ALTER");
			static const ::rtl::OUString sREFERENCE = ::rtl::OUString::createFromAscii("REFERENCE");
			static const ::rtl::OUString sDROP		= ::rtl::OUString::createFromAscii("DROP");
			// after creation the set is positioned before the first record, per definitionem
#ifdef DBG_UTIL
			Reference< XResultSetMetaDataSupplier > xSup(xPrivileges,UNO_QUERY);
			if ( xSup.is() )
			{
				Reference< XResultSetMetaData > xRsMetaData = xSup->getMetaData();
				if ( xRsMetaData.is() )
				{
					sal_Int32 nCount = xRsMetaData->getColumnCount();
					for (sal_Int32 i=1; i<=nCount; ++i)
					{
						::rtl::OUString sColumnName = xRsMetaData->getColumnName(i);
					}
				}
			}
#endif

			::rtl::OUString sPrivilege, sGrantee;
			while ( xPrivileges->next() )
			{
#ifdef DBG_UTIL
				::rtl::OUString sCat, sSchema, sName, sGrantor, sGrantable;
				sCat		= xCurrentRow->getString(1);
				sSchema		= xCurrentRow->getString(2);
				sName		= xCurrentRow->getString(3);
				sGrantor	= xCurrentRow->getString(4);
#endif
				sGrantee	= xCurrentRow->getString(5);
				sPrivilege	= xCurrentRow->getString(6);
#ifdef DBG_UTIL
				sGrantable	= xCurrentRow->getString(7);
#endif

				if (!sUserWorkingFor.equalsIgnoreAsciiCase(sGrantee))
					continue;

				if (sPrivilege.equalsIgnoreAsciiCase(sSELECT))
					nPrivileges |= Privilege::SELECT;
				else if (sPrivilege.equalsIgnoreAsciiCase(sINSERT))
					nPrivileges |= Privilege::INSERT;
				else if (sPrivilege.equalsIgnoreAsciiCase(sUPDATE))
					nPrivileges |= Privilege::UPDATE;
				else if (sPrivilege.equalsIgnoreAsciiCase(sDELETE))
					nPrivileges |= Privilege::DELETE;
				else if (sPrivilege.equalsIgnoreAsciiCase(sREAD))
					nPrivileges |= Privilege::READ;
				else if (sPrivilege.equalsIgnoreAsciiCase(sCREATE))
					nPrivileges |= Privilege::CREATE;
				else if (sPrivilege.equalsIgnoreAsciiCase(sALTER))
					nPrivileges |= Privilege::ALTER;
				else if (sPrivilege.equalsIgnoreAsciiCase(sREFERENCE))
					nPrivileges |= Privilege::REFERENCE;
				else if (sPrivilege.equalsIgnoreAsciiCase(sDROP))
					nPrivileges |= Privilege::DROP;
			}
		}
		disposeComponent(xPrivileges);
	}
	catch(const SQLException& e)
	{
		static ::rtl::OUString sNotSupportedState = ::rtl::OUString::createFromAscii("IM001");
		// some drivers don't support any privileges so we assume that we are allowed to do all we want :-)
		if(e.SQLState == sNotSupportedState)
			nPrivileges |=	Privilege::DROP			| 
							Privilege::REFERENCE	| 
							Privilege::ALTER		|
							Privilege::CREATE		|
							Privilege::READ			|
							Privilege::DELETE		|
							Privilege::UPDATE		|
							Privilege::INSERT		|
							Privilege::SELECT;
		else
			OSL_ENSURE(0,"Could not collect the privileges !");
	}
	return nPrivileges;
}
// -----------------------------------------------------------------------------
// we need some more information about the column
void collectColumnInformation(const Reference< XConnection>& _xConnection,
							  const ::rtl::OUString& _sComposedName,
							  const ::rtl::OUString& _rName,
							  ColumnInformationMap& _rInfo)
{
	static ::rtl::OUString STR_WHERE = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" WHERE "));

	::rtl::OUString sSelect = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SELECT "));
	sSelect += _rName;
	sSelect += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" FROM "));
	sSelect += _sComposedName;
	sSelect += STR_WHERE;
	sSelect += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("0 = 1"));

	try
	{
        ::utl::SharedUNOComponent< XStatement > xStmt( _xConnection->createStatement() );
        Reference< XPropertySet > xStatementProps( xStmt, UNO_QUERY_THROW );
        xStatementProps->setPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_ESCAPEPROCESSING ), makeAny( (sal_Bool)sal_False ) );
		Reference< XResultSet > xResult( xStmt->executeQuery( sSelect ), UNO_QUERY_THROW );
        Reference< XResultSetMetaDataSupplier > xSuppMeta( xResult, UNO_QUERY_THROW );
		Reference< XResultSetMetaData > xMeta( xSuppMeta->getMetaData(), UNO_QUERY_THROW );

        sal_Int32 nCount = xMeta->getColumnCount();
        OSL_ENSURE( nCount != 0, "::dbtools::collectColumnInformation: result set has empty (column-less) meta data!" );
		for (sal_Int32 i=1; i <= nCount ; ++i)
		{
			_rInfo.insert(ColumnInformationMap::value_type(xMeta->getColumnName(i),
				ColumnInformation(TBoolPair(xMeta->isAutoIncrement(i),xMeta->isCurrency(i)),xMeta->getColumnType(i))));
		}
	}
    catch( const Exception& )
    {
    	DBG_UNHANDLED_EXCEPTION();
    }
}

// -----------------------------------------------------------------------------
bool isEmbeddedInDatabase( const Reference< XInterface >& _rxComponent, Reference< XConnection >& _rxActualConnection )
{
    bool bIsEmbedded = false;
	try
	{
		Reference< XModel > xModel = lcl_getXModel( _rxComponent );
    	
		if ( xModel.is() )
		{
			Sequence< PropertyValue > aArgs = xModel->getArgs();
			const PropertyValue* pIter = aArgs.getConstArray();
			const PropertyValue* pEnd  = pIter + aArgs.getLength();
			for(;pIter != pEnd;++pIter)
			{
				if ( pIter->Name.equalsAscii("ComponentData") )
				{
					Sequence<PropertyValue> aDocumentContext;
					pIter->Value >>= aDocumentContext;
					const PropertyValue* pContextIter = aDocumentContext.getConstArray();
					const PropertyValue* pContextEnd  = pContextIter + aDocumentContext.getLength();
					for(;pContextIter != pContextEnd;++pContextIter)
					{
						if (  pContextIter->Name.equalsAscii( "ActiveConnection" )
                        && ( pContextIter->Value >>= _rxActualConnection )
                        )
						{
                            bIsEmbedded = true;
							break;
						}
					}
					break;
				}
			}
		}
	}
	catch(Exception&)
	{
		// not intereseted in 
	}
    return bIsEmbedded;
}
// -----------------------------------------------------------------------------
namespace
{
    ::rtl::OUString lcl_getEncodingName( rtl_TextEncoding _eEncoding )
    {
        ::rtl::OUString sEncodingName;

        OCharsetMap aCharsets;
        OCharsetMap::CharsetIterator aEncodingPos = aCharsets.find( _eEncoding );
        OSL_ENSURE( aEncodingPos != aCharsets.end(), "lcl_getEncodingName: *which* encoding?" );
        if ( aEncodingPos != aCharsets.end() )
            sEncodingName = (*aEncodingPos).getIanaName();

        return sEncodingName;
    }
}

// -----------------------------------------------------------------------------
sal_Int32 DBTypeConversion::convertUnicodeString( const ::rtl::OUString& _rSource, ::rtl::OString& _rDest, rtl_TextEncoding _eEncoding ) SAL_THROW((com::sun::star::sdbc::SQLException))
{
    if ( !rtl_convertUStringToString( &_rDest.pData, _rSource.getStr(), _rSource.getLength(),
            _eEncoding,
            RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
            RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE |
            RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 |
            RTL_UNICODETOTEXT_FLAGS_NOCOMPOSITE )
        )
    {
        SharedResources aResources;
        ::rtl::OUString sMessage = aResources.getResourceStringWithSubstitution( STR_CANNOT_CONVERT_STRING,
            "$string$", _rSource,
            "$charset$",  lcl_getEncodingName( _eEncoding )
        );
        
        throw SQLException(
            sMessage,
            NULL,
            ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "22018" ) ),
            22018,
            Any()
        );
    }

    return _rDest.getLength();
}

// -----------------------------------------------------------------------------
sal_Int32 DBTypeConversion::convertUnicodeStringToLength( const ::rtl::OUString& _rSource, ::rtl::OString&  _rDest,
   sal_Int32 _nMaxLen, rtl_TextEncoding _eEncoding ) SAL_THROW((SQLException))
{
    sal_Int32 nLen = convertUnicodeString( _rSource, _rDest, _eEncoding );
    if ( nLen > _nMaxLen )
    {
        SharedResources aResources;
        ::rtl::OUString sMessage = aResources.getResourceStringWithSubstitution( STR_STRING_LENGTH_EXCEEDED,
            "$string$", _rSource,
            "$maxlen$", ::rtl::OUString::valueOf( _nMaxLen ),
            "$charset$", lcl_getEncodingName( _eEncoding )
        );

        throw SQLException(
            sMessage,
            NULL,
            ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "22001" ) ),
            22001,
            Any()
        );
    }

   return nLen;
}
::rtl::OUString lcl_getReportEngines()
{
	static ::rtl::OUString s_sNodeName(RTL_CONSTASCII_USTRINGPARAM("org.openoffice.Office.DataAccess/ReportEngines"));
	return s_sNodeName;
}
// -----------------------------------------------------------------------------
::rtl::OUString lcl_getDefaultReportEngine()
{
	static ::rtl::OUString s_sNodeName(RTL_CONSTASCII_USTRINGPARAM("DefaultReportEngine"));
	return s_sNodeName;
}
// -----------------------------------------------------------------------------
::rtl::OUString lcl_getReportEngineNames()
{
	static ::rtl::OUString s_sNodeName(RTL_CONSTASCII_USTRINGPARAM("ReportEngineNames"));
	return s_sNodeName;
}
// -----------------------------------------------------------------------------
::rtl::OUString getDefaultReportEngineServiceName(const Reference< XMultiServiceFactory >& _rxORB)
{
	::utl::OConfigurationTreeRoot aReportEngines = ::utl::OConfigurationTreeRoot::createWithServiceFactory(
		_rxORB, lcl_getReportEngines(), -1, ::utl::OConfigurationTreeRoot::CM_READONLY);

	if ( aReportEngines.isValid() )
	{
		::rtl::OUString sDefaultReportEngineName;
		aReportEngines.getNodeValue(lcl_getDefaultReportEngine()) >>= sDefaultReportEngineName;
        if ( sDefaultReportEngineName.getLength() )
        {
		    ::utl::OConfigurationNode aReportEngineNames = aReportEngines.openNode(lcl_getReportEngineNames());
		    if ( aReportEngineNames.isValid() )
		    {
			    ::utl::OConfigurationNode aReportEngine = aReportEngineNames.openNode(sDefaultReportEngineName);
			    if ( aReportEngine.isValid() )
			    {
                    ::rtl::OUString sRet;
		            const static ::rtl::OUString s_sService(RTL_CONSTASCII_USTRINGPARAM("ServiceName"));
		            aReportEngine.getNodeValue(s_sService) >>= sRet;
				    return sRet;
			    }
		    }
        }
    	else
        	return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.report.pentaho.SOReportJobFactory"));
	}
    else
        return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.report.pentaho.SOReportJobFactory"));
	return ::rtl::OUString();
}
// -----------------------------------------------------------------------------
//.........................................................................
}	// namespace dbtools
//.........................................................................