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

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

9 files changed, 2452 insertions, 0 deletions

diff --git a/sc/source/ui/dataprovider/csvdataprovider.cxx b/sc/source/ui/dataprovider/csvdataprovider.cxx
new file mode 100644
index 000000000..29391c378
--- /dev/null
+++ b/sc/source/ui/dataprovider/csvdataprovider.cxx
@@ -0,0 +1,176 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <dataprovider.hxx>
+#include <datatransformation.hxx>
+#include <datamapper.hxx>
+#include <stringutil.hxx>
+
+#include <tools/stream.hxx>
+#include <vcl/svapp.hxx>
+#include <docsh.hxx>
+#include <orcus/csv_parser.hpp>
+#include <utility>
+
+namespace {
+
+class CSVHandler
+{
+    ScDocument* mpDoc;
+    SCCOL mnCol;
+    SCROW mnRow;
+
+public:
+    CSVHandler(ScDocument* pDoc) :
+        mpDoc(pDoc), mnCol(0), mnRow(0)
+    {
+    }
+
+    static void begin_parse() {}
+    static void end_parse() {}
+    static void begin_row() {}
+    void end_row()
+    {
+        ++mnRow;
+        mnCol = 0;
+    }
+
+    void cell(const char* p, size_t n, bool /*transient*/)
+    {
+        if (mnCol > mpDoc->MaxCol())
+            return;
+
+        double mfValue = 0.0;
+        if (ScStringUtil::parseSimpleNumber(p, n, '.', ',', mfValue))
+        {
+            mpDoc->SetValue(mnCol, mnRow, 0, mfValue);
+        }
+        else
+        {
+            OString aStr(p, n);
+            mpDoc->SetString(mnCol, mnRow, 0, OStringToOUString(aStr, RTL_TEXTENCODING_UTF8));
+        }
+
+        ++mnCol;
+    }
+};
+
+}
+
+namespace sc {
+CSVFetchThread::CSVFetchThread(
+    ScDocument& rDoc, const OUString& mrURL, std::function<void()> aImportFinishedHdl,
+    std::vector<std::shared_ptr<sc::DataTransformation>>&& rDataTransformations)
+    : Thread("CSV Fetch Thread")
+    , mrDocument(rDoc)
+    , maURL(mrURL)
+    , mbTerminate(false)
+    , maDataTransformations(std::move(rDataTransformations))
+    , maImportFinishedHdl(std::move(aImportFinishedHdl))
+{
+    maConfig.delimiters.push_back(',');
+    maConfig.text_qualifier = '"';
+}
+
+CSVFetchThread::~CSVFetchThread()
+{
+}
+
+bool CSVFetchThread::IsRequestedTerminate()
+{
+    osl::MutexGuard aGuard(maMtxTerminate);
+    return mbTerminate;
+}
+
+void CSVFetchThread::RequestTerminate()
+{
+    osl::MutexGuard aGuard(maMtxTerminate);
+    mbTerminate = true;
+}
+
+void CSVFetchThread::EndThread()
+{
+    RequestTerminate();
+}
+
+void CSVFetchThread::execute()
+{
+    OStringBuffer aBuffer(64000);
+    DataProvider::FetchStreamFromURL(maURL, aBuffer);
+    if (mbTerminate)
+        return;
+
+    CSVHandler aHdl(&mrDocument);
+    orcus::csv_parser<CSVHandler> parser(aBuffer.getStr(), aBuffer.getLength(), aHdl, maConfig);
+    parser.parse();
+
+    for (const auto& itr : maDataTransformations)
+    {
+        itr->Transform(mrDocument);
+    }
+
+    SolarMutexGuard aGuard;
+    maImportFinishedHdl();
+}
+
+CSVDataProvider::CSVDataProvider(ScDocument* pDoc, sc::ExternalDataSource& rDataSource):
+    DataProvider(rDataSource),
+    mpDocument(pDoc)
+{
+}
+
+CSVDataProvider::~CSVDataProvider()
+{
+    if (mxCSVFetchThread.is())
+    {
+        SolarMutexReleaser aReleaser;
+        mxCSVFetchThread->join();
+    }
+}
+
+void CSVDataProvider::Import()
+{
+    // already importing data
+    if (mpDoc)
+        return;
+
+    mpDoc.reset(new ScDocument(SCDOCMODE_CLIP));
+    mpDoc->ResetClip(mpDocument, SCTAB(0));
+    mxCSVFetchThread = new CSVFetchThread(*mpDoc, mrDataSource.getURL(), std::bind(&CSVDataProvider::ImportFinished, this), std::vector(mrDataSource.getDataTransformation()));
+    mxCSVFetchThread->launch();
+
+    if (mbDeterministic)
+    {
+        SolarMutexReleaser aReleaser;
+        mxCSVFetchThread->join();
+    }
+}
+
+void CSVDataProvider::ImportFinished()
+{
+    mrDataSource.getDBManager()->WriteToDoc(*mpDoc);
+    mpDoc.reset();
+    Refresh();
+}
+
+void CSVDataProvider::Refresh()
+{
+    ScDocShell* pDocShell = static_cast<ScDocShell*>(mpDocument->GetDocumentShell());
+    if (pDocShell)
+        pDocShell->SetDocumentModified();
+}
+
+const OUString& CSVDataProvider::GetURL() const
+{
+    return mrDataSource.getURL();
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/dataprovider.cxx b/sc/source/ui/dataprovider/dataprovider.cxx
new file mode 100644
index 000000000..72f674a7b
--- /dev/null
+++ b/sc/source/ui/dataprovider/dataprovider.cxx
@@ -0,0 +1,313 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <dataprovider.hxx>
+#include <com/sun/star/ucb/XSimpleFileAccess3.hpp>
+#include <com/sun/star/ucb/SimpleFileAccess.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <o3tl/string_view.hxx>
+#include <rtl/strbuf.hxx>
+#include <sal/log.hxx>
+#include <unotools/charclass.hxx>
+#include <tools/stream.hxx>
+#include <comphelper/processfactory.hxx>
+
+#include "htmldataprovider.hxx"
+#include "xmldataprovider.hxx"
+#include "sqldataprovider.hxx"
+#include <datamapper.hxx>
+#include <dbdata.hxx>
+#include <docsh.hxx>
+
+using namespace com::sun::star;
+
+namespace sc {
+
+std::unique_ptr<SvStream> DataProvider::FetchStreamFromURL(const OUString& rURL, OStringBuffer& rBuffer)
+{
+    try
+    {
+        uno::Reference< ucb::XSimpleFileAccess3 > xFileAccess = ucb::SimpleFileAccess::create( comphelper::getProcessComponentContext() );
+
+        uno::Reference< io::XInputStream > xStream = xFileAccess->openFileRead( rURL );
+
+        const sal_Int32 BUF_LEN = 8000;
+        uno::Sequence< sal_Int8 > buffer( BUF_LEN );
+
+        sal_Int32 nRead = 0;
+        while ( ( nRead = xStream->readBytes( buffer, BUF_LEN ) ) == BUF_LEN )
+        {
+            rBuffer.append( reinterpret_cast< const char* >( buffer.getConstArray() ), nRead );
+        }
+
+        if ( nRead > 0 )
+        {
+            rBuffer.append( reinterpret_cast< const char* >( buffer.getConstArray() ), nRead );
+        }
+
+        xStream->closeInput();
+
+        SvStream* pStream = new SvMemoryStream(const_cast<char*>(rBuffer.getStr()), rBuffer.getLength(), StreamMode::READ);
+        return std::unique_ptr<SvStream>(pStream);
+    }
+    catch(...)
+    {
+        rBuffer.setLength(0);
+        return nullptr;
+    }
+}
+
+ExternalDataSource::ExternalDataSource(const OUString& rURL,
+        const OUString& rProvider, ScDocument* pDoc)
+    : maURL(rURL)
+    , maProvider(rProvider)
+    , mpDoc(pDoc)
+{
+}
+
+void ExternalDataSource::setID(const OUString& rID)
+{
+    maID = rID;
+}
+
+void ExternalDataSource::setXMLImportParam(const ScOrcusImportXMLParam& rParam)
+{
+    maParam = rParam;
+}
+
+
+
+void ExternalDataSource::setURL(const OUString& rURL)
+{
+    maURL = rURL;
+}
+
+void ExternalDataSource::setProvider(const OUString& rProvider)
+{
+    maProvider = rProvider;
+    mpDataProvider.reset();
+}
+
+const OUString& ExternalDataSource::getURL() const
+{
+    return maURL;
+}
+
+const OUString& ExternalDataSource::getProvider() const
+{
+    return maProvider;
+}
+
+const OUString& ExternalDataSource::getID() const
+{
+    return maID;
+}
+
+const ScOrcusImportXMLParam& ExternalDataSource::getXMLImportParam() const
+{
+    return maParam;
+}
+
+OUString ExternalDataSource::getDBName() const
+{
+    if (mpDBDataManager)
+    {
+        ScDBData* pDBData = mpDBDataManager->getDBData();
+        if (pDBData)
+            return pDBData->GetName();
+    }
+    return OUString();
+}
+
+void ExternalDataSource::setDBData(const OUString& rDBName)
+{
+    if (!mpDBDataManager)
+    {
+        mpDBDataManager = std::make_shared<ScDBDataManager>(rDBName, mpDoc);
+    }
+    else
+    {
+        mpDBDataManager->SetDatabase(rDBName);
+    }
+}
+
+double ExternalDataSource::getUpdateFrequency()
+{
+    return 0;
+}
+
+ScDBDataManager* ExternalDataSource::getDBManager()
+{
+    return mpDBDataManager.get();
+}
+
+void ExternalDataSource::refresh(ScDocument* pDoc, bool bDeterministic)
+{
+    // no DB data available
+    if (!mpDBDataManager)
+        return;
+
+    // if no data provider exists, try to create one
+    if (!mpDataProvider)
+        mpDataProvider = DataProviderFactory::getDataProvider(pDoc, *this);
+
+    // if we still have not been able to create one, we can not refresh the data
+    if (!mpDataProvider)
+        return;
+
+    if (bDeterministic)
+        mpDataProvider->setDeterministic();
+
+    mpDataProvider->Import();
+}
+
+void ExternalDataSource::AddDataTransformation(
+    const std::shared_ptr<sc::DataTransformation>& mpDataTransformation)
+{
+    maDataTransformations.push_back(mpDataTransformation);
+}
+
+const std::vector<std::shared_ptr<sc::DataTransformation>>& ExternalDataSource::getDataTransformation() const
+{
+    return maDataTransformations;
+}
+
+ExternalDataMapper::ExternalDataMapper(ScDocument& /*rDoc*/)
+    //mrDoc(rDoc)
+{
+}
+
+ExternalDataMapper::~ExternalDataMapper()
+{
+}
+
+void ExternalDataMapper::insertDataSource(const sc::ExternalDataSource& rSource)
+{
+    maDataSources.push_back(rSource);
+}
+
+const std::vector<sc::ExternalDataSource>& ExternalDataMapper::getDataSources() const
+{
+    return maDataSources;
+}
+
+std::vector<sc::ExternalDataSource>& ExternalDataMapper::getDataSources()
+{
+    return maDataSources;
+}
+
+DataProvider::DataProvider(sc::ExternalDataSource& rDataSource):
+    mbDeterministic(false),
+    mrDataSource(rDataSource)
+{
+}
+
+void DataProvider::setDeterministic()
+{
+    mbDeterministic = true;
+}
+
+DataProvider::~DataProvider()
+{
+}
+
+void ScDBDataManager::WriteToDoc(ScDocument& rDoc)
+{
+    // first apply all data transformations
+
+    bool bShrunk = false;
+    SCCOL nStartCol = 0;
+    SCROW nStartRow = 0;
+    SCCOL nEndCol = rDoc.MaxCol();
+    SCROW nEndRow = rDoc.MaxRow();
+    rDoc.ShrinkToUsedDataArea(bShrunk, 0, nStartCol, nStartRow, nEndCol, nEndRow, false, true, true);
+    ScRange aClipRange(nStartCol, nStartRow, 0, nEndCol, nEndRow, 0);
+    rDoc.SetClipArea(aClipRange);
+
+    ScRange aDestRange;
+    getDBData()->GetArea(aDestRange);
+    SCCOL nColSize = std::min<SCCOL>(aDestRange.aEnd.Col() - aDestRange.aStart.Col(), nEndCol);
+    aDestRange.aEnd.SetCol(aDestRange.aStart.Col() + nColSize);
+
+    SCROW nRowSize = std::min<SCROW>(aDestRange.aEnd.Row() - aDestRange.aStart.Row(), nEndRow);
+    aDestRange.aEnd.SetRow(aDestRange.aStart.Row() + nRowSize);
+
+    ScMarkData aMark(mpDoc->GetSheetLimits());
+    aMark.SelectTable(0, true);
+    mpDoc->CopyFromClip(aDestRange, aMark, InsertDeleteFlags::CONTENTS, nullptr, &rDoc);
+    ScDocShell* pDocShell = static_cast<ScDocShell*>(mpDoc->GetDocumentShell());
+    if (pDocShell)
+        pDocShell->PostPaint(aDestRange, PaintPartFlags::All);
+}
+
+ScDBDataManager::ScDBDataManager(const OUString& rDBName, ScDocument* pDoc):
+    maDBName(rDBName),
+    mpDoc(pDoc)
+{
+}
+
+ScDBDataManager::~ScDBDataManager()
+{
+}
+
+void ScDBDataManager::SetDatabase(const OUString& rDBName)
+{
+    maDBName = rDBName;
+}
+
+ScDBData* ScDBDataManager::getDBData()
+{
+    ScDBData* pDBData = mpDoc->GetDBCollection()->getNamedDBs().findByUpperName(ScGlobal::getCharClass().uppercase(maDBName));
+    return pDBData;
+}
+
+bool DataProviderFactory::isInternalDataProvider(std::u16string_view rProvider)
+{
+    return o3tl::starts_with(rProvider, u"org.libreoffice.calc");
+}
+
+std::shared_ptr<DataProvider> DataProviderFactory::getDataProvider(ScDocument* pDoc,
+        sc::ExternalDataSource& rDataSource)
+{
+    const OUString& rDataProvider = rDataSource.getProvider();
+    bool bInternal = DataProviderFactory::isInternalDataProvider(rDataProvider);
+    if (bInternal)
+    {
+        if (rDataProvider == "org.libreoffice.calc.csv")
+            return std::make_shared<CSVDataProvider>(pDoc, rDataSource);
+        else if (rDataProvider == "org.libreoffice.calc.html")
+            return std::make_shared<HTMLDataProvider>(pDoc, rDataSource);
+        else if (rDataProvider == "org.libreoffice.calc.xml")
+            return std::make_shared<XMLDataProvider>(pDoc, rDataSource);
+        else if (rDataProvider == "org.libreoffice.calc.sql")
+            return std::make_shared<SQLDataProvider>(pDoc, rDataSource);
+    }
+    else
+    {
+        SAL_WARN("sc", "no external data provider supported yet");
+        return std::shared_ptr<DataProvider>();
+    }
+
+    return std::shared_ptr<DataProvider>();
+}
+
+std::vector<OUString> DataProviderFactory::getDataProviders()
+{
+    std::vector<OUString> aDataProviders;
+    aDataProviders.emplace_back("org.libreoffice.calc.csv");
+    aDataProviders.emplace_back("org.libreoffice.calc.html");
+    aDataProviders.emplace_back("org.libreoffice.calc.xml");
+    aDataProviders.emplace_back("org.libreoffice.calc.sql");
+
+    return aDataProviders;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/datatransformation.cxx b/sc/source/ui/dataprovider/datatransformation.cxx
new file mode 100644
index 000000000..62c82adb9
--- /dev/null
+++ b/sc/source/ui/dataprovider/datatransformation.cxx
@@ -0,0 +1,1275 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <datatransformation.hxx>
+#include <limits>
+#include <document.hxx>
+#include <rtl/math.hxx>
+#include <cmath>
+#include <svl/numformat.hxx>
+#include <svl/zforlist.hxx>
+#include <unotools/charclass.hxx>
+
+namespace {
+
+Date getDate(double nDateTime, const SvNumberFormatter* pFormatter)
+{
+    Date aDate = pFormatter->GetNullDate();
+    aDate.AddDays(static_cast<sal_Int32>(::rtl::math::approxFloor(nDateTime)));
+    return aDate;
+}
+}
+
+namespace sc {
+DataTransformation::~DataTransformation()
+{
+}
+
+SCROW DataTransformation::getLastRow(const ScDocument& rDoc, SCCOL nCol)
+{
+    SCROW nEndRow = rDoc.MaxRow();
+
+    return rDoc.GetLastDataRow(0, nCol, nCol, nEndRow);
+}
+
+ColumnRemoveTransformation::ColumnRemoveTransformation(std::set<SCCOL>&& rColumns):
+    maColumns(std::move(rColumns))
+{
+}
+
+ColumnRemoveTransformation::~ColumnRemoveTransformation()
+{
+}
+
+void ColumnRemoveTransformation::Transform(ScDocument& rDoc) const
+{
+    sal_Int32 nIncrementIndex = 0;
+    for (auto& rCol : maColumns)
+    {
+        rDoc.DeleteCol(0, 0, rDoc.MaxRow(), 0, rCol - nIncrementIndex, 1);
+        nIncrementIndex++;
+    }
+}
+
+TransformationType ColumnRemoveTransformation::getTransformationType() const
+{
+    return TransformationType::DELETE_TRANSFORMATION;
+}
+
+const std::set<SCCOL> & ColumnRemoveTransformation::getColumns() const
+{
+    return maColumns;
+}
+
+SplitColumnTransformation::SplitColumnTransformation(SCCOL nCol, sal_Unicode cSeparator):
+    mnCol(nCol),
+    mcSeparator(cSeparator)
+{
+}
+
+void SplitColumnTransformation::Transform(ScDocument& rDoc) const
+{
+    if (mnCol == -1)
+        return;
+
+    rDoc.InsertCol(0, 0, rDoc.MaxRow(), 0, mnCol + 1, 1);
+
+    SCROW nEndRow = getLastRow(rDoc, mnCol);
+    for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+    {
+        CellType eType = rDoc.GetCellType(mnCol, nRow, 0);
+        if (eType == CELLTYPE_STRING)
+        {
+            OUString aStr = rDoc.GetString(mnCol, nRow, 0);
+            sal_Int32 nIndex = aStr.indexOf(mcSeparator);
+            if (nIndex != -1)
+            {
+                rDoc.SetString(mnCol + 1, nRow, 0, aStr.copy(nIndex + 1));
+                rDoc.SetString(mnCol, nRow, 0, aStr.copy(0, nIndex));
+            }
+        }
+    }
+}
+
+TransformationType SplitColumnTransformation::getTransformationType() const
+{
+    return TransformationType::SPLIT_TRANSFORMATION;
+}
+
+SCCOL SplitColumnTransformation::getColumn() const
+{
+    return mnCol;
+}
+
+sal_Unicode SplitColumnTransformation::getSeparator() const
+{
+    return mcSeparator;
+}
+
+MergeColumnTransformation::MergeColumnTransformation( std::set<SCCOL>&& rColumns, const OUString& rMergeString):
+    maColumns(std::move(rColumns)),
+    maMergeString(rMergeString)
+{
+}
+
+void MergeColumnTransformation::Transform(ScDocument& rDoc) const
+{
+    if (maColumns.empty())
+        return;
+
+    SCROW nMaxRow = 0;
+    for (auto& itr : maColumns)
+    {
+        nMaxRow = getLastRow(rDoc, itr);
+    }
+    assert(nMaxRow != -1);
+
+    SCCOL nTargetCol = *maColumns.begin();
+
+
+    for (SCROW nRow = 0; nRow <= nMaxRow; ++nRow)
+    {
+        OUStringBuffer aStr(rDoc.GetString(nTargetCol, nRow, 0));
+        for (auto& itr : maColumns)
+        {
+            if (itr != nTargetCol)
+            {
+                aStr.append(maMergeString + rDoc.GetString(itr, nRow, 0));
+            }
+        }
+        rDoc.SetString(nTargetCol, nRow, 0, aStr.makeStringAndClear());
+    }
+
+    for (auto& itr : maColumns)
+    {
+        if (itr == nTargetCol)
+            continue;
+
+        rDoc.DeleteCol(0, 0, rDoc.MaxRow(), 0, itr, 1);
+    }
+}
+
+TransformationType MergeColumnTransformation::getTransformationType() const
+{
+    return TransformationType::MERGE_TRANSFORMATION;
+}
+
+const OUString & MergeColumnTransformation::getMergeString() const
+{
+    return maMergeString;
+}
+
+const std::set<SCCOL> & MergeColumnTransformation::getColumns() const
+{
+    return maColumns;
+}
+
+SortTransformation::SortTransformation(const ScSortParam& rSortParam):
+    maSortParam(rSortParam)
+{
+}
+
+void SortTransformation::Transform(ScDocument& rDoc) const
+{
+    rDoc.Sort(0, maSortParam, false, false, nullptr, nullptr);
+}
+
+TransformationType SortTransformation::getTransformationType() const
+{
+    return TransformationType::SORT_TRANSFORMATION;
+}
+
+const ScSortParam & SortTransformation::getSortParam() const
+{
+    return maSortParam;
+}
+
+TextTransformation::TextTransformation( std::set<SCCOL>&& nCol, const TEXT_TRANSFORM_TYPE rType):
+    mnCol(std::move(nCol)),
+    maType(rType)
+{
+}
+
+void TextTransformation::Transform(ScDocument& rDoc) const
+{
+    SCROW nEndRow = 0;
+    for(auto& rCol : mnCol)
+    {
+        nEndRow = getLastRow(rDoc, rCol);
+    }
+    assert(nEndRow != -1);
+
+    for(auto& rCol : mnCol)
+    {
+        switch (maType)
+        {
+            case TEXT_TRANSFORM_TYPE::TO_LOWER:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_STRING)
+                    {
+                        OUString aStr = rDoc.GetString(rCol, nRow, 0);
+                        rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClass().lowercase(aStr));
+                    }
+                }
+            }
+            break;
+            case TEXT_TRANSFORM_TYPE::TO_UPPER:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_STRING)
+                    {
+                        OUString aStr = rDoc.GetString(rCol, nRow, 0);
+                        rDoc.SetString(rCol, nRow, 0, ScGlobal::getCharClass().uppercase(aStr));
+                    }
+                }
+            }
+            break;
+            case TEXT_TRANSFORM_TYPE::CAPITALIZE:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_STRING)
+                    {
+                        OUString aStr = rDoc.GetString(rCol, nRow, 0);
+
+                        sal_Int32 length = aStr.getLength();
+
+                        if(length != 0)
+                            aStr = aStr.replaceAt(0, 1, ScGlobal::getCharClass().uppercase(OUString(aStr[0])));
+
+                        for (sal_Int32 i = 1; i < length; i++){
+                            if (aStr[i-1] == sal_Unicode(U' '))
+                            {
+                                aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClass().uppercase(OUString(aStr[i])));
+                            }
+                            else
+                            {
+                                aStr = aStr.replaceAt(i, 1, ScGlobal::getCharClass().lowercase(OUString(aStr[i])));
+                            }
+                        }
+                        rDoc.SetString(rCol, nRow, 0, aStr);
+                    }
+                }
+            }
+            break;
+            case TEXT_TRANSFORM_TYPE::TRIM:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_STRING)
+                    {
+                        OUString aStr = rDoc.GetString(rCol, nRow, 0);
+                        rDoc.SetString(rCol, nRow, 0, aStr.trim());
+                    }
+                }
+            }
+            break;
+            default:
+            break;
+        }
+    }
+}
+
+TransformationType TextTransformation::getTransformationType() const
+{
+    return TransformationType::TEXT_TRANSFORMATION;
+}
+
+TEXT_TRANSFORM_TYPE TextTransformation::getTextTransformationType() const
+{
+    return maType;
+}
+
+const std::set<SCCOL>& TextTransformation::getColumns() const
+{
+    return mnCol;
+}
+
+AggregateFunction::AggregateFunction(std::set<SCCOL>&& rColumns, const AGGREGATE_FUNCTION rType):
+    maColumns(std::move(rColumns)),
+    maType(rType)
+{
+}
+
+void AggregateFunction::Transform(ScDocument& rDoc) const
+{
+    SCROW nEndRow = 0;
+    for (auto& itr : maColumns)
+    {
+        nEndRow = getLastRow(rDoc, itr);
+    }
+    assert(nEndRow != -1);
+
+    for (auto& rCol : maColumns)
+    {
+        switch (maType)
+        {
+            case AGGREGATE_FUNCTION::SUM:
+            {
+                double nSum = 0;
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        nSum += nVal;
+                    }
+                }
+                rDoc.SetValue(rCol, nEndRow + 1, 0, nSum);
+            }
+            break;
+            case AGGREGATE_FUNCTION::AVERAGE:
+            {
+                double nSum = 0;
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        nSum += nVal;
+                    }
+                }
+
+                double nAvg = nSum / (nEndRow + 1);
+                rDoc.SetValue(rCol, nEndRow + 1, 0, nAvg);
+            }
+            break;
+            case AGGREGATE_FUNCTION::MIN:
+            {
+                double nMin = std::numeric_limits<double>::max();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if(nVal < nMin)
+                            nMin = nVal;
+                    }
+                }
+                rDoc.SetValue(rCol, nEndRow + 1, 0, nMin);
+            }
+            break;
+            case AGGREGATE_FUNCTION::MAX:
+            {
+                double nMax = std::numeric_limits<double>::lowest();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if(nMax < nVal)
+                            nMax = nVal;
+                    }
+                }
+                rDoc.SetValue(rCol, nEndRow + 1, 0, nMax);
+            }
+            break;
+            default:
+            break;
+        }
+    }
+}
+
+TransformationType AggregateFunction::getTransformationType() const
+{
+    return TransformationType::AGGREGATE_FUNCTION;
+}
+
+AGGREGATE_FUNCTION AggregateFunction::getAggregateType() const
+{
+     return maType;
+}
+
+const std::set<SCCOL>& AggregateFunction::getColumns() const
+{
+     return maColumns;
+}
+
+NumberTransformation::NumberTransformation(std::set<SCCOL>&& nCol,
+                                           const NUMBER_TRANSFORM_TYPE rType)
+    : mnCol(std::move(nCol))
+    , maType(rType)
+    , maPrecision(-1)
+{
+}
+
+NumberTransformation::NumberTransformation(std::set<SCCOL>&& nCol,
+                                           const NUMBER_TRANSFORM_TYPE rType, int nPrecision)
+    : mnCol(std::move(nCol))
+    , maType(rType)
+    , maPrecision(nPrecision)
+{
+}
+
+void NumberTransformation::Transform(ScDocument& rDoc) const
+{
+    SCROW nEndRow = 0;
+    for(auto& rCol : mnCol)
+    {
+        nEndRow = getLastRow(rDoc, rCol);
+    }
+    assert(nEndRow != -1);
+
+    for(auto& rCol : mnCol)
+    {
+        switch (maType)
+        {
+            case NUMBER_TRANSFORM_TYPE::ROUND:
+            {
+                if(maPrecision > -1)
+                {
+                    for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                    {
+                        CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                        if (eType == CELLTYPE_VALUE)
+                        {
+                            double nVal = rDoc.GetValue(rCol, nRow, 0);
+                            rDoc.SetValue(rCol, nRow, 0, rtl::math::round(nVal, maPrecision));
+                        }
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::ROUND_UP:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        rDoc.SetValue(rCol, nRow, 0, rtl::math::approxCeil(nVal));
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::ROUND_DOWN:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        rDoc.SetValue(rCol, nRow, 0, rtl::math::approxFloor(nVal));
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::ABSOLUTE:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if(std::signbit(nVal))
+                            rDoc.SetValue(rCol, nRow, 0, -1 * nVal);
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::LOG_E:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if (nVal > 0)
+                        {
+                            rDoc.SetValue(rCol, nRow, 0, rtl::math::log1p(nVal-1));
+                        }
+                        else
+                        {
+                            rDoc.SetString(rCol, nRow, 0, OUString());
+                        }
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::LOG_10:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if (nVal > 0)
+                        {
+                            rDoc.SetValue(rCol, nRow, 0, log10(nVal));
+                        }
+                        else
+                        {
+                            rDoc.SetString(rCol, nRow, 0, OUString());
+                        }
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::CUBE:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        rDoc.SetValue(rCol, nRow, 0, nVal * nVal * nVal);
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::SQUARE:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        rDoc.SetValue(rCol, nRow, 0, nVal * nVal);
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::SQUARE_ROOT:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if (!std::signbit(nVal))
+                        {
+                            rDoc.SetValue(rCol, nRow, 0, sqrt(nVal));
+                        }
+                        else
+                        {
+                            rDoc.SetString(rCol, nRow, 0, OUString());
+                        }
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::IS_EVEN:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if (fmod(nVal, 1) == 0 && fmod(nVal, 2) == 0)
+                            rDoc.SetValue(rCol, nRow, 0, 1);
+                        else
+                            rDoc.SetValue(rCol, nRow, 0, 0);
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::IS_ODD:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if (fmod(nVal, 1) == 0 && fmod(nVal, 2) != 0)
+                            rDoc.SetValue(rCol, nRow, 0, 1);
+                        else
+                            rDoc.SetValue(rCol, nRow, 0, 0);
+                    }
+                }
+            }
+            break;
+            case NUMBER_TRANSFORM_TYPE::SIGN:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        if (nVal > 0)
+                            rDoc.SetValue(rCol, nRow, 0, 1);
+                        else if (nVal < 0)
+                            rDoc.SetValue(rCol, nRow, 0, -1);
+                        else
+                            rDoc.SetValue(rCol, nRow, 0, 0);
+                    }
+                }
+            }
+            break;
+            default:
+            break;
+        }
+    }
+}
+
+TransformationType NumberTransformation::getTransformationType() const
+{
+    return TransformationType::NUMBER_TRANSFORMATION;
+}
+
+NUMBER_TRANSFORM_TYPE NumberTransformation::getNumberTransformationType() const
+{
+    return maType;
+}
+
+int NumberTransformation::getPrecision() const
+{
+    return maPrecision;
+}
+
+const std::set<SCCOL>& NumberTransformation::getColumn() const
+{
+    return mnCol;
+}
+
+ReplaceNullTransformation::ReplaceNullTransformation(std::set<SCCOL>&& nCol,
+                                                     const OUString& sReplaceWith)
+    : mnCol(std::move(nCol))
+    , msReplaceWith(sReplaceWith)
+{
+}
+
+void ReplaceNullTransformation::Transform(ScDocument& rDoc) const
+{
+    if (mnCol.empty())
+        return;
+
+    for(auto& rCol : mnCol)
+    {
+        SCROW nEndRow = getLastRow(rDoc, rCol);
+        for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+        {
+            CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+            if (eType == CELLTYPE_NONE)
+            {
+               // OUString aStr = rDoc.GetString(rCol, nRow, 0);
+               // if (aStr == "" || aStr.isEmpty())
+                    rDoc.SetString(rCol, nRow, 0, msReplaceWith);
+            }
+        }
+    }
+
+}
+
+const std::set<SCCOL>& ReplaceNullTransformation::getColumn() const
+{
+    return mnCol;
+}
+
+const OUString& ReplaceNullTransformation::getReplaceString() const
+{
+    return msReplaceWith;
+}
+
+TransformationType ReplaceNullTransformation::getTransformationType() const
+{
+     return TransformationType::REMOVE_NULL_TRANSFORMATION;
+}
+
+DateTimeTransformation::DateTimeTransformation(std::set<SCCOL>&& nCol,
+                                               const DATETIME_TRANSFORMATION_TYPE rType)
+    : mnCol(std::move(nCol))
+    , maType(rType)
+{
+}
+
+void DateTimeTransformation::Transform(ScDocument& rDoc) const
+{
+    SCROW nEndRow = 0;
+    for(auto& rCol : mnCol)
+    {
+        nEndRow = getLastRow(rDoc, rCol);
+    }
+    assert(nEndRow != -1);
+
+    for(auto& rCol : mnCol)
+    {
+        switch (maType)
+        {
+            case DATETIME_TRANSFORMATION_TYPE::DATE_STRING:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType        eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        ScAddress aAddress(rCol, nRow, 0);
+                        rDoc.SetNumberFormat(aAddress, nFormat);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::YEAR:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        rDoc.SetValue(rCol, nRow, 0, aDate.GetYear());
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::START_OF_YEAR:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType        eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        aDate.SetDay(1);
+                        aDate.SetMonth(1);
+                        nVal = aDate - pFormatter->GetNullDate();
+                        ScAddress aAddress(rCol, nRow, 0);
+                        rDoc.SetValue(rCol, nRow, 0, nVal);
+                        rDoc.SetNumberFormat(aAddress, nFormat);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::END_OF_YEAR:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType        eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
+
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        aDate.SetMonth(12);
+                        aDate.SetDay(31);
+                        nVal = aDate - pFormatter->GetNullDate();
+                        ScAddress aAddress(rCol, nRow, 0);
+                        rDoc.SetValue(rCol, nRow, 0, nVal);
+                        rDoc.SetNumberFormat(aAddress, nFormat);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::MONTH:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        rDoc.SetValue(rCol, nRow, 0, aDate.GetMonth());
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::MONTH_NAME:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType eLanguage = ScGlobal::eLnge;
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        const Color* pColor = nullptr;
+                        OUString aResult;
+                        pFormatter->GetPreviewStringGuess("MMMM", nVal, aResult, &pColor, eLanguage);
+                        rDoc.SetString(rCol, nRow, 0, aResult);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::START_OF_MONTH:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        ScAddress aAddress(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        aDate.SetDay(1);
+                        nVal = aDate - pFormatter->GetNullDate();
+                        rDoc.SetValue(rCol, nRow, 0, nVal);
+                        rDoc.SetNumberFormat(aAddress, nFormat);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::END_OF_MONTH:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        ScAddress aAddress(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        aDate.SetDay(aDate.GetDaysInMonth());
+                        nVal = aDate - pFormatter->GetNullDate();
+                        rDoc.SetValue(rCol, nRow, 0, nVal);
+                        rDoc.SetNumberFormat(aAddress, nFormat);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::DAY:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        rDoc.SetValue(rCol, nRow, 0, aDate.GetDay());
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::DAY_OF_WEEK:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfWeek());
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::DAY_OF_YEAR:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        rDoc.SetValue(rCol, nRow, 0, aDate.GetDayOfYear());
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::QUARTER:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+
+                        int nMonth = aDate.GetMonth();
+
+                        if(nMonth >= 1 && nMonth <=3)
+                            rDoc.SetValue(rCol, nRow, 0, 1);
+
+                        else if(nMonth >= 4 && nMonth <=6)
+                            rDoc.SetValue(rCol, nRow, 0, 2);
+
+                        else if(nMonth >= 7 && nMonth <=9)
+                            rDoc.SetValue(rCol, nRow, 0, 3);
+
+                        else if(nMonth >= 10 && nMonth <=12)
+                            rDoc.SetValue(rCol, nRow, 0, 4);
+                        else
+                            rDoc.SetValue(rCol, nRow, 0, -1);
+
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::START_OF_QUARTER:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        ScAddress aAddress(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+
+                        int nMonth = aDate.GetMonth();
+
+                        if(nMonth >= 1 && nMonth <=3)
+                        {
+                            aDate.SetDay(1);
+                            aDate.SetMonth(1);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+                        else if(nMonth >= 4 && nMonth <=6)
+                        {
+                            aDate.SetDay(1);
+                            aDate.SetMonth(4);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+                        else if(nMonth >= 7 && nMonth <=9)
+                        {
+                            aDate.SetDay(1);
+                            aDate.SetMonth(7);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+                        else if(nMonth >= 10 && nMonth <=12)
+                        {
+                            aDate.SetDay(1);
+                            aDate.SetMonth(10);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+                        else
+                            rDoc.SetValue(rCol, nRow, 0, -1);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::END_OF_QUARTER:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType        eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATE, eLanguage );
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    ScAddress aAddress(rCol, nRow, 0);
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        Date aDate = getDate(nVal, pFormatter);
+                        int nMonth = aDate.GetMonth();
+
+                        if(nMonth >= 1 && nMonth <=3)
+                        {
+                            aDate.SetDay(31);
+                            aDate.SetMonth(3);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+
+                        else if(nMonth >= 4 && nMonth <=6)
+                        {
+                            aDate.SetDay(30);
+                            aDate.SetMonth(6);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+
+                        else if(nMonth >= 7 && nMonth <=9)
+                        {
+                            aDate.SetDay(30);
+                            aDate.SetMonth(9);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+
+                        else if(nMonth >= 10 && nMonth <=12)
+                        {
+                            aDate.SetDay(31);
+                            aDate.SetMonth(12);
+                            nVal = aDate - pFormatter->GetNullDate();
+                            rDoc.SetValue(rCol, nRow, 0, nVal);
+                            rDoc.SetNumberFormat(aAddress, nFormat);
+                        }
+                        else
+                            rDoc.SetValue(rCol, nRow, 0, -1);
+
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::TIME:
+            {
+                SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
+                LanguageType eLanguage = ScGlobal::eLnge;
+                sal_uInt32 nFormat = pFormatter->GetStandardFormat(SvNumFormatType::TIME, eLanguage);
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    ScAddress aAddress(rCol, nRow, 0);
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        rDoc.SetNumberFormat(aAddress, nFormat);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::HOUR:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        sal_uInt16 nHour, nMinute, nSecond;
+                        double fFractionOfSecond;
+                        tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
+                        rDoc.SetValue(rCol, nRow, 0, nHour);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::MINUTE:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        sal_uInt16 nHour, nMinute, nSecond;
+                        double fFractionOfSecond;
+                        tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
+                        rDoc.SetValue(rCol, nRow, 0, nMinute);
+                    }
+                }
+            }
+            break;
+            case DATETIME_TRANSFORMATION_TYPE::SECOND:
+            {
+                for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+                {
+                    CellType eType = rDoc.GetCellType(rCol, nRow, 0);
+                    if (eType == CELLTYPE_VALUE)
+                    {
+                        double nVal = rDoc.GetValue(rCol, nRow, 0);
+                        sal_uInt16 nHour, nMinute, nSecond;
+                        double fFractionOfSecond;
+                        tools::Time::GetClock( nVal, nHour, nMinute, nSecond, fFractionOfSecond, 0);
+                        rDoc.SetValue(rCol, nRow, 0, nSecond);
+                    }
+                }
+            }
+            break;
+            default:
+            break;
+        }
+    }
+}
+
+TransformationType DateTimeTransformation::getTransformationType() const
+{
+    return TransformationType::DATETIME_TRANSFORMATION;
+}
+
+DATETIME_TRANSFORMATION_TYPE DateTimeTransformation::getDateTimeTransformationType() const
+{
+    return maType;
+}
+
+const std::set<SCCOL>& DateTimeTransformation::getColumn() const
+{
+    return mnCol;
+}
+
+FindReplaceTransformation::FindReplaceTransformation(SCCOL nCol, const OUString& aFindString, const OUString& aReplaceString)
+    : mnCol(nCol)
+    , maFindString(aFindString)
+    , maReplaceString(aReplaceString)
+{
+}
+
+void FindReplaceTransformation::Transform(ScDocument& rDoc) const
+{
+    if (mnCol == -1)
+        return;
+
+    SCROW nEndRow = getLastRow(rDoc, mnCol);
+    for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+    {
+        CellType eType = rDoc.GetCellType(mnCol, nRow, 0);
+        if (eType != CELLTYPE_NONE)
+        {
+            OUString aStr = rDoc.GetString(mnCol, nRow, 0);
+            if (aStr == maFindString)
+                rDoc.SetString(mnCol, nRow, 0, maReplaceString);
+        }
+    }
+}
+
+TransformationType FindReplaceTransformation::getTransformationType() const
+{
+    return TransformationType::FINDREPLACE_TRANSFORMATION;
+}
+
+SCCOL FindReplaceTransformation::getColumn() const
+{
+    return mnCol;
+}
+
+const OUString& FindReplaceTransformation::getFindString() const
+{
+    return maFindString;
+}
+
+const OUString& FindReplaceTransformation::getReplaceString() const
+{
+    return maReplaceString;
+}
+
+DeleteRowTransformation::DeleteRowTransformation(SCCOL nCol, const OUString& aFindString)
+    : mnCol(nCol)
+    , maFindString(aFindString)
+{
+}
+
+void DeleteRowTransformation::Transform(ScDocument& rDoc) const
+{
+    sal_Int32 nIncrementIndex = 0;
+    if (mnCol == -1)
+        return;
+
+    SCROW nEndRow = getLastRow(rDoc, mnCol);
+    for (SCROW nRow = 0; nRow <= nEndRow; ++nRow)
+    {
+        CellType eType = rDoc.GetCellType(mnCol, nRow - nIncrementIndex, 0);
+        if (eType != CELLTYPE_NONE)
+        {
+            OUString aStr = rDoc.GetString(mnCol, nRow - nIncrementIndex, 0);
+            if (aStr == maFindString)
+            {
+                rDoc.DeleteRow(0, 0, rDoc.MaxCol(), 0, nRow - nIncrementIndex, 1);
+                nIncrementIndex++;
+            }
+        }
+    }
+}
+
+TransformationType DeleteRowTransformation::getTransformationType() const
+{
+    return TransformationType::DELETEROW_TRANSFORMATION;
+}
+
+SCCOL DeleteRowTransformation::getColumn() const
+{
+    return mnCol;
+}
+
+const OUString& DeleteRowTransformation::getFindString() const
+{
+    return maFindString;
+}
+
+SwapRowsTransformation::SwapRowsTransformation(SCROW mRow, SCROW nRow)
+    : mxRow(mRow)
+    , nxRow(nRow)
+{
+}
+
+void SwapRowsTransformation::Transform(ScDocument& rDoc) const
+{
+    if (mxRow == -1 || nxRow == -1)
+        return;
+
+    for (SCCOL nCol = 0; nCol <= rDoc.MaxCol(); ++nCol)
+    {
+        CellType aType = rDoc.GetCellType(nCol, mxRow, 0);
+        if (aType == CELLTYPE_STRING)
+        {
+            OUString aStr = rDoc.GetString(nCol, mxRow, 0);
+            OUString bStr = rDoc.GetString(nCol, nxRow, 0);
+            rDoc.SetString(nCol, mxRow, 0, bStr);
+            rDoc.SetString(nCol, nxRow, 0, aStr);
+        }
+        else if (aType == CELLTYPE_VALUE)
+        {
+            double aVal = rDoc.GetValue(nCol, mxRow, 0);
+            double bVal = rDoc.GetValue(nCol, nxRow, 0);
+            rDoc.SetValue(nCol, mxRow, 0, bVal);
+            rDoc.SetValue(nCol, nxRow, 0, aVal);
+        }
+    }
+}
+
+TransformationType SwapRowsTransformation::getTransformationType() const
+{
+    return TransformationType::SWAPROWS_TRANSFORMATION;
+}
+
+SCROW SwapRowsTransformation::getFirstRow() const
+{
+    return mxRow;
+}
+
+SCROW SwapRowsTransformation::getSecondRow() const
+{
+    return nxRow;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/htmldataprovider.cxx b/sc/source/ui/dataprovider/htmldataprovider.cxx
new file mode 100644
index 000000000..8b241ddfe
--- /dev/null
+++ b/sc/source/ui/dataprovider/htmldataprovider.cxx
@@ -0,0 +1,280 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include "htmldataprovider.hxx"
+#include <datamapper.hxx>
+#include <datatransformation.hxx>
+#include <salhelper/thread.hxx>
+#include <vcl/svapp.hxx>
+#include <tools/stream.hxx>
+
+#include <libxml/HTMLparser.h>
+
+#include <libxml/xpath.h>
+
+#include <comphelper/string.hxx>
+#include <utility>
+
+namespace sc {
+
+class HTMLFetchThread : public salhelper::Thread
+{
+    ScDocument& mrDocument;
+    OUString maURL;
+    OUString maID;
+    const std::vector<std::shared_ptr<sc::DataTransformation>> maDataTransformations;
+    std::function<void()> maImportFinishedHdl;
+
+    void handleTable(xmlNodePtr pTable);
+    void handleRow(xmlNodePtr pRow, SCROW nRow);
+    void skipHeadBody(xmlNodePtr pSkip, SCROW& rRow);
+    void handleCell(xmlNodePtr pCell, SCROW nRow, SCCOL nCol);
+
+public:
+    HTMLFetchThread(ScDocument& rDoc, const OUString&, const OUString& rID, std::function<void()> aImportFinishedHdl,
+            std::vector<std::shared_ptr<sc::DataTransformation>>&& rTransformations);
+
+    virtual void execute() override;
+};
+
+HTMLFetchThread::HTMLFetchThread(
+    ScDocument& rDoc, const OUString& rURL, const OUString& rID,
+    std::function<void()> aImportFinishedHdl,
+    std::vector<std::shared_ptr<sc::DataTransformation>>&& rTransformations)
+    : salhelper::Thread("HTML Fetch Thread")
+    , mrDocument(rDoc)
+    , maURL(rURL)
+    , maID(rID)
+    , maDataTransformations(std::move(rTransformations))
+    , maImportFinishedHdl(std::move(aImportFinishedHdl))
+{
+}
+
+namespace {
+
+OString toString(const xmlChar* pStr)
+{
+    return OString(reinterpret_cast<const char*>(pStr), xmlStrlen(pStr));
+}
+
+OUString trim_string(const OUString& aStr)
+{
+    OUString aOldString;
+    OUString aString = aStr;
+    do
+    {
+        aOldString = aString;
+        aString = comphelper::string::strip(aString, ' ');
+        aString = comphelper::string::strip(aString, '\n');
+        aString = comphelper::string::strip(aString, '\r');
+        aString = comphelper::string::strip(aString, '\t');
+    }
+    while (aOldString != aString);
+
+    return aString;
+}
+
+OUString get_node_str(xmlNodePtr pNode)
+{
+    OUStringBuffer aStr;
+    for (xmlNodePtr cur_node = pNode->children; cur_node; cur_node = cur_node->next)
+    {
+        if (cur_node->type == XML_TEXT_NODE)
+        {
+            OUString aString = OStringToOUString(toString(cur_node->content), RTL_TEXTENCODING_UTF8);
+            aStr.append(trim_string(aString));
+        }
+        else if (cur_node->type == XML_ELEMENT_NODE)
+        {
+            aStr.append(get_node_str(cur_node));
+        }
+    }
+
+    return aStr.makeStringAndClear();
+}
+
+}
+
+void HTMLFetchThread::handleCell(xmlNodePtr pCellNode, SCROW nRow, SCCOL nCol)
+{
+    OUStringBuffer aStr;
+    for (xmlNodePtr cur_node = pCellNode->children; cur_node; cur_node = cur_node->next)
+    {
+        if (cur_node->type == XML_TEXT_NODE)
+        {
+            OUString aString = OStringToOUString(toString(cur_node->content), RTL_TEXTENCODING_UTF8);
+            aStr.append(trim_string(aString));
+        }
+        else if (cur_node->type == XML_ELEMENT_NODE)
+        {
+            aStr.append(get_node_str(cur_node));
+        }
+    }
+
+    if (!aStr.isEmpty())
+    {
+        OUString aCellStr = aStr.makeStringAndClear();
+        mrDocument.SetString(nCol, nRow, 0, aCellStr);
+    }
+}
+
+void HTMLFetchThread::handleRow(xmlNodePtr pRowNode, SCROW nRow)
+{
+    sal_Int32 nCol = 0;
+    for (xmlNodePtr cur_node = pRowNode->children; cur_node; cur_node = cur_node->next)
+    {
+        if (cur_node->type == XML_ELEMENT_NODE)
+        {
+            OString aNodeName = toString(cur_node->name);
+            if (aNodeName == "td" || aNodeName == "th")
+            {
+                handleCell(cur_node, nRow, nCol);
+                ++nCol;
+            }
+        }
+    }
+}
+
+void HTMLFetchThread::skipHeadBody(xmlNodePtr pSkipElement, SCROW& rRow)
+{
+    for (xmlNodePtr cur_node = pSkipElement->children; cur_node; cur_node = cur_node->next)
+    {
+        if (cur_node->type == XML_ELEMENT_NODE)
+        {
+            OString aNodeName = toString(cur_node->name);
+            if (aNodeName == "tr")
+            {
+                handleRow(cur_node, rRow);
+                ++rRow;
+            }
+
+        }
+    }
+}
+
+void HTMLFetchThread::handleTable(xmlNodePtr pTable)
+{
+    sal_Int32 nRow = 0;
+    for (xmlNodePtr cur_node = pTable->children; cur_node; cur_node = cur_node->next)
+    {
+        if (cur_node->type == XML_ELEMENT_NODE)
+        {
+            OString aNodeName = toString(cur_node->name);
+            if (aNodeName == "tr")
+            {
+                handleRow(cur_node, nRow);
+                ++nRow;
+            }
+            else if (aNodeName == "thead" || aNodeName == "tbody")
+            {
+                skipHeadBody(cur_node, nRow);
+            }
+        }
+    }
+}
+
+void HTMLFetchThread::execute()
+{
+    OStringBuffer aBuffer(64000);
+    DataProvider::FetchStreamFromURL(maURL, aBuffer);
+
+    if (aBuffer.isEmpty())
+        return;
+
+    htmlDocPtr pHtmlPtr = htmlParseDoc(reinterpret_cast<xmlChar*>(const_cast<char*>(aBuffer.getStr())), nullptr);
+
+    OString aID = OUStringToOString(maID, RTL_TEXTENCODING_UTF8);
+    xmlXPathContextPtr pXmlXpathCtx = xmlXPathNewContext(pHtmlPtr);
+    xmlXPathObjectPtr pXmlXpathObj = xmlXPathEvalExpression(BAD_CAST(aID.getStr()), pXmlXpathCtx);
+
+    if (!pXmlXpathObj)
+    {
+        xmlXPathFreeContext(pXmlXpathCtx);
+        return;
+    }
+    xmlNodeSetPtr pXmlNodes = pXmlXpathObj->nodesetval;
+
+    if (!pXmlNodes)
+    {
+        xmlXPathFreeNodeSetList(pXmlXpathObj);
+        xmlXPathFreeContext(pXmlXpathCtx);
+        return;
+    }
+
+    if (pXmlNodes->nodeNr == 0)
+    {
+        xmlXPathFreeNodeSet(pXmlNodes);
+        xmlXPathFreeNodeSetList(pXmlXpathObj);
+        xmlXPathFreeContext(pXmlXpathCtx);
+        return;
+    }
+
+    xmlNodePtr pNode = pXmlNodes->nodeTab[0];
+    handleTable(pNode);
+
+    xmlXPathFreeNodeSet(pXmlNodes);
+    xmlXPathFreeNodeSetList(pXmlXpathObj);
+    xmlXPathFreeContext(pXmlXpathCtx);
+
+    for (auto& itr : maDataTransformations)
+    {
+        itr->Transform(mrDocument);
+    }
+
+    SolarMutexGuard aGuard;
+    maImportFinishedHdl();
+}
+
+HTMLDataProvider::HTMLDataProvider(ScDocument* pDoc, sc::ExternalDataSource& rDataSource):
+    DataProvider(rDataSource),
+    mpDocument(pDoc)
+{
+}
+
+HTMLDataProvider::~HTMLDataProvider()
+{
+    if (mxHTMLFetchThread.is())
+    {
+        SolarMutexReleaser aReleaser;
+        mxHTMLFetchThread->join();
+    }
+}
+
+void HTMLDataProvider::Import()
+{
+    // already importing data
+    if (mpDoc)
+        return;
+
+    mpDoc.reset(new ScDocument(SCDOCMODE_CLIP));
+    mpDoc->ResetClip(mpDocument, SCTAB(0));
+    mxHTMLFetchThread = new HTMLFetchThread(*mpDoc, mrDataSource.getURL(), mrDataSource.getID(),
+            std::bind(&HTMLDataProvider::ImportFinished, this), std::vector(mrDataSource.getDataTransformation()));
+    mxHTMLFetchThread->launch();
+
+    if (mbDeterministic)
+    {
+        SolarMutexReleaser aReleaser;
+        mxHTMLFetchThread->join();
+    }
+}
+
+void HTMLDataProvider::ImportFinished()
+{
+    mrDataSource.getDBManager()->WriteToDoc(*mpDoc);
+}
+
+const OUString& HTMLDataProvider::GetURL() const
+{
+    return mrDataSource.getURL();
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/htmldataprovider.hxx b/sc/source/ui/dataprovider/htmldataprovider.hxx
new file mode 100644
index 000000000..f978ebdd1
--- /dev/null
+++ b/sc/source/ui/dataprovider/htmldataprovider.hxx
@@ -0,0 +1,38 @@
+/* -*- 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/.
+ */
+
+#pragma once
+
+#include <dataprovider.hxx>
+
+namespace sc
+{
+class HTMLFetchThread;
+
+class HTMLDataProvider : public DataProvider
+{
+private:
+    ScDocument* mpDocument;
+    rtl::Reference<HTMLFetchThread> mxHTMLFetchThread;
+
+    ScDocumentUniquePtr mpDoc;
+
+public:
+    HTMLDataProvider(ScDocument* pDoc, sc::ExternalDataSource& rDataSource);
+    virtual ~HTMLDataProvider() override;
+
+    virtual void Import() override;
+
+    virtual const OUString& GetURL() const override;
+
+    void ImportFinished();
+};
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/sqldataprovider.cxx b/sc/source/ui/dataprovider/sqldataprovider.cxx
new file mode 100644
index 000000000..a7d27dfa9
--- /dev/null
+++ b/sc/source/ui/dataprovider/sqldataprovider.cxx
@@ -0,0 +1,169 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include "sqldataprovider.hxx"
+#include <datatransformation.hxx>
+#include <salhelper/thread.hxx>
+#include <com/sun/star/sdb/DatabaseContext.hpp>
+#include <com/sun/star/sdb/XCompletedConnection.hpp>
+#include <com/sun/star/task/InteractionHandler.hpp>
+#include <com/sun/star/sdbc/XRow.hpp>
+#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
+#include <com/sun/star/sdbc/XResultSetMetaData.hpp>
+#include <dbdocutl.hxx>
+#include <datamapper.hxx>
+#include <vcl/svapp.hxx>
+#include <comphelper/processfactory.hxx>
+#include <tools/diagnose_ex.h>
+
+using namespace css;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::uno;
+
+namespace sc
+{
+class SQLFetchThread : public salhelper::Thread
+{
+    ScDocument& mrDocument;
+    OUString maID;
+    const std::vector<std::shared_ptr<sc::DataTransformation>> maDataTransformations;
+    std::function<void()> maImportFinishedHdl;
+
+public:
+    SQLFetchThread(ScDocument& rDoc, const OUString& rID, std::function<void()> aImportFinishedHdl,
+                   std::vector<std::shared_ptr<sc::DataTransformation>>&& rTransformations);
+
+    virtual void execute() override;
+};
+
+SQLFetchThread::SQLFetchThread(
+    ScDocument& rDoc, const OUString& rID, std::function<void()> aImportFinishedHdl,
+    std::vector<std::shared_ptr<sc::DataTransformation>>&& rTransformations)
+    : salhelper::Thread("SQL Fetch Thread")
+    , mrDocument(rDoc)
+    , maID(rID)
+    , maDataTransformations(std::move(rTransformations))
+    , maImportFinishedHdl(aImportFinishedHdl)
+{
+}
+
+void SQLFetchThread::execute()
+{
+    sal_Int32 nIndex = maID.indexOf("@");
+    if (nIndex == -1)
+        return;
+
+    OUString aTable = maID.copy(0, nIndex);
+    OUString aDatabase = maID.copy(nIndex + 1);
+
+    try
+    {
+        uno::Reference<sdb::XDatabaseContext> xContext
+            = sdb::DatabaseContext::create(comphelper::getProcessComponentContext());
+        uno::Any aSourceAny = xContext->getByName(aDatabase);
+
+        uno::Reference<sdb::XCompletedConnection> xSource(aSourceAny, uno::UNO_QUERY);
+        if (!xSource.is())
+            return;
+
+        uno::Reference<task::XInteractionHandler> xHandler(
+            task::InteractionHandler::createWithParent(comphelper::getProcessComponentContext(),
+                                                       nullptr),
+            uno::UNO_QUERY_THROW);
+
+        uno::Reference<sdbc::XConnection> xConnection = xSource->connectWithCompletion(xHandler);
+
+        uno::Reference<sdbc::XStatement> xStatement = xConnection->createStatement();
+
+        uno::Reference<sdbc::XResultSet> xResult
+            = xStatement->executeQuery("SELECT * FROM " + aTable);
+
+        if (xResult.is())
+        {
+            Reference<sdbc::XResultSetMetaDataSupplier> xMetaDataSupplier(xResult, UNO_QUERY);
+
+            Reference<sdbc::XResultSetMetaData> xMetaData = xMetaDataSupplier->getMetaData();
+
+            Reference<XRow> xRow(xResult, UNO_QUERY);
+
+            SCCOL nColCount = static_cast<SCCOL>(xMetaData->getColumnCount());
+
+            while (xResult->next())
+            {
+                SCROW nRow = static_cast<SCROW>(xResult->getRow());
+
+                for (SCCOL nCol = 0; nCol < nColCount; nCol++)
+                {
+                    ScDatabaseDocUtil::PutData(mrDocument, nCol, nRow - 1, 0, xRow, nCol + 1,
+                                               xMetaData->getColumnType(nCol + 1), false);
+                }
+            }
+        }
+    }
+    catch (uno::Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("sc", "exception in database");
+    }
+
+    for (auto& itr : maDataTransformations)
+    {
+        itr->Transform(mrDocument);
+    }
+
+    SolarMutexGuard aGuard;
+    maImportFinishedHdl();
+}
+
+SQLDataProvider::SQLDataProvider(ScDocument* pDoc, sc::ExternalDataSource& rDataSource)
+    : DataProvider(rDataSource)
+    , mpDocument(pDoc)
+{
+}
+
+SQLDataProvider::~SQLDataProvider()
+{
+    if (mxSQLFetchThread.is())
+    {
+        SolarMutexReleaser aReleaser;
+        mxSQLFetchThread->join();
+    }
+}
+
+void SQLDataProvider::Import()
+{
+    // already importing data
+    if (mpDoc)
+        return;
+
+    mpDoc.reset(new ScDocument(SCDOCMODE_CLIP));
+    mpDoc->ResetClip(mpDocument, SCTAB(0));
+    mxSQLFetchThread = new SQLFetchThread(*mpDoc, mrDataSource.getID(),
+                                          std::bind(&SQLDataProvider::ImportFinished, this),
+                                          std::vector(mrDataSource.getDataTransformation()));
+    mxSQLFetchThread->launch();
+
+    if (mbDeterministic)
+    {
+        SolarMutexReleaser aReleaser;
+        mxSQLFetchThread->join();
+    }
+}
+
+void SQLDataProvider::ImportFinished()
+{
+    mrDataSource.getDBManager()->WriteToDoc(*mpDoc);
+    mxSQLFetchThread.clear();
+    mpDoc.reset();
+}
+
+const OUString& SQLDataProvider::GetURL() const { return mrDataSource.getURL(); }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/sqldataprovider.hxx b/sc/source/ui/dataprovider/sqldataprovider.hxx
new file mode 100644
index 000000000..fbbca7601
--- /dev/null
+++ b/sc/source/ui/dataprovider/sqldataprovider.hxx
@@ -0,0 +1,38 @@
+/* -*- 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/.
+ */
+
+#pragma once
+
+#include <dataprovider.hxx>
+
+namespace sc
+{
+class SQLFetchThread;
+
+class SQLDataProvider : public DataProvider
+{
+private:
+    ScDocument* mpDocument;
+    rtl::Reference<SQLFetchThread> mxSQLFetchThread;
+
+    ScDocumentUniquePtr mpDoc;
+
+public:
+    SQLDataProvider(ScDocument* pDoc, sc::ExternalDataSource& rDataSource);
+    virtual ~SQLDataProvider() override;
+
+    virtual void Import() override;
+
+    virtual const OUString& GetURL() const override;
+
+    void ImportFinished();
+};
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/xmldataprovider.cxx b/sc/source/ui/dataprovider/xmldataprovider.cxx
new file mode 100644
index 000000000..4ffa45bd1
--- /dev/null
+++ b/sc/source/ui/dataprovider/xmldataprovider.cxx
@@ -0,0 +1,126 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include "xmldataprovider.hxx"
+#include <datatransformation.hxx>
+#include <salhelper/thread.hxx>
+#include <filter.hxx>
+#include <document.hxx>
+#include <datamapper.hxx>
+#include <vcl/svapp.hxx>
+#include <orcusfilters.hxx>
+#include <utility>
+
+using namespace com::sun::star;
+
+namespace sc
+{
+class XMLFetchThread : public salhelper::Thread
+{
+    ScDocument& mrDocument;
+    OUString maURL;
+    OUString maID;
+    ScOrcusImportXMLParam maParam;
+    std::unique_ptr<ScOrcusXMLContext> mpXMLContext;
+    const std::vector<std::shared_ptr<sc::DataTransformation>> maDataTransformations;
+    std::function<void()> maImportFinishedHdl;
+
+public:
+    XMLFetchThread(ScDocument& rDoc, const OUString&, const ScOrcusImportXMLParam& rParam,
+                   const OUString& rID, std::function<void()> aImportFinishedHdl,
+                   std::vector<std::shared_ptr<sc::DataTransformation>>&& rTransformations);
+    virtual void execute() override;
+};
+
+XMLFetchThread::XMLFetchThread(
+    ScDocument& rDoc, const OUString& rURL, const ScOrcusImportXMLParam& rParam,
+    const OUString& rID, std::function<void()> aImportFinishedHdl,
+    std::vector<std::shared_ptr<sc::DataTransformation>>&& rTransformations)
+    : salhelper::Thread("XML Fetch Thread")
+    , mrDocument(rDoc)
+    , maURL(rURL)
+    , maID(rID)
+    , maParam(rParam)
+    , maDataTransformations(std::move(rTransformations))
+    , maImportFinishedHdl(std::move(aImportFinishedHdl))
+{
+}
+
+void XMLFetchThread::execute()
+{
+    ScOrcusFilters* pOrcus = ScFormatFilter::Get().GetOrcusFilters();
+    if (!pOrcus)
+        return;
+
+    mpXMLContext = pOrcus->createXMLContext(mrDocument, maURL);
+    if (!mpXMLContext)
+        return;
+
+    if (!maID.isEmpty())
+    {
+        ScOrcusImportXMLParam::RangeLink aRangeLink;
+        aRangeLink.maPos = ScAddress(0, 0, 0);
+        aRangeLink.maFieldPaths.push_back(OUStringToOString(maID, RTL_TEXTENCODING_UTF8));
+        maParam.maRangeLinks.clear();
+        maParam.maRangeLinks.push_back(aRangeLink);
+    }
+    // Do the import.
+    mpXMLContext->importXML(maParam);
+
+    for (auto& itr : maDataTransformations)
+    {
+        itr->Transform(mrDocument);
+    }
+
+    SolarMutexGuard aGuard;
+    maImportFinishedHdl();
+}
+
+XMLDataProvider::XMLDataProvider(ScDocument* pDoc, sc::ExternalDataSource& rDataSource)
+    : DataProvider(rDataSource)
+    , mpDocument(pDoc)
+{
+}
+
+XMLDataProvider::~XMLDataProvider()
+{
+    if (mxXMLFetchThread.is())
+    {
+        SolarMutexReleaser aReleaser;
+        mxXMLFetchThread->join();
+    }
+}
+
+void XMLDataProvider::Import()
+{
+    // already importing data
+    if (mpDoc)
+        return;
+
+    mpDoc.reset(new ScDocument(SCDOCMODE_CLIP));
+    mpDoc->ResetClip(mpDocument, SCTAB(0));
+    mxXMLFetchThread = new XMLFetchThread(*mpDoc, mrDataSource.getURL(),
+                                          mrDataSource.getXMLImportParam(), mrDataSource.getID(),
+                                          std::bind(&XMLDataProvider::ImportFinished, this),
+                                          std::vector(mrDataSource.getDataTransformation()));
+    mxXMLFetchThread->launch();
+
+    if (mbDeterministic)
+    {
+        SolarMutexReleaser aReleaser;
+        mxXMLFetchThread->join();
+    }
+}
+
+void XMLDataProvider::ImportFinished() { mrDataSource.getDBManager()->WriteToDoc(*mpDoc); }
+
+const OUString& XMLDataProvider::GetURL() const { return mrDataSource.getURL(); }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/ui/dataprovider/xmldataprovider.hxx b/sc/source/ui/dataprovider/xmldataprovider.hxx
new file mode 100644
index 000000000..7be3f95c3
--- /dev/null
+++ b/sc/source/ui/dataprovider/xmldataprovider.hxx
@@ -0,0 +1,37 @@
+/* -*- 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/.
+ */
+
+#pragma once
+
+#include <dataprovider.hxx>
+
+namespace sc
+{
+class XMLFetchThread;
+
+class XMLDataProvider : public DataProvider
+{
+private:
+    ScDocument* mpDocument;
+    rtl::Reference<XMLFetchThread> mxXMLFetchThread;
+    ScDocumentUniquePtr mpDoc;
+
+public:
+    XMLDataProvider(ScDocument* pDoc, sc::ExternalDataSource& rDataSource);
+    virtual ~XMLDataProvider() override;
+
+    virtual void Import() override;
+
+    virtual const OUString& GetURL() const override;
+
+    void ImportFinished();
+};
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */