/* -*- 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/CommonTools.hxx>

#include <TConnection.hxx>

#include <ParameterCont.hxx>

#include <com/sun/star/awt/XWindow.hpp>

#include <com/sun/star/beans/NamedValue.hpp>

#include <com/sun/star/beans/PropertyAttribute.hpp>

#include <com/sun/star/container/XChild.hpp>

#include <com/sun/star/form/FormComponentType.hpp>

#include <com/sun/star/io/XInputStream.hpp>

#include <com/sun/star/lang/DisposedException.hpp>

#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>

#include <com/sun/star/lang/XInitialization.hpp>

#include <com/sun/star/lang/XMultiServiceFactory.hpp>

#include <com/sun/star/sdb/DatabaseContext.hpp>

#include <com/sun/star/sdb/BooleanComparisonMode.hpp>

#include <com/sun/star/sdb/CommandType.hpp>

#include <com/sun/star/sdb/ErrorMessageDialog.hpp>

#include <com/sun/star/sdb/ParametersRequest.hpp>

#include <com/sun/star/sdb/RowSetVetoException.hpp>

#include <com/sun/star/sdb/SQLContext.hpp>

#include <com/sun/star/sdb/XCompletedConnection.hpp>

#include <com/sun/star/sdb/XOfficeDatabaseDocument.hpp>

#include <com/sun/star/sdb/XParametersSupplier.hpp>

#include <com/sun/star/sdb/XQueriesSupplier.hpp>

#include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp>

#include <com/sun/star/sdbc/ConnectionPool.hpp>

#include <com/sun/star/sdbc/DataType.hpp>

#include <com/sun/star/sdbc/XConnection.hpp>

#include <com/sun/star/sdbc/XDataSource.hpp>

#include <com/sun/star/sdbc/XParameters.hpp>

#include <com/sun/star/sdbc/XRow.hpp>

#include <com/sun/star/sdbc/XRowSet.hpp>

#include <com/sun/star/sdbc/XRowUpdate.hpp>

#include <com/sun/star/sdbcx/KeyType.hpp>

#include <com/sun/star/sdbcx/Privilege.hpp>

#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>

#include <com/sun/star/sdbcx/XKeysSupplier.hpp>

#include <com/sun/star/sdbcx/XTablesSupplier.hpp>

#include <com/sun/star/task/InteractionHandler.hpp>

#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>

#include <com/sun/star/util/NumberFormat.hpp>

#include <com/sun/star/util/NumberFormatsSupplier.hpp>

#include <com/sun/star/util/XNumberFormatTypes.hpp>

#include <comphelper/extract.hxx>

#include <comphelper/interaction.hxx>

#include <comphelper/property.hxx>

#include <comphelper/propertysequence.hxx>

#include <comphelper/types.hxx>

#include <connectivity/conncleanup.hxx>

#include <connectivity/dbconversion.hxx>

#include <connectivity/dbexception.hxx>

#include <connectivity/dbtools.hxx>

#include <connectivity/FValue.hxx>

#include <connectivity/statementcomposer.hxx>

#include <o3tl/any.hxx>

#include <o3tl/safeint.hxx>

#include <osl/diagnose.h>

#include <rtl/ustrbuf.hxx>

#include <sal/log.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <tools/stream.hxx>

#include <cppuhelper/implbase.hxx>

#include <strings.hrc>

#include <resource/sharedresources.hxx>

#include <algorithm>

#include <iterator>

#include <set>

using namespace ::comphelper;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star::io;

using namespace ::com::sun::star::awt;

using namespace ::com::sun::star::ui::dialogs;

using namespace ::com::sun::star::util;

using namespace ::com::sun::star::lang;

using namespace ::com::sun::star::beans;

using namespace ::com::sun::star::container;

using namespace ::com::sun::star::sdb;

using namespace ::com::sun::star::sdbc;

using namespace ::com::sun::star::sdbcx;

using namespace ::com::sun::star::task;

using namespace ::com::sun::star::form;

using namespace connectivity;

namespace dbtools

{

namespace

{

    typedef sal_Bool (SAL_CALL XDatabaseMetaData::*FMetaDataSupport)();

}

sal_Int32 getDefaultNumberFormat(const Reference< XPropertySet >& _xColumn,

                                 const Reference< XNumberFormatTypes >& _xTypes,

                                 const Locale& _rLocale)

{

    OSL_ENSURE(_xTypes.is() && _xColumn.is(), "dbtools::getDefaultNumberFormat: invalid arg !");

    if (!_xTypes.is() || !_xColumn.is())

        return NumberFormat::UNDEFINED;

    sal_Int32 nDataType = 0;

    sal_Int32 nScale = 0;

    try

    {

        // determine the datatype of the column

        _xColumn->getPropertyValue(u"Type"_ustr) >>= nDataType;

        if (DataType::NUMERIC == nDataType || DataType::DECIMAL == nDataType)

            _xColumn->getPropertyValue(u"Scale"_ustr) >>= nScale;

    }

    catch (Exception&)

    {

        return NumberFormat::UNDEFINED;

    }

    return getDefaultNumberFormat(nDataType,

                    nScale,

                    ::cppu::any2bool(_xColumn->getPropertyValue(u"IsCurrency"_ustr)),

                    _xTypes,

                    _rLocale);

}

sal_Int32 getDefaultNumberFormat(sal_Int32 _nDataType,

                                 sal_Int32 _nScale,

                                 bool _bIsCurrency,

                                 const Reference< XNumberFormatTypes >& _xTypes,

                                 const Locale& _rLocale)

{

    OSL_ENSURE(_xTypes.is() , "dbtools::getDefaultNumberFormat: invalid arg !");

    if (!_xTypes.is())

        return NumberFormat::UNDEFINED;

    sal_Int32 nFormat = 0;

    sal_Int32 nNumberType   = _bIsCurrency ? NumberFormat::CURRENCY : NumberFormat::NUMBER;

    switch (_nDataType)

    {

        case DataType::BIT:

        case DataType::BOOLEAN:

            nFormat = _xTypes->getStandardFormat(NumberFormat::LOGICAL, _rLocale);

            break;

        case DataType::TINYINT:

        case DataType::SMALLINT:

        case DataType::INTEGER:

        case DataType::BIGINT:

        case DataType::FLOAT:

        case DataType::REAL:

        case DataType::DOUBLE:

        case DataType::NUMERIC:

        case DataType::DECIMAL:

        {

            try

            {

                nFormat = _xTypes->getStandardFormat(static_cast<sal_Int16>(nNumberType), _rLocale);

                if(_nScale > 0)

                {

                    // generate a new format if necessary

                    Reference< XNumberFormats > xFormats(_xTypes, UNO_QUERY);

                    OUString sNewFormat = xFormats->generateFormat( 0, _rLocale, false, false, static_cast<sal_Int16>(_nScale), 1);

                    // and add it to the formatter if necessary

                    nFormat = xFormats->queryKey(sNewFormat, _rLocale, false);

                    if (nFormat == sal_Int32(-1))

                        nFormat = xFormats->addNew(sNewFormat, _rLocale);

                }

            }

            catch (Exception&)

            {

                nFormat = _xTypes->getStandardFormat(static_cast<sal_Int16>(nNumberType), _rLocale);

            }

        }   break;

        case DataType::CHAR:

        case DataType::VARCHAR:

        case DataType::LONGVARCHAR:

        case DataType::CLOB:

            nFormat = _xTypes->getStandardFormat(NumberFormat::TEXT, _rLocale);

            break;

        case DataType::DATE:

            nFormat = _xTypes->getStandardFormat(NumberFormat::DATE, _rLocale);

            break;

        case DataType::TIME:

            nFormat = _xTypes->getStandardFormat(NumberFormat::TIME, _rLocale);

            break;

        case DataType::TIMESTAMP:

            nFormat = _xTypes->getStandardFormat(NumberFormat::DATETIME, _rLocale);

            break;

        case DataType::BINARY:

        case DataType::VARBINARY:

        case DataType::LONGVARBINARY:

        case DataType::SQLNULL:

        case DataType::OTHER:

        case DataType::OBJECT:

        case DataType::DISTINCT:

        case DataType::STRUCT:

        case DataType::ARRAY:

        case DataType::BLOB:

        case DataType::REF:

        default:

            nFormat = _xTypes->getStandardFormat(NumberFormat::UNDEFINED, _rLocale);

    }

    return nFormat;

}

static Reference< XConnection> findConnection(const Reference< XInterface >& xParent)

{

    Reference< XConnection> xConnection(xParent, UNO_QUERY);

    if (!xConnection.is())

    {

        Reference< XChild> xChild(xParent, UNO_QUERY);

        if (xChild.is())

            xConnection = findConnection(xChild->getParent());

    }

    return xConnection;

}

static Reference< XDataSource> getDataSource_allowException(

            const OUString& _rsTitleOrPath,

            const Reference< XComponentContext >& _rxContext )

{

    ENSURE_OR_RETURN( !_rsTitleOrPath.isEmpty(), "getDataSource_allowException: invalid arg !", nullptr );

    Reference< XDatabaseContext> xDatabaseContext = DatabaseContext::create(_rxContext);

    return Reference< XDataSource >( xDatabaseContext->getByName( _rsTitleOrPath ), UNO_QUERY );

}

Reference< XDataSource > getDataSource(

            const OUString& _rsTitleOrPath,

            const Reference< XComponentContext >& _rxContext )

{

    Reference< XDataSource > xDS;

    try

    {

        xDS = getDataSource_allowException( _rsTitleOrPath, _rxContext );

    }

    catch( const Exception& )

    {

        DBG_UNHANDLED_EXCEPTION("connectivity.commontools");

    }

    return xDS;

}

static Reference< XConnection > getConnection_allowException(

            const OUString& _rsTitleOrPath,

            const OUString& _rsUser,

            const OUString& _rsPwd,

            const Reference< XComponentContext>& _rxContext,

            const Reference< XWindow >& _rxParent)

{

    Reference< XDataSource> xDataSource( getDataSource_allowException(_rsTitleOrPath, _rxContext) );

    Reference<XConnection> xConnection;

    if (xDataSource.is())

    {

        //set ParentWindow for dialog, but just for the duration of this

        //call, undo at end of scope

        Reference<XInitialization> xIni(xDataSource, UNO_QUERY);

        if (xIni.is())

        {

            Sequence< Any > aArgs{ Any(NamedValue( u"ParentWindow"_ustr, Any(_rxParent) )) };

            xIni->initialize(aArgs);

        }

        // do it with interaction handler

        if(_rsUser.isEmpty() || _rsPwd.isEmpty())

        {

            Reference<XPropertySet> xProp(xDataSource,UNO_QUERY);

            OUString sPwd, sUser;

            bool bPwdReq = false;

            try

            {

                xProp->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD)) >>= sPwd;

                bPwdReq = ::cppu::any2bool(xProp->getPropertyValue(u"IsPasswordRequired"_ustr));

                xProp->getPropertyValue(u"User"_ustr) >>= sUser;

            }

            catch(Exception&)

            {

                OSL_FAIL("dbtools::getConnection: error while retrieving data source properties!");

            }

            if(bPwdReq && sPwd.isEmpty())

            {   // password required, but empty -> connect using an interaction handler

                Reference<XCompletedConnection> xConnectionCompletion(xProp, UNO_QUERY);

                if (xConnectionCompletion.is())

                {   // instantiate the default SDB interaction handler

                    Reference< XInteractionHandler > xHandler =

                        InteractionHandler::createWithParent(_rxContext, _rxParent);

                    xConnection = xConnectionCompletion->connectWithCompletion(xHandler);

                }

            }

            else

                xConnection = xDataSource->getConnection(sUser, sPwd);

        }

        if(!xConnection.is()) // try to get one if not already have one, just to make sure

            xConnection = xDataSource->getConnection(_rsUser, _rsPwd);

        if (xIni.is())

        {

            Sequence< Any > aArgs{ Any(NamedValue( u"ParentWindow"_ustr, Any(Reference<XWindow>()) )) };

            xIni->initialize(aArgs);

        }

    }

    return xConnection;

}

Reference< XConnection> getConnection_withFeedback(const OUString& _rDataSourceName,

        const OUString& _rUser, const OUString& _rPwd, const Reference< XComponentContext>& _rxContext,

        const Reference< XWindow >& _rxParent)

{

    Reference< XConnection > xReturn;

    try

    {

        xReturn = getConnection_allowException(_rDataSourceName, _rUser, _rPwd, _rxContext, _rxParent);

    }

    catch(SQLException&)

    {

        // allowed to pass

        throw;

    }

    catch(Exception&)

    {

        TOOLS_WARN_EXCEPTION( "connectivity.commontools", "::dbtools::getConnection_withFeedback: unexpected (non-SQL) exception caught!");

    }

    return xReturn;

}

Reference< XConnection> getConnection(const Reference< XRowSet>& _rxRowSet)

{

    Reference< XConnection> xReturn;

    Reference< XPropertySet> xRowSetProps(_rxRowSet, UNO_QUERY);

    if (xRowSetProps.is())

        xRowSetProps->getPropertyValue(u"ActiveConnection"_ustr) >>= xReturn;

    return xReturn;

}

// helper function which allows to implement both the connectRowset and the ensureRowSetConnection semantics

// if connectRowset (which is deprecated) is removed, this function and one of its parameters are

// not needed anymore, the whole implementation can be moved into ensureRowSetConnection then)

static SharedConnection lcl_connectRowSet(const Reference< XRowSet>& _rxRowSet, const Reference< XComponentContext >& _rxContext,

        bool _bAttachAutoDisposer, const Reference< XWindow >& _rxParent)

{

    SharedConnection xConnection;

    do

    {

        Reference< XPropertySet> xRowSetProps(_rxRowSet, UNO_QUERY);

        if ( !xRowSetProps.is() )

            break;

        // 1. already connected?

        Reference< XConnection > xExistingConn(

            xRowSetProps->getPropertyValue(u"ActiveConnection"_ustr),

            UNO_QUERY );

        if  (   xExistingConn.is()

            // 2. embedded in a database?

            ||  isEmbeddedInDatabase( _rxRowSet, xExistingConn )

            // 3. is there a connection in the parent hierarchy?

            ||  ( xExistingConn = findConnection( _rxRowSet ) ).is()

            )

        {

            xRowSetProps->setPropertyValue(u"ActiveConnection"_ustr, Any( xExistingConn ) );

            // no auto disposer needed, since we did not create the connection

            xConnection.reset( xExistingConn, SharedConnection::NoTakeOwnership );

            break;

        }

        // build a connection with its current settings (4. data source name, or 5. URL)

        static constexpr OUString sUserProp( u"User"_ustr );

        OUString sDataSourceName;

        xRowSetProps->getPropertyValue(u"DataSourceName"_ustr) >>= sDataSourceName;

        OUString sURL;

        xRowSetProps->getPropertyValue(u"URL"_ustr) >>= sURL;

        Reference< XConnection > xPureConnection;

        if (!sDataSourceName.isEmpty())

        {   // the row set's data source property is set

            // -> try to connect, get user and pwd setting for that

            OUString sUser, sPwd;

            if (hasProperty(sUserProp, xRowSetProps))

                xRowSetProps->getPropertyValue(sUserProp) >>= sUser;

            if (hasProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD), xRowSetProps))

                xRowSetProps->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD)) >>= sPwd;

            xPureConnection = getConnection_allowException( sDataSourceName, sUser, sPwd, _rxContext, _rxParent );

        }

        else if (!sURL.isEmpty())

        {   // the row set has no data source, but a connection url set

            // -> try to connection with that url

            Reference< XConnectionPool > xDriverManager;

            try {

                xDriverManager = ConnectionPool::create( _rxContext );

            } catch( const Exception& ) {  }

            if (xDriverManager.is())

            {

                OUString sUser, sPwd;

                if (hasProperty(sUserProp, xRowSetProps))

                    xRowSetProps->getPropertyValue(sUserProp) >>= sUser;

                if (hasProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD), xRowSetProps))

                    xRowSetProps->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PASSWORD)) >>= sPwd;

                if (!sUser.isEmpty())

                {   // use user and pwd together with the url

                    auto aInfo(::comphelper::InitPropertySequence({

                        { "user", Any(sUser) },

                        { "password", Any(sPwd) }

                    }));

                    xPureConnection = xDriverManager->getConnectionWithInfo( sURL, aInfo );

                }

                else

                    // just use the url

                    xPureConnection = xDriverManager->getConnection( sURL );

            }

        }

        xConnection.reset(

            xPureConnection,

            _bAttachAutoDisposer ? SharedConnection::NoTakeOwnership : SharedConnection::TakeOwnership

            /* take ownership if and only if we're *not* going to auto-dispose the connection */

        );

        // now if we created a connection, forward it to the row set

        if ( xConnection.is() )

        {

            try

            {

                if ( _bAttachAutoDisposer )

                {

                    new OAutoConnectionDisposer( _rxRowSet, xConnection );

                }

                else

                    xRowSetProps->setPropertyValue(

                        u"ActiveConnection"_ustr,

                        Any( xConnection.getTyped() )

                    );

            }

            catch(Exception&)

            {

                TOOLS_WARN_EXCEPTION( "connectivity.commontools", "EXception when we set the new active connection!");

            }

        }

    }

    while ( false );

    return xConnection;

}

Reference< XConnection> connectRowset(const Reference< XRowSet>& _rxRowSet, const Reference< XComponentContext >& _rxContext, const Reference< XWindow >& _rxParent)

{

    SharedConnection xConnection = lcl_connectRowSet( _rxRowSet, _rxContext, true, _rxParent );

    return xConnection.getTyped();

}

SharedConnection ensureRowSetConnection(const Reference< XRowSet>& _rxRowSet, const Reference< XComponentContext>& _rxContext, const Reference< XWindow >& _rxParent)

{

    return lcl_connectRowSet( _rxRowSet, _rxContext, false/*bUseAutoConnectionDisposer*/, _rxParent );

}

Reference< XNameAccess> getTableFields(const Reference< XConnection>& _rxConn,const OUString& _rName)

{

    Reference< XComponent > xDummy;

    return getFieldsByCommandDescriptor( _rxConn, CommandType::TABLE, _rName, xDummy );

}

Reference< XNameAccess> getPrimaryKeyColumns_throw(const Any& i_aTable)

{

    const Reference< XPropertySet > xTable(i_aTable,UNO_QUERY_THROW);

    return getPrimaryKeyColumns_throw(xTable);

}

Reference< XNameAccess> getPrimaryKeyColumns_throw(const Reference< XPropertySet >& i_xTable)

{

    Reference<XNameAccess> xKeyColumns;

    const Reference<XKeysSupplier> xKeySup(i_xTable,UNO_QUERY);

    if ( xKeySup.is() )

    {

        const Reference<XIndexAccess> xKeys = xKeySup->getKeys();

        if ( xKeys.is() )

        {

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

            const OUString& sPropName = rPropMap.getNameByIndex(PROPERTY_ID_TYPE);

            Reference<XPropertySet> xProp;

            const sal_Int32 nCount = xKeys->getCount();

            for(sal_Int32 i = 0;i< nCount;++i)

            {

                xProp.set(xKeys->getByIndex(i),UNO_QUERY_THROW);

                sal_Int32 nKeyType = 0;

                xProp->getPropertyValue(sPropName) >>= nKeyType;

                if(KeyType::PRIMARY == nKeyType)

                {

                    const Reference<XColumnsSupplier> xKeyColsSup(xProp,UNO_QUERY_THROW);

                    xKeyColumns = xKeyColsSup->getColumns();

                    break;

                }

            }

        }

    }

    return xKeyColumns;

}

namespace

{

    enum FieldLookupState

    {

        HANDLE_TABLE, HANDLE_QUERY, HANDLE_SQL, RETRIEVE_OBJECT, RETRIEVE_COLUMNS, DONE, FAILED

    };

}

Reference< XNameAccess > getFieldsByCommandDescriptor( const Reference< XConnection >& _rxConnection,

    const sal_Int32 _nCommandType, const OUString& _rCommand,

    Reference< XComponent >& _rxKeepFieldsAlive, SQLExceptionInfo* _pErrorInfo )

{

    OSL_PRECOND( _rxConnection.is(), "::dbtools::getFieldsByCommandDescriptor: invalid connection!" );

    OSL_PRECOND( ( CommandType::TABLE == _nCommandType ) || ( CommandType::QUERY == _nCommandType ) || ( CommandType::COMMAND == _nCommandType ),

        "::dbtools::getFieldsByCommandDescriptor: invalid command type!" );

    OSL_PRECOND( !_rCommand.isEmpty(), "::dbtools::getFieldsByCommandDescriptor: invalid command (empty)!" );

    Reference< XNameAccess > xFields;

    // reset the error

    if ( _pErrorInfo )

        *_pErrorInfo = SQLExceptionInfo();

    // reset the ownership holder

    _rxKeepFieldsAlive.clear();

    // go for the fields

    try

    {

        // some kind of state machine to ease the sharing of code

        FieldLookupState eState = FAILED;

        switch ( _nCommandType )

        {

            case CommandType::TABLE:

                eState = HANDLE_TABLE;

                break;

            case CommandType::QUERY:

                eState = HANDLE_QUERY;

                break;

            case CommandType::COMMAND:

                eState = HANDLE_SQL;

                break;

        }

        // needed in various states:

        Reference< XNameAccess > xObjectCollection;

        Reference< XColumnsSupplier > xSupplyColumns;

        // go!

        while ( ( DONE != eState ) && ( FAILED != eState ) )

        {

            switch ( eState )

            {

                case HANDLE_TABLE:

                {

                    // initial state for handling the tables

                    // get the table objects

                    Reference< XTablesSupplier > xSupplyTables( _rxConnection, UNO_QUERY );

                    if ( xSupplyTables.is() )

                        xObjectCollection = xSupplyTables->getTables();

                    // if something went wrong 'til here, then this will be handled in the next state

                    // next state: get the object

                    eState = RETRIEVE_OBJECT;

                }

                break;

                case HANDLE_QUERY:

                {

                    // initial state for handling the tables

                    // get the table objects

                    Reference< XQueriesSupplier > xSupplyQueries( _rxConnection, UNO_QUERY );

                    if ( xSupplyQueries.is() )

                        xObjectCollection = xSupplyQueries->getQueries();

                    // if something went wrong 'til here, then this will be handled in the next state

                    // next state: get the object

                    eState = RETRIEVE_OBJECT;

                }

                break;

                case RETRIEVE_OBJECT:

                    // here we should have an object (aka query or table) collection, and are going

                    // to retrieve the desired object

                    // next state: default to FAILED

                    eState = FAILED;

                    OSL_ENSURE( xObjectCollection.is(), "::dbtools::getFieldsByCommandDescriptor: invalid connection (no sdb.Connection, or no Tables-/QueriesSupplier)!");

                    if ( xObjectCollection.is() && xObjectCollection->hasByName( _rCommand ) )

                    {

                        xObjectCollection->getByName( _rCommand ) >>= xSupplyColumns;

                            // (xSupplyColumns being NULL will be handled in the next state)

                        // next: go for the columns

                        eState = RETRIEVE_COLUMNS;

                    }

                    break;

                case RETRIEVE_COLUMNS:

                    OSL_ENSURE( xSupplyColumns.is(), "::dbtools::getFieldsByCommandDescriptor: could not retrieve the columns supplier!" );

                    // next state: default to FAILED

                    eState = FAILED;

                    if ( xSupplyColumns.is() )

                    {

                        xFields = xSupplyColumns->getColumns();

                        // that's it

                        eState = DONE;

                    }

                    break;

                case HANDLE_SQL:

                {

                    OUString sStatementToExecute( _rCommand );

                    // well, the main problem here is to handle statements which contain a parameter

                    // If we would simply execute a parametrized statement, then this will fail because

                    // we cannot supply any parameter values.

                    // Thus, we try to analyze the statement, and to append a WHERE 0=1 filter criterion

                    // This should cause every driver to not really execute the statement, but to return

                    // an empty result set with the proper structure. We then can use this result set

                    // to retrieve the columns.

                    try

                    {

                        Reference< XMultiServiceFactory > xComposerFac( _rxConnection, UNO_QUERY );

                        if ( xComposerFac.is() )

                        {

                            Reference< XSingleSelectQueryComposer > xComposer(xComposerFac->createInstance(u"com.sun.star.sdb.SingleSelectQueryComposer"_ustr),UNO_QUERY);

                            if ( xComposer.is() )

                            {

                                xComposer->setQuery( sStatementToExecute );

                                // Now set the filter to a dummy restriction which will result in an empty

                                // result set.

                                xComposer->setFilter( u"0=1"_ustr );

                                sStatementToExecute = xComposer->getQuery( );

                            }

                        }

                    }

                    catch( const Exception& )

                    {

                        // silent this error, this was just a try. If we're here, we did not change sStatementToExecute,

                        // so it will still be _rCommand, which then will be executed without being touched

                    }

                    // now execute

                    Reference< XPreparedStatement > xStatement = _rxConnection->prepareStatement( sStatementToExecute );

                    // transfer ownership of this temporary object to the caller

                    _rxKeepFieldsAlive.set(xStatement, css::uno::UNO_QUERY);

                    // set the "MaxRows" to 0. This is just in case our attempt to append a 0=1 filter

                    // failed - in this case, the MaxRows restriction should at least ensure that there

                    // is no data returned (which would be potentially expensive)

                    Reference< XPropertySet > xStatementProps( xStatement,UNO_QUERY );

                    try

                    {

                        if ( xStatementProps.is() )

                            xStatementProps->setPropertyValue( u"MaxRows"_ustr,  Any( sal_Int32( 0 ) ) );

                    }

                    catch( const Exception& )

                    {

                        OSL_FAIL( "::dbtools::getFieldsByCommandDescriptor: could not set the MaxRows!" );

                        // oh damn. Not much of a chance to recover, we will no retrieve the complete

                        // full blown result set

                    }

                    xSupplyColumns.set(xStatement->executeQuery(), css::uno::UNO_QUERY);

                    // this should have given us a result set which does not contain any data, but

                    // the structural information we need

                    // so the next state is to get the columns

                    eState = RETRIEVE_COLUMNS;

                }

                break;

                default:

                    OSL_FAIL( "::dbtools::getFieldsByCommandDescriptor: oops! unhandled state here!" );

                    eState = FAILED;

            }

        }

    }

    catch( const SQLContext& e ) { if ( _pErrorInfo ) *_pErrorInfo = SQLExceptionInfo( e ); }

    catch( const SQLWarning& e ) { if ( _pErrorInfo ) *_pErrorInfo = SQLExceptionInfo( e ); }

    catch( const SQLException& e ) { if ( _pErrorInfo ) *_pErrorInfo = SQLExceptionInfo( e ); }

    catch( const Exception& )

    {

        TOOLS_WARN_EXCEPTION( "connectivity.commontools", "::dbtools::getFieldsByCommandDescriptor: caught an exception while retrieving the fields!" );

    }

    return xFields;

}

Sequence< OUString > getFieldNamesByCommandDescriptor( const Reference< XConnection >& _rxConnection,

    const sal_Int32 _nCommandType, const OUString& _rCommand,

    SQLExceptionInfo* _pErrorInfo )

{

    // get the container for the fields

    Reference< XComponent > xKeepFieldsAlive;

    Reference< XNameAccess > xFieldContainer = getFieldsByCommandDescriptor( _rxConnection, _nCommandType, _rCommand, xKeepFieldsAlive, _pErrorInfo );

    // get the names of the fields

    Sequence< OUString > aNames;

    if ( xFieldContainer.is() )

        aNames = xFieldContainer->getElementNames();

    // clean up any temporary objects which have been created

    disposeComponent( xKeepFieldsAlive );

    // outta here

    return aNames;

}

SQLException prependErrorInfo( const SQLException& _rChainedException, const Reference< XInterface >& _rxContext,

    const OUString& _rAdditionalError, const StandardSQLState _eSQLState )

{

    return SQLException( _rAdditionalError, _rxContext,

        _eSQLState == StandardSQLState::ERROR_UNSPECIFIED ? OUString() : getStandardSQLState( _eSQLState ),

        0, Any( _rChainedException ) );

}

namespace

{

    struct NameComponentSupport

    {

        const bool  bCatalogs;

        const bool  bSchemas;

        NameComponentSupport( const bool _bCatalogs, const bool _bSchemas )

            :bCatalogs( _bCatalogs )

            ,bSchemas( _bSchemas )

        {

        }

    };

    NameComponentSupport lcl_getNameComponentSupport( const Reference< XDatabaseMetaData >& _rxMetaData, EComposeRule _eComposeRule )

    {

        OSL_PRECOND( _rxMetaData.is(), "lcl_getNameComponentSupport: invalid meta data!" );

        FMetaDataSupport pCatalogCall = &XDatabaseMetaData::supportsCatalogsInDataManipulation;

        FMetaDataSupport pSchemaCall = &XDatabaseMetaData::supportsSchemasInDataManipulation;

        bool bIgnoreMetaData = false;

        switch ( _eComposeRule )

        {

            case EComposeRule::InTableDefinitions:

                pCatalogCall = &XDatabaseMetaData::supportsCatalogsInTableDefinitions;

                pSchemaCall = &XDatabaseMetaData::supportsSchemasInTableDefinitions;

                break;

            case EComposeRule::InIndexDefinitions:

                pCatalogCall = &XDatabaseMetaData::supportsCatalogsInIndexDefinitions;

                pSchemaCall = &XDatabaseMetaData::supportsSchemasInIndexDefinitions;

                break;

            case EComposeRule::InProcedureCalls:

                pCatalogCall = &XDatabaseMetaData::supportsCatalogsInProcedureCalls;

                pSchemaCall = &XDatabaseMetaData::supportsSchemasInProcedureCalls;

                break;

            case EComposeRule::InPrivilegeDefinitions:

                pCatalogCall = &XDatabaseMetaData::supportsCatalogsInPrivilegeDefinitions;

                pSchemaCall = &XDatabaseMetaData::supportsSchemasInPrivilegeDefinitions;

                break;

            case EComposeRule::Complete:

                bIgnoreMetaData = true;

                break;

            case EComposeRule::InDataManipulation:

                // already properly set above

                break;

        }

        return NameComponentSupport(

            bIgnoreMetaData || (_rxMetaData.get()->*pCatalogCall)(),

            bIgnoreMetaData || (_rxMetaData.get()->*pSchemaCall)()

        );

    }

}

static OUString impl_doComposeTableName( const Reference< XDatabaseMetaData >& _rxMetaData,

                const OUString& _rCatalog, const OUString& _rSchema, const OUString& _rName,

                bool _bQuote, EComposeRule _eComposeRule )

{

    OSL_ENSURE(_rxMetaData.is(), "impl_doComposeTableName : invalid meta data !");

    if ( !_rxMetaData.is() )

        return OUString();

    OSL_ENSURE(!_rName.isEmpty(), "impl_doComposeTableName : at least the name should be non-empty !");

    const OUString sQuoteString = _rxMetaData->getIdentifierQuoteString();

    const NameComponentSupport aNameComps( lcl_getNameComponentSupport( _rxMetaData, _eComposeRule ) );

    OUStringBuffer aComposedName;

    OUString sCatalogSep;

    bool bCatalogAtStart = true;

    if ( !_rCatalog.isEmpty() && aNameComps.bCatalogs )

    {

        sCatalogSep     = _rxMetaData->getCatalogSeparator();

        bCatalogAtStart  = _rxMetaData->isCatalogAtStart();

        if ( bCatalogAtStart && !sCatalogSep.isEmpty())

        {

            aComposedName.append( _bQuote ? quoteName( sQuoteString, _rCatalog ) : _rCatalog );

            aComposedName.append( sCatalogSep );

        }

    }

    if ( !_rSchema.isEmpty() && aNameComps.bSchemas )

    {

        aComposedName.append(

            (_bQuote ? quoteName( sQuoteString, _rSchema ) : _rSchema )

            + "." );

    }

    aComposedName.append( _bQuote ? quoteName( sQuoteString, _rName ) : _rName );

    if  (   !_rCatalog.isEmpty()

        &&  !bCatalogAtStart

        &&  !sCatalogSep.isEmpty()

        &&  aNameComps.bCatalogs

        )

    {

        aComposedName.append( sCatalogSep );

        aComposedName.append( _bQuote ? quoteName( sQuoteString, _rCatalog ) : _rCatalog );

    }

    return aComposedName.makeStringAndClear();

}

OUString quoteTableName(const Reference< XDatabaseMetaData>& _rxMeta

                               , const OUString& _rName

                               , EComposeRule _eComposeRule)

{

    OUString sCatalog, sSchema, sTable;

    qualifiedNameComponents(_rxMeta,_rName,sCatalog,sSchema,sTable,_eComposeRule);

    return impl_doComposeTableName( _rxMeta, sCatalog, sSchema, sTable, true, _eComposeRule );

}

void qualifiedNameComponents(const Reference< XDatabaseMetaData >& _rxConnMetaData, const OUString& _rQualifiedName, OUString& _rCatalog, OUString& _rSchema, OUString& _rName,EComposeRule _eComposeRule)

{

    OSL_ENSURE(_rxConnMetaData.is(), "QualifiedNameComponents : invalid meta data!");

    NameComponentSupport aNameComps( lcl_getNameComponentSupport( _rxConnMetaData, _eComposeRule ) );

    OUString sSeparator = _rxConnMetaData->getCatalogSeparator();

    OUString sName(_rQualifiedName);

    // do we have catalogs?

    if ( aNameComps.bCatalogs )

    {

        if (_rxConnMetaData->isCatalogAtStart())

        {

            // search for the catalog name at the beginning

            sal_Int32 nIndex = sName.indexOf(sSeparator);

            if (-1 != nIndex)

            {

                _rCatalog = sName.copy(0, nIndex);

                sName = sName.copy(nIndex + 1);

            }

        }

        else

        {

            // Catalog name at the end

            sal_Int32 nIndex = sName.lastIndexOf(sSeparator);

            if (-1 != nIndex)

            {

                _rCatalog = sName.copy(nIndex + 1);

                sName = sName.copy(0, nIndex);

            }

        }

    }

    if ( aNameComps.bSchemas )

    {

        sal_Int32 nIndex = sName.indexOf('.');

        //  OSL_ENSURE(-1 != nIndex, "QualifiedNameComponents: no schema separator!");

        if ( nIndex != -1 )

            _rSchema = sName.copy(0, nIndex);

        sName = sName.copy(nIndex + 1);

    }

    _rName = sName;

}

Reference< XNumberFormatsSupplier> getNumberFormats(

            const Reference< XConnection>& _rxConn,

            bool _bAlloweDefault,

            const Reference< XComponentContext>& _rxContext)

{

    // ask the parent of the connection (should be a DatabaseAccess)

    Reference< XNumberFormatsSupplier> xReturn;

    Reference< XChild> xConnAsChild(_rxConn, UNO_QUERY);

    static constexpr OUString sPropFormatsSupplier( u"NumberFormatsSupplier"_ustr );

    if (xConnAsChild.is())

    {

        Reference< XPropertySet> xConnParentProps(xConnAsChild->getParent(), UNO_QUERY);

        if (xConnParentProps.is() && hasProperty(sPropFormatsSupplier, xConnParentProps))

            xConnParentProps->getPropertyValue(sPropFormatsSupplier) >>= xReturn;

    }

    else if(_bAlloweDefault && _rxContext.is())

    {

        xReturn = NumberFormatsSupplier::createWithDefaultLocale( _rxContext );