Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 867 insertions, 0 deletions

diff --git a/include/connectivity/dbtools.hxx b/include/connectivity/dbtools.hxx
new file mode 100644
index 0000000000..17f329ad33
--- /dev/null
+++ b/include/connectivity/dbtools.hxx
@@ -0,0 +1,867 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_CONNECTIVITY_DBTOOLS_HXX
+#define INCLUDED_CONNECTIVITY_DBTOOLS_HXX
+
+#include <sal/config.h>
+
+#include <string_view>
+
+#include <connectivity/dbexception.hxx>
+#include <comphelper/stl_types.hxx>
+#include <unotools/sharedunocomponent.hxx>
+#include <connectivity/dbtoolsdllapi.hxx>
+#include <connectivity/FValue.hxx>
+
+namespace com::sun::star {
+
+namespace sdb {
+    class XSingleSelectQueryComposer;
+}
+namespace sdbcx {
+    class XTablesSupplier;
+}
+namespace sdbc {
+    class XConnection;
+    class XDatabaseMetaData;
+    class XRowSet;
+    class XDataSource;
+    class SQLException;
+    class XParameters;
+    class XRowUpdate;
+}
+namespace beans {
+    class XPropertySet;
+}
+namespace awt {
+    class XWindow;
+}
+namespace lang {
+    struct Locale;
+}
+namespace container {
+    class XNameAccess;
+}
+namespace uno {
+    class XComponentContext;
+}
+namespace util {
+    class XNumberFormatTypes;
+    class XNumberFormatsSupplier;
+}
+namespace task {
+    class XInteractionHandler;
+}
+
+}
+
+class SvStream;
+
+namespace dbtools
+{
+    class ISQLStatementHelper;
+    typedef ::utl::SharedUNOComponent< css::sdbc::XConnection > SharedConnection;
+
+    enum class EComposeRule
+    {
+        InTableDefinitions,
+        InIndexDefinitions,
+        InDataManipulation,
+        InProcedureCalls,
+        InPrivilegeDefinitions,
+        Complete
+    };
+
+    // date conversion
+
+    // calculates the default numberformat for a given datatype and a give language
+    OOO_DLLPUBLIC_DBTOOLS
+    sal_Int32 getDefaultNumberFormat(const css::uno::Reference< css::beans::XPropertySet >& _xColumn,
+                                     const css::uno::Reference< css::util::XNumberFormatTypes >& _xTypes,
+                                     const css::lang::Locale& _rLocale);
+
+    // calculates the default numberformat for a given datatype and a give language
+    // @param  _nDataType @see com.sun.star.sdbc.DataType
+    // @param _nScale       can be zero
+    OOO_DLLPUBLIC_DBTOOLS
+    sal_Int32 getDefaultNumberFormat(sal_Int32 _nDataType,
+                                     sal_Int32 _nScale,
+                                     bool _bIsCurrency,
+                                     const css::uno::Reference< css::util::XNumberFormatTypes >& _xTypes,
+                                     const css::lang::Locale& _rLocale);
+
+
+    /** creates a connection which can be used for the rowset given
+
+        The function tries to obtain a connection for the row set with the following
+        steps (in this order):
+        <nl>
+            <li>If the rowset already has an ActiveConnection (means a non-<NULL/> value for this property),
+                this one is used.</li>
+            <li>If row set is part of a database form document (see ->isEmbeddedInDatabase),
+                a connection for the respective database is used.</li>
+            <li>If in the parent hierarchy of the row set, there is an object supporting
+                the XConnection interface, this one is returned.</li>
+            <li>If the DataSourceName property of the row set is not empty, a connection for this
+                data source is retrieved.</li>
+            <li>If the URL property of the row set is not empty, a connection for this URL is
+                retrieved from the driver manager.
+        </nl>
+
+        The calculated connection is set as ActiveConnection property on the rowset.
+
+        If the connection was newly created by the method, then
+        the ownership of the connection is delivered to a temporary object, which observes the
+        row set: As soon as a connection-relevant property of the row set changes, or as soon
+        as somebody else sets another ActiveConnection at the row set, the original
+        connection (the one which this function calculated) is disposed and discarded. At this
+        very moment, also the temporary observer object dies. This way, it is ensured that
+        there's no resource leak from an un-owned connection object.
+
+        @param _rxRowSet
+            the row set
+
+        @param _rxFactory
+            a service factory, which can be used to create data sources, interaction handler etc (the usual stuff)
+
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    css::uno::Reference< css::sdbc::XConnection> connectRowset(
+        const css::uno::Reference< css::sdbc::XRowSet>& _rxRowSet,
+        const css::uno::Reference< css::uno::XComponentContext>& _rxContext,
+        const css::uno::Reference< css::awt::XWindow>& _rxParent
+    );
+
+    /** ensures that a row set has a valid ActiveConnection, if possible
+
+        This function does nearly the same as ->connectRowset. In fact, it is to be preferred over
+        ->connectRowset, if possible.
+
+        There are a few differences:
+        <ul><li>If a connection could be determined for the given RowSet, it is always
+                set as ActiveConnection.</li>
+            <li>Definition of the ownership of the created connection allows for more scenarios:
+                <ul><li>If the connection was not newly created, the returned ->SharedConnection
+                        instance will not have the ownership, since in this case it's assumed
+                        that there already is an instance which has the ownership.</li>
+                    <li>If the connection was newly created, then the returned SharedConnection
+                        instance will have the ownership of the XConnection.</li>
+                </ul>
+            </li>
+        </ul>
+    */
+    OOO_DLLPUBLIC_DBTOOLS SharedConnection    ensureRowSetConnection(
+        const css::uno::Reference< css::sdbc::XRowSet>& _rxRowSet,
+        const css::uno::Reference< css::uno::XComponentContext>& _rxContext,
+        const css::uno::Reference< css::awt::XWindow>& _rxParent
+    );
+
+    /** returns the connection the RowSet is currently working with (which is the ActiveConnection property)
+
+        @throws css::uno::RuntimeException
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::sdbc::XConnection> getConnection(const css::uno::Reference< css::sdbc::XRowSet>& _rxRowSet);
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::sdbc::XConnection> getConnection_withFeedback(
+            const OUString& _rDataSourceName,
+            const OUString& _rUser,
+            const OUString& _rPwd,
+            const css::uno::Reference< css::uno::XComponentContext>& _rxContext,
+            const css::uno::Reference< css::awt::XWindow>& _rxParent);
+
+
+    /** determines whether the given component is part of a document which is an embedded database
+        document (such as a form)
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool    isEmbeddedInDatabase(
+                const css::uno::Reference< css::uno::XInterface >& _rxComponent,
+                css::uno::Reference< css::sdbc::XConnection >& _rxActualConnection
+            );
+
+    /** returns the columns of the named table of the given connection
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::container::XNameAccess> getTableFields(
+        const css::uno::Reference< css::sdbc::XConnection>& _rxConn,
+        const OUString& _rName
+    );
+
+    /** returns the primary key columns of the table
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::container::XNameAccess> getPrimaryKeyColumns_throw(
+        const css::uno::Any& i_aTable
+    );
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::container::XNameAccess> getPrimaryKeyColumns_throw(
+        const css::uno::Reference< css::beans::XPropertySet >& i_xTable
+    );
+
+    /** get fields for a result set given by a "command descriptor"
+
+        <p>A command descriptor here means:
+        <ul><li>a SDB-level connection (com.sun.star.sdb::Connection</li>
+            <li>a string specifying the name of an object relative to the connection</li>
+            <li>a com.sun.star.sdb::CommandType value specifying the type
+                of the object</type></li>
+        </ul>
+        </p>
+
+        @param _rxConnection
+            the connection relative to which the to-be-examined object exists
+
+        @param _nCommandType
+            the type of the object
+
+        @param _rCommand
+            the object. This may be a table name, a query name, or an SQL statement, depending on the value
+            of <arg>_nCommandType</arg>
+
+        @param _rxCollectionOner
+            If (and only if) <arg>CommandType</arg> is CommandType.COMMAND, the fields collection which is returned
+            by this function here is a temporary object. It is kept alive by another object, which is to be
+            created temporarily, too. To ensure that the fields you get are valid as long as you need them,
+            the owner which controls their life time is transferred to this parameter upon return.<br/>
+
+            Your fields live as long as this component lives.<br/>
+
+            Additionally, you are encouraged to dispose this component as soon as you don't need the fields anymore.
+            It depends on the connection's implementation if this is necessary, but the is no guarantee, so to
+            be on the safe side with respect to resource leaks, you should dispose the component.
+
+        @param _pErrorInfo
+            If not <NULL/>, then upon return from the function the instance pointed to by this argument will
+            contain any available error information in case something went wrong.
+
+        @return
+            the container of the columns (aka fields) of the object
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    css::uno::Reference< css::container::XNameAccess >
+        getFieldsByCommandDescriptor(
+            const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
+            const sal_Int32 _nCommandType,
+            const OUString& _rCommand,
+            css::uno::Reference< css::lang::XComponent >& _rxKeepFieldsAlive,
+            SQLExceptionInfo* _pErrorInfo = nullptr
+        );
+
+
+    /** get fields for a result set given by a "command descriptor"
+
+        <p>A command descriptor here means:
+        <ul><li>a SDB-level connection (com.sun.star.sdb::Connection</li>
+            <li>a string specifying the name of an object relative to the connection</li>
+            <li>a com.sun.star.sdb::CommandType value specifying the type
+                of the object</type></li>
+        </ul>
+        </p>
+
+        @param _rxConnection
+            the connection relative to which the to-be-examined object exists
+
+        @param _nCommandType
+            the type of the object
+
+        @param _rCommand
+            the object. This may be a table name, a query name, or an SQL statement, depending on the value
+            of <arg>_nCommandType</arg>
+
+        @param _pErrorInfo
+            If not <NULL/>, then upon return from the function the instance pointed to by this argument will
+            contain any available error information in case something went wrong.
+
+        @return
+            an array of strings containing the names of the columns (aka fields) of the object
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Sequence< OUString >
+        getFieldNamesByCommandDescriptor(
+            const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
+            const sal_Int32 _nCommandType,
+            const OUString& _rCommand,
+            SQLExceptionInfo* _pErrorInfo = nullptr
+        );
+
+
+    /** create a new css::sdbc::SQLContext, fill it with the given descriptions and the given source,
+        and <i>append</i> _rException (i.e. put it into the NextException member of the SQLContext).
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    css::sdbc::SQLException prependErrorInfo(
+        const css::sdbc::SQLException& _rChainedException,
+        const css::uno::Reference< css::uno::XInterface >& _rxContext,
+        const OUString& _rAdditionalError,
+        const StandardSQLState _eSQLState = StandardSQLState::ERROR_UNSPECIFIED);
+
+    /** search the parent hierarchy for a data source.
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::sdbc::XDataSource> findDataSource(const css::uno::Reference< css::uno::XInterface >& _xParent);
+
+    /** determines the value of a boolean data source setting, given by ASCII name
+
+        @param _rxConnection
+            the connection belonging to the data source whose setting is to be retrieved
+        @param _pAsciiSettingName
+            the ASCII name of the setting
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool getBooleanDataSourceSetting(
+            const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
+            const char* _pAsciiSettingName
+        );
+    OOO_DLLPUBLIC_DBTOOLS bool getBooleanDataSourceSetting(
+            const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
+            const OUString& rSettingName
+        );
+
+    /** check if a specific property is enabled in the info sequence
+        @deprecated
+            Use getBooleanDataSourceSetting instead, which cares for the default of the property itself,
+            instead of spreading this knowledge through all callers.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    bool isDataSourcePropertyEnabled(const css::uno::Reference< css::uno::XInterface>& _xProp,
+                                     const OUString& _sProperty,
+                                           bool _bDefault);
+
+    /** retrieves a particular indirect data source setting
+
+        @param _rxDataSource
+            a data source component
+        @param _pAsciiSettingsName
+            the ASCII name of the setting to obtain
+        @param _rSettingsValue
+            the value of the setting, upon successful return
+
+        @return
+            <FALSE/> if the setting is not present in the <member scope="css::sdb">DataSource::Info</member>
+            member of the data source
+            <TRUE/> otherwise
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    bool    getDataSourceSetting(
+        const css::uno::Reference< css::uno::XInterface >& _rxDataSource,
+        const char* _pAsciiSettingsName,
+        css::uno::Any& /* [out] */ _rSettingsValue
+    );
+    OOO_DLLPUBLIC_DBTOOLS
+    bool    getDataSourceSetting(
+        const css::uno::Reference< css::uno::XInterface >& _rxDataSource,
+        const OUString& _sSettingsName,
+        css::uno::Any& /* [out] */ _rSettingsValue
+    );
+
+    OOO_DLLPUBLIC_DBTOOLS OUString getDefaultReportEngineServiceName(const css::uno::Reference< css::uno::XComponentContext>& _rxFactory);
+
+    /** quote the given name with the given quote string.
+    */
+    OOO_DLLPUBLIC_DBTOOLS OUString quoteName(std::u16string_view _rQuote, const OUString& _rName);
+
+    /** quote the given table name (which may contain a catalog and a schema) according to the rules provided by the meta data
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    OUString quoteTableName(const css::uno::Reference< css::sdbc::XDatabaseMetaData>& _rxMeta
+                                    , const OUString& _rName
+                                    ,EComposeRule _eComposeRule);
+
+    /** split a fully qualified table name (including catalog and schema, if applicable) into its component parts.
+        @param  _rxConnMetaData     meta data describing the connection where you got the table name from
+        @param  _rQualifiedName     fully qualified table name
+        @param  _rCatalog           (out parameter) upon return, contains the catalog name
+        @param  _rSchema            (out parameter) upon return, contains the schema name
+        @param  _rName              (out parameter) upon return, contains the table name
+        @param  _eComposeRule       where do you need the name for
+    */
+    OOO_DLLPUBLIC_DBTOOLS void qualifiedNameComponents(const css::uno::Reference< css::sdbc::XDatabaseMetaData >& _rxConnMetaData,
+        const OUString& _rQualifiedName, OUString& _rCatalog, OUString& _rSchema, OUString& _rName,EComposeRule _eComposeRule);
+
+    /** calculate a NumberFormatsSupplier for use with a given connection
+        @param      _rxConn         the connection for which the formatter is requested
+        @param      _bAllowDefault  if the connection (and related components, such as its parent) cannot supply
+                                    a formatter, we can ask the DatabaseEnvironment for a default one. This parameter
+                                    states if this is allowed.
+        @param      _rxFactory      required (only of _bAllowDefault is sal_True) for creating the DatabaseEnvironment.
+        @return     the formatter all object related to the given connection should work with.
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::util::XNumberFormatsSupplier> getNumberFormats(
+        const css::uno::Reference< css::sdbc::XConnection>& _rxConn,
+        bool _bAllowDefault = false,
+        const css::uno::Reference< css::uno::XComponentContext>& _rxContext = css::uno::Reference< css::uno::XComponentContext>()
+    );
+
+    /** create a css::sdb::XSingleSelectQueryComposer which represents
+        the current settings (Command/CommandType/Filter/Order) of the given rowset.
+
+        As such an instance can be obtained from a css::sdb::Connection
+        only the function searches for the connection the RowSet is using via connectRowset.
+        This implies that a connection will be set on the RowSet if needed.
+        (need to changes this sometimes ...)
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::sdb::XSingleSelectQueryComposer > getCurrentSettingsComposer(
+        const css::uno::Reference< css::beans::XPropertySet>& _rxRowSetProps,
+        const css::uno::Reference< css::uno::XComponentContext>& _rxContext,
+        const css::uno::Reference< css::awt::XWindow>& _rxParent
+    );
+
+    /** transfer and translate properties between two FormComponents
+        @param      _rxOld      the source property set
+        @param      _rxNew      the destination property set
+        @param      _rLocale    the locale for converting number related properties
+    */
+    OOO_DLLPUBLIC_DBTOOLS void TransferFormComponentProperties(
+        const css::uno::Reference< css::beans::XPropertySet>& _rxOld,
+        const css::uno::Reference< css::beans::XPropertySet>& _rxNew,
+        const css::lang::Locale& _rLocale
+        );
+
+    /** check if the property "Privileges" supports css::sdbcx::Privilege::INSERT
+        @param      _rxCursorSet    the property set
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool canInsert(const css::uno::Reference< css::beans::XPropertySet>& _rxCursorSet);
+    /** check if the property "Privileges" supports css::sdbcx::Privilege::UPDATE
+        @param      _rxCursorSet    the property set
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool canUpdate(const css::uno::Reference< css::beans::XPropertySet>& _rxCursorSet);
+    /** check if the property "Privileges" supports css::sdbcx::Privilege::DELETE
+        @param      _rxCursorSet    the property set
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool canDelete(const css::uno::Reference< css::beans::XPropertySet>& _rxCursorSet);
+
+
+    /** compose a complete table name from its up to three parts, regarding to the database meta data composing rules
+    */
+    OOO_DLLPUBLIC_DBTOOLS OUString composeTableName( const css::uno::Reference< css::sdbc::XDatabaseMetaData >& _rxMetaData,
+                            const OUString& _rCatalog,
+                            const OUString& _rSchema,
+                            const OUString& _rName,
+                            bool _bQuote,
+                            EComposeRule _eComposeRule);
+
+    /** composes a table name for usage in a SELECT statement
+
+        This includes quoting of the table as indicated by the connection's meta data, plus respecting
+        the settings "UseCatalogInSelect" and "UseSchemaInSelect", which might be present
+        in the data source which the connection belongs to.
+    */
+    OOO_DLLPUBLIC_DBTOOLS OUString composeTableNameForSelect(
+                            const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
+                            const OUString& _rCatalog,
+                            const OUString& _rSchema,
+                            const OUString& _rName );
+
+    /** composes a table name for usage in a SELECT statement
+
+        This includes quoting of the table as indicated by the connection's meta data, plus respecting
+        the settings "UseCatalogInSelect" and "UseSchemaInSelect", which might be present
+        in the data source which the connection belongs to.
+    */
+    OOO_DLLPUBLIC_DBTOOLS OUString composeTableNameForSelect(
+                            const css::uno::Reference< css::sdbc::XConnection >& _rxConnection,
+                            const css::uno::Reference< css::beans::XPropertySet>& _xTable );
+
+    /** compose the table name out of the property set which must support the properties from the service <member scope= "css::sdbcx">table</member>
+        @param  _xMetaData
+            The metadata from the connection.
+        @param  _xTable
+            The table.
+    */
+    OOO_DLLPUBLIC_DBTOOLS OUString composeTableName(
+        const css::uno::Reference< css::sdbc::XDatabaseMetaData>& _xMetaData,
+        const css::uno::Reference< css::beans::XPropertySet>& _xTable,
+        EComposeRule _eComposeRule,
+        bool _bQuote);
+
+
+    OOO_DLLPUBLIC_DBTOOLS sal_Int32 getSearchColumnFlag( const css::uno::Reference< css::sdbc::XConnection>& _rxConn,
+                                    sal_Int32 _nDataType);
+    // return the datasource for the given datasource name
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::sdbc::XDataSource> getDataSource(const OUString& _rsDataSourceName,
+                        const css::uno::Reference< css::uno::XComponentContext>& _rxContext);
+
+    /** search for a name that is NOT in the NameAcces
+        @param  _rxContainer
+            the NameAccess container to search in
+        @param  _rBaseName
+            the base name that should be used to create the new name
+        @param  _bStartWithNumber
+            When <TRUE/> the name ends with number even when the name itself doesn't occur in the collection.
+        @return
+            A name which doesn't exist in the collection.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    OUString createUniqueName(const css::uno::Reference< css::container::XNameAccess>& _rxContainer,
+                                     const OUString& _rBaseName,
+                                     bool _bStartWithNumber = true);
+
+    /** creates a unique name which is not already used in the given name array
+    */
+    OOO_DLLPUBLIC_DBTOOLS OUString createUniqueName(
+        const css::uno::Sequence< OUString >& _rNames,
+        const OUString& _rBaseName,
+        bool _bStartWithNumber
+    );
+
+    /** create a name which is a valid SQL 92 identifier name
+        @param      _rName          the string which should be converted
+        @param      _rSpecials      @see com.sun.star.sdbc.XDatabaseMetaData.getExtraNameCharacters
+
+        @see isValidSQLName
+    */
+    OOO_DLLPUBLIC_DBTOOLS OUString convertName2SQLName(const OUString& _rName, std::u16string_view _rSpecials);
+
+    /** checks whether the given name is a valid SQL name
+
+        @param      _rName          the string which should be converted
+        @param      _rSpecials      @see com.sun.star.sdbc.XDatabaseMetaData.getExtraNameCharacters
+
+        @see convertName2SQLName
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool isValidSQLName( const OUString& _rName, std::u16string_view _rSpecials );
+
+    OOO_DLLPUBLIC_DBTOOLS
+    void showError( const SQLExceptionInfo& _rInfo,
+                    const css::uno::Reference< css::awt::XWindow>& _pParent,
+                    const css::uno::Reference< css::uno::XComponentContext>& _rxContext);
+
+    /** implements <method scope="com.sun.star.sdb">XRowUpdate::updateObject</method>
+        <p>The object which is to be set is analyzed, and in case it is a simlpe scalar type for which there
+        is another updateXXX method, this other method is used.</p>
+        @param _rxUpdatedObject
+            the interface to forward all updateXXX calls to (except updateObject)
+        @param _nColumnIndex
+            the column index to update
+        @param _rValue
+            the value to update
+        @return
+            <TRUE/> if the update request was successfully re-routed to one of the other updateXXX methods
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    bool implUpdateObject(  const css::uno::Reference< css::sdbc::XRowUpdate >& _rxUpdatedObject,
+                                const sal_Int32 _nColumnIndex,
+                                const css::uno::Any& _rValue);
+
+
+    /** ask the user for parameters if the prepared statement needs some and sets them in the prepared statement
+        @param _xConnection     the connection must be able to create css::sdb::SingleSelectQueryComposers
+        @param _xPreparedStmt   the prepared statement where the parameters could be set when needed
+        @param _aParametersSet  contains which parameters have to asked for and which already have set.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    void askForParameters(  const css::uno::Reference< css::sdb::XSingleSelectQueryComposer >& _xComposer,
+                            const css::uno::Reference< css::sdbc::XParameters>& _xParameters,
+                            const css::uno::Reference< css::sdbc::XConnection>& _xConnection,
+                            const css::uno::Reference< css::task::XInteractionHandler >& _rxHandler,
+                            const ::std::vector<bool, std::allocator<bool> >& _aParametersSet = ::std::vector<bool, std::allocator<bool> >());
+
+    /** call the appropriate set method for the specific sql type @see css::sdbc::DataType
+        @param  _xParams        the parameters where to set the value
+        @param  parameterIndex  the index of the parameter, 1 based
+        @param  x               the value to set
+        @param  sqlType         the corresponding sql type @see css::sdbc::DataType
+        @param  scale           the scale of the sql type can be 0
+        @throws css::sdbc::SQLException
+        @throws css::uno::RuntimeException
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    void setObjectWithInfo( const css::uno::Reference< css::sdbc::XParameters>& _xParameters,
+                            sal_Int32 parameterIndex,
+                            const css::uno::Any& x,
+                            sal_Int32 sqlType,
+                            sal_Int32 scale=0);
+
+    /** call the appropriate set method for the specific sql type @see css::sdbc::DataType
+        @param  _xParams        the parameters where to set the value
+        @param  parameterIndex  the index of the parameter, 1 based
+        @param  x               the value to set
+        @param  sqlType         the corresponding sql type @see css::sdbc::DataType
+        @param  scale           the scale of the sql type can be 0
+        @throws css::sdbc::SQLException
+        @throws css::uno::RuntimeException
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    void setObjectWithInfo( const css::uno::Reference< css::sdbc::XParameters>& _xParameters,
+                            sal_Int32 parameterIndex,
+                            const ::connectivity::ORowSetValue& x,
+                            sal_Int32 sqlType,
+                            sal_Int32 scale);
+
+
+    /** implements <method scope="com.sun.star.sdb">XParameters::setObject</method>
+        <p>The object which is to be set is analyzed, and in case it is a simlpe scalar type for which there
+        is another setXXX method, this other method is used.</p>
+        @param _rxParameters
+            the interface to forward all setXXX calls to (except setObject)
+        @param _nColumnIndex
+            the column index to update
+        @param _rValue
+            the value to update
+        @return
+            <TRUE/> if the update request was successfully re-routed to one of the other updateXXX methods
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    bool implSetObject( const css::uno::Reference< css::sdbc::XParameters>& _rxParameters,
+                            const sal_Int32 _nColumnIndex,
+                            const css::uno::Any& _rValue);
+
+    /** creates the standard sql create table statement without the key part.
+        @param  descriptor
+            The descriptor of the new table.
+        @param  _xConnection
+            The connection.
+        @param  _bAddScale
+            The scale will also be added when the value is 0.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    OUString createStandardCreateStatement(  const css::uno::Reference< css::beans::XPropertySet >& descriptor,
+                                                    const css::uno::Reference< css::sdbc::XConnection>& _xConnection,
+                                                    ISQLStatementHelper* _pHelper,
+                                                    std::u16string_view _sCreatePattern);
+
+    /** creates the standard sql statement for the key part of a create table statement.
+        @param  descriptor
+            The descriptor of the new table.
+        @param  _xConnection
+            The connection.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    OUString createStandardKeyStatement( const css::uno::Reference< css::beans::XPropertySet >& descriptor,
+                                                const css::uno::Reference< css::sdbc::XConnection>& _xConnection);
+
+    /** creates the standard sql statement for the type part of a create or alter table statement.
+        @param  _pHelper
+            Allow to add special SQL constructs.
+        @param  descriptor
+            The descriptor of the column.
+        @param  _xConnection
+            The connection.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    OUString createStandardTypePart(     const css::uno::Reference< css::beans::XPropertySet >& descriptor
+                                                ,const css::uno::Reference< css::sdbc::XConnection>& _xConnection
+                                                ,std::u16string_view _sCreatePattern = {});
+
+    /** creates the standard sql statement for the column part of a create table statement.
+        @param  _pHelper
+            Allow to add special SQL constructs.
+        @param  descriptor
+            The descriptor of the column.
+        @param  _xConnection
+            The connection.
+        @param  _pHelper
+            Allow to add special SQL constructs.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    OUString createStandardColumnPart(   const css::uno::Reference< css::beans::XPropertySet >& descriptor
+                                                ,const css::uno::Reference< css::sdbc::XConnection>& _xConnection
+                                                ,ISQLStatementHelper* _pHelper = nullptr
+                                                ,std::u16string_view _sCreatePattern = {});
+
+    /** creates a SQL CREATE TABLE statement
+
+        @param  descriptor
+            The descriptor of the new table.
+        @param  _xConnection
+            The connection.
+
+        @return
+            The CREATE TABLE statement.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    OUString createSqlCreateTableStatement(  const css::uno::Reference< css::beans::XPropertySet >& descriptor
+                                                    ,const css::uno::Reference< css::sdbc::XConnection>& _xConnection);
+
+    /** creates a SDBC column with the help of getColumns.
+        @param  _xTable
+            The table.
+        @param  _rName
+            The name of the column.
+        @param  _bCase
+            Is the column case sensitive.
+        @param  _bQueryForInfo
+            If <TRUE/> the autoincrement and currency field will be read from the meta data, otherwise the following parameters will be used instead
+        @param  _bIsAutoIncrement
+            <TRUE/> if the column is an autoincrement.
+        @param  _bIsCurrency
+            <TRUE/> if the column is a currency field.
+        @param  _nDataType
+            The data type of the column.
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    css::uno::Reference< css::beans::XPropertySet>
+            createSDBCXColumn(  const css::uno::Reference< css::beans::XPropertySet>& _xTable,
+                                const css::uno::Reference< css::sdbc::XConnection>& _xConnection,
+                                const OUString& _rName,
+                                bool _bCase,
+                                bool _bQueryForInfo,
+                                bool _bIsAutoIncrement,
+                                bool _bIsCurrency,
+                                sal_Int32 _nDataType);
+
+    /** tries to locate the corresponding DataDefinitionSupplier for the given url and connection
+        @param  _rsUrl
+            The URL used to connect to the database.
+        @param  _xConnection
+            The connection used to find the correct driver.
+        @param  _rxContext
+            Used to create the drivermanager.
+        @return
+            The datadefinition object.
+    */
+    OOO_DLLPUBLIC_DBTOOLS css::uno::Reference< css::sdbcx::XTablesSupplier> getDataDefinitionByURLAndConnection(
+            const OUString& _rsUrl,
+            const css::uno::Reference< css::sdbc::XConnection>& _xConnection,
+            const css::uno::Reference< css::uno::XComponentContext>& _rxContext);
+
+    /** returns the table privileges to the given parameters
+        @param  _xMetaData
+            The meta data.
+        @param  _sCatalog
+            contains the catalog name
+        @param  _sSchema
+            contains the schema name
+        @param  _sTable
+            contains the table name
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    sal_Int32 getTablePrivileges(const css::uno::Reference< css::sdbc::XDatabaseMetaData>& _xMetaData,
+                                 const OUString& _sCatalog,
+                                 const OUString& _sSchema,
+                                 const OUString& _sTable);
+
+    typedef ::std::pair<bool,bool> TBoolPair;
+    typedef ::std::pair< TBoolPair,sal_Int32 > ColumnInformation;
+    typedef ::std::multimap< OUString, ColumnInformation, ::comphelper::UStringMixLess> ColumnInformationMap;
+    /** collects the information about auto increment, currency and data type for the given column name.
+        The column must be quoted, * is also valid.
+        @param  _xConnection
+            The connection.
+        @param  _sComposedTableName
+            The quoted table name. ccc.sss.ttt
+        @param  _sName
+            The name of the column, or *
+        @param  _rInfo
+            The information about the column(s).
+    */
+    OOO_DLLPUBLIC_DBTOOLS
+    void collectColumnInformation(  const css::uno::Reference< css::sdbc::XConnection>& _xConnection,
+                                    std::u16string_view _sComposedTableName,
+                                    std::u16string_view _rName,
+                                    ColumnInformationMap& _rInfo);
+
+
+    /** adds a boolean comparison clause to the given SQL predicate
+
+        @param _rExpression
+            the expression which is to be compared with a boolean value
+        @param _bValue
+            the boolean value which the expression is to be compared with
+        @param _nBooleanComparisonMode
+            the boolean comparison mode to be used. Usually obtained from
+            a css.sdb.DataSource's Settings member.
+        @param _out_rSQLPredicate
+            the buffer to which the comparison predicate will be appended
+    */
+    OOO_DLLPUBLIC_DBTOOLS void getBooleanComparisonPredicate(
+            std::u16string_view _rExpression,
+            const bool  _bValue,
+            const sal_Int32 _nBooleanComparisonMode,
+            OUStringBuffer& _out_rSQLPredicate
+        );
+
+    /** is this field an aggregate?
+
+        @param _xComposer
+            a query composer that knows the field by name
+        @param _xField
+            the field
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool isAggregateColumn(
+            const css::uno::Reference< css::sdb::XSingleSelectQueryComposer > &_xComposer,
+            const css::uno::Reference< css::beans::XPropertySet > &_xField
+        );
+
+    /** is this column an aggregate?
+
+        @param _xColumns collection of columns
+            look for column sName in there
+        @param _sName
+            name of the column
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool isAggregateColumn(
+            const css::uno::Reference< css::container::XNameAccess > &_xColumns,
+            const OUString &_sName
+        );
+
+    /** is this column an aggregate?
+
+        @param _xColumn
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool isAggregateColumn(
+            const css::uno::Reference< css::beans::XPropertySet > &_xColumn
+        );
+
+}   // namespace dbtools
+
+namespace connectivity
+{
+namespace dbase
+{
+    enum DBFType  { dBaseIII         = 0x03,
+                    dBaseIV          = 0x04,
+                    dBaseV           = 0x05,
+                    VisualFoxPro     = 0x30,
+                    VisualFoxProAuto = 0x31, // Visual FoxPro with AutoIncrement field
+                    dBaseFS          = 0x43,
+                    dBaseFSMemo      = 0xB3,
+                    dBaseIIIMemo     = 0x83,
+                    dBaseIVMemo      = 0x8B,
+                    dBaseIVMemoSQL   = 0x8E,
+                    FoxProMemo       = 0xF5
+    };
+
+    /** decode a DBase file's codepage byte to a RTL charset
+        @param  _out_nCharset
+            in case of success, the decoded RTL charset is written there.
+            else, this is not written to.
+        @param  nType
+            the file's type byte
+        @param  nCodepage
+            the file's codepage byte
+        @return
+            true if a RTL charset was successfully decoded and written to _out_nCharset
+            false if nothing was written to _out_nCharset
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool dbfDecodeCharset(rtl_TextEncoding &_out_nCharset, sal_uInt8 nType, sal_uInt8 nCodepage);
+
+    /** decode a DBase file's codepage byte to a RTL charset
+        @param  _out_nCharset
+            in case of success, the decoded RTL charset is written there.
+            else, this is not written to.
+        @param  dbf_Stream
+            pointer to a SvStream encapsulating the DBase file.
+            The stream will be rewinded and read from.
+            No guarantee is made on its position afterwards. Caller must reposition it itself.
+        @return
+            true if a RTL charset was successfully decoded and written to _out_nCharset
+            false if nothing was written to _out_nCharset
+    */
+    OOO_DLLPUBLIC_DBTOOLS bool dbfReadCharset(rtl_TextEncoding &nCharSet, SvStream* dbf_Stream);
+
+} // namespace connectivity::dbase
+} // namespace connectivity
+
+#endif // INCLUDED_CONNECTIVITY_DBTOOLS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */