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

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

16 files changed, 6040 insertions, 0 deletions

diff --git a/connectivity/source/drivers/dbase/DCatalog.cxx b/connectivity/source/drivers/dbase/DCatalog.cxx
new file mode 100644
index 0000000000..a8aaf89c52
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DCatalog.cxx
@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DCatalog.hxx>
+#include <dbase/DConnection.hxx>
+#include <dbase/DTables.hxx>
+#include <com/sun/star/sdbc/XRow.hpp>
+#include <com/sun/star/sdbc/XResultSet.hpp>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::container;
+
+using namespace connectivity::dbase;
+
+ODbaseCatalog::ODbaseCatalog(ODbaseConnection* _pCon)
+    : file::OFileCatalog(_pCon)
+{
+}
+
+void ODbaseCatalog::refreshTables()
+{
+    ::std::vector<OUString> aVector;
+    Sequence<OUString> aTypes;
+    Reference<XResultSet> xResult = m_xMetaData->getTables(Any(), "%", "%", aTypes);
+
+    if (xResult.is())
+    {
+        Reference<XRow> xRow(xResult, UNO_QUERY);
+        while (xResult->next())
+            aVector.push_back(xRow->getString(3));
+    }
+    if (m_pTables)
+        m_pTables->reFill(aVector);
+    else
+        m_pTables.reset(new ODbaseTables(m_xMetaData, *this, m_aMutex, aVector));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DColumns.cxx b/connectivity/source/drivers/dbase/DColumns.cxx
new file mode 100644
index 0000000000..b997ec8d90
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DColumns.cxx
@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DColumns.hxx>
+#include <dbase/DTable.hxx>
+#include <connectivity/sdbcx/VColumn.hxx>
+
+using namespace connectivity::dbase;
+using namespace connectivity;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::container;
+
+sdbcx::ObjectType ODbaseColumns::createObject(const OUString& _rName)
+{
+    ODbaseTable* pTable = static_cast<ODbaseTable*>(m_pTable);
+
+    const ::rtl::Reference<OSQLColumns>& aCols = pTable->getTableColumns();
+    OSQLColumns::const_iterator aIter = find(aCols->begin(),aCols->end(),_rName,::comphelper::UStringMixEqual(isCaseSensitive()));
+
+    sdbcx::ObjectType xRet;
+    if(aIter != aCols->end())
+        xRet = sdbcx::ObjectType(*aIter,UNO_QUERY);
+    return xRet;
+}
+
+
+void ODbaseColumns::impl_refresh()
+{
+    m_pTable->refreshColumns();
+}
+
+Reference< XPropertySet > ODbaseColumns::createDescriptor()
+{
+    return new sdbcx::OColumn(isCaseSensitive());
+}
+
+
+// XAppend
+sdbcx::ObjectType ODbaseColumns::appendObject( const OUString& _rForName, const Reference< XPropertySet >& descriptor )
+{
+    if ( m_pTable->isNew() )
+        return cloneDescriptor( descriptor );
+
+    m_pTable->addColumn( descriptor );
+    return createObject( _rForName );
+}
+
+
+// XDrop
+void ODbaseColumns::dropObject(sal_Int32 _nPos, const OUString& /*_sElementName*/)
+{
+    if(!m_pTable->isNew())
+        m_pTable->dropColumn(_nPos);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DConnection.cxx b/connectivity/source/drivers/dbase/DConnection.cxx
new file mode 100644
index 0000000000..c9c7a93fa9
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DConnection.cxx
@@ -0,0 +1,112 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <dbase/DConnection.hxx>
+#include <dbase/DDatabaseMetaData.hxx>
+#include <dbase/DCatalog.hxx>
+#include <dbase/DDriver.hxx>
+#include <dbase/DPreparedStatement.hxx>
+#include <dbase/DStatement.hxx>
+#include <connectivity/dbexception.hxx>
+
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+
+typedef connectivity::file::OConnection  OConnection_BASE;
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::lang;
+
+ODbaseConnection::ODbaseConnection(ODriver* _pDriver) : OConnection(_pDriver)
+{
+    m_aFilenameExtension = "dbf";
+}
+
+ODbaseConnection::~ODbaseConnection()
+{
+}
+
+// XServiceInfo
+
+IMPLEMENT_SERVICE_INFO(ODbaseConnection, "com.sun.star.sdbc.drivers.dbase.Connection", "com.sun.star.sdbc.Connection")
+
+
+Reference< XDatabaseMetaData > SAL_CALL ODbaseConnection::getMetaData(  )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OConnection_BASE::rBHelper.bDisposed);
+
+
+    Reference< XDatabaseMetaData > xMetaData = m_xMetaData;
+    if(!xMetaData.is())
+    {
+        xMetaData = new ODbaseDatabaseMetaData(this);
+        m_xMetaData = xMetaData;
+    }
+
+    return xMetaData;
+}
+
+css::uno::Reference< XTablesSupplier > ODbaseConnection::createCatalog()
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    Reference< XTablesSupplier > xTab = m_xCatalog;
+    if(!xTab.is())
+    {
+        xTab = new ODbaseCatalog(this);
+        m_xCatalog = xTab;
+    }
+    return xTab;
+}
+
+Reference< XStatement > SAL_CALL ODbaseConnection::createStatement(  )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OConnection_BASE::rBHelper.bDisposed);
+
+
+    Reference< XStatement > xReturn = new ODbaseStatement(this);
+    m_aStatements.push_back(WeakReferenceHelper(xReturn));
+    return xReturn;
+}
+
+Reference< XPreparedStatement > SAL_CALL ODbaseConnection::prepareStatement( const OUString& sql )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OConnection_BASE::rBHelper.bDisposed);
+
+    rtl::Reference<ODbasePreparedStatement> pStmt = new ODbasePreparedStatement(this);
+    pStmt->construct(sql);
+    m_aStatements.push_back(WeakReferenceHelper(*pStmt));
+    return pStmt;
+}
+
+Reference< XPreparedStatement > SAL_CALL ODbaseConnection::prepareCall( const OUString& /*sql*/ )
+{
+    ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::prepareCall", *this );
+    return nullptr;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DDatabaseMetaData.cxx b/connectivity/source/drivers/dbase/DDatabaseMetaData.cxx
new file mode 100644
index 0000000000..b3791f7d85
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DDatabaseMetaData.cxx
@@ -0,0 +1,381 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DDatabaseMetaData.hxx>
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <com/sun/star/sdbc/ColumnSearch.hpp>
+#include <com/sun/star/sdbc/DataType.hpp>
+#include <com/sun/star/sdbc/ColumnValue.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
+#include <com/sun/star/sdbcx/XIndexesSupplier.hpp>
+#include <FDatabaseMetaDataResultSet.hxx>
+#include <dbase/DIndex.hxx>
+#include <connectivity/FValue.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <comphelper/types.hxx>
+#include <ucbhelper/content.hxx>
+
+using namespace ::comphelper;
+using namespace connectivity::dbase;
+using namespace connectivity;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::lang;
+
+ODbaseDatabaseMetaData::ODbaseDatabaseMetaData(::connectivity::file::OConnection* _pCon)    :ODatabaseMetaData(_pCon)
+{
+}
+
+ODbaseDatabaseMetaData::~ODbaseDatabaseMetaData()
+{
+}
+
+Reference< XResultSet > ODbaseDatabaseMetaData::impl_getTypeInfo_throw(  )
+{
+    rtl::Reference<::connectivity::ODatabaseMetaDataResultSet> pResult = new ::connectivity::ODatabaseMetaDataResultSet(::connectivity::ODatabaseMetaDataResultSet::eTypeInfo);
+
+    ODatabaseMetaDataResultSet::ORows aRows;
+    aRows.reserve(10);
+    ODatabaseMetaDataResultSet::ORow aRow
+    {
+        ODatabaseMetaDataResultSet::getEmptyValue(),
+        new ORowSetValueDecorator(OUString("VARCHAR")),
+        new ORowSetValueDecorator(DataType::VARCHAR),
+        new ORowSetValueDecorator(sal_Int32(254)),
+        ODatabaseMetaDataResultSet::getQuoteValue(),
+        ODatabaseMetaDataResultSet::getQuoteValue(),
+        new ORowSetValueDecorator(OUString("length")),
+        new ORowSetValueDecorator(sal_Int32(ColumnValue::NULLABLE)),
+        ODatabaseMetaDataResultSet::get1Value(),
+        new ORowSetValueDecorator(sal_Int32(ColumnSearch::FULL)),
+        ODatabaseMetaDataResultSet::get1Value(),
+        ODatabaseMetaDataResultSet::get0Value(),
+        ODatabaseMetaDataResultSet::get0Value(),
+        new ORowSetValueDecorator(OUString("C")),
+        ODatabaseMetaDataResultSet::get0Value(),
+        ODatabaseMetaDataResultSet::get0Value(),
+        ODatabaseMetaDataResultSet::getEmptyValue(),
+        ODatabaseMetaDataResultSet::getEmptyValue(),
+        new ORowSetValueDecorator(sal_Int32(10))
+    };
+
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("LONGVARCHAR"));
+    aRow[2] = new ORowSetValueDecorator(DataType::LONGVARCHAR);
+    aRow[3] = new ORowSetValueDecorator(sal_Int32(2147483647));
+    aRow[6] = new ORowSetValueDecorator();
+    aRow[13] = new ORowSetValueDecorator(OUString("M"));
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("DATE"));
+    aRow[2] = new ORowSetValueDecorator(DataType::DATE);
+    aRow[3] = new ORowSetValueDecorator(sal_Int32(10));
+    aRow[13] = new ORowSetValueDecorator(OUString("D"));
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("BOOLEAN"));
+    aRow[2] = new ORowSetValueDecorator(DataType::BIT);
+    aRow[3] = ODatabaseMetaDataResultSet::get1Value();
+    aRow[4] = ODatabaseMetaDataResultSet::getEmptyValue();
+    aRow[5] = ODatabaseMetaDataResultSet::getEmptyValue();
+    aRow[6] = new ORowSetValueDecorator(OUString());
+    aRow[9] = ODatabaseMetaDataResultSet::getBasicValue();
+    aRow[13] = new ORowSetValueDecorator(OUString("L"));
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("DOUBLE"));
+    aRow[2] = new ORowSetValueDecorator(DataType::DOUBLE);
+    aRow[3] = new ORowSetValueDecorator(sal_Int32(8));
+    aRow[13] = new ORowSetValueDecorator(OUString("B"));
+    aRows.push_back(aRow);
+
+    aRow[11] = new ORowSetValueDecorator(ORowSetValue(true));
+    aRow[13] = new ORowSetValueDecorator(OUString("Y"));
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("TIMESTAMP"));
+    aRow[2] = new ORowSetValueDecorator(DataType::TIMESTAMP);
+    aRow[11] = new ORowSetValueDecorator(ORowSetValue(false));
+    aRow[13] = new ORowSetValueDecorator(OUString("T"));
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("INTEGER"));
+    aRow[2] = new ORowSetValueDecorator(DataType::INTEGER);
+    aRow[3] = new ORowSetValueDecorator(sal_Int32(10));
+    aRow[13] = new ORowSetValueDecorator(OUString("I"));
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("DECIMAL"));
+    aRow[2] = new ORowSetValueDecorator(DataType::DECIMAL);
+    aRow[3] = new ORowSetValueDecorator(sal_Int32(20));
+    aRow[6] = new ORowSetValueDecorator(OUString("length,scale"));
+    aRow[13] = new ORowSetValueDecorator(OUString("F"));
+    aRows.push_back(aRow);
+
+    aRow[1] = new ORowSetValueDecorator(OUString("NUMERIC"));
+    aRow[2] = new ORowSetValueDecorator(DataType::DECIMAL);
+    aRow[3] = new ORowSetValueDecorator(sal_Int32(16));
+    aRow[13] = new ORowSetValueDecorator(OUString("N"));
+    aRow[15] = new ORowSetValueDecorator(sal_Int32(16));
+    aRows.push_back(aRow);
+
+    pResult->setRows(std::move(aRows));
+    return pResult;
+}
+
+Reference< XResultSet > SAL_CALL ODbaseDatabaseMetaData::getColumns(
+    const Any& /*catalog*/, const OUString& /*schemaPattern*/, const OUString& tableNamePattern,
+        const OUString& columnNamePattern )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    Reference< XTablesSupplier > xTables = m_pConnection->createCatalog();
+    if(!xTables.is())
+        throw SQLException();
+
+    Reference< XNameAccess> xNames = xTables->getTables();
+    if(!xNames.is())
+        throw SQLException();
+
+    ODatabaseMetaDataResultSet::ORows aRows;
+    ODatabaseMetaDataResultSet::ORow aRow(19);
+
+    try
+    {
+        aRow[10] = new ORowSetValueDecorator(sal_Int32(10));
+        Sequence< OUString> aTabNames(xNames->getElementNames());
+        const OUString* pTabBegin    = aTabNames.getConstArray();
+        const OUString* pTabEnd      = pTabBegin + aTabNames.getLength();
+        for(;pTabBegin != pTabEnd;++pTabBegin)
+        {
+            if(match(tableNamePattern,*pTabBegin,'\0'))
+            {
+                Reference< XColumnsSupplier> xTable(
+                    xNames->getByName(*pTabBegin), css::uno::UNO_QUERY);
+                OSL_ENSURE(xTable.is(),"Table not found! Normally an exception had to be thrown here!");
+                aRow[3] = new ORowSetValueDecorator(*pTabBegin);
+
+                Reference< XNameAccess> xColumns = xTable->getColumns();
+                if(!xColumns.is())
+                    throw SQLException();
+
+                Sequence< OUString> aColNames(xColumns->getElementNames());
+
+                const OUString* pBegin = aColNames.getConstArray();
+                const OUString* pEnd = pBegin + aColNames.getLength();
+                Reference< XPropertySet> xColumn;
+                for(sal_Int32 i=1;pBegin != pEnd;++pBegin,++i)
+                {
+                    if(match(columnNamePattern,*pBegin,'\0'))
+                    {
+                        aRow[4] = new ORowSetValueDecorator(*pBegin);
+
+                        xColumn.set(
+                            xColumns->getByName(*pBegin), css::uno::UNO_QUERY);
+                        OSL_ENSURE(xColumn.is(),"Columns contains a column who isn't a fastpropertyset!");
+                        aRow[5] = new ORowSetValueDecorator(getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))));
+                        aRow[6] = new ORowSetValueDecorator(getString(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME))));
+                        aRow[7] = new ORowSetValueDecorator(getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))));
+                        aRow[9] = new ORowSetValueDecorator(getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))));
+                        aRow[11] = new ORowSetValueDecorator(getINT32(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE))));
+                        aRow[13] = new ORowSetValueDecorator(getString(xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DEFAULTVALUE))));
+                        switch(aRow[5]->getValue().getInt32())
+                        {
+                        case DataType::CHAR:
+                        case DataType::VARCHAR:
+                            aRow[16] = new ORowSetValueDecorator(sal_Int32(254));
+                            break;
+                        case DataType::LONGVARCHAR:
+                            aRow[16] = new ORowSetValueDecorator(sal_Int32(65535));
+                            break;
+                        default:
+                            aRow[16] = new ORowSetValueDecorator(sal_Int32(0));
+                        }
+                        aRow[17] = new ORowSetValueDecorator(i);
+                        switch(aRow[11]->getValue().getInt32())
+                        {
+                        case ColumnValue::NO_NULLS:
+                            aRow[18] = new ORowSetValueDecorator(OUString("NO"));
+                            break;
+                        case ColumnValue::NULLABLE:
+                            aRow[18] = new ORowSetValueDecorator(OUString("YES"));
+                            break;
+                        default:
+                            aRow[18] = new ORowSetValueDecorator(OUString());
+                        }
+                        aRows.push_back(aRow);
+                    }
+                }
+            }
+        }
+    }
+    catch (const WrappedTargetException& e)
+    {
+        SQLException aSql;
+        if (e.TargetException >>= aSql)
+            throw aSql;
+        throw WrappedTargetRuntimeException(e.Message, e.Context, e.TargetException);
+    }
+    rtl::Reference<::connectivity::ODatabaseMetaDataResultSet> pResult = new ::connectivity::ODatabaseMetaDataResultSet(::connectivity::ODatabaseMetaDataResultSet::eColumns);
+    pResult->setRows(std::move(aRows));
+
+    return pResult;
+}
+
+Reference< XResultSet > SAL_CALL ODbaseDatabaseMetaData::getIndexInfo(
+    const Any& /*catalog*/, const OUString& /*schema*/, const OUString& table,
+        sal_Bool unique, sal_Bool /*approximate*/ )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    Reference< XTablesSupplier > xTables = m_pConnection->createCatalog();
+    if(!xTables.is())
+                throw SQLException();
+
+    Reference< XNameAccess> xNames = xTables->getTables();
+    if(!xNames.is())
+                throw SQLException();
+
+    ODatabaseMetaDataResultSet::ORows aRows;
+    ODatabaseMetaDataResultSet::ORow aRow(14);
+
+    aRow[5]     = new ORowSetValueDecorator(OUString());
+    aRow[10]    = new ORowSetValueDecorator(OUString("A"));
+
+    Reference< XIndexesSupplier> xTable(
+        xNames->getByName(table), css::uno::UNO_QUERY);
+    aRow[3] = new ORowSetValueDecorator(table);
+    aRow[7] = new ORowSetValueDecorator(sal_Int32(3));
+
+    Reference< XNameAccess> xIndexes = xTable->getIndexes();
+    if(!xIndexes.is())
+        throw SQLException();
+
+    Sequence< OUString> aIdxNames(xIndexes->getElementNames());
+
+    const OUString* pBegin = aIdxNames.getConstArray();
+    const OUString* pEnd = pBegin + aIdxNames.getLength();
+    Reference< XPropertySet> xIndex;
+    for(;pBegin != pEnd;++pBegin)
+    {
+        xIndex.set(xIndexes->getByName(*pBegin), css::uno::UNO_QUERY);
+        OSL_ENSURE(xIndex.is(),"Indexes contains a column who isn't a fastpropertyset!");
+
+        if(unique && !getBOOL(xIndex->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISUNIQUE))))
+            continue;
+        aRow[4] = new ORowSetValueDecorator(ORowSetValue(getBOOL(xIndex->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISUNIQUE)))));
+        aRow[6] = new ORowSetValueDecorator(*pBegin);
+
+        auto pIndex = dynamic_cast<ODbaseIndex*>(xIndex.get());
+        if(pIndex)
+        {
+            aRow[11] = new ORowSetValueDecorator(static_cast<sal_Int32>(pIndex->getHeader().db_maxkeys));
+            aRow[12] = new ORowSetValueDecorator(static_cast<sal_Int32>(pIndex->getHeader().db_pagecount));
+        }
+
+        Reference<XColumnsSupplier> xColumnsSup(xIndex,UNO_QUERY);
+        Reference< XNameAccess> xColumns = xColumnsSup->getColumns();
+        Sequence< OUString> aColNames(xColumns->getElementNames());
+
+        const OUString* pColBegin = aColNames.getConstArray();
+        const OUString* pColEnd = pColBegin + aColNames.getLength();
+        for(sal_Int32 j=1;pColBegin != pColEnd;++pColBegin,++j)
+        {
+            aRow[8] = new ORowSetValueDecorator(j);
+            aRow[9] = new ORowSetValueDecorator(*pColBegin);
+            aRows.push_back(aRow);
+        }
+    }
+
+    rtl::Reference<::connectivity::ODatabaseMetaDataResultSet> pResult = new ::connectivity::ODatabaseMetaDataResultSet(::connectivity::ODatabaseMetaDataResultSet::eIndexInfo);
+    pResult->setRows(std::move(aRows));
+    return pResult;
+}
+
+OUString SAL_CALL ODbaseDatabaseMetaData::getURL(  )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    return "sdbc:dbase:" + m_pConnection->getURL();
+}
+
+sal_Int32 SAL_CALL ODbaseDatabaseMetaData::getMaxBinaryLiteralLength(  )
+{
+    return SAL_MAX_INT32;
+}
+
+sal_Int32 SAL_CALL ODbaseDatabaseMetaData::getMaxCharLiteralLength(  )
+{
+    return 254;
+}
+
+sal_Int32 SAL_CALL ODbaseDatabaseMetaData::getMaxColumnNameLength(  )
+{
+    return 10;
+}
+
+sal_Int32 SAL_CALL ODbaseDatabaseMetaData::getMaxColumnsInIndex(  )
+{
+    return 1;
+}
+
+sal_Int32 SAL_CALL ODbaseDatabaseMetaData::getMaxColumnsInTable(  )
+{
+    return 128;
+}
+
+sal_Bool SAL_CALL ODbaseDatabaseMetaData::supportsAlterTableWithAddColumn(  )
+{
+    return true;
+}
+
+sal_Bool SAL_CALL ODbaseDatabaseMetaData::supportsAlterTableWithDropColumn(  )
+{
+    return false;
+}
+
+sal_Bool SAL_CALL ODbaseDatabaseMetaData::isReadOnly(  )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    bool bReadOnly = false;
+    ::ucbhelper::Content aFile(m_pConnection->getContent(),Reference< XCommandEnvironment >(), comphelper::getProcessComponentContext());
+    aFile.getPropertyValue("IsReadOnly") >>= bReadOnly;
+
+    return bReadOnly;
+}
+
+bool ODbaseDatabaseMetaData::impl_storesMixedCaseQuotedIdentifiers_throw(  )
+{
+    return true;
+}
+
+bool ODbaseDatabaseMetaData::impl_supportsMixedCaseQuotedIdentifiers_throw(  )
+{
+    return true;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DDriver.cxx b/connectivity/source/drivers/dbase/DDriver.cxx
new file mode 100644
index 0000000000..ff0ec256e1
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DDriver.cxx
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DDriver.hxx>
+#include <dbase/DConnection.hxx>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <connectivity/dbexception.hxx>
+#include <strings.hrc>
+
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::lang;
+
+
+// XServiceInfo
+
+OUString SAL_CALL ODriver::getImplementationName(  )
+{
+    return "com.sun.star.comp.sdbc.dbase.ODriver";
+}
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+connectivity_dbase_ODriver(
+    css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
+{
+    rtl::Reference<ODriver> ret;
+    try {
+        ret = new ODriver(context);
+    } catch (...) {
+    }
+    if (ret)
+        ret->acquire();
+    return getXWeak(ret.get());
+}
+
+
+Reference< XConnection > SAL_CALL ODriver::connect( const OUString& url, const Sequence< PropertyValue >& info )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    if (ODriver_BASE::rBHelper.bDisposed)
+        throw DisposedException();
+
+    if ( ! acceptsURL(url) )
+        return nullptr;
+
+    rtl::Reference<ODbaseConnection> pCon = new ODbaseConnection(this);
+    pCon->construct(url,info);
+    m_xConnections.push_back(WeakReferenceHelper(*pCon));
+
+    return pCon;
+}
+
+sal_Bool SAL_CALL ODriver::acceptsURL( const OUString& url )
+{
+    return url.startsWith("sdbc:dbase:");
+}
+
+Sequence< DriverPropertyInfo > SAL_CALL ODriver::getPropertyInfo( const OUString& url, const Sequence< PropertyValue >& /*info*/ )
+{
+    if ( acceptsURL(url) )
+    {
+        Sequence< OUString > aBoolean { "0", "1" };
+
+        return
+        {
+            {
+                "CharSet"
+                ,"CharSet of the database."
+                ,false
+                ,OUString()
+                ,Sequence< OUString >()
+            },
+            {
+                "ShowDeleted"
+                ,"Display inactive records."
+                ,false
+                ,"0"
+                ,aBoolean
+            },
+            {
+                "EnableSQL92Check"
+                ,"Use SQL92 naming constraints."
+                ,false
+                ,"0"
+                ,aBoolean
+            }
+        };
+    }
+
+    SharedResources aResources;
+    const OUString sMessage = aResources.getResourceString(STR_URI_SYNTAX_ERROR);
+    ::dbtools::throwGenericSQLException(sMessage ,*this);
+    return Sequence< DriverPropertyInfo >();
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DIndex.cxx b/connectivity/source/drivers/dbase/DIndex.cxx
new file mode 100644
index 0000000000..cc489ad77c
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DIndex.cxx
@@ -0,0 +1,591 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DIndex.hxx>
+#include <dbase/DIndexColumns.hxx>
+#include <dbase/DTable.hxx>
+#include <dbase/DIndexIter.hxx>
+#include <osl/file.hxx>
+#include <sal/log.hxx>
+#include <tools/config.hxx>
+#include <connectivity/CommonTools.hxx>
+#include <com/sun/star/sdbc/XResultSet.hpp>
+#include <com/sun/star/sdbc/XRow.hpp>
+#include <unotools/ucbhelper.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <comphelper/types.hxx>
+#include <connectivity/dbexception.hxx>
+#include <dbase/DResultSet.hxx>
+#include <strings.hrc>
+#include <unotools/sharedunocomponent.hxx>
+
+using namespace ::comphelper;
+
+using namespace connectivity;
+using namespace utl;
+using namespace ::cppu;
+using namespace connectivity::file;
+using namespace connectivity::sdbcx;
+using namespace connectivity::dbase;
+using namespace com::sun::star::sdbc;
+using namespace com::sun::star::sdbcx;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::lang;
+
+IMPLEMENT_SERVICE_INFO(ODbaseIndex,"com.sun.star.sdbcx.driver.dbase.Index","com.sun.star.sdbcx.Index");
+
+ODbaseIndex::ODbaseIndex(ODbaseTable* _pTable)
+    : OIndex(true/*_pTable->getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers()*/)
+    , m_nCurNode(NODE_NOTFOUND)
+    , m_nPageCount(0)
+    , m_nRootPage(0)
+    , m_pTable(_pTable)
+    , m_bUseCollector(false)
+{
+    construct();
+}
+
+ODbaseIndex::ODbaseIndex(   ODbaseTable* _pTable,
+                            const NDXHeader& _rHeader,
+                            const OUString& _rName)
+    : OIndex(_rName, OUString(), _rHeader.db_unique, false, false, true)
+    , m_aHeader(_rHeader)
+    , m_nCurNode(NODE_NOTFOUND)
+    , m_nPageCount(0)
+    , m_nRootPage(0)
+    , m_pTable(_pTable)
+    , m_bUseCollector(false)
+{
+    construct();
+}
+
+ODbaseIndex::~ODbaseIndex()
+{
+    closeImpl();
+}
+
+void ODbaseIndex::refreshColumns()
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    ::std::vector< OUString> aVector;
+    if(!isNew())
+    {
+        OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
+        OSL_ENSURE(m_aHeader.db_name[0] != '\0',"Invalid name for the column!");
+        aVector.push_back(OUString::createFromAscii(m_aHeader.db_name));
+    }
+
+    if(m_pColumns)
+        m_pColumns->reFill(aVector);
+    else
+        m_pColumns.reset(new ODbaseIndexColumns(this,m_aMutex,aVector));
+}
+
+ONDXPagePtr const & ODbaseIndex::getRoot()
+{
+    openIndexFile();
+    if (!m_aRoot.Is())
+    {
+        m_nRootPage = m_aHeader.db_rootpage;
+        m_nPageCount = m_aHeader.db_pagecount;
+        m_aRoot = CreatePage(m_nRootPage,nullptr,true);
+    }
+    return m_aRoot;
+}
+
+void ODbaseIndex::openIndexFile()
+{
+    if(m_pFileStream)
+        return;
+
+    OUString sFile = getCompletePath();
+    if(UCBContentHelper::Exists(sFile))
+    {
+        m_pFileStream = OFileTable::createStream_simpleError(sFile, StreamMode::READWRITE | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
+        if (!m_pFileStream)
+            m_pFileStream = OFileTable::createStream_simpleError(sFile, StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYNONE);
+        if(m_pFileStream)
+        {
+            m_pFileStream->SetEndian(SvStreamEndian::LITTLE);
+            m_pFileStream->SetBufferSize(DINDEX_PAGE_SIZE);
+            (*m_pFileStream) >> *this;
+        }
+    }
+    if(!m_pFileStream)
+    {
+        const OUString sError( m_pTable->getConnection()->getResources().getResourceStringWithSubstitution(
+            STR_COULD_NOT_LOAD_FILE,
+            "$filename$", sFile
+         ) );
+        ::dbtools::throwGenericSQLException( sError, *this );
+    }
+}
+
+std::unique_ptr<OIndexIterator> ODbaseIndex::createIterator()
+{
+    openIndexFile();
+    return std::make_unique<OIndexIterator>(this);
+}
+
+bool ODbaseIndex::ConvertToKey(ONDXKey* rKey, sal_uInt32 nRec, const ORowSetValue& rValue)
+{
+    OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
+    // Search a specific value in Index
+    // If the Index is unique, the key doesn't matter
+    try
+    {
+        if (m_aHeader.db_keytype == 0)
+        {
+            *rKey = ONDXKey(rValue.getString(), nRec );
+        }
+        else
+        {
+            if (rValue.isNull())
+                *rKey = ONDXKey(rValue.getDouble(), DataType::DOUBLE, nRec );
+            else
+                *rKey = ONDXKey(rValue.getDouble(), nRec );
+        }
+    }
+    catch (Exception&)
+    {
+        OSL_ASSERT(false);
+        return false;
+    }
+    return true;
+}
+
+
+bool ODbaseIndex::Find(sal_uInt32 nRec, const ORowSetValue& rValue)
+{
+    openIndexFile();
+    OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
+    // Search a specific value in Index
+    // If the Index is unique, the key doesn't matter
+    ONDXKey aKey;
+    return ConvertToKey(&aKey, nRec, rValue) && getRoot()->Find(aKey);
+}
+
+
+bool ODbaseIndex::Insert(sal_uInt32 nRec, const ORowSetValue& rValue)
+{
+    openIndexFile();
+    OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
+    ONDXKey aKey;
+
+    // Does the value already exist
+    // Use Find() always to determine the actual leaf
+    if (!ConvertToKey(&aKey, nRec, rValue) || (getRoot()->Find(aKey) && isUnique()))
+        return false;
+
+    ONDXNode aNewNode(aKey);
+
+    // insert in the current leaf
+    if (!m_aCurLeaf.Is())
+        return false;
+
+    bool bResult = m_aCurLeaf->Insert(aNewNode);
+    Release(bResult);
+
+    return bResult;
+}
+
+
+bool ODbaseIndex::Update(sal_uInt32 nRec, const ORowSetValue& rOldValue,
+                         const ORowSetValue& rNewValue)
+{
+    openIndexFile();
+    OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
+    ONDXKey aKey;
+    if (!ConvertToKey(&aKey, nRec, rNewValue) || (isUnique() && getRoot()->Find(aKey)))
+        return false;
+    else
+        return Delete(nRec, rOldValue) && Insert(nRec,rNewValue);
+}
+
+
+bool ODbaseIndex::Delete(sal_uInt32 nRec, const ORowSetValue& rValue)
+{
+    openIndexFile();
+    OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
+    // Does the value already exist
+    // Always use Find() to determine the actual leaf
+    ONDXKey aKey;
+    if (!ConvertToKey(&aKey, nRec, rValue) || !getRoot()->Find(aKey))
+        return false;
+
+    // insert in the current leaf
+    if (!m_aCurLeaf.Is())
+        return false;
+#if OSL_DEBUG_LEVEL > 1
+    m_aRoot->PrintPage();
+#endif
+
+    m_aCurLeaf->Delete(m_nCurNode);
+    return true;
+}
+
+void ODbaseIndex::Collect(ONDXPage* pPage)
+{
+    if (pPage)
+        m_aCollector.push_back(pPage);
+}
+
+void ODbaseIndex::Release(bool bSave)
+{
+    // Release the Index-resources
+    m_bUseCollector = false;
+
+    if (m_aCurLeaf.Is())
+    {
+        m_aCurLeaf->Release(bSave);
+        m_aCurLeaf.Clear();
+    }
+
+    // Release the root
+    if (m_aRoot.Is())
+    {
+        m_aRoot->Release(bSave);
+        m_aRoot.Clear();
+    }
+    // Release all references, before the FileStream will be closed
+    for (auto& i : m_aCollector)
+        i->QueryDelete();
+
+    m_aCollector.clear();
+
+    // Header modified?
+    if (bSave && (m_aHeader.db_rootpage != m_nRootPage ||
+        m_aHeader.db_pagecount != m_nPageCount))
+    {
+        m_aHeader.db_rootpage = m_nRootPage;
+        m_aHeader.db_pagecount = m_nPageCount;
+        WriteODbaseIndex( *m_pFileStream, *this );
+    }
+    m_nRootPage = m_nPageCount = 0;
+    m_nCurNode = NODE_NOTFOUND;
+
+    closeImpl();
+}
+
+void ODbaseIndex::closeImpl()
+{
+    m_pFileStream.reset();
+}
+
+ONDXPage* ODbaseIndex::CreatePage(sal_uInt32 nPagePos, ONDXPage* pParent, bool bLoad)
+{
+    OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
+
+    ONDXPage* pPage;
+    if ( !m_aCollector.empty() )
+    {
+        pPage = *(m_aCollector.rbegin());
+        m_aCollector.pop_back();
+        pPage->SetPagePos(nPagePos);
+        pPage->SetParent(pParent);
+    }
+    else
+        pPage = new ONDXPage(*this, nPagePos, pParent);
+
+    if (bLoad)
+        (*m_pFileStream) >> *pPage;
+
+    return pPage;
+}
+
+void connectivity::dbase::ReadHeader(
+        SvStream & rStream, ODbaseIndex::NDXHeader & rHeader)
+{
+#if !defined(NDEBUG)
+    sal_uInt64 const nOldPos(rStream.Tell());
+#endif
+    rStream.ReadUInt32(rHeader.db_rootpage);
+    rStream.ReadUInt32(rHeader.db_pagecount);
+    rStream.ReadBytes(&rHeader.db_free, 4);
+    rStream.ReadUInt16(rHeader.db_keylen);
+    rStream.ReadUInt16(rHeader.db_maxkeys);
+    rStream.ReadUInt16(rHeader.db_keytype);
+    rStream.ReadUInt16(rHeader.db_keyrec);
+    rStream.ReadBytes(&rHeader.db_free1, 3);
+    rStream.ReadUChar(rHeader.db_unique);
+    rStream.ReadBytes(&rHeader.db_name, 488);
+    assert(rStream.GetError() || rStream.Tell() == nOldPos + DINDEX_PAGE_SIZE);
+}
+
+SvStream& connectivity::dbase::operator >> (SvStream &rStream, ODbaseIndex& rIndex)
+{
+    rStream.Seek(0);
+    ReadHeader(rStream, rIndex.m_aHeader);
+
+    rIndex.m_nRootPage = rIndex.m_aHeader.db_rootpage;
+    rIndex.m_nPageCount = rIndex.m_aHeader.db_pagecount;
+    return rStream;
+}
+
+SvStream& connectivity::dbase::WriteODbaseIndex(SvStream &rStream, const ODbaseIndex& rIndex)
+{
+    rStream.Seek(0);
+    rStream.WriteUInt32(rIndex.m_aHeader.db_rootpage);
+    rStream.WriteUInt32(rIndex.m_aHeader.db_pagecount);
+    rStream.WriteBytes(&rIndex.m_aHeader.db_free, 4);
+    rStream.WriteUInt16(rIndex.m_aHeader.db_keylen);
+    rStream.WriteUInt16(rIndex.m_aHeader.db_maxkeys);
+    rStream.WriteUInt16(rIndex.m_aHeader.db_keytype);
+    rStream.WriteUInt16(rIndex.m_aHeader.db_keyrec);
+    rStream.WriteBytes(&rIndex.m_aHeader.db_free1, 3);
+    rStream.WriteUChar(rIndex.m_aHeader.db_unique);
+    rStream.WriteBytes(&rIndex.m_aHeader.db_name, 488);
+    assert(rStream.GetError() || rStream.Tell() == DINDEX_PAGE_SIZE);
+    SAL_WARN_IF(rStream.GetError(), "connectivity.dbase", "write error");
+    return rStream;
+}
+
+OUString ODbaseIndex::getCompletePath() const
+{
+    OUString sDir = m_pTable->getConnection()->getURL() +
+        OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DELIMITER) +
+        m_Name + ".ndx";
+    return sDir;
+}
+
+void ODbaseIndex::createINFEntry()
+{
+    // synchronize inf-file
+    const OUString sEntry(m_Name + ".ndx");
+
+    OUString sCfgFile(m_pTable->getConnection()->getURL() +
+                      OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DELIMITER) +
+                      m_pTable->getName() +
+                      ".inf");
+
+    OUString sPhysicalPath;
+    osl::FileBase::getSystemPathFromFileURL(sCfgFile, sPhysicalPath);
+
+    Config aInfFile(sPhysicalPath);
+    aInfFile.SetGroup(dBASE_III_GROUP);
+
+    sal_uInt16 nSuffix = aInfFile.GetKeyCount();
+    OString aNewEntry,aKeyName;
+    bool bCase = isCaseSensitive();
+    while (aNewEntry.isEmpty())
+    {
+        aNewEntry = "NDX" + OString::number(++nSuffix);
+        for (sal_uInt16 i = 0; i < aInfFile.GetKeyCount(); i++)
+        {
+            aKeyName = aInfFile.GetKeyName(i);
+            if (bCase ? aKeyName == aNewEntry : aKeyName.equalsIgnoreAsciiCase(aNewEntry))
+            {
+                aNewEntry.clear();
+                break;
+            }
+        }
+    }
+    aInfFile.WriteKey(aNewEntry, OUStringToOString(sEntry, m_pTable->getConnection()->getTextEncoding()));
+}
+
+void ODbaseIndex::DropImpl()
+{
+    closeImpl();
+
+    OUString sPath = getCompletePath();
+    if(UCBContentHelper::Exists(sPath))
+    {
+        if(!UCBContentHelper::Kill(sPath))
+            m_pTable->getConnection()->throwGenericSQLException(STR_COULD_NOT_DELETE_INDEX,*m_pTable);
+    }
+
+    // synchronize inf-file
+    OUString sCfgFile = m_pTable->getConnection()->getURL() +
+        OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DELIMITER) +
+        m_pTable->getName() + ".inf";
+
+    OUString sPhysicalPath;
+    OSL_VERIFY( osl::FileBase::getSystemPathFromFileURL(sCfgFile, sPhysicalPath)
+                    == osl::FileBase::E_None );
+
+    Config aInfFile(sPhysicalPath);
+    aInfFile.SetGroup(dBASE_III_GROUP);
+    sal_uInt16 nKeyCnt = aInfFile.GetKeyCount();
+    OString aKeyName;
+    OUString sEntry = m_Name + ".ndx";
+
+    // delete entries from the inf file
+    for (sal_uInt16 nKey = 0; nKey < nKeyCnt; nKey++)
+    {
+        // References the Key to an Index-file?
+        aKeyName = aInfFile.GetKeyName( nKey );
+        if (aKeyName.startsWith("NDX"))
+        {
+            if(sEntry == OStringToOUString(aInfFile.ReadKey(aKeyName),m_pTable->getConnection()->getTextEncoding()))
+            {
+                aInfFile.DeleteKey(aKeyName);
+                break;
+            }
+        }
+    }
+}
+
+void ODbaseIndex::impl_killFileAndthrowError_throw(TranslateId pErrorId, const OUString& _sFile)
+{
+    closeImpl();
+    if(UCBContentHelper::Exists(_sFile))
+        UCBContentHelper::Kill(_sFile);
+    m_pTable->getConnection()->throwGenericSQLException(pErrorId, *this);
+}
+
+void ODbaseIndex::CreateImpl()
+{
+    // Create the Index
+    const OUString sFile = getCompletePath();
+    if(UCBContentHelper::Exists(sFile))
+    {
+        const OUString sError( m_pTable->getConnection()->getResources().getResourceStringWithSubstitution(
+            STR_COULD_NOT_CREATE_INDEX_NAME,
+            "$filename$", sFile
+         ) );
+        ::dbtools::throwGenericSQLException( sError, *this );
+    }
+    // Index comprises only one column
+    if (m_pColumns->getCount() > 1)
+        m_pTable->getConnection()->throwGenericSQLException(STR_ONL_ONE_COLUMN_PER_INDEX,*this);
+
+    Reference<XFastPropertySet> xCol(m_pColumns->getByIndex(0),UNO_QUERY);
+
+    // Is the column already indexed?
+    if ( !xCol.is() )
+        ::dbtools::throwFunctionSequenceException(*this);
+
+    // create the index file
+    m_pFileStream = OFileTable::createStream_simpleError(sFile,StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE | StreamMode::TRUNC);
+    if (!m_pFileStream)
+    {
+        const OUString sError( m_pTable->getConnection()->getResources().getResourceStringWithSubstitution(
+            STR_COULD_NOT_LOAD_FILE,
+            "$filename$", sFile
+         ) );
+        ::dbtools::throwGenericSQLException( sError, *this );
+    }
+
+    m_pFileStream->SetEndian(SvStreamEndian::LITTLE);
+    m_pFileStream->SetBufferSize(DINDEX_PAGE_SIZE);
+
+    // firstly the result must be sorted
+    utl::SharedUNOComponent<XStatement> xStmt;
+    utl::SharedUNOComponent<XResultSet> xSet;
+    OUString aName;
+    try
+    {
+        xStmt.set( m_pTable->getConnection()->createStatement(), UNO_SET_THROW);
+
+        aName = getString(xCol->getFastPropertyValue(PROPERTY_ID_NAME));
+
+        const OUString aQuote(m_pTable->getConnection()->getMetaData()->getIdentifierQuoteString());
+        OUString aStatement( "SELECT " + aQuote + aName + aQuote +" FROM " + aQuote + m_pTable->getName() + aQuote + " ORDER BY " + aQuote + aName + aQuote);
+
+        xSet.set( xStmt->executeQuery(aStatement),UNO_SET_THROW );
+    }
+    catch(const Exception& )
+    {
+        impl_killFileAndthrowError_throw(STR_COULD_NOT_CREATE_INDEX,sFile);
+    }
+    if (!xSet.is())
+    {
+        impl_killFileAndthrowError_throw(STR_COULD_NOT_CREATE_INDEX,sFile);
+    }
+
+    // Set the header info
+    memset(&m_aHeader,0,sizeof(m_aHeader));
+    sal_Int32 nType = 0;
+    ::rtl::Reference<OSQLColumns> aCols = m_pTable->getTableColumns();
+    const Reference< XPropertySet > xTableCol(*find(aCols->begin(),aCols->end(),aName,::comphelper::UStringMixEqual(isCaseSensitive())));
+
+    xTableCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nType;
+
+    m_aHeader.db_keytype = (nType == DataType::VARCHAR || nType == DataType::CHAR) ? 0 : 1;
+    m_aHeader.db_keylen  = (m_aHeader.db_keytype) ? 8 : static_cast<sal_uInt16>(getINT32(xTableCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))));
+    m_aHeader.db_keylen = (( m_aHeader.db_keylen - 1) / 4 + 1) * 4;
+    m_aHeader.db_maxkeys = (DINDEX_PAGE_SIZE - 4) / (8 + m_aHeader.db_keylen);
+    if ( m_aHeader.db_maxkeys < 3 )
+    {
+        impl_killFileAndthrowError_throw(STR_COULD_NOT_CREATE_INDEX_KEYSIZE,sFile);
+    }
+
+    m_pFileStream->SetStreamSize(DINDEX_PAGE_SIZE);
+
+    OString aCol(OUStringToOString(aName, m_pTable->getConnection()->getTextEncoding()));
+    strncpy(m_aHeader.db_name, aCol.getStr(), std::min<size_t>(sizeof(m_aHeader.db_name), aCol.getLength()));
+    m_aHeader.db_unique  = m_IsUnique ? 1: 0;
+    m_aHeader.db_keyrec  = m_aHeader.db_keylen + 8;
+
+    // modifications of the header are detected by differences between
+    // the HeaderInfo and nRootPage or nPageCount respectively
+    m_nRootPage = 1;
+    m_nPageCount = 2;
+
+    m_aCurLeaf = m_aRoot = CreatePage(m_nRootPage);
+    m_aRoot->SetModified(true);
+
+    m_bUseCollector = true;
+
+    sal_Int32 nRowsLeft = 0;
+    Reference<XRow> xRow(xSet,UNO_QUERY);
+
+    if(xSet->last())
+    {
+        ODbaseResultSet* pDbaseRes = dynamic_cast<ODbaseResultSet*>(xSet.getTyped().get());
+        assert(pDbaseRes); //"No dbase resultset found? What's going on here!
+        nRowsLeft = xSet->getRow();
+
+        xSet->beforeFirst();
+        ONDXKey aKey(ORowSetValue(), nType, 0);
+        ONDXKey aInsertKey(ORowSetValue(), nType, 0);
+        // Create the index structure
+        while (xSet->next())
+        {
+            ORowSetValue aValue(m_aHeader.db_keytype ? ORowSetValue(xRow->getDouble(1)) : ORowSetValue(xRow->getString(1)));
+            // checking for duplicate entries
+            if (m_IsUnique && m_nCurNode != NODE_NOTFOUND)
+            {
+                aKey.setValue(aValue);
+                if (aKey == (*m_aCurLeaf)[m_nCurNode].GetKey())
+                {
+                    impl_killFileAndthrowError_throw(STR_COULD_NOT_CREATE_INDEX_NOT_UNIQUE,sFile);
+                }
+            }
+            aInsertKey.setValue(aValue);
+            aInsertKey.setRecord(pDbaseRes->getCurrentFilePos());
+
+            ONDXNode aNewNode(aInsertKey);
+            if (!m_aCurLeaf->Insert(aNewNode, --nRowsLeft))
+                break;
+        }
+    }
+
+    if(nRowsLeft)
+    {
+        impl_killFileAndthrowError_throw(STR_COULD_NOT_CREATE_INDEX,sFile);
+    }
+    Release();
+    createINFEntry();
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DIndexColumns.cxx b/connectivity/source/drivers/dbase/DIndexColumns.cxx
new file mode 100644
index 0000000000..886c7273db
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DIndexColumns.cxx
@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DIndexColumns.hxx>
+#include <dbase/DTable.hxx>
+#include <sdbcx/VIndexColumn.hxx>
+#include <comphelper/types.hxx>
+
+using namespace ::comphelper;
+
+using namespace connectivity::dbase;
+using namespace connectivity;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::container;
+
+
+sdbcx::ObjectType ODbaseIndexColumns::createObject(const OUString& _rName)
+{
+    const ODbaseTable* pTable = m_pIndex->getTable();
+
+    const ::rtl::Reference<OSQLColumns>& aCols = pTable->getTableColumns();
+    OSQLColumns::const_iterator aIter = find(aCols->begin(),aCols->end(),_rName,::comphelper::UStringMixEqual(isCaseSensitive()));
+
+    Reference< XPropertySet > xCol;
+    if(aIter != aCols->end())
+        xCol = *aIter;
+
+    if(!xCol.is())
+        return sdbcx::ObjectType();
+
+    sdbcx::ObjectType xRet = new sdbcx::OIndexColumn(true,_rName
+                                                    ,getString(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPENAME)))
+                                                    ,OUString()
+                                                    ,getINT32(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISNULLABLE)))
+                                                    ,getINT32(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)))
+                                                    ,getINT32(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE)))
+                                                    ,getINT32(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)))
+                                                    ,pTable->getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers()
+                                                    ,getString(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_CATALOGNAME)))
+                                                    ,getString(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCHEMANAME)))
+                                                    ,getString(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TABLENAME))));
+
+    return xRet;
+}
+
+
+void ODbaseIndexColumns::impl_refresh()
+{
+    m_pIndex->refreshColumns();
+}
+
+Reference< XPropertySet > ODbaseIndexColumns::createDescriptor()
+{
+    return new sdbcx::OIndexColumn(m_pIndex->getTable()->getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
+}
+
+sdbcx::ObjectType ODbaseIndexColumns::appendObject( const OUString& /*_rForName*/, const Reference< XPropertySet >& descriptor )
+{
+    return cloneDescriptor( descriptor );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DIndexIter.cxx b/connectivity/source/drivers/dbase/DIndexIter.cxx
new file mode 100644
index 0000000000..37e28a073f
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DIndexIter.cxx
@@ -0,0 +1,282 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DIndexIter.hxx>
+#include <com/sun/star/sdb/SQLFilterOperator.hpp>
+
+using namespace ::com::sun::star::sdb;
+using namespace connectivity;
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+
+// OIndexIterator
+
+OIndexIterator::~OIndexIterator() {}
+
+sal_uInt32 OIndexIterator::First() { return Find(true); }
+
+sal_uInt32 OIndexIterator::Next() { return Find(false); }
+
+sal_uInt32 OIndexIterator::Find(bool bFirst)
+{
+    sal_uInt32 nRes = NODE_NOTFOUND;
+
+    if (bFirst)
+    {
+        m_aRoot = m_xIndex->getRoot();
+        m_aCurLeaf.Clear();
+    }
+
+    if (!m_pOperator)
+    {
+        // Preparation, position on the smallest element
+        if (bFirst)
+        {
+            ONDXPage* pPage = m_aRoot;
+            while (pPage && !pPage->IsLeaf())
+                pPage = pPage->GetChild(m_xIndex.get());
+
+            m_aCurLeaf = pPage;
+            m_nCurNode = NODE_NOTFOUND;
+        }
+        ONDXKey* pKey = GetNextKey();
+        nRes = pKey ? pKey->GetRecord() : NODE_NOTFOUND;
+    }
+    else if (dynamic_cast<const OOp_ISNOTNULL*>(m_pOperator) != nullptr)
+        nRes = GetNotNull(bFirst);
+    else if (dynamic_cast<const OOp_ISNULL*>(m_pOperator) != nullptr)
+        nRes = GetNull(bFirst);
+    else if (dynamic_cast<const OOp_LIKE*>(m_pOperator) != nullptr)
+        nRes = GetLike(bFirst);
+    else if (dynamic_cast<const OOp_COMPARE*>(m_pOperator) != nullptr)
+        nRes = GetCompare(bFirst);
+
+    return nRes;
+}
+
+ONDXKey* OIndexIterator::GetFirstKey(ONDXPage* pPage, const OOperand& rKey)
+{
+    // searches a given key
+    // Speciality: At the end of the algorithm
+    // the actual page and the position of the node which fulfil the
+    // '<='-condition are saved. this is considered for inserts.
+    //  ONDXIndex* m_pIndex = GetNDXIndex();
+    OOp_COMPARE aTempOp(SQLFilterOperator::GREATER);
+    sal_uInt16 i = 0;
+
+    if (pPage->IsLeaf())
+    {
+        // in the leaf the actual operation is run, otherwise temp. (>)
+        while (i < pPage->Count() && !m_pOperator->operate(&((*pPage)[i]).GetKey(), &rKey))
+            i++;
+    }
+    else
+        while (i < pPage->Count() && !aTempOp.operate(&((*pPage)[i]).GetKey(), &rKey))
+            i++;
+
+    ONDXKey* pFoundKey = nullptr;
+    if (!pPage->IsLeaf())
+    {
+        // descend further
+        ONDXPagePtr aPage = (i == 0) ? pPage->GetChild(m_xIndex.get())
+                                     : ((*pPage)[i - 1]).GetChild(m_xIndex.get(), pPage);
+        pFoundKey = aPage.Is() ? GetFirstKey(aPage, rKey) : nullptr;
+    }
+    else if (i == pPage->Count())
+    {
+        pFoundKey = nullptr;
+    }
+    else
+    {
+        pFoundKey = &(*pPage)[i].GetKey();
+        if (!m_pOperator->operate(pFoundKey, &rKey))
+            pFoundKey = nullptr;
+
+        m_aCurLeaf = pPage;
+        m_nCurNode = pFoundKey ? i : i - 1;
+    }
+    return pFoundKey;
+}
+
+sal_uInt32 OIndexIterator::GetCompare(bool bFirst)
+{
+    ONDXKey* pKey = nullptr;
+    sal_Int32 ePredicateType = dynamic_cast<file::OOp_COMPARE&>(*m_pOperator).getPredicateType();
+
+    if (bFirst)
+    {
+        // Preparation, position on the smallest element
+        ONDXPage* pPage = m_aRoot;
+        switch (ePredicateType)
+        {
+            case SQLFilterOperator::NOT_EQUAL:
+            case SQLFilterOperator::LESS:
+            case SQLFilterOperator::LESS_EQUAL:
+                while (pPage && !pPage->IsLeaf())
+                    pPage = pPage->GetChild(m_xIndex.get());
+
+                m_aCurLeaf = pPage;
+                m_nCurNode = NODE_NOTFOUND;
+        }
+
+        switch (ePredicateType)
+        {
+            case SQLFilterOperator::NOT_EQUAL:
+                while ((pKey = GetNextKey()) != nullptr)
+                    if (m_pOperator->operate(pKey, m_pOperand))
+                        break;
+                break;
+            case SQLFilterOperator::LESS:
+                while ((pKey = GetNextKey()) != nullptr)
+                    if (!pKey->getValue().isNull())
+                        break;
+                break;
+            case SQLFilterOperator::LESS_EQUAL:
+                while ((pKey = GetNextKey()) != nullptr)
+                    ;
+                break;
+            case SQLFilterOperator::GREATER_EQUAL:
+            case SQLFilterOperator::EQUAL:
+                pKey = GetFirstKey(m_aRoot, *m_pOperand);
+                break;
+            case SQLFilterOperator::GREATER:
+                pKey = GetFirstKey(m_aRoot, *m_pOperand);
+                if (!pKey)
+                    while ((pKey = GetNextKey()) != nullptr)
+                        if (m_pOperator->operate(pKey, m_pOperand))
+                            break;
+        }
+    }
+    else
+    {
+        switch (ePredicateType)
+        {
+            case SQLFilterOperator::NOT_EQUAL:
+                while ((pKey = GetNextKey()) != nullptr)
+                    if (m_pOperator->operate(pKey, m_pOperand))
+                        break;
+                break;
+            case SQLFilterOperator::LESS:
+            case SQLFilterOperator::LESS_EQUAL:
+            case SQLFilterOperator::EQUAL:
+                pKey = GetNextKey();
+                if (pKey == nullptr || !m_pOperator->operate(pKey, m_pOperand))
+                {
+                    pKey = nullptr;
+                    m_aCurLeaf.Clear();
+                }
+                break;
+            case SQLFilterOperator::GREATER_EQUAL:
+            case SQLFilterOperator::GREATER:
+                pKey = GetNextKey();
+        }
+    }
+
+    return pKey ? pKey->GetRecord() : NODE_NOTFOUND;
+}
+
+sal_uInt32 OIndexIterator::GetLike(bool bFirst)
+{
+    if (bFirst)
+    {
+        ONDXPage* pPage = m_aRoot;
+
+        while (pPage && !pPage->IsLeaf())
+            pPage = pPage->GetChild(m_xIndex.get());
+
+        m_aCurLeaf = pPage;
+        m_nCurNode = NODE_NOTFOUND;
+    }
+
+    ONDXKey* pKey;
+    while ((pKey = GetNextKey()) != nullptr)
+        if (m_pOperator->operate(pKey, m_pOperand))
+            break;
+    return pKey ? pKey->GetRecord() : NODE_NOTFOUND;
+}
+
+sal_uInt32 OIndexIterator::GetNull(bool bFirst)
+{
+    if (bFirst)
+    {
+        ONDXPage* pPage = m_aRoot;
+        while (pPage && !pPage->IsLeaf())
+            pPage = pPage->GetChild(m_xIndex.get());
+
+        m_aCurLeaf = pPage;
+        m_nCurNode = NODE_NOTFOUND;
+    }
+
+    ONDXKey* pKey = GetNextKey();
+    if (pKey == nullptr || !pKey->getValue().isNull())
+    {
+        pKey = nullptr;
+        m_aCurLeaf.Clear();
+    }
+    return pKey ? pKey->GetRecord() : NODE_NOTFOUND;
+}
+
+sal_uInt32 OIndexIterator::GetNotNull(bool bFirst)
+{
+    ONDXKey* pKey;
+    if (bFirst)
+    {
+        // go through all NULL values first
+        for (sal_uInt32 nRec = GetNull(bFirst); nRec != NODE_NOTFOUND; nRec = GetNull(false))
+            ;
+        pKey = m_aCurLeaf.Is() ? &(*m_aCurLeaf)[m_nCurNode].GetKey() : nullptr;
+    }
+    else
+        pKey = GetNextKey();
+
+    return pKey ? pKey->GetRecord() : NODE_NOTFOUND;
+}
+
+ONDXKey* OIndexIterator::GetNextKey()
+{
+    if (m_aCurLeaf.Is() && ((++m_nCurNode) >= m_aCurLeaf->Count()))
+    {
+        ONDXPage* pPage = m_aCurLeaf;
+        // search next page
+        while (pPage)
+        {
+            ONDXPage* pParentPage = pPage->GetParent();
+            if (pParentPage)
+            {
+                sal_uInt16 nPos = pParentPage->Search(pPage);
+                if (nPos != pParentPage->Count() - 1)
+                { // page found
+                    pPage = (*pParentPage)[nPos + 1].GetChild(m_xIndex.get(), pParentPage);
+                    break;
+                }
+            }
+            pPage = pParentPage;
+        }
+
+        // now go on with leaf
+        while (pPage && !pPage->IsLeaf())
+            pPage = pPage->GetChild(m_xIndex.get());
+
+        m_aCurLeaf = pPage;
+        m_nCurNode = 0;
+    }
+    return m_aCurLeaf.Is() ? &(*m_aCurLeaf)[m_nCurNode].GetKey() : nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DIndexes.cxx b/connectivity/source/drivers/dbase/DIndexes.cxx
new file mode 100644
index 0000000000..c0a4dead50
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DIndexes.cxx
@@ -0,0 +1,111 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DIndexes.hxx>
+#include <dbase/DIndex.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <connectivity/dbexception.hxx>
+#include <unotools/ucbhelper.hxx>
+#include <strings.hrc>
+
+using namespace ::comphelper;
+
+using namespace utl;
+using namespace ::connectivity;
+using namespace ::dbtools;
+using namespace ::connectivity::dbase;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+
+sdbcx::ObjectType ODbaseIndexes::createObject(const OUString& _rName)
+{
+    OUString sFile = m_pTable->getConnection()->getURL() +
+        OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_DELIMITER) +
+        _rName + ".ndx";
+    if ( !UCBContentHelper::Exists(sFile) )
+    {
+        const OUString sError( m_pTable->getConnection()->getResources().getResourceStringWithSubstitution(
+                STR_COULD_NOT_LOAD_FILE,
+                "$filename$", sFile
+            ) );
+        ::dbtools::throwGenericSQLException( sError, *m_pTable );
+    }
+
+    sdbcx::ObjectType xRet;
+    std::unique_ptr<SvStream> pFileStream = ::connectivity::file::OFileTable::createStream_simpleError(sFile, StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
+    if(pFileStream)
+    {
+        pFileStream->SetEndian(SvStreamEndian::LITTLE);
+        pFileStream->SetBufferSize(DINDEX_PAGE_SIZE);
+        ODbaseIndex::NDXHeader aHeader;
+
+        pFileStream->Seek(0);
+        ReadHeader(*pFileStream, aHeader);
+        pFileStream.reset();
+
+        rtl::Reference<ODbaseIndex> pIndex = new ODbaseIndex(m_pTable,aHeader,_rName);
+        xRet = pIndex;
+        pIndex->openIndexFile();
+    }
+    else
+    {
+        const OUString sError( m_pTable->getConnection()->getResources().getResourceStringWithSubstitution(
+                STR_COULD_NOT_LOAD_FILE,
+                "$filename$", sFile
+             ) );
+        ::dbtools::throwGenericSQLException( sError, *m_pTable );
+    }
+    return xRet;
+}
+
+void ODbaseIndexes::impl_refresh(  )
+{
+    if(m_pTable)
+        m_pTable->refreshIndexes();
+}
+
+Reference< XPropertySet > ODbaseIndexes::createDescriptor()
+{
+    return new ODbaseIndex(m_pTable);
+}
+
+// XAppend
+sdbcx::ObjectType ODbaseIndexes::appendObject( const OUString& _rForName, const Reference< XPropertySet >& descriptor )
+{
+    ODbaseIndex* pIndex = dynamic_cast<ODbaseIndex*>(descriptor.get());
+    if(pIndex)
+        pIndex->CreateImpl();
+
+    return createObject( _rForName );
+}
+
+// XDrop
+void ODbaseIndexes::dropObject(sal_Int32 _nPos, const OUString& /*_sElementName*/)
+{
+    rtl::Reference<ODbaseIndex> pIndex = dynamic_cast<ODbaseIndex*>(getObject(_nPos).get());
+    if ( pIndex )
+        pIndex->DropImpl();
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DPreparedStatement.cxx b/connectivity/source/drivers/dbase/DPreparedStatement.cxx
new file mode 100644
index 0000000000..9a2b54409b
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DPreparedStatement.cxx
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DPreparedStatement.hxx>
+#include <dbase/DResultSet.hxx>
+
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+using namespace com::sun::star::uno;
+
+rtl::Reference<OResultSet> ODbasePreparedStatement::createResultSet()
+{
+    return new ODbaseResultSet(this, m_aSQLIterator);
+}
+
+IMPLEMENT_SERVICE_INFO(ODbasePreparedStatement, "com.sun.star.sdbc.driver.dbase.PreparedStatement",
+                       "com.sun.star.sdbc.PreparedStatement");
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DResultSet.cxx b/connectivity/source/drivers/dbase/DResultSet.cxx
new file mode 100644
index 0000000000..123a29b8b0
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DResultSet.cxx
@@ -0,0 +1,211 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/sdbcx/CompareBookmark.hpp>
+#include <dbase/DResultSet.hxx>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <comphelper/sequence.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <dbase/DIndex.hxx>
+#include <dbase/DIndexIter.hxx>
+#include <comphelper/types.hxx>
+#include <connectivity/dbexception.hxx>
+#include <strings.hrc>
+
+using namespace ::comphelper;
+
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+using namespace ::cppu;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::sdbc;
+using namespace com::sun::star::sdbcx;
+
+ODbaseResultSet::ODbaseResultSet( OStatement_Base* pStmt,connectivity::OSQLParseTreeIterator&   _aSQLIterator)
+                : file::OResultSet(pStmt,_aSQLIterator)
+                ,m_bBookmarkable(true)
+{
+    registerProperty(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISBOOKMARKABLE),         PROPERTY_ID_ISBOOKMARKABLE,       PropertyAttribute::READONLY,&m_bBookmarkable,                cppu::UnoType<bool>::get());
+}
+
+OUString SAL_CALL ODbaseResultSet::getImplementationName(  )
+{
+    return "com.sun.star.sdbcx.dbase.ResultSet";
+}
+
+Sequence< OUString > SAL_CALL ODbaseResultSet::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.sdbc.ResultSet", "com.sun.star.sdbcx.ResultSet" };
+}
+
+sal_Bool SAL_CALL ODbaseResultSet::supportsService( const OUString& _rServiceName )
+{
+    return cppu::supportsService(this, _rServiceName);
+}
+
+Any SAL_CALL ODbaseResultSet::queryInterface( const Type & rType )
+{
+    Any aRet = ODbaseResultSet_BASE::queryInterface(rType);
+    return aRet.hasValue() ? aRet : OResultSet::queryInterface(rType);
+}
+
+ Sequence<  Type > SAL_CALL ODbaseResultSet::getTypes(  )
+{
+    return ::comphelper::concatSequences(OResultSet::getTypes(),ODbaseResultSet_BASE::getTypes());
+}
+
+
+// XRowLocate
+Any SAL_CALL ODbaseResultSet::getBookmark(  )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
+    OSL_ENSURE((m_bShowDeleted || !m_aRow->isDeleted()),"getBookmark called for deleted row");
+
+    return Any((*m_aRow)[0]->getValue().getInt32());
+}
+
+sal_Bool SAL_CALL ODbaseResultSet::moveToBookmark( const  Any& bookmark )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
+
+
+    m_bRowDeleted = m_bRowInserted = m_bRowUpdated = false;
+
+    return m_pTable.is() && Move(IResultSetHelper::BOOKMARK,comphelper::getINT32(bookmark),true);
+}
+
+sal_Bool SAL_CALL ODbaseResultSet::moveRelativeToBookmark( const  Any& bookmark, sal_Int32 rows )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
+    if(!m_pTable.is())
+        return false;
+
+
+    Move(IResultSetHelper::BOOKMARK,comphelper::getINT32(bookmark),false);
+
+    return relative(rows);
+}
+
+
+sal_Int32 SAL_CALL ODbaseResultSet::compareBookmarks( const Any& lhs, const Any& rhs )
+{
+    sal_Int32 nFirst(0),nSecond(0),nResult(0);
+    if ( !( lhs  >>= nFirst ) || !( rhs >>= nSecond ) )
+    {
+        ::connectivity::SharedResources aResources;
+        const OUString sMessage = aResources.getResourceString(STR_INVALID_BOOKMARK);
+        ::dbtools::throwGenericSQLException(sMessage ,*this);
+    } // if ( !( lhs  >>= nFirst ) || !( rhs >>= nSecond ) )
+
+    if(nFirst < nSecond)
+        nResult = CompareBookmark::LESS;
+    else if(nFirst > nSecond)
+        nResult = CompareBookmark::GREATER;
+    else
+        nResult = CompareBookmark::EQUAL;
+
+    return  nResult;
+}
+
+sal_Bool SAL_CALL ODbaseResultSet::hasOrderedBookmarks(  )
+{
+    return true;
+}
+
+sal_Int32 SAL_CALL ODbaseResultSet::hashBookmark( const  Any& bookmark )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
+
+
+    return comphelper::getINT32(bookmark);
+}
+
+// XDeleteRows
+Sequence< sal_Int32 > SAL_CALL ODbaseResultSet::deleteRows( const  Sequence<  Any >& /*rows*/ )
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+    checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
+
+    ::dbtools::throwFeatureNotImplementedSQLException( "XDeleteRows::deleteRows", *this );
+    return Sequence< sal_Int32 >();
+}
+
+bool ODbaseResultSet::fillIndexValues(const Reference< XColumnsSupplier> &_xIndex)
+{
+    auto pIndex = dynamic_cast<dbase::ODbaseIndex*>(_xIndex.get());
+    if(pIndex)
+    {
+        std::unique_ptr<dbase::OIndexIterator> pIter = pIndex->createIterator();
+
+        if (pIter)
+        {
+            sal_uInt32 nRec = pIter->First();
+            while (nRec != NODE_NOTFOUND)
+            {
+                m_pFileSet->push_back(nRec);
+                nRec = pIter->Next();
+            }
+            m_pFileSet->setFrozen();
+            return true;
+        }
+    }
+    return false;
+}
+
+::cppu::IPropertyArrayHelper & ODbaseResultSet::getInfoHelper()
+{
+    return *ODbaseResultSet_BASE3::getArrayHelper();
+}
+
+::cppu::IPropertyArrayHelper* ODbaseResultSet::createArrayHelper() const
+{
+    Sequence< Property > aProps;
+    describeProperties(aProps);
+    return new ::cppu::OPropertyArrayHelper(aProps);
+}
+
+void SAL_CALL ODbaseResultSet::acquire() noexcept
+{
+    ODbaseResultSet_BASE2::acquire();
+}
+
+void SAL_CALL ODbaseResultSet::release() noexcept
+{
+    ODbaseResultSet_BASE2::release();
+}
+
+css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL ODbaseResultSet::getPropertySetInfo(  )
+{
+    return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
+}
+
+sal_Int32 ODbaseResultSet::getCurrentFilePos() const
+{
+    return m_pTable->getFilePos();
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DStatement.cxx b/connectivity/source/drivers/dbase/DStatement.cxx
new file mode 100644
index 0000000000..d253723277
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DStatement.cxx
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DStatement.hxx>
+#include <dbase/DResultSet.hxx>
+
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+using namespace com::sun::star::uno;
+
+
+rtl::Reference<OResultSet> ODbaseStatement::createResultSet()
+{
+    return new ODbaseResultSet(this,m_aSQLIterator);
+}
+
+IMPLEMENT_SERVICE_INFO(ODbaseStatement,"com.sun.star.sdbc.driver.dbase.Statement","com.sun.star.sdbc.Statement");
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DTable.cxx b/connectivity/source/drivers/dbase/DTable.cxx
new file mode 100644
index 0000000000..3995ee8984
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DTable.cxx
@@ -0,0 +1,2747 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/DTable.hxx>
+#include <com/sun/star/container/ElementExistException.hpp>
+#include <com/sun/star/sdbc/ColumnValue.hpp>
+#include <com/sun/star/sdbc/DataType.hpp>
+#include <com/sun/star/ucb/XContentAccess.hpp>
+#include <com/sun/star/sdbc/XRow.hpp>
+#include <o3tl/safeint.hxx>
+#include <svl/converter.hxx>
+#include <dbase/DConnection.hxx>
+#include <dbase/DColumns.hxx>
+#include <tools/config.hxx>
+#include <comphelper/diagnose_ex.hxx>
+#include <dbase/DIndex.hxx>
+#include <dbase/DIndexes.hxx>
+#include <comphelper/processfactory.hxx>
+#include <rtl/math.hxx>
+#include <ucbhelper/content.hxx>
+#include <com/sun/star/ucb/ContentCreationException.hpp>
+#include <connectivity/dbexception.hxx>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <comphelper/property.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <o3tl/string_view.hxx>
+#include <comphelper/string.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/tempfile.hxx>
+#include <unotools/ucbhelper.hxx>
+#include <comphelper/types.hxx>
+#include <cppuhelper/exc_hlp.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <connectivity/dbtools.hxx>
+#include <connectivity/FValue.hxx>
+#include <connectivity/dbconversion.hxx>
+#include <connectivity/sdbcx/VColumn.hxx>
+#include <strings.hrc>
+#include <rtl/strbuf.hxx>
+#include <sal/log.hxx>
+#include <tools/date.hxx>
+#include <i18nutil/calendar.hxx>
+
+#include <algorithm>
+#include <cassert>
+#include <memory>
+#include <string_view>
+
+using namespace ::comphelper;
+using namespace connectivity;
+using namespace connectivity::sdbcx;
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+using namespace ::ucbhelper;
+using namespace ::utl;
+using namespace ::cppu;
+using namespace ::dbtools;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::i18n;
+
+// stored as the Field Descriptor terminator
+#define FIELD_DESCRIPTOR_TERMINATOR 0x0D
+#define DBF_EOL                     0x1A
+
+namespace
+{
+std::size_t lcl_getFileSize(SvStream& _rStream)
+{
+    std::size_t nFileSize = 0;
+    _rStream.Seek(STREAM_SEEK_TO_END);
+    _rStream.SeekRel(-1);
+    char cEOL;
+    _rStream.ReadChar( cEOL );
+    nFileSize = _rStream.Tell();
+    if ( cEOL == DBF_EOL )
+        nFileSize -= 1;
+    return nFileSize;
+}
+/**
+    calculates the Julian date
+*/
+void lcl_CalcJulDate(sal_Int32& _nJulianDate,sal_Int32& _nJulianTime, const css::util::DateTime& rDateTime)
+{
+    css::util::DateTime aDateTime = rDateTime;
+    // weird: months fix
+    if (aDateTime.Month > 12)
+    {
+        aDateTime.Month--;
+        sal_uInt16 delta = rDateTime.Month / 12;
+        aDateTime.Year += delta;
+        aDateTime.Month -= delta * 12;
+        aDateTime.Month++;
+    }
+
+    _nJulianTime = ((aDateTime.Hours*3600000)+(aDateTime.Minutes*60000)+(aDateTime.Seconds*1000)+(aDateTime.NanoSeconds/1000000));
+    /* conversion factors */
+    sal_uInt16 iy0;
+    sal_uInt16 im0;
+    if ( aDateTime.Month <= 2 )
+    {
+        iy0 = aDateTime.Year - 1;
+        im0 = aDateTime.Month + 12;
+    }
+    else
+    {
+        iy0 = aDateTime.Year;
+        im0 = aDateTime.Month;
+    }
+    sal_Int32 ia = iy0 / 100;
+    sal_Int32 ib = 2 - ia + (ia >> 2);
+    /* calculate julian date    */
+    if ( aDateTime.Year <= 0 )
+    {
+        _nJulianDate = static_cast<sal_Int32>((365.25 * iy0) - 0.75)
+            + static_cast<sal_Int32>(i18nutil::monthDaysWithoutJanFeb * (im0 + 1) )
+            + aDateTime.Day + 1720994;
+    } // if ( rDateTime.Year <= 0 )
+    else
+    {
+        _nJulianDate = static_cast<sal_Int32>(365.25 * iy0)
+            + static_cast<sal_Int32>(i18nutil::monthDaysWithoutJanFeb * (im0 + 1))
+            + aDateTime.Day + 1720994;
+    }
+    double JD = _nJulianDate + 0.5;
+    _nJulianDate = static_cast<sal_Int32>( JD + 0.5);
+    const double gyr = aDateTime.Year + (0.01 * aDateTime.Month) + (0.0001 * aDateTime.Day);
+    if ( gyr >= 1582.1015 ) /* on or after 15 October 1582  */
+        _nJulianDate += ib;
+}
+
+/**
+    calculates date time from the Julian Date
+*/
+void lcl_CalDate(sal_Int32 _nJulianDate,sal_Int32 _nJulianTime,css::util::DateTime& _rDateTime)
+{
+    if ( _nJulianDate )
+    {
+        sal_Int64 ka = _nJulianDate;
+        if ( _nJulianDate >= 2299161 )
+        {
+            sal_Int64 ialp = static_cast<sal_Int64>( (static_cast<double>(_nJulianDate) - 1867216.25 ) / 36524.25 );
+            ka = ka + 1 + ialp - ( ialp >> 2 );
+        }
+        sal_Int64 kb = ka + 1524;
+        sal_Int64 kc = static_cast<sal_Int64>((static_cast<double>(kb) - 122.1) / 365.25);
+        sal_Int64 kd = static_cast<sal_Int64>(static_cast<double>(kc) * 365.25);
+        sal_Int64 ke = static_cast<sal_Int64>(static_cast<double>(kb - kd) / i18nutil::monthDaysWithoutJanFeb);
+        _rDateTime.Day = static_cast<sal_uInt16>(kb - kd - static_cast<sal_Int64>( static_cast<double>(ke) * i18nutil::monthDaysWithoutJanFeb ));
+        if ( ke > 13 )
+            _rDateTime.Month = static_cast<sal_uInt16>(ke - 13);
+        else
+            _rDateTime.Month = static_cast<sal_uInt16>(ke - 1);
+        if ( (_rDateTime.Month == 2) && (_rDateTime.Day > 28) )
+            _rDateTime.Day = 29;
+        if ( (_rDateTime.Month == 2) && (_rDateTime.Day == 29) && (ke == 3) )
+            _rDateTime.Year = static_cast<sal_uInt16>(kc - 4716);
+        else if ( _rDateTime.Month > 2 )
+            _rDateTime.Year = static_cast<sal_uInt16>(kc - 4716);
+        else
+            _rDateTime.Year = static_cast<sal_uInt16>(kc - 4715);
+    }
+
+    if ( _nJulianTime )
+    {
+        double d_s = _nJulianTime / 1000.0;
+        double d_m = d_s / 60.0;
+        double d_h  = d_m / 60.0;
+        _rDateTime.Hours = static_cast<sal_uInt16>(d_h);
+        _rDateTime.Minutes = static_cast<sal_uInt16>((d_h - static_cast<double>(_rDateTime.Hours)) * 60.0);
+        _rDateTime.Seconds = static_cast<sal_uInt16>(((d_m - static_cast<double>(_rDateTime.Minutes)) * 60.0)
+                - (static_cast<double>(_rDateTime.Hours) * 3600.0));
+    }
+}
+
+}
+
+
+void ODbaseTable::readHeader()
+{
+    OSL_ENSURE(m_pFileStream,"No Stream available!");
+    if(!m_pFileStream)
+        return;
+    m_pFileStream->RefreshBuffer(); // Make sure, that the header information actually is read again
+    m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
+
+    sal_uInt8 nType=0;
+    m_pFileStream->ReadUChar( nType );
+    if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
+        throwInvalidDbaseFormat();
+
+    m_pFileStream->ReadBytes(m_aHeader.dateElems, 3);
+    if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
+        throwInvalidDbaseFormat();
+
+    m_pFileStream->ReadUInt32( m_aHeader.nbRecords);
+    if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
+        throwInvalidDbaseFormat();
+
+    m_pFileStream->ReadUInt16( m_aHeader.headerLength);
+    if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
+        throwInvalidDbaseFormat();
+
+    m_pFileStream->ReadUInt16( m_aHeader.recordLength);
+    if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
+        throwInvalidDbaseFormat();
+    if (m_aHeader.recordLength == 0)
+        throwInvalidDbaseFormat();
+
+    m_pFileStream->ReadBytes(m_aHeader.trailer, 20);
+    if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
+        throwInvalidDbaseFormat();
+
+
+    if ( ( ( m_aHeader.headerLength - 1 ) / 32 - 1 ) <= 0 ) // number of fields
+    {
+        // no dBASE file
+        throwInvalidDbaseFormat();
+    }
+    else
+    {
+        // Consistency check of the header:
+        m_aHeader.type = static_cast<DBFType>(nType);
+        switch (m_aHeader.type)
+        {
+            case dBaseIII:
+            case dBaseIV:
+            case dBaseV:
+            case VisualFoxPro:
+            case VisualFoxProAuto:
+            case dBaseFS:
+            case dBaseFSMemo:
+            case dBaseIVMemoSQL:
+            case dBaseIIIMemo:
+            case FoxProMemo:
+                m_pFileStream->SetEndian(SvStreamEndian::LITTLE);
+                if( getConnection()->isTextEncodingDefaulted() &&
+                   !dbfDecodeCharset(m_eEncoding, nType, m_aHeader.trailer[17]))
+                {
+                    m_eEncoding = RTL_TEXTENCODING_IBM_850;
+                }
+                break;
+            case dBaseIVMemo:
+                m_pFileStream->SetEndian(SvStreamEndian::LITTLE);
+                break;
+            default:
+            {
+                throwInvalidDbaseFormat();
+            }
+        }
+    }
+}
+
+void ODbaseTable::fillColumns()
+{
+    m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
+    if (!checkSeek(*m_pFileStream, 32))
+    {
+        SAL_WARN("connectivity.drivers", "ODbaseTable::fillColumns: bad offset!");
+        return;
+    }
+
+    if(!m_aColumns.is())
+        m_aColumns = new OSQLColumns();
+    else
+        m_aColumns->clear();
+
+    m_aTypes.clear();
+    m_aPrecisions.clear();
+    m_aScales.clear();
+
+    // Number of fields:
+    sal_Int32 nFieldCount = (m_aHeader.headerLength - 1) / 32 - 1;
+    if (nFieldCount <= 0)
+    {
+        SAL_WARN("connectivity.drivers", "No columns in table!");
+        return;
+    }
+
+    auto nRemainingsize = m_pFileStream->remainingSize();
+    auto nMaxPossibleRecords = nRemainingsize / 32;
+    if (o3tl::make_unsigned(nFieldCount) > nMaxPossibleRecords)
+    {
+        SAL_WARN("connectivity.drivers", "Parsing error: " << nMaxPossibleRecords <<
+                 " max possible entries, but " << nFieldCount << " claimed, truncating");
+        nFieldCount = nMaxPossibleRecords;
+    }
+
+    m_aColumns->reserve(nFieldCount);
+    m_aTypes.reserve(nFieldCount);
+    m_aPrecisions.reserve(nFieldCount);
+    m_aScales.reserve(nFieldCount);
+
+    OUString aTypeName;
+    const bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
+    const bool bFoxPro = m_aHeader.type == VisualFoxPro || m_aHeader.type == VisualFoxProAuto || m_aHeader.type == FoxProMemo;
+
+    sal_Int32 i = 0;
+    for (; i < nFieldCount; i++)
+    {
+        DBFColumn aDBFColumn;
+        m_pFileStream->ReadBytes(aDBFColumn.db_fnm, 11);
+        m_pFileStream->ReadUChar(aDBFColumn.db_typ);
+        m_pFileStream->ReadUInt32(aDBFColumn.db_adr);
+        m_pFileStream->ReadUChar(aDBFColumn.db_flng);
+        m_pFileStream->ReadUChar(aDBFColumn.db_dez);
+        m_pFileStream->ReadBytes(aDBFColumn.db_free2, 14);
+        if (!m_pFileStream->good())
+        {
+            SAL_WARN("connectivity.drivers", "ODbaseTable::fillColumns: short read!");
+            break;
+        }
+        if ( FIELD_DESCRIPTOR_TERMINATOR == aDBFColumn.db_fnm[0] ) // 0x0D stored as the Field Descriptor terminator.
+            break;
+
+        aDBFColumn.db_fnm[sizeof(aDBFColumn.db_fnm)-1] = 0; //ensure null termination for broken input
+        const OUString aColumnName(reinterpret_cast<char *>(aDBFColumn.db_fnm), strlen(reinterpret_cast<char *>(aDBFColumn.db_fnm)), m_eEncoding);
+
+        bool bIsRowVersion = bFoxPro && ( aDBFColumn.db_free2[0] & 0x01 ) == 0x01;
+
+        m_aRealFieldLengths.push_back(aDBFColumn.db_flng);
+        sal_Int32 nPrecision = aDBFColumn.db_flng;
+        sal_Int32 eType;
+        bool bIsCurrency = false;
+
+        char cType[2];
+        cType[0] = aDBFColumn.db_typ;
+        cType[1] = 0;
+        aTypeName = OUString(cType, 1, RTL_TEXTENCODING_ASCII_US);
+        SAL_INFO( "connectivity.drivers","column type: " << aDBFColumn.db_typ);
+
+        switch (aDBFColumn.db_typ)
+        {
+        case 'C':
+            eType = DataType::VARCHAR;
+            aTypeName = "VARCHAR";
+            break;
+        case 'F':
+        case 'N':
+            aTypeName = "DECIMAL";
+            if ( aDBFColumn.db_typ == 'N' )
+                aTypeName = "NUMERIC";
+            eType = DataType::DECIMAL;
+
+            // for numeric fields two characters more are written, then the precision of the column description predescribes,
+            // to keep room for the possible sign and the comma. This has to be considered...
+            nPrecision = SvDbaseConverter::ConvertPrecisionToOdbc(nPrecision,aDBFColumn.db_dez);
+            // This is not true for older versions...
+            break;
+        case 'L':
+            eType = DataType::BIT;
+            aTypeName = "BOOLEAN";
+            break;
+        case 'Y':
+            bIsCurrency = true;
+            eType = DataType::DOUBLE;
+            aTypeName = "DOUBLE";
+            break;
+        case 'D':
+            eType = DataType::DATE;
+            aTypeName = "DATE";
+            break;
+        case 'T':
+            eType = DataType::TIMESTAMP;
+            aTypeName = "TIMESTAMP";
+            break;
+        case 'I':
+            eType = DataType::INTEGER;
+            aTypeName = "INTEGER";
+            break;
+        case 'M':
+            if ( bFoxPro && ( aDBFColumn.db_free2[0] & 0x04 ) == 0x04 )
+            {
+                eType = DataType::LONGVARBINARY;
+                aTypeName = "LONGVARBINARY";
+            }
+            else
+            {
+                aTypeName = "LONGVARCHAR";
+                eType = DataType::LONGVARCHAR;
+            }
+            nPrecision = 2147483647;
+            break;
+        case 'P':
+            aTypeName = "LONGVARBINARY";
+            eType = DataType::LONGVARBINARY;
+            nPrecision = 2147483647;
+            break;
+        case '0':
+        case 'B':
+            if ( m_aHeader.type == VisualFoxPro || m_aHeader.type == VisualFoxProAuto )
+            {
+                aTypeName = "DOUBLE";
+                eType = DataType::DOUBLE;
+            }
+            else
+            {
+                aTypeName = "LONGVARBINARY";
+                eType = DataType::LONGVARBINARY;
+                nPrecision = 2147483647;
+            }
+            break;
+        default:
+            eType = DataType::OTHER;
+        }
+
+        m_aTypes.push_back(eType);
+        m_aPrecisions.push_back(nPrecision);
+        m_aScales.push_back(aDBFColumn.db_dez);
+
+        Reference< XPropertySet> xCol = new sdbcx::OColumn(aColumnName,
+                                                    aTypeName,
+                                                    OUString(),
+                                                    OUString(),
+                                                    ColumnValue::NULLABLE,
+                                                    nPrecision,
+                                                    aDBFColumn.db_dez,
+                                                    eType,
+                                                    false,
+                                                    bIsRowVersion,
+                                                    bIsCurrency,
+                                                    bCase,
+                                                    m_CatalogName, getSchema(), getName());
+        m_aColumns->push_back(xCol);
+    } // for (; i < nFieldCount; i++)
+    OSL_ENSURE(i,"No columns in table!");
+}
+
+ODbaseTable::ODbaseTable(sdbcx::OCollection* _pTables, ODbaseConnection* _pConnection)
+    : ODbaseTable_BASE(_pTables,_pConnection)
+{
+    // initialize the header
+    m_aHeader.type = dBaseIII;
+    m_eEncoding = getConnection()->getTextEncoding();
+}
+
+ODbaseTable::ODbaseTable(sdbcx::OCollection* _pTables, ODbaseConnection* _pConnection,
+                         const OUString& Name,
+                         const OUString& Type,
+                         const OUString& Description ,
+                         const OUString& SchemaName,
+                         const OUString& CatalogName )
+    : ODbaseTable_BASE(_pTables,_pConnection,Name,
+                       Type,
+                       Description,
+                       SchemaName,
+                       CatalogName)
+{
+    m_eEncoding = getConnection()->getTextEncoding();
+}
+
+void ODbaseTable::construct()
+{
+    // initialize the header
+    m_aHeader.type = dBaseIII;
+    m_aHeader.nbRecords = 0;
+    m_aHeader.headerLength = 0;
+    m_aHeader.recordLength = 0;
+    m_aMemoHeader.db_size = 0;
+
+    OUString sFileName(getEntry(m_pConnection, m_Name));
+
+    INetURLObject aURL;
+    aURL.SetURL(sFileName);
+
+    OSL_ENSURE( m_pConnection->matchesExtension( aURL.getExtension() ),
+        "ODbaseTable::ODbaseTable: invalid extension!");
+        // getEntry is expected to ensure the correct file name
+
+    m_pFileStream = createStream_simpleError( sFileName, StreamMode::READWRITE | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
+    m_bWriteable = ( m_pFileStream != nullptr );
+
+    if ( !m_pFileStream )
+    {
+        m_bWriteable = false;
+        m_pFileStream = createStream_simpleError( sFileName, StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYNONE);
+    }
+
+    if (!m_pFileStream)
+        return;
+
+    readHeader();
+
+    std::size_t nFileSize = lcl_getFileSize(*m_pFileStream);
+
+    if (m_aHeader.headerLength > nFileSize)
+    {
+        SAL_WARN("connectivity.drivers", "Parsing error: " << nFileSize <<
+                 " max possible size, but " << m_aHeader.headerLength << " claimed, abandoning");
+        return;
+    }
+
+    if (m_aHeader.recordLength)
+    {
+        std::size_t nMaxPossibleRecords = (nFileSize - m_aHeader.headerLength) / m_aHeader.recordLength;
+        // #i83401# seems to be empty or someone wrote nonsense into the dbase
+        // file try and recover if m_aHeader.db_slng is sane
+        if (m_aHeader.nbRecords == 0)
+        {
+            SAL_WARN("connectivity.drivers", "Parsing warning: 0 records claimed, recovering");
+            m_aHeader.nbRecords = nMaxPossibleRecords;
+        }
+        else if (m_aHeader.nbRecords > nMaxPossibleRecords)
+        {
+            SAL_WARN("connectivity.drivers", "Parsing error: " << nMaxPossibleRecords <<
+                     " max possible records, but " << m_aHeader.nbRecords << " claimed, truncating");
+            m_aHeader.nbRecords = std::max(nMaxPossibleRecords, static_cast<size_t>(1));
+        }
+    }
+
+    if (HasMemoFields())
+    {
+    // Create Memo-Filename (.DBT):
+    // nyi: Ugly for Unix and Mac!
+
+        if ( m_aHeader.type == FoxProMemo || m_aHeader.type == VisualFoxPro || m_aHeader.type == VisualFoxProAuto) // foxpro uses another extension
+            aURL.SetExtension(u"fpt");
+        else
+            aURL.SetExtension(u"dbt");
+
+        // If the memo file isn't found, the data will be displayed anyhow.
+        // However, updates can't be done
+        // but the operation is executed
+        m_pMemoStream = createStream_simpleError( aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READWRITE | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
+        if ( !m_pMemoStream )
+        {
+            m_pMemoStream = createStream_simpleError( aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYNONE);
+        }
+        if (m_pMemoStream)
+            ReadMemoHeader();
+    }
+
+    fillColumns();
+    m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
+
+
+    // Buffersize dependent on the file size
+    m_pFileStream->SetBufferSize(nFileSize > 1000000 ? 32768 :
+                              nFileSize > 100000 ? 16384 :
+                              nFileSize > 10000 ? 4096 : 1024);
+
+    if (m_pMemoStream)
+    {
+        // set the buffer exactly to the length of a record
+        nFileSize = m_pMemoStream->TellEnd();
+        m_pMemoStream->Seek(STREAM_SEEK_TO_BEGIN);
+
+        // Buffersize dependent on the file size
+        m_pMemoStream->SetBufferSize(nFileSize > 1000000 ? 32768 :
+                                      nFileSize > 100000 ? 16384 :
+                                      nFileSize > 10000 ? 4096 :
+                                      m_aMemoHeader.db_size);
+    }
+
+    AllocBuffer();
+}
+
+void ODbaseTable::ReadMemoHeader()
+{
+    m_pMemoStream->SetEndian(SvStreamEndian::LITTLE);
+    m_pMemoStream->RefreshBuffer();         // make sure that the header information is actually read again
+    m_pMemoStream->Seek(0);
+
+    (*m_pMemoStream).ReadUInt32( m_aMemoHeader.db_next );
+    switch (m_aHeader.type)
+    {
+        case dBaseIIIMemo:  // dBase III: fixed block size
+        case dBaseIVMemo:
+            // sometimes dBase3 is attached to dBase4 memo
+            m_pMemoStream->Seek(20);
+            (*m_pMemoStream).ReadUInt16( m_aMemoHeader.db_size );
+            if (m_aMemoHeader.db_size > 1 && m_aMemoHeader.db_size != 512)  // 1 is also for dBase 3
+                m_aMemoHeader.db_typ  = MemodBaseIV;
+            else if (m_aMemoHeader.db_size == 512)
+            {
+                // There are files using size specification, though they are dBase-files
+                char sHeader[4];
+                m_pMemoStream->Seek(m_aMemoHeader.db_size);
+                m_pMemoStream->ReadBytes(sHeader, 4);
+
+                if ((m_pMemoStream->GetErrorCode() != ERRCODE_NONE) || static_cast<sal_uInt8>(sHeader[0]) != 0xFF || static_cast<sal_uInt8>(sHeader[1]) != 0xFF || static_cast<sal_uInt8>(sHeader[2]) != 0x08)
+                    m_aMemoHeader.db_typ  = MemodBaseIII;
+                else
+                    m_aMemoHeader.db_typ  = MemodBaseIV;
+            }
+            else
+            {
+                m_aMemoHeader.db_typ  = MemodBaseIII;
+                m_aMemoHeader.db_size = 512;
+            }
+            break;
+        case VisualFoxPro:
+        case VisualFoxProAuto:
+        case FoxProMemo:
+            m_aMemoHeader.db_typ    = MemoFoxPro;
+            m_pMemoStream->Seek(6);
+            m_pMemoStream->SetEndian(SvStreamEndian::BIG);
+            (*m_pMemoStream).ReadUInt16( m_aMemoHeader.db_size );
+            break;
+        default:
+            SAL_WARN( "connectivity.drivers", "ODbaseTable::ReadMemoHeader: unsupported memo type!" );
+            break;
+    }
+}
+
+OUString ODbaseTable::getEntry(file::OConnection const * _pConnection, std::u16string_view _sName )
+{
+    OUString sURL;
+    try
+    {
+        Reference< XResultSet > xDir = _pConnection->getDir()->getStaticResultSet();
+        Reference< XRow> xRow(xDir,UNO_QUERY);
+        OUString sName;
+        OUString sExt;
+        INetURLObject aURL;
+        xDir->beforeFirst();
+        while(xDir->next())
+        {
+            sName = xRow->getString(1);
+            aURL.SetSmartProtocol(INetProtocol::File);
+            OUString sUrl = _pConnection->getURL() + "/" + sName;
+            aURL.SetSmartURL( sUrl );
+
+            // cut the extension
+            sExt = aURL.getExtension();
+
+            // name and extension have to coincide
+            if ( _pConnection->matchesExtension( sExt ) )
+            {
+                sName = sName.replaceAt(sName.getLength() - (sExt.getLength() + 1), sExt.getLength() + 1, u"");
+                if ( sName == _sName )
+                {
+                    Reference< XContentAccess > xContentAccess( xDir, UNO_QUERY );
+                    sURL = xContentAccess->queryContentIdentifierString();
+                    break;
+                }
+            }
+        }
+        xDir->beforeFirst(); // move back to before first record
+    }
+    catch(const Exception&)
+    {
+        OSL_ASSERT(false);
+    }
+    return sURL;
+}
+
+void ODbaseTable::refreshColumns()
+{
+    ::osl::MutexGuard aGuard( m_aMutex );
+
+    ::std::vector< OUString> aVector;
+    aVector.reserve(m_aColumns->size());
+
+    for (auto const& column : *m_aColumns)
+        aVector.push_back(Reference< XNamed>(column,UNO_QUERY_THROW)->getName());
+
+    if(m_xColumns)
+        m_xColumns->reFill(aVector);
+    else
+        m_xColumns.reset(new ODbaseColumns(this,m_aMutex,aVector));
+}
+
+void ODbaseTable::refreshIndexes()
+{
+    ::std::vector< OUString> aVector;
+    if(m_pFileStream && (!m_xIndexes || m_xIndexes->getCount() == 0))
+    {
+        INetURLObject aURL;
+        aURL.SetURL(getEntry(m_pConnection,m_Name));
+
+        aURL.setExtension(u"inf");
+        Config aInfFile(aURL.getFSysPath(FSysStyle::Detect));
+        aInfFile.SetGroup(dBASE_III_GROUP);
+        sal_uInt16 nKeyCnt = aInfFile.GetKeyCount();
+        OString aKeyName;
+
+        for (sal_uInt16 nKey = 0; nKey < nKeyCnt; nKey++)
+        {
+            // References the key an index-file?
+            aKeyName = aInfFile.GetKeyName( nKey );
+            //...if yes, add the index list of the table
+            if (aKeyName.startsWith("NDX"))
+            {
+                OString aIndexName = aInfFile.ReadKey(aKeyName);
+                aURL.setName(OStringToOUString(aIndexName, m_eEncoding));
+                try
+                {
+                    Content aCnt(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
+                    if (aCnt.isDocument())
+                    {
+                        aVector.push_back(aURL.getBase());
+                    }
+                }
+                catch(const Exception&) // an exception is thrown when no file exists
+                {
+                }
+            }
+        }
+    }
+    if(m_xIndexes)
+        m_xIndexes->reFill(aVector);
+    else
+        m_xIndexes.reset(new ODbaseIndexes(this,m_aMutex,aVector));
+}
+
+
+void SAL_CALL ODbaseTable::disposing()
+{
+    OFileTable::disposing();
+    ::osl::MutexGuard aGuard(m_aMutex);
+    m_aColumns = nullptr;
+}
+
+Sequence< Type > SAL_CALL ODbaseTable::getTypes(  )
+{
+    Sequence< Type > aTypes = OTable_TYPEDEF::getTypes();
+    std::vector<Type> aOwnTypes;
+    aOwnTypes.reserve(aTypes.getLength());
+
+    const Type* pBegin = aTypes.getConstArray();
+    const Type* pEnd = pBegin + aTypes.getLength();
+    for(;pBegin != pEnd;++pBegin)
+    {
+        if(*pBegin != cppu::UnoType<XKeysSupplier>::get() &&
+           *pBegin != cppu::UnoType<XDataDescriptorFactory>::get())
+        {
+            aOwnTypes.push_back(*pBegin);
+        }
+    }
+    aOwnTypes.push_back(cppu::UnoType<css::lang::XUnoTunnel>::get());
+    return Sequence< Type >(aOwnTypes.data(), aOwnTypes.size());
+}
+
+
+Any SAL_CALL ODbaseTable::queryInterface( const Type & rType )
+{
+    if( rType == cppu::UnoType<XKeysSupplier>::get()||
+        rType == cppu::UnoType<XDataDescriptorFactory>::get())
+        return Any();
+
+    Any aRet = OTable_TYPEDEF::queryInterface(rType);
+    return aRet;
+}
+
+
+bool ODbaseTable::fetchRow(OValueRefRow& _rRow, const OSQLColumns & _rCols, bool bRetrieveData)
+{
+    if (!m_pBuffer)
+        return false;
+
+    // Read the data
+    bool bIsCurRecordDeleted = m_pBuffer[0] == '*';
+
+    // only read the bookmark
+
+    // Mark record as deleted
+    _rRow->setDeleted(bIsCurRecordDeleted);
+    *(*_rRow)[0] = m_nFilePos;
+
+    if (!bRetrieveData)
+        return true;
+
+    std::size_t nByteOffset = 1;
+    // Fields:
+    OSQLColumns::const_iterator aIter = _rCols.begin();
+    OSQLColumns::const_iterator aEnd  = _rCols.end();
+    const std::size_t nCount = _rRow->size();
+    for (std::size_t i = 1; aIter != aEnd && nByteOffset <= m_nBufferSize && i < nCount;++aIter, i++)
+    {
+        // Lengths depending on data type:
+        sal_Int32 nLen = m_aPrecisions[i-1];
+        sal_Int32 nType = m_aTypes[i-1];
+
+        switch(nType)
+        {
+            case DataType::INTEGER:
+            case DataType::DOUBLE:
+            case DataType::TIMESTAMP:
+            case DataType::DATE:
+            case DataType::BIT:
+            case DataType::LONGVARCHAR:
+            case DataType::LONGVARBINARY:
+                nLen = m_aRealFieldLengths[i-1];
+                break;
+            case DataType::DECIMAL:
+                nLen = SvDbaseConverter::ConvertPrecisionToDbase(nLen,m_aScales[i-1]);
+                break;  // the sign and the comma
+
+            case DataType::BINARY:
+            case DataType::OTHER:
+                nByteOffset += nLen;
+                continue;
+        }
+
+        // Is the variable bound?
+        if ( !(*_rRow)[i]->isBound() )
+        {
+            // No - next field.
+            nByteOffset += nLen;
+            OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
+            continue;
+        } // if ( !(_rRow->get())[i]->isBound() )
+        if ( ( nByteOffset + nLen) > m_nBufferSize )
+            break; // length doesn't match buffer size.
+
+        char *pData = reinterpret_cast<char *>(m_pBuffer.get() + nByteOffset);
+
+        if (nType == DataType::CHAR || nType == DataType::VARCHAR)
+        {
+            sal_Int32 nLastPos = -1;
+            for (sal_Int32 k = 0; k < nLen; ++k)
+            {
+                if (pData[k] != ' ')
+                    // Record last non-empty position.
+                    nLastPos = k;
+            }
+            if (nLastPos < 0)
+            {
+                // Empty string.  Skip it.
+                (*_rRow)[i]->setNull();
+            }
+            else
+            {
+                // Commit the string
+                *(*_rRow)[i] = OUString(pData, static_cast<sal_Int32>(nLastPos+1), m_eEncoding);
+            }
+        } // if (nType == DataType::CHAR || nType == DataType::VARCHAR)
+        else if ( DataType::TIMESTAMP == nType )
+        {
+            sal_Int32 nDate = 0,nTime = 0;
+            if (o3tl::make_unsigned(nLen) < 8)
+            {
+                SAL_WARN("connectivity.drivers", "short TIMESTAMP");
+                return false;
+            }
+            memcpy(&nDate, pData, 4);
+            memcpy(&nTime, pData + 4, 4);
+            if ( !nDate && !nTime )
+            {
+                (*_rRow)[i]->setNull();
+            }
+            else
+            {
+                css::util::DateTime aDateTime;
+                lcl_CalDate(nDate,nTime,aDateTime);
+                *(*_rRow)[i] = aDateTime;
+            }
+        }
+        else if ( DataType::INTEGER == nType )
+        {
+            sal_Int32 nValue = 0;
+            if (o3tl::make_unsigned(nLen) > sizeof(nValue))
+                return false;
+            memcpy(&nValue, pData, nLen);
+            *(*_rRow)[i] = nValue;
+        }
+        else if ( DataType::DOUBLE == nType )
+        {
+            double d = 0.0;
+            if (getBOOL((*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency is treated separately
+            {
+                sal_Int64 nValue = 0;
+                if (o3tl::make_unsigned(nLen) > sizeof(nValue))
+                    return false;
+                memcpy(&nValue, pData, nLen);
+
+                if ( m_aScales[i-1] )
+                    d = (nValue / pow(10.0,static_cast<int>(m_aScales[i-1])));
+                else
+                    d = static_cast<double>(nValue);
+            }
+            else
+            {
+                if (o3tl::make_unsigned(nLen) > sizeof(d))
+                    return false;
+                memcpy(&d, pData, nLen);
+            }
+
+            *(*_rRow)[i] = d;
+        }
+        else
+        {
+            sal_Int32 nPos1 = -1, nPos2 = -1;
+            // If the string contains Nul-characters, then convert them to blanks!
+            for (sal_Int32 k = 0; k < nLen; k++)
+            {
+                if (pData[k] == '\0')
+                    pData[k] = ' ';
+
+                if (pData[k] != ' ')
+                {
+                    if (nPos1 < 0)
+                        // first non-empty char position.
+                        nPos1 = k;
+
+                    // last non-empty char position.
+                    nPos2 = k;
+                }
+            }
+
+            if (nPos1 < 0)
+            {
+                // Empty string.  Skip it.
+                nByteOffset += nLen;
+                (*_rRow)[i]->setNull();   // no values -> done
+                continue;
+            }
+
+            OUString aStr(pData+nPos1, nPos2-nPos1+1, m_eEncoding);
+
+            switch (nType)
+            {
+                case DataType::DATE:
+                {
+                    if (nLen < 8 || aStr.getLength() != nLen)
+                    {
+                        (*_rRow)[i]->setNull();
+                        break;
+                    }
+                    const sal_uInt16  nYear   = static_cast<sal_uInt16>(o3tl::toInt32(aStr.subView( 0, 4 )));
+                    const sal_uInt16  nMonth  = static_cast<sal_uInt16>(o3tl::toInt32(aStr.subView( 4, 2 )));
+                    const sal_uInt16  nDay    = static_cast<sal_uInt16>(o3tl::toInt32(aStr.subView( 6, 2 )));
+
+                    const css::util::Date aDate(nDay,nMonth,nYear);
+                    *(*_rRow)[i] = aDate;
+                }
+                break;
+                case DataType::DECIMAL:
+                    *(*_rRow)[i] = ORowSetValue(aStr);
+                break;
+                case DataType::BIT:
+                {
+                    bool b;
+                    switch (*pData)
+                    {
+                        case 'T':
+                        case 'Y':
+                        case 'J':   b = true; break;
+                        default:    b = false; break;
+                    }
+                    *(*_rRow)[i] = b;
+                }
+                break;
+                case DataType::LONGVARBINARY:
+                case DataType::BINARY:
+                case DataType::LONGVARCHAR:
+                {
+                    const tools::Long nBlockNo = aStr.toInt32();   // read blocknumber
+                    if (nBlockNo > 0 && m_pMemoStream) // Read data from memo-file, only if
+                    {
+                        if ( !ReadMemo(nBlockNo, (*_rRow)[i]->get()) )
+                            break;
+                    }
+                    else
+                        (*_rRow)[i]->setNull();
+                }   break;
+                default:
+                    SAL_WARN( "connectivity.drivers","Wrong type");
+            }
+            (*_rRow)[i]->setTypeKind(nType);
+        }
+
+        nByteOffset += nLen;
+        OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
+    }
+    return true;
+}
+
+
+void ODbaseTable::FileClose()
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    m_pMemoStream.reset();
+
+    ODbaseTable_BASE::FileClose();
+}
+
+bool ODbaseTable::CreateImpl()
+{
+    OSL_ENSURE(!m_pFileStream, "SequenceError");
+
+    if ( m_pConnection->isCheckEnabled() && ::dbtools::convertName2SQLName(m_Name, u"") != m_Name )
+    {
+        const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                STR_SQL_NAME_ERROR,
+                "$name$", m_Name
+             ) );
+        ::dbtools::throwGenericSQLException( sError, *this );
+    }
+
+    INetURLObject aURL;
+    aURL.SetSmartProtocol(INetProtocol::File);
+    OUString aName = getEntry(m_pConnection, m_Name);
+    if(aName.isEmpty())
+    {
+        OUString aIdent = m_pConnection->getContent()->getIdentifier()->getContentIdentifier();
+        if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
+            aIdent += "/";
+        aIdent += m_Name;
+        aName = aIdent;
+    }
+    aURL.SetURL(aName);
+
+    if ( !m_pConnection->matchesExtension( aURL.getExtension() ) )
+        aURL.setExtension(m_pConnection->getExtension());
+
+    try
+    {
+        Content aContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
+        if (aContent.isDocument())
+        {
+            // Only if the file exists with length > 0 raise an error
+            std::unique_ptr<SvStream> pFileStream(createStream_simpleError( aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READ));
+
+            if (pFileStream && pFileStream->TellEnd())
+                return false;
+        }
+    }
+    catch(const Exception&) // an exception is thrown when no file exists
+    {
+    }
+
+    bool bMemoFile = false;
+
+    bool bOk = CreateFile(aURL, bMemoFile);
+
+    FileClose();
+
+    if (!bOk)
+    {
+        try
+        {
+            Content aContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
+            aContent.executeCommand( "delete", css::uno::Any( true ) );
+        }
+        catch(const Exception&) // an exception is thrown when no file exists
+        {
+        }
+        return false;
+    }
+
+    if (bMemoFile)
+    {
+        OUString aExt = aURL.getExtension();
+        aURL.setExtension(u"dbt");                      // extension for memo file
+
+        bool bMemoAlreadyExists = false;
+        try
+        {
+            Content aMemo1Content(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
+            bMemoAlreadyExists = aMemo1Content.isDocument();
+        }
+        catch(const Exception&) // an exception is thrown when no file exists
+        {
+        }
+        if (bMemoAlreadyExists)
+        {
+            aURL.setExtension(aExt);      // kill dbf file
+            try
+            {
+                Content aMemoContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
+                aMemoContent.executeCommand( "delete", css::uno::Any( true ) );
+            }
+            catch(const Exception&)
+            {
+                css::uno::Any anyEx = cppu::getCaughtException();
+                const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                        STR_COULD_NOT_DELETE_FILE,
+                        "$name$", aName
+                     ) );
+                ::dbtools::throwGenericSQLException( sError, *this, anyEx );
+            }
+        }
+        if (!CreateMemoFile(aURL))
+        {
+            aURL.setExtension(aExt);      // kill dbf file
+            try
+            {
+                Content aMemoContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
+                aMemoContent.executeCommand( "delete", css::uno::Any( true ) );
+            }
+            catch(const ContentCreationException&)
+            {
+                css::uno::Any anyEx = cppu::getCaughtException();
+                const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                        STR_COULD_NOT_DELETE_FILE,
+                        "$name$", aName
+                     ) );
+                ::dbtools::throwGenericSQLException( sError, *this, anyEx );
+            }
+            return false;
+        }
+        m_aHeader.type = dBaseIIIMemo;
+    }
+    else
+        m_aHeader.type = dBaseIII;
+
+    return true;
+}
+
+void ODbaseTable::throwInvalidColumnType(TranslateId pErrorId, const OUString& _sColumnName)
+{
+    try
+    {
+        // we have to drop the file because it is corrupted now
+        DropImpl();
+    }
+    catch(const Exception&)
+    {
+    }
+
+    const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+            pErrorId,
+            "$columnname$", _sColumnName
+         ) );
+    ::dbtools::throwGenericSQLException( sError, *this );
+}
+
+// creates in principle dBase IV file format
+bool ODbaseTable::CreateFile(const INetURLObject& aFile, bool& bCreateMemo)
+{
+    bCreateMemo = false;
+    Date aDate( Date::SYSTEM );                     // current date
+
+    m_pFileStream = createStream_simpleError( aFile.GetMainURL(INetURLObject::DecodeMechanism::NONE),StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE | StreamMode::TRUNC );
+
+    if (!m_pFileStream)
+        return false;
+
+    sal_uInt8 nDbaseType = dBaseIII;
+    Reference<XIndexAccess> xColumns(getColumns(),UNO_QUERY);
+    Reference<XPropertySet> xCol;
+    const OUString sPropType = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE);
+
+    try
+    {
+        const sal_Int32 nCount = xColumns->getCount();
+        for(sal_Int32 i=0;i<nCount;++i)
+        {
+            xColumns->getByIndex(i) >>= xCol;
+            OSL_ENSURE(xCol.is(),"This should be a column!");
+
+            switch (getINT32(xCol->getPropertyValue(sPropType)))
+            {
+                case DataType::DOUBLE:
+                case DataType::INTEGER:
+                case DataType::TIMESTAMP:
+                case DataType::LONGVARBINARY:
+                    nDbaseType = VisualFoxPro;
+                    i = nCount; // no more columns need to be checked
+                    break;
+            } // switch (getINT32(xCol->getPropertyValue(sPropType)))
+        }
+    }
+    catch ( const Exception& )
+    {
+        try
+        {
+            // we have to drop the file because it is corrupted now
+            DropImpl();
+        }
+        catch(const Exception&) { }
+        throw;
+    }
+
+    char aBuffer[21] = {}; // write buffer
+
+    m_pFileStream->Seek(0);
+    (*m_pFileStream).WriteUChar( nDbaseType );                            // dBase format
+    (*m_pFileStream).WriteUChar( aDate.GetYearUnsigned() % 100 );         // current date
+
+
+    (*m_pFileStream).WriteUChar( aDate.GetMonth() );
+    (*m_pFileStream).WriteUChar( aDate.GetDay() );
+    (*m_pFileStream).WriteUInt32( 0 );                                    // number of data records
+    (*m_pFileStream).WriteUInt16( (m_xColumns->getCount()+1) * 32 + 1 );  // header information,
+                                                                          // pColumns contains always an additional column
+    (*m_pFileStream).WriteUInt16( 0 );                                     // record length will be determined later
+    m_pFileStream->WriteBytes(aBuffer, 20);
+
+    sal_uInt16 nRecLength = 1;                                              // Length 1 for deleted flag
+    sal_Int32  nMaxFieldLength = m_pConnection->getMetaData()->getMaxColumnNameLength();
+    OUString aName;
+    const OUString sPropName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
+    const OUString sPropPrec = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION);
+    const OUString sPropScale = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE);
+
+    try
+    {
+        const sal_Int32 nCount = xColumns->getCount();
+        for(sal_Int32 i=0;i<nCount;++i)
+        {
+            xColumns->getByIndex(i) >>= xCol;
+            OSL_ENSURE(xCol.is(),"This should be a column!");
+
+            char cTyp( 'C' );
+
+            xCol->getPropertyValue(sPropName) >>= aName;
+
+            OString aCol;
+            if ( DBTypeConversion::convertUnicodeString( aName, aCol, m_eEncoding ) > nMaxFieldLength)
+            {
+                throwInvalidColumnType( STR_INVALID_COLUMN_NAME_LENGTH, aName );
+            }
+
+            m_pFileStream->WriteOString( aCol );
+            m_pFileStream->WriteBytes(aBuffer, 11 - aCol.getLength());
+
+            sal_Int32 nPrecision = 0;
+            xCol->getPropertyValue(sPropPrec) >>= nPrecision;
+            sal_Int32 nScale = 0;
+            xCol->getPropertyValue(sPropScale) >>= nScale;
+
+            bool bBinary = false;
+
+            switch (getINT32(xCol->getPropertyValue(sPropType)))
+            {
+                case DataType::CHAR:
+                case DataType::VARCHAR:
+                    cTyp = 'C';
+                    break;
+                case DataType::DOUBLE:
+                    if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency will be treated separately
+                        cTyp = 'Y';
+                    else
+                        cTyp = 'B';
+                    break;
+                case DataType::INTEGER:
+                    cTyp = 'I';
+                    break;
+                case DataType::TINYINT:
+                case DataType::SMALLINT:
+                case DataType::BIGINT:
+                case DataType::DECIMAL:
+                case DataType::NUMERIC:
+                case DataType::REAL:
+                    cTyp = 'N';                             // only dBase 3 format
+                    break;
+                case DataType::TIMESTAMP:
+                    cTyp = 'T';
+                    break;
+                case DataType::DATE:
+                    cTyp = 'D';
+                    break;
+                case DataType::BIT:
+                    cTyp = 'L';
+                    break;
+                case DataType::LONGVARBINARY:
+                    bBinary = true;
+                    [[fallthrough]];
+                case DataType::LONGVARCHAR:
+                    cTyp = 'M';
+                    break;
+                default:
+                    {
+                        throwInvalidColumnType(STR_INVALID_COLUMN_TYPE, aName);
+                    }
+            }
+
+            (*m_pFileStream).WriteChar( cTyp );
+            if ( nDbaseType == VisualFoxPro )
+                (*m_pFileStream).WriteUInt32( nRecLength-1 );
+            else
+                m_pFileStream->WriteBytes(aBuffer, 4);
+
+            switch(cTyp)
+            {
+                case 'C':
+                    OSL_ENSURE(nPrecision < 255, "ODbaseTable::Create: Column too long!");
+                    if (nPrecision > 254)
+                    {
+                        throwInvalidColumnType(STR_INVALID_COLUMN_PRECISION, aName);
+                    }
+                    (*m_pFileStream).WriteUChar( std::min(static_cast<unsigned>(nPrecision), 255U) );      // field length
+                    nRecLength = nRecLength + static_cast<sal_uInt16>(std::min(static_cast<sal_uInt16>(nPrecision), sal_uInt16(255UL)));
+                    (*m_pFileStream).WriteUChar( 0 );                                                                // decimals
+                    break;
+                case 'F':
+                case 'N':
+                    OSL_ENSURE(nPrecision >=  nScale,
+                            "ODbaseTable::Create: Field length must be larger than decimal places!");
+                    if (nPrecision <  nScale)
+                    {
+                        throwInvalidColumnType(STR_INVALID_PRECISION_SCALE, aName);
+                    }
+                    if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency will be treated separately
+                    {
+                        (*m_pFileStream).WriteUChar( 10 );          // standard length
+                        (*m_pFileStream).WriteUChar( 4 );
+                        nRecLength += 10;
+                    }
+                    else
+                    {
+                        sal_Int32 nPrec = SvDbaseConverter::ConvertPrecisionToDbase(nPrecision,nScale);
+
+                        (*m_pFileStream).WriteUChar( nPrec );
+                        (*m_pFileStream).WriteUChar( nScale );
+                        nRecLength += static_cast<sal_uInt16>(nPrec);
+                    }
+                    break;
+                case 'L':
+                    (*m_pFileStream).WriteUChar( 1 );
+                    (*m_pFileStream).WriteUChar( 0 );
+                    ++nRecLength;
+                    break;
+                case 'I':
+                    (*m_pFileStream).WriteUChar( 4 );
+                    (*m_pFileStream).WriteUChar( 0 );
+                    nRecLength += 4;
+                    break;
+                case 'Y':
+                case 'B':
+                case 'T':
+                case 'D':
+                    (*m_pFileStream).WriteUChar( 8 );
+                    (*m_pFileStream).WriteUChar( 0 );
+                    nRecLength += 8;
+                    break;
+                case 'M':
+                    bCreateMemo = true;
+                    (*m_pFileStream).WriteUChar( 10 );
+                    (*m_pFileStream).WriteUChar( 0 );
+                    nRecLength += 10;
+                    if ( bBinary )
+                        aBuffer[0] = 0x06;
+                    break;
+                default:
+                    throwInvalidColumnType(STR_INVALID_COLUMN_TYPE, aName);
+            }
+            m_pFileStream->WriteBytes(aBuffer, 14);
+            aBuffer[0] = 0x00;
+        }
+
+        (*m_pFileStream).WriteUChar( FIELD_DESCRIPTOR_TERMINATOR );              // end of header
+        (*m_pFileStream).WriteChar( char(DBF_EOL) );
+        m_pFileStream->Seek(10);
+        (*m_pFileStream).WriteUInt16( nRecLength );                                     // set record length afterwards
+
+        if (bCreateMemo)
+        {
+            m_pFileStream->Seek(0);
+            if (nDbaseType == VisualFoxPro)
+                (*m_pFileStream).WriteUChar( FoxProMemo );
+            else
+                (*m_pFileStream).WriteUChar( dBaseIIIMemo );
+        } // if (bCreateMemo)
+    }
+    catch ( const Exception& )
+    {
+        try
+        {
+            // we have to drop the file because it is corrupted now
+            DropImpl();
+        }
+        catch(const Exception&) { }
+        throw;
+    }
+    return true;
+}
+
+bool ODbaseTable::HasMemoFields() const
+{
+    return m_aHeader.type > dBaseIV && !utl::ConfigManager::IsFuzzing();
+}
+
+// creates in principle dBase III file format
+bool ODbaseTable::CreateMemoFile(const INetURLObject& aFile)
+{
+    // filehandling macro for table creation
+    m_pMemoStream = createStream_simpleError( aFile.GetMainURL(INetURLObject::DecodeMechanism::NONE),StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE);
+
+    if (!m_pMemoStream)
+        return false;
+
+    m_pMemoStream->SetStreamSize(512);
+
+    m_pMemoStream->Seek(0);
+    (*m_pMemoStream).WriteUInt32( 1 );                  // pointer to the first free block
+
+    m_pMemoStream.reset();
+    return true;
+}
+
+bool ODbaseTable::Drop_Static(std::u16string_view _sUrl, bool _bHasMemoFields, OCollection* _pIndexes )
+{
+    INetURLObject aURL;
+    aURL.SetURL(_sUrl);
+
+    bool bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE));
+
+    if(bDropped)
+    {
+        if (_bHasMemoFields)
+        {  // delete the memo fields
+            aURL.setExtension(u"dbt");
+            bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE));
+        }
+
+        if(bDropped)
+        {
+            if(_pIndexes)
+            {
+                try
+                {
+                    sal_Int32 i = _pIndexes->getCount();
+                    while (i)
+                    {
+                        _pIndexes->dropByIndex(--i);
+                    }
+                }
+                catch(const SQLException&)
+                {
+                }
+            }
+            aURL.setExtension(u"inf");
+
+            // as the inf file does not necessarily exist, we aren't allowed to use UCBContentHelper::Kill
+            try
+            {
+                ::ucbhelper::Content aDeleteContent( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), Reference< XCommandEnvironment >(), comphelper::getProcessComponentContext() );
+                aDeleteContent.executeCommand( "delete", Any( true ) );
+            }
+            catch(const Exception&)
+            {
+                // silently ignore this...
+            }
+        }
+    }
+    return bDropped;
+}
+
+bool ODbaseTable::DropImpl()
+{
+    FileClose();
+
+    if(!m_xIndexes)
+        refreshIndexes(); // look for indexes which must be deleted as well
+
+    bool bDropped = Drop_Static(getEntry(m_pConnection,m_Name),HasMemoFields(),m_xIndexes.get());
+    if(!bDropped)
+    {// we couldn't drop the table so we have to reopen it
+        construct();
+        if(m_xColumns)
+            m_xColumns->refresh();
+    }
+    return bDropped;
+}
+
+
+bool ODbaseTable::InsertRow(OValueRefVector& rRow, const Reference<XIndexAccess>& _xCols)
+{
+    // fill buffer with blanks
+    if (!AllocBuffer())
+        return false;
+
+    memset(m_pBuffer.get(), 0, m_aHeader.recordLength);
+    m_pBuffer[0] = ' ';
+
+    // Copy new row completely:
+    // ... and add at the end as new Record:
+    std::size_t nTempPos = m_nFilePos;
+
+    m_nFilePos = static_cast<std::size_t>(m_aHeader.nbRecords) + 1;
+    bool bInsertRow = UpdateBuffer( rRow, nullptr, _xCols, true );
+    if ( bInsertRow )
+    {
+        std::size_t nFileSize = 0, nMemoFileSize = 0;
+
+        nFileSize = lcl_getFileSize(*m_pFileStream);
+
+        if (HasMemoFields() && m_pMemoStream)
+        {
+            m_pMemoStream->Seek(STREAM_SEEK_TO_END);
+            nMemoFileSize = m_pMemoStream->Tell();
+        }
+
+        if (!WriteBuffer())
+        {
+            m_pFileStream->SetStreamSize(nFileSize);                // restore old size
+
+            if (HasMemoFields() && m_pMemoStream)
+                m_pMemoStream->SetStreamSize(nMemoFileSize);    // restore old size
+            m_nFilePos = nTempPos;              // restore file position
+        }
+        else
+        {
+            (*m_pFileStream).WriteChar( char(DBF_EOL) ); // write EOL
+            // raise number of datasets in the header:
+            m_pFileStream->Seek( 4 );
+            (*m_pFileStream).WriteUInt32( m_aHeader.nbRecords + 1 );
+
+            m_pFileStream->Flush();
+
+            // raise number if successfully
+            m_aHeader.nbRecords++;
+            *rRow[0] = m_nFilePos;                                // set bookmark
+            m_nFilePos = nTempPos;
+        }
+    }
+    else
+        m_nFilePos = nTempPos;
+
+    return bInsertRow;
+}
+
+
+bool ODbaseTable::UpdateRow(OValueRefVector& rRow, OValueRefRow& pOrgRow, const Reference<XIndexAccess>& _xCols)
+{
+    // fill buffer with blanks
+    if (!AllocBuffer())
+        return false;
+
+    // position on desired record:
+    std::size_t nPos = m_aHeader.headerLength + static_cast<tools::Long>(m_nFilePos-1) * m_aHeader.recordLength;
+    m_pFileStream->Seek(nPos);
+    m_pFileStream->ReadBytes(m_pBuffer.get(), m_aHeader.recordLength);
+
+    std::size_t nMemoFileSize( 0 );
+    if (HasMemoFields() && m_pMemoStream)
+    {
+        m_pMemoStream->Seek(STREAM_SEEK_TO_END);
+        nMemoFileSize = m_pMemoStream->Tell();
+    }
+    if (!UpdateBuffer(rRow, pOrgRow, _xCols, false) || !WriteBuffer())
+    {
+        if (HasMemoFields() && m_pMemoStream)
+            m_pMemoStream->SetStreamSize(nMemoFileSize);    // restore old size
+    }
+    else
+    {
+        m_pFileStream->Flush();
+    }
+    return true;
+}
+
+
+bool ODbaseTable::DeleteRow(const OSQLColumns& _rCols)
+{
+    // Set the Delete-Flag (be it set or not):
+    // Position on desired record:
+    std::size_t nFilePos = m_aHeader.headerLength + static_cast<tools::Long>(m_nFilePos-1) * m_aHeader.recordLength;
+    m_pFileStream->Seek(nFilePos);
+
+    OValueRefRow aRow = new OValueRefVector(_rCols.size());
+
+    if (!fetchRow(aRow,_rCols,true))
+        return false;
+
+    Reference<XPropertySet> xCol;
+    OUString aColName;
+    ::comphelper::UStringMixEqual aCase(isCaseSensitive());
+    for (sal_Int32 i = 0; i < m_xColumns->getCount(); i++)
+    {
+        Reference<XPropertySet> xIndex = isUniqueByColumnName(i);
+        if (xIndex.is())
+        {
+            xCol.set(m_xColumns->getByIndex(i), css::uno::UNO_QUERY);
+            OSL_ENSURE(xCol.is(),"ODbaseTable::DeleteRow column is null!");
+            if(xCol.is())
+            {
+                xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
+
+                ODbaseIndex* pIndex = dynamic_cast<ODbaseIndex*>(xIndex.get());
+                assert(pIndex && "ODbaseTable::DeleteRow: No Index returned!");
+
+                OSQLColumns::const_iterator aIter = std::find_if(_rCols.begin(), _rCols.end(),
+                    [&aCase, &aColName](const OSQLColumns::value_type& rxCol) {
+                        return aCase(getString(rxCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME))), aColName); });
+                if (aIter == _rCols.end())
+                    continue;
+
+                auto nPos = static_cast<sal_Int32>(std::distance(_rCols.begin(), aIter)) + 1;
+                pIndex->Delete(m_nFilePos,*(*aRow)[nPos]);
+            }
+        }
+    }
+
+    m_pFileStream->Seek(nFilePos);
+    (*m_pFileStream).WriteUChar( '*' ); // mark the row in the table as deleted
+    m_pFileStream->Flush();
+    return true;
+}
+
+Reference<XPropertySet> ODbaseTable::isUniqueByColumnName(sal_Int32 _nColumnPos)
+{
+    if(!m_xIndexes)
+        refreshIndexes();
+    if(m_xIndexes->hasElements())
+    {
+        Reference<XPropertySet> xCol;
+        m_xColumns->getByIndex(_nColumnPos) >>= xCol;
+        OSL_ENSURE(xCol.is(),"ODbaseTable::isUniqueByColumnName column is null!");
+        OUString sColName;
+        xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sColName;
+
+        Reference<XPropertySet> xIndex;
+        for(sal_Int32 i=0;i<m_xIndexes->getCount();++i)
+        {
+            xIndex.set(m_xIndexes->getByIndex(i), css::uno::UNO_QUERY);
+            if(xIndex.is() && getBOOL(xIndex->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISUNIQUE))))
+            {
+                Reference<XNameAccess> xCols(Reference<XColumnsSupplier>(xIndex,UNO_QUERY_THROW)->getColumns());
+                if(xCols->hasByName(sColName))
+                    return xIndex;
+
+            }
+        }
+    }
+    return Reference<XPropertySet>();
+}
+
+static double toDouble(std::string_view rString)
+{
+    return ::rtl::math::stringToDouble( rString, '.', ',' );
+}
+
+
+bool ODbaseTable::UpdateBuffer(OValueRefVector& rRow, const OValueRefRow& pOrgRow, const Reference<XIndexAccess>& _xCols, const bool bForceAllFields)
+{
+    OSL_ENSURE(m_pBuffer,"Buffer is NULL!");
+    if ( !m_pBuffer )
+        return false;
+    sal_Int32 nByteOffset  = 1;
+
+    // Update fields:
+    Reference<XPropertySet> xCol;
+    Reference<XPropertySet> xIndex;
+    OUString aColName;
+    const sal_Int32 nColumnCount = m_xColumns->getCount();
+    std::vector< Reference<XPropertySet> > aIndexedCols(nColumnCount);
+
+    ::comphelper::UStringMixEqual aCase(isCaseSensitive());
+
+    Reference<XIndexAccess> xColumns(m_xColumns.get());
+    // first search a key that exist already in the table
+    for (sal_Int32 i = 0; i < nColumnCount; ++i)
+    {
+        sal_Int32 nPos = i;
+        if(_xCols != xColumns)
+        {
+            m_xColumns->getByIndex(i) >>= xCol;
+            OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
+            xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
+
+            for(nPos = 0;nPos<_xCols->getCount();++nPos)
+            {
+                Reference<XPropertySet> xFindCol(
+                    _xCols->getByIndex(nPos), css::uno::UNO_QUERY);
+                OSL_ENSURE(xFindCol.is(),"ODbaseTable::UpdateBuffer column is null!");
+                if(aCase(getString(xFindCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))),aColName))
+                    break;
+            }
+            if (nPos >= _xCols->getCount())
+                continue;
+        }
+
+        ++nPos;
+        xIndex = isUniqueByColumnName(i);
+        aIndexedCols[i] = xIndex;
+        if (xIndex.is())
+        {
+            // first check if the value is different to the old one and when if it conform to the index
+            if(pOrgRow.is() && (rRow[nPos]->getValue().isNull() || rRow[nPos] == (*pOrgRow)[nPos]))
+                continue;
+            else
+            {
+                ODbaseIndex* pIndex = dynamic_cast<ODbaseIndex*>(xIndex.get());
+                assert(pIndex && "ODbaseTable::UpdateBuffer: No Index returned!");
+
+                if (pIndex->Find(0,*rRow[nPos]))
+                {
+                    // There is no unique value
+                    if ( aColName.isEmpty() )
+                    {
+                        m_xColumns->getByIndex(i) >>= xCol;
+                        OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
+                        xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
+                        xCol.clear();
+                    } // if ( !aColName.getLength() )
+                    const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                            STR_DUPLICATE_VALUE_IN_COLUMN
+                            ,"$columnname$", aColName
+                         ) );
+                    ::dbtools::throwGenericSQLException( sError, *this );
+                }
+            }
+        }
+    }
+
+    // when we are here there is no double key in the table
+
+    for (sal_Int32 i = 0; i < nColumnCount && nByteOffset <= m_nBufferSize ; ++i)
+    {
+        // Lengths for each data type:
+        assert(i >= 0);
+        OSL_ENSURE(o3tl::make_unsigned(i) < m_aPrecisions.size(),"Illegal index!");
+        sal_Int32 nLen = 0;
+        sal_Int32 nType = 0;
+        sal_Int32 nScale = 0;
+        if ( o3tl::make_unsigned(i) < m_aPrecisions.size() )
+        {
+            nLen    = m_aPrecisions[i];
+            nType   = m_aTypes[i];
+            nScale  = m_aScales[i];
+        }
+        else
+        {
+            m_xColumns->getByIndex(i) >>= xCol;
+            if ( xCol.is() )
+            {
+                xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)) >>= nLen;
+                xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))      >>= nType;
+                xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))     >>= nScale;
+            }
+        }
+
+        bool bSetZero = false;
+        switch (nType)
+        {
+            case DataType::INTEGER:
+            case DataType::DOUBLE:
+            case DataType::TIMESTAMP:
+                bSetZero = true;
+                [[fallthrough]];
+            case DataType::LONGVARBINARY:
+            case DataType::DATE:
+            case DataType::BIT:
+            case DataType::LONGVARCHAR:
+                nLen = m_aRealFieldLengths[i];
+                break;
+            case DataType::DECIMAL:
+                nLen = SvDbaseConverter::ConvertPrecisionToDbase(nLen,nScale);
+                break;  // The sign and the comma
+            default:
+                break;
+
+        } // switch (nType)
+
+        sal_Int32 nPos = i;
+        if(_xCols != xColumns)
+        {
+            m_xColumns->getByIndex(i) >>= xCol;
+            OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
+            xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
+            for(nPos = 0;nPos<_xCols->getCount();++nPos)
+            {
+                Reference<XPropertySet> xFindCol(
+                    _xCols->getByIndex(nPos), css::uno::UNO_QUERY);
+                if(aCase(getString(xFindCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))),aColName))
+                    break;
+            }
+            if (nPos >= _xCols->getCount())
+            {
+                nByteOffset += nLen;
+                continue;
+            }
+        }
+
+
+        ++nPos; // the row values start at 1
+        const ORowSetValue &thisColVal = rRow[nPos]->get();
+        const bool thisColIsBound = thisColVal.isBound();
+        const bool thisColIsNull = !thisColIsBound || thisColVal.isNull();
+        // don't overwrite non-bound columns
+        if ( ! (bForceAllFields || thisColIsBound) )
+        {
+            // No - don't overwrite this field, it has not changed.
+            nByteOffset += nLen;
+            continue;
+        }
+        if (aIndexedCols[i].is())
+        {
+            ODbaseIndex* pIndex = dynamic_cast<ODbaseIndex*>(aIndexedCols[i].get());
+            assert(pIndex && "ODbaseTable::UpdateBuffer: No Index returned!");
+            // Update !!
+            if (pOrgRow.is() && !thisColIsNull)
+                pIndex->Update(m_nFilePos, *(*pOrgRow)[nPos], thisColVal);
+            else
+                pIndex->Insert(m_nFilePos, thisColVal);
+        }
+
+        char* pData = reinterpret_cast<char *>(m_pBuffer.get() + nByteOffset);
+        if (thisColIsNull)
+        {
+            if ( bSetZero )
+                memset(pData,0,nLen);   // Clear to NULL char ('\0')
+            else
+                memset(pData,' ',nLen); // Clear to space/blank ('\0x20')
+            nByteOffset += nLen;
+            OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
+            continue;
+        }
+
+        try
+        {
+            switch (nType)
+            {
+                case DataType::TIMESTAMP:
+                    {
+                        sal_Int32 nJulianDate = 0, nJulianTime = 0;
+                        lcl_CalcJulDate(nJulianDate,nJulianTime, thisColVal.getDateTime());
+                        // Exactly 8 bytes to copy:
+                        memcpy(pData,&nJulianDate,4);
+                        memcpy(pData+4,&nJulianTime,4);
+                    }
+                    break;
+                case DataType::DATE:
+                {
+                    css::util::Date aDate;
+                    if(thisColVal.getTypeKind() == DataType::DOUBLE)
+                        aDate = ::dbtools::DBTypeConversion::toDate(thisColVal.getDouble());
+                    else
+                        aDate = thisColVal.getDate();
+                    char s[sizeof("-327686553565535")];
+                        // reserve enough space for hypothetical max length
+                    snprintf(s,
+                        sizeof(s),
+                        "%04" SAL_PRIdINT32 "%02" SAL_PRIuUINT32 "%02" SAL_PRIuUINT32,
+                        static_cast<sal_Int32>(aDate.Year),
+                        static_cast<sal_uInt32>(aDate.Month),
+                        static_cast<sal_uInt32>(aDate.Day));
+
+                    // Exactly 8 bytes to copy (even if s could hypothetically be longer):
+                    memcpy(pData,s,8);
+                } break;
+                case DataType::INTEGER:
+                    {
+                        sal_Int32 nValue = thisColVal.getInt32();
+                        if (o3tl::make_unsigned(nLen) > sizeof(nValue))
+                            return false;
+                        memcpy(pData,&nValue,nLen);
+                    }
+                    break;
+                case DataType::DOUBLE:
+                    {
+                        const double d = thisColVal.getDouble();
+                        m_xColumns->getByIndex(i) >>= xCol;
+
+                        if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency is treated separately
+                        {
+                            sal_Int64 nValue = 0;
+                            if ( m_aScales[i] )
+                                nValue = static_cast<sal_Int64>(d * pow(10.0,static_cast<int>(m_aScales[i])));
+                            else
+                                nValue = static_cast<sal_Int64>(d);
+                            if (o3tl::make_unsigned(nLen) > sizeof(nValue))
+                                return false;
+                            memcpy(pData,&nValue,nLen);
+                        } // if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency is treated separately
+                        else
+                        {
+                            if (o3tl::make_unsigned(nLen) > sizeof(d))
+                                return false;
+                            memcpy(pData,&d,nLen);
+                        }
+                    }
+                    break;
+                case DataType::DECIMAL:
+                {
+                    memset(pData,' ',nLen); // Clear to NULL
+
+                    const double n = thisColVal.getDouble();
+
+                    // one, because const_cast GetFormatPrecision on SvNumberFormat is not constant,
+                    // even though it really could and should be
+                    const OString aDefaultValue( ::rtl::math::doubleToString( n, rtl_math_StringFormat_F, nScale, '.', nullptr, 0));
+                    const sal_Int32 nValueLen = aDefaultValue.getLength();
+                    if ( nValueLen <= nLen )
+                    {
+                        // Write value right-justified, padded with blanks to the left.
+                        memcpy(pData+nLen-nValueLen,aDefaultValue.getStr(),nValueLen);
+                        // write the resulting double back
+                        *rRow[nPos] = toDouble(aDefaultValue);
+                    }
+                    else
+                    {
+                        m_xColumns->getByIndex(i) >>= xCol;
+                        OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
+                        xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
+                        std::vector< std::pair<const char* , OUString > > aStringToSubstitutes
+                        {
+                            { "$columnname$", aColName },
+                            { "$precision$", OUString::number(nLen) },
+                            { "$scale$", OUString::number(nScale) },
+                            { "$value$", OStringToOUString(aDefaultValue,RTL_TEXTENCODING_UTF8) }
+                        };
+
+                        const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                                STR_INVALID_COLUMN_DECIMAL_VALUE
+                                ,aStringToSubstitutes
+                             ) );
+                        ::dbtools::throwGenericSQLException( sError, *this );
+                    }
+                } break;
+                case DataType::BIT:
+                    *pData = thisColVal.getBool() ? 'T' : 'F';
+                    break;
+                case DataType::LONGVARBINARY:
+                case DataType::LONGVARCHAR:
+                {
+                    char cNext = pData[nLen]; // Mark's scratch and replaced by 0
+                    pData[nLen] = '\0';       // This is because the buffer is always a sign of greater ...
+
+                    std::size_t nBlockNo = strtol(pData,nullptr,10); // Block number read
+
+                    // Next initial character restore again:
+                    pData[nLen] = cNext;
+                    if (!m_pMemoStream)
+                        break;
+                    WriteMemo(thisColVal, nBlockNo);
+
+                    OString aBlock(OString::number(nBlockNo));
+                    //align aBlock at the right of a nLen sequence, fill to the left with '0'
+                    OStringBuffer aStr;
+                    comphelper::string::padToLength(aStr, nLen - aBlock.getLength(), '0');
+                    aStr.append(aBlock);
+
+                    // Copy characters:
+                    memcpy(pData, aStr.getStr(), nLen);
+                }   break;
+                default:
+                {
+                    memset(pData,' ',nLen); // Clear to NULL
+
+                    OUString sStringToWrite( thisColVal.getString() );
+
+                    // convert the string, using the connection's encoding
+                    OString sEncoded;
+
+                    DBTypeConversion::convertUnicodeStringToLength( sStringToWrite, sEncoded, nLen, m_eEncoding );
+                    memcpy( pData, sEncoded.getStr(), sEncoded.getLength() );
+
+                }
+                break;
+            }
+        }
+        catch( const SQLException&  )
+        {
+            throw;
+        }
+        catch ( const Exception& )
+        {
+            m_xColumns->getByIndex(i) >>= xCol;
+            OSL_ENSURE( xCol.is(), "ODbaseTable::UpdateBuffer column is null!" );
+            if ( xCol.is() )
+                xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
+
+            const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                    STR_INVALID_COLUMN_VALUE,
+                    "$columnname$", aColName
+                 ) );
+            ::dbtools::throwGenericSQLException( sError, *this );
+        }
+        // And more ...
+        nByteOffset += nLen;
+        OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
+    }
+    return true;
+}
+
+
+void ODbaseTable::WriteMemo(const ORowSetValue& aVariable, std::size_t& rBlockNr)
+{
+    // if the BlockNo 0 is given, the block will be appended at the end
+    std::size_t nSize = 0;
+    OString aStr;
+    css::uno::Sequence<sal_Int8> aValue;
+    sal_uInt8 nHeader[4];
+    const bool bBinary = aVariable.getTypeKind() == DataType::LONGVARBINARY && m_aMemoHeader.db_typ == MemoFoxPro;
+    if ( bBinary )
+    {
+        aValue = aVariable.getSequence();
+        nSize = aValue.getLength();
+    }
+    else
+    {
+        nSize = DBTypeConversion::convertUnicodeString( aVariable.getString(), aStr, m_eEncoding );
+    }
+
+    // append or overwrite
+    bool bAppend = rBlockNr == 0;
+
+    if (!bAppend)
+    {
+        switch (m_aMemoHeader.db_typ)
+        {
+            case MemodBaseIII: // dBase III-Memofield, ends with 2 * Ctrl-Z
+                bAppend = nSize > (512 - 2);
+                break;
+            case MemoFoxPro:
+            case MemodBaseIV: // dBase IV-Memofield with length
+            {
+                char sHeader[4];
+                m_pMemoStream->Seek(rBlockNr * m_aMemoHeader.db_size);
+                m_pMemoStream->SeekRel(4);
+                m_pMemoStream->ReadBytes(sHeader, 4);
+
+                std::size_t nOldSize;
+                if (m_aMemoHeader.db_typ == MemoFoxPro)
+                    nOldSize = ((static_cast<unsigned char>(sHeader[0]) * 256 +
+                                 static_cast<unsigned char>(sHeader[1])) * 256 +
+                                 static_cast<unsigned char>(sHeader[2])) * 256 +
+                                 static_cast<unsigned char>(sHeader[3]);
+                else
+                    nOldSize = ((static_cast<unsigned char>(sHeader[3]) * 256 +
+                                 static_cast<unsigned char>(sHeader[2])) * 256 +
+                                 static_cast<unsigned char>(sHeader[1])) * 256 +
+                                 static_cast<unsigned char>(sHeader[0])  - 8;
+
+                // fits the new length in the used blocks
+                std::size_t nUsedBlocks = ((nSize + 8) / m_aMemoHeader.db_size) + (((nSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0),
+                      nOldUsedBlocks = ((nOldSize + 8) / m_aMemoHeader.db_size) + (((nOldSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0);
+                bAppend = nUsedBlocks > nOldUsedBlocks;
+            }
+        }
+    }
+
+    if (bAppend)
+    {
+        sal_uInt64 const nStreamSize = m_pMemoStream->TellEnd();
+        // fill last block
+        rBlockNr = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);
+
+        m_pMemoStream->SetStreamSize(rBlockNr * m_aMemoHeader.db_size);
+        m_pMemoStream->Seek(STREAM_SEEK_TO_END);
+    }
+    else
+    {
+        m_pMemoStream->Seek(rBlockNr * m_aMemoHeader.db_size);
+    }
+
+    switch (m_aMemoHeader.db_typ)
+    {
+        case MemodBaseIII: // dBase III-Memofield, ends with Ctrl-Z
+        {
+            const char cEOF = char(DBF_EOL);
+            nSize++;
+            m_pMemoStream->WriteBytes(aStr.getStr(), aStr.getLength());
+            m_pMemoStream->WriteChar( cEOF ).WriteChar( cEOF );
+        } break;
+        case MemoFoxPro:
+        case MemodBaseIV: // dBase IV-Memofield with length
+        {
+            if ( MemodBaseIV == m_aMemoHeader.db_typ )
+                (*m_pMemoStream).WriteUChar( 0xFF )
+                                .WriteUChar( 0xFF )
+                                .WriteUChar( 0x08 );
+            else
+                (*m_pMemoStream).WriteUChar( 0x00 )
+                                .WriteUChar( 0x00 )
+                                .WriteUChar( 0x00 );
+
+            sal_uInt32 nWriteSize = nSize;
+            if (m_aMemoHeader.db_typ == MemoFoxPro)
+            {
+                if ( bBinary )
+                    (*m_pMemoStream).WriteUChar( 0x00 ); // Picture
+                else
+                    (*m_pMemoStream).WriteUChar( 0x01 ); // Memo
+                for (int i = 4; i > 0; nWriteSize >>= 8)
+                    nHeader[--i] = static_cast<sal_uInt8>(nWriteSize % 256);
+            }
+            else
+            {
+                (*m_pMemoStream).WriteUChar( 0x00 );
+                nWriteSize += 8;
+                for (int i = 0; i < 4; nWriteSize >>= 8)
+                    nHeader[i++] = static_cast<sal_uInt8>(nWriteSize % 256);
+            }
+
+            m_pMemoStream->WriteBytes(nHeader, 4);
+            if ( bBinary )
+                m_pMemoStream->WriteBytes(aValue.getConstArray(), aValue.getLength());
+            else
+                m_pMemoStream->WriteBytes(aStr.getStr(), aStr.getLength());
+            m_pMemoStream->Flush();
+        }
+    }
+
+
+    // Write the new block number
+    if (bAppend)
+    {
+        sal_uInt64 const nStreamSize = m_pMemoStream->TellEnd();
+        m_aMemoHeader.db_next = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);
+
+        // Write the new block number
+        m_pMemoStream->Seek(0);
+        (*m_pMemoStream).WriteUInt32( m_aMemoHeader.db_next );
+        m_pMemoStream->Flush();
+    }
+}
+
+
+// XAlterTable
+void SAL_CALL ODbaseTable::alterColumnByName( const OUString& colName, const Reference< XPropertySet >& descriptor )
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+    checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
+
+
+    Reference<XDataDescriptorFactory> xOldColumn;
+    m_xColumns->getByName(colName) >>= xOldColumn;
+
+    try
+    {
+        alterColumn(m_xColumns->findColumn(colName)-1,descriptor,xOldColumn);
+    }
+    catch (const css::lang::IndexOutOfBoundsException&)
+    {
+        throw NoSuchElementException(colName, *this);
+    }
+}
+
+void SAL_CALL ODbaseTable::alterColumnByIndex( sal_Int32 index, const Reference< XPropertySet >& descriptor )
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+    checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
+
+    if(index < 0 || index >= m_xColumns->getCount())
+        throw IndexOutOfBoundsException(OUString::number(index),*this);
+
+    Reference<XDataDescriptorFactory> xOldColumn;
+    m_xColumns->getByIndex(index) >>= xOldColumn;
+    alterColumn(index,descriptor,xOldColumn);
+}
+
+void ODbaseTable::alterColumn(sal_Int32 index,
+                              const Reference< XPropertySet >& descriptor ,
+                              const Reference< XDataDescriptorFactory >& xOldColumn )
+{
+    if(index < 0 || index >= m_xColumns->getCount())
+        throw IndexOutOfBoundsException(OUString::number(index),*this);
+
+    try
+    {
+        OSL_ENSURE(descriptor.is(),"ODbaseTable::alterColumn: descriptor can not be null!");
+        // creates a copy of the original column and copy all properties from descriptor in xCopyColumn
+        Reference<XPropertySet> xCopyColumn;
+        if(xOldColumn.is())
+            xCopyColumn = xOldColumn->createDataDescriptor();
+        else
+            xCopyColumn = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
+
+        ::comphelper::copyProperties(descriptor,xCopyColumn);
+
+        // creates a temp file
+
+        OUString sTempName = createTempFile();
+
+        rtl::Reference<ODbaseTable> pNewTable = new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection));
+        Reference<XPropertySet> xHoldTable = pNewTable;
+        pNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),Any(sTempName));
+        Reference<XAppend> xAppend(pNewTable->getColumns(),UNO_QUERY);
+        OSL_ENSURE(xAppend.is(),"ODbaseTable::alterColumn: No XAppend interface!");
+
+        // copy the structure
+        sal_Int32 i=0;
+        for(;i < index;++i)
+        {
+            Reference<XPropertySet> xProp;
+            m_xColumns->getByIndex(i) >>= xProp;
+            Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
+            Reference<XPropertySet> xCpy;
+            if(xColumn.is())
+                xCpy = xColumn->createDataDescriptor();
+            else
+                xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
+            ::comphelper::copyProperties(xProp,xCpy);
+            xAppend->appendByDescriptor(xCpy);
+        }
+        ++i; // now insert our new column
+        xAppend->appendByDescriptor(xCopyColumn);
+
+        for(;i < m_xColumns->getCount();++i)
+        {
+            Reference<XPropertySet> xProp;
+            m_xColumns->getByIndex(i) >>= xProp;
+            Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
+            Reference<XPropertySet> xCpy;
+            if(xColumn.is())
+                xCpy = xColumn->createDataDescriptor();
+            else
+                xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
+            ::comphelper::copyProperties(xProp,xCpy);
+            xAppend->appendByDescriptor(xCpy);
+        }
+
+        // construct the new table
+        if(!pNewTable->CreateImpl())
+        {
+            const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                    STR_COLUMN_NOT_ALTERABLE,
+                    "$columnname$", ::comphelper::getString(descriptor->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)))
+                 ) );
+            ::dbtools::throwGenericSQLException( sError, *this );
+        }
+
+        pNewTable->construct();
+
+        // copy the data
+        copyData(pNewTable.get(),0);
+
+        // now drop the old one
+        if( DropImpl() ) // we don't want to delete the memo columns too
+        {
+            try
+            {
+                // rename the new one to the old one
+                pNewTable->renameImpl(m_Name);
+            }
+            catch(const css::container::ElementExistException&)
+            {
+                const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                        STR_COULD_NOT_DELETE_FILE,
+                        "$filename$", m_Name
+                     ) );
+                ::dbtools::throwGenericSQLException( sError, *this );
+            }
+            // release the temp file
+            pNewTable = nullptr;
+            ::comphelper::disposeComponent(xHoldTable);
+        }
+        else
+        {
+            pNewTable = nullptr;
+        }
+        FileClose();
+        construct();
+        if(m_xColumns)
+            m_xColumns->refresh();
+
+    }
+    catch(const SQLException&)
+    {
+        throw;
+    }
+    catch(const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION( "connectivity.drivers","");
+        throw;
+    }
+}
+
+Reference< XDatabaseMetaData> ODbaseTable::getMetaData() const
+{
+    return getConnection()->getMetaData();
+}
+
+void SAL_CALL ODbaseTable::rename( const OUString& newName )
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+    checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
+    if(m_pTables && m_pTables->hasByName(newName))
+        throw ElementExistException(newName,*this);
+
+
+    renameImpl(newName);
+
+    ODbaseTable_BASE::rename(newName);
+
+    construct();
+    if(m_xColumns)
+        m_xColumns->refresh();
+}
+namespace
+{
+    void renameFile(file::OConnection const * _pConnection,std::u16string_view oldName,
+                    const OUString& newName, std::u16string_view _sExtension)
+    {
+        OUString aName = ODbaseTable::getEntry(_pConnection,oldName);
+        if(aName.isEmpty())
+        {
+            OUString aIdent = _pConnection->getContent()->getIdentifier()->getContentIdentifier();
+            if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
+                aIdent += "/";
+            aIdent += oldName;
+            aName = aIdent;
+        }
+        INetURLObject aURL;
+        aURL.SetURL(aName);
+
+        aURL.setExtension( _sExtension );
+        OUString sNewName(newName + "." + _sExtension);
+
+        try
+        {
+            Content aContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
+
+            Sequence< PropertyValue > aProps{ { "Title",
+                                                -1, // n/a
+                                                Any(sNewName),
+                                                css::beans::PropertyState_DIRECT_VALUE } };
+            Sequence< Any > aValues;
+            aContent.executeCommand( "setPropertyValues",Any(aProps) ) >>= aValues;
+            if(aValues.hasElements() && aValues[0].hasValue())
+                throw Exception("setPropertyValues returned non-zero", nullptr);
+        }
+        catch(const Exception&)
+        {
+            throw ElementExistException(newName);
+        }
+    }
+}
+
+void ODbaseTable::renameImpl( const OUString& newName )
+{
+    ::osl::MutexGuard aGuard(m_aMutex);
+
+    FileClose();
+
+
+    renameFile(m_pConnection,m_Name,newName,m_pConnection->getExtension());
+    if ( HasMemoFields() )
+    {  // delete the memo fields
+        renameFile(m_pConnection,m_Name,newName,u"dbt");
+    }
+}
+
+void ODbaseTable::addColumn(const Reference< XPropertySet >& _xNewColumn)
+{
+    OUString sTempName = createTempFile();
+
+    rtl::Reference xNewTable(new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection)));
+    xNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),Any(sTempName));
+    {
+        Reference<XAppend> xAppend(xNewTable->getColumns(),UNO_QUERY);
+        bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
+        // copy the structure
+        for(sal_Int32 i=0;i < m_xColumns->getCount();++i)
+        {
+            Reference<XPropertySet> xProp;
+            m_xColumns->getByIndex(i) >>= xProp;
+            Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
+            Reference<XPropertySet> xCpy;
+            if(xColumn.is())
+                xCpy = xColumn->createDataDescriptor();
+            else
+            {
+                xCpy = new OColumn(bCase);
+                ::comphelper::copyProperties(xProp,xCpy);
+            }
+
+            xAppend->appendByDescriptor(xCpy);
+        }
+        Reference<XPropertySet> xCpy = new OColumn(bCase);
+        ::comphelper::copyProperties(_xNewColumn,xCpy);
+        xAppend->appendByDescriptor(xCpy);
+    }
+
+    // construct the new table
+    if(!xNewTable->CreateImpl())
+    {
+        const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                STR_COLUMN_NOT_ADDABLE,
+                "$columnname$", ::comphelper::getString(_xNewColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)))
+             ) );
+        ::dbtools::throwGenericSQLException( sError, *this );
+    }
+
+    xNewTable->construct();
+    // copy the data
+    copyData(xNewTable.get(),xNewTable->m_xColumns->getCount());
+    // drop the old table
+    if(DropImpl())
+    {
+        xNewTable->renameImpl(m_Name);
+        // release the temp file
+    }
+    xNewTable.clear();
+
+    FileClose();
+    construct();
+    if(m_xColumns)
+        m_xColumns->refresh();
+}
+
+void ODbaseTable::dropColumn(sal_Int32 _nPos)
+{
+    OUString sTempName = createTempFile();
+
+    rtl::Reference xNewTable(new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection)));
+    xNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),Any(sTempName));
+    {
+        Reference<XAppend> xAppend(xNewTable->getColumns(),UNO_QUERY);
+        bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
+        // copy the structure
+        for(sal_Int32 i=0;i < m_xColumns->getCount();++i)
+        {
+            if(_nPos != i)
+            {
+                Reference<XPropertySet> xProp;
+                m_xColumns->getByIndex(i) >>= xProp;
+                Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
+                Reference<XPropertySet> xCpy;
+                if(xColumn.is())
+                    xCpy = xColumn->createDataDescriptor();
+                else
+                {
+                    xCpy = new OColumn(bCase);
+                    ::comphelper::copyProperties(xProp,xCpy);
+                }
+                xAppend->appendByDescriptor(xCpy);
+            }
+        }
+    }
+
+    // construct the new table
+    if(!xNewTable->CreateImpl())
+    {
+        const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                STR_COLUMN_NOT_DROP,
+                "$position$", OUString::number(_nPos)
+             ) );
+        ::dbtools::throwGenericSQLException( sError, *this );
+    }
+    xNewTable->construct();
+    // copy the data
+    copyData(xNewTable.get(),_nPos);
+    // drop the old table
+    if(DropImpl())
+        xNewTable->renameImpl(m_Name);
+        // release the temp file
+
+    xNewTable.clear();
+
+    FileClose();
+    construct();
+}
+
+OUString ODbaseTable::createTempFile()
+{
+    OUString aIdent = m_pConnection->getContent()->getIdentifier()->getContentIdentifier();
+    if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
+        aIdent += "/";
+
+    OUString sExt("." + m_pConnection->getExtension());
+    OUString aTempFileURL = utl::CreateTempURL(m_Name, true, sExt, &aIdent);
+    if(aTempFileURL.isEmpty())
+        getConnection()->throwGenericSQLException(STR_COULD_NOT_ALTER_TABLE, *this);
+
+    INetURLObject aURL;
+    aURL.SetSmartProtocol(INetProtocol::File);
+    aURL.SetURL(aTempFileURL);
+
+    OUString sNewName(aURL.getName().copy(0, aURL.getName().getLength() - sExt.getLength()));
+
+    return sNewName;
+}
+
+void ODbaseTable::copyData(ODbaseTable* _pNewTable,sal_Int32 _nPos)
+{
+    sal_Int32 nPos = _nPos + 1; // +1 because we always have the bookmark column as well
+    OValueRefRow aRow = new OValueRefVector(m_xColumns->getCount());
+    OValueRefRow aInsertRow;
+    if(_nPos)
+    {
+        aInsertRow = new OValueRefVector(_pNewTable->m_xColumns->getCount());
+        std::for_each(aInsertRow->begin(),aInsertRow->end(),TSetRefBound(true));
+    }
+    else
+        aInsertRow = aRow;
+
+    // we only have to bind the values which we need to copy into the new table
+    std::for_each(aRow->begin(),aRow->end(),TSetRefBound(true));
+    if(_nPos && (_nPos < static_cast<sal_Int32>(aRow->size())))
+        (*aRow)[nPos]->setBound(false);
+
+
+    sal_Int32 nCurPos;
+    OValueRefVector::const_iterator aIter;
+    for(sal_uInt32 nRowPos = 0; nRowPos < m_aHeader.nbRecords;++nRowPos)
+    {
+        bool bOk = seekRow( IResultSetHelper::BOOKMARK, nRowPos+1, nCurPos );
+        if ( bOk )
+        {
+            bOk = fetchRow( aRow, *m_aColumns, true);
+            if ( bOk && !aRow->isDeleted() ) // copy only not deleted rows
+            {
+                // special handling when pos == 0 then we don't have to distinguish between the two rows
+                if(_nPos)
+                {
+                    aIter = aRow->begin()+1;
+                    sal_Int32 nCount = 1;
+                    for(OValueRefVector::iterator aInsertIter = aInsertRow->begin()+1; aIter != aRow->end() && aInsertIter != aInsertRow->end();++aIter,++nCount)
+                    {
+                        if(nPos != nCount)
+                        {
+                            (*aInsertIter)->setValue( (*aIter)->getValue() );
+                            ++aInsertIter;
+                        }
+                    }
+                }
+                bOk = _pNewTable->InsertRow(*aInsertRow, _pNewTable->m_xColumns.get());
+                SAL_WARN_IF(!bOk, "connectivity.drivers", "Row could not be inserted!");
+            }
+            else
+            {
+                SAL_WARN_IF(!bOk, "connectivity.drivers", "Row could not be fetched!");
+            }
+        }
+        else
+        {
+            OSL_ASSERT(false);
+        }
+    } // for(sal_uInt32 nRowPos = 0; nRowPos < m_aHeader.db_anz;++nRowPos)
+}
+
+void ODbaseTable::throwInvalidDbaseFormat()
+{
+    FileClose();
+    // no dbase file
+
+    const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
+                STR_INVALID_DBASE_FILE,
+                "$filename$", getEntry(m_pConnection,m_Name)
+             ) );
+    ::dbtools::throwGenericSQLException( sError, *this );
+}
+
+void ODbaseTable::refreshHeader()
+{
+    if ( m_aHeader.nbRecords == 0 )
+        readHeader();
+}
+
+bool ODbaseTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_Int32 nOffset, sal_Int32& nCurPos)
+{
+    // prepare positioning:
+    OSL_ENSURE(m_pFileStream,"ODbaseTable::seekRow: FileStream is NULL!");
+
+    sal_uInt32  nNumberOfRecords = m_aHeader.nbRecords;
+    sal_uInt32 nTempPos = m_nFilePos;
+    m_nFilePos = nCurPos;
+
+    switch(eCursorPosition)
+    {
+        case IResultSetHelper::NEXT:
+            ++m_nFilePos;
+            break;
+        case IResultSetHelper::PRIOR:
+            if (m_nFilePos > 0)
+                --m_nFilePos;
+            break;
+        case IResultSetHelper::FIRST:
+            m_nFilePos = 1;
+            break;
+        case IResultSetHelper::LAST:
+            m_nFilePos = nNumberOfRecords;
+            break;
+        case IResultSetHelper::RELATIVE1:
+            m_nFilePos = (m_nFilePos + nOffset < 0) ? 0
+                            : static_cast<sal_uInt32>(m_nFilePos + nOffset);
+            break;
+        case IResultSetHelper::ABSOLUTE1:
+        case IResultSetHelper::BOOKMARK:
+            m_nFilePos = static_cast<sal_uInt32>(nOffset);
+            break;
+    }
+
+    if (m_nFilePos > static_cast<sal_Int32>(nNumberOfRecords))
+        m_nFilePos = static_cast<sal_Int32>(nNumberOfRecords) + 1;
+
+    if (m_nFilePos == 0 || m_nFilePos == static_cast<sal_Int32>(nNumberOfRecords) + 1)
+        goto Error;
+    else
+    {
+        std::size_t nEntryLen = m_aHeader.recordLength;
+
+        OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: invalid record position");
+        std::size_t nPos = m_aHeader.headerLength + static_cast<std::size_t>(m_nFilePos-1) * nEntryLen;
+
+        m_pFileStream->Seek(nPos);
+        if (m_pFileStream->GetError() != ERRCODE_NONE)
+            goto Error;
+
+        std::size_t nRead = m_pFileStream->ReadBytes(m_pBuffer.get(), nEntryLen);
+        if (nRead != nEntryLen)
+        {
+            SAL_WARN("connectivity.drivers", "ODbaseTable::seekRow: short read!");
+            goto Error;
+        }
+        if (m_pFileStream->GetError() != ERRCODE_NONE)
+            goto Error;
+    }
+    goto End;
+
+Error:
+    switch(eCursorPosition)
+    {
+        case IResultSetHelper::PRIOR:
+        case IResultSetHelper::FIRST:
+            m_nFilePos = 0;
+            break;
+        case IResultSetHelper::LAST:
+        case IResultSetHelper::NEXT:
+        case IResultSetHelper::ABSOLUTE1:
+        case IResultSetHelper::RELATIVE1:
+            if (nOffset > 0)
+                m_nFilePos = nNumberOfRecords + 1;
+            else if (nOffset < 0)
+                m_nFilePos = 0;
+            break;
+        case IResultSetHelper::BOOKMARK:
+            m_nFilePos = nTempPos;   // last position
+    }
+    return false;
+
+End:
+    nCurPos = m_nFilePos;
+    return true;
+}
+
+bool ODbaseTable::ReadMemo(std::size_t nBlockNo, ORowSetValue& aVariable)
+{
+    m_pMemoStream->Seek(nBlockNo * m_aMemoHeader.db_size);
+    switch (m_aMemoHeader.db_typ)
+    {
+        case MemodBaseIII: // dBase III-Memofield, ends with Ctrl-Z
+        {
+            const char cEOF = char(DBF_EOL);
+            OStringBuffer aBStr;
+            static char aBuf[514];
+            aBuf[512] = 0;          // avoid random value
+            bool bReady = false;
+
+            do
+            {
+                m_pMemoStream->ReadBytes(&aBuf, 512);
+
+                sal_uInt16 i = 0;
+                while (aBuf[i] != cEOF && ++i < 512)
+                    ;
+                bReady = aBuf[i] == cEOF;
+
+                aBuf[i] = 0;
+                aBStr.append(aBuf);
+
+            } while (!bReady && !m_pMemoStream->eof());
+
+            aVariable = OStringToOUString(aBStr,
+                m_eEncoding);
+
+        } break;
+        case MemoFoxPro:
+        case MemodBaseIV: // dBase IV-Memofield with length
+        {
+            bool bIsText = true;
+            char sHeader[4];
+            m_pMemoStream->ReadBytes(sHeader, 4);
+            // Foxpro stores text and binary data
+            if (m_aMemoHeader.db_typ == MemoFoxPro)
+            {
+                bIsText = sHeader[3] != 0;
+            }
+            else if (static_cast<sal_uInt8>(sHeader[0]) != 0xFF || static_cast<sal_uInt8>(sHeader[1]) != 0xFF || static_cast<sal_uInt8>(sHeader[2]) != 0x08)
+            {
+                return false;
+            }
+
+            sal_uInt32 nLength(0);
+            (*m_pMemoStream).ReadUInt32( nLength );
+
+            if (m_aMemoHeader.db_typ == MemodBaseIV)
+                nLength -= 8;
+
+            if ( nLength )
+            {
+                if ( bIsText )
+                {
+                    OStringBuffer aBuffer(read_uInt8s_ToOString(*m_pMemoStream, nLength));
+                    //pad it out with ' ' to expected length on short read
+                    sal_Int32 nRequested = sal::static_int_cast<sal_Int32>(nLength);
+                    comphelper::string::padToLength(aBuffer, nRequested, ' ');
+                    aVariable = OStringToOUString(aBuffer, m_eEncoding);
+                } // if ( bIsText )
+                else
+                {
+                    css::uno::Sequence< sal_Int8 > aData(nLength);
+                    m_pMemoStream->ReadBytes(aData.getArray(), nLength);
+                    aVariable = aData;
+                }
+            } // if ( nLength )
+        }
+    }
+    return true;
+}
+
+bool ODbaseTable::AllocBuffer()
+{
+    sal_uInt16 nSize = m_aHeader.recordLength;
+    SAL_WARN_IF(nSize == 0, "connectivity.drivers", "Size too small");
+
+    if (m_nBufferSize != nSize)
+    {
+        m_pBuffer.reset();
+    }
+
+    // if there is no buffer available: allocate:
+    if (!m_pBuffer && nSize > 0)
+    {
+        m_nBufferSize = nSize;
+        m_pBuffer.reset(new sal_uInt8[m_nBufferSize+1]);
+    }
+
+    return m_pBuffer != nullptr;
+}
+
+bool ODbaseTable::WriteBuffer()
+{
+    OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: invalid record position");
+
+    // position on desired record:
+    std::size_t nPos = m_aHeader.headerLength + static_cast<tools::Long>(m_nFilePos-1) * m_aHeader.recordLength;
+    m_pFileStream->Seek(nPos);
+    return m_pFileStream->WriteBytes(m_pBuffer.get(), m_aHeader.recordLength) > 0;
+}
+
+sal_Int32 ODbaseTable::getCurrentLastPos() const
+{
+    return m_aHeader.nbRecords;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/DTables.cxx b/connectivity/source/drivers/dbase/DTables.cxx
new file mode 100644
index 0000000000..81b355f63d
--- /dev/null
+++ b/connectivity/source/drivers/dbase/DTables.cxx
@@ -0,0 +1,127 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <dbase/DConnection.hxx>
+#include <dbase/DTables.hxx>
+#include <dbase/DTable.hxx>
+#include <com/sun/star/sdbc/SQLException.hpp>
+#include <file/FCatalog.hxx>
+#include <file/FConnection.hxx>
+#include <com/sun/star/lang/XUnoTunnel.hpp>
+#include <dbase/DCatalog.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <cppuhelper/exc_hlp.hxx>
+#include <strings.hrc>
+#include <connectivity/dbexception.hxx>
+
+using namespace ::comphelper;
+using namespace connectivity;
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::sdbcx;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+
+sdbcx::ObjectType ODbaseTables::createObject(const OUString& _rName)
+{
+    rtl::Reference<ODbaseTable> pRet = new ODbaseTable(this, static_cast<ODbaseConnection*>(static_cast<OFileCatalog&>(m_rParent).getConnection()),
+                                        _rName,"TABLE");
+
+    pRet->construct();
+    return pRet;
+}
+
+void ODbaseTables::impl_refresh(  )
+{
+    static_cast<ODbaseCatalog*>(&m_rParent)->refreshTables();
+}
+
+Reference< XPropertySet > ODbaseTables::createDescriptor()
+{
+    return new ODbaseTable(this, static_cast<ODbaseConnection*>(static_cast<OFileCatalog&>(m_rParent).getConnection()));
+}
+
+// XAppend
+sdbcx::ObjectType ODbaseTables::appendObject( const OUString& _rForName, const Reference< XPropertySet >& descriptor )
+{
+    auto pTable = dynamic_cast<ODbaseTable*>(descriptor.get());
+    if(pTable)
+    {
+        pTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),Any(_rForName));
+        try
+        {
+            if(!pTable->CreateImpl())
+                throw SQLException();
+        }
+        catch(SQLException&)
+        {
+            throw;
+        }
+        catch(Exception& ex)
+        {
+            css::uno::Any anyEx = cppu::getCaughtException();
+            throw SQLException( ex.Message, nullptr, "", 0, anyEx );
+        }
+    }
+    return createObject( _rForName );
+}
+
+// XDrop
+void ODbaseTables::dropObject(sal_Int32 _nPos, const OUString& _sElementName)
+{
+    Reference< XInterface > xTunnel;
+    try
+    {
+        xTunnel.set(getObject(_nPos),UNO_QUERY);
+    }
+    catch(const Exception&)
+    {
+        if(ODbaseTable::Drop_Static(ODbaseTable::getEntry(static_cast<OFileCatalog&>(m_rParent).getConnection(),_sElementName),false,nullptr))
+            return;
+    }
+
+    if ( xTunnel.is() )
+    {
+        ODbaseTable* pTable = dynamic_cast<ODbaseTable*>(xTunnel.get());
+        if(pTable)
+            pTable->DropImpl();
+    }
+    else
+    {
+        const OUString sError( static_cast<OFileCatalog&>(m_rParent).getConnection()->getResources().getResourceStringWithSubstitution(
+                    STR_TABLE_NOT_DROP,
+                    "$tablename$", _sElementName
+                 ) );
+        ::dbtools::throwGenericSQLException( sError, nullptr );
+    }
+}
+
+Any SAL_CALL ODbaseTables::queryInterface( const Type & rType )
+{
+    typedef sdbcx::OCollection OTables_BASE;
+    return OTables_BASE::queryInterface(rType);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/connectivity/source/drivers/dbase/dbase.component b/connectivity/source/drivers/dbase/dbase.component
new file mode 100644
index 0000000000..b078a765d8
--- /dev/null
+++ b/connectivity/source/drivers/dbase/dbase.component
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * 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 .
+ -->
+
+<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
+    xmlns="http://openoffice.org/2010/uno-components">
+  <implementation name="com.sun.star.comp.sdbc.dbase.ODriver"
+    constructor="connectivity_dbase_ODriver">
+    <service name="com.sun.star.sdbc.Driver"/>
+    <service name="com.sun.star.sdbcx.Driver"/>
+  </implementation>
+</component>
diff --git a/connectivity/source/drivers/dbase/dindexnode.cxx b/connectivity/source/drivers/dbase/dindexnode.cxx
new file mode 100644
index 0000000000..d091335f54
--- /dev/null
+++ b/connectivity/source/drivers/dbase/dindexnode.cxx
@@ -0,0 +1,1047 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <dbase/dindexnode.hxx>
+#include <dbase/DIndex.hxx>
+#include <o3tl/safeint.hxx>
+#include <tools/debug.hxx>
+#include <tools/stream.hxx>
+#include <sal/log.hxx>
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+
+using namespace connectivity;
+using namespace connectivity::dbase;
+using namespace connectivity::file;
+using namespace com::sun::star::sdbc;
+
+ONDXKey::ONDXKey()
+    :nRecord(0)
+{
+}
+
+ONDXKey::ONDXKey(ORowSetValue aVal, sal_Int32 eType, sal_uInt32 nRec)
+    : ONDXKey_BASE(eType)
+    , nRecord(nRec)
+    , xValue(std::move(aVal))
+{
+}
+
+ONDXKey::ONDXKey(const OUString& aStr, sal_uInt32 nRec)
+    : ONDXKey_BASE(css::sdbc::DataType::VARCHAR)
+     ,nRecord(nRec)
+{
+    if (!aStr.isEmpty())
+    {
+        xValue = aStr;
+        xValue.setBound(true);
+    }
+}
+
+ONDXKey::ONDXKey(double aVal, sal_uInt32 nRec)
+    : ONDXKey_BASE(css::sdbc::DataType::DOUBLE)
+     ,nRecord(nRec)
+     ,xValue(aVal)
+{
+}
+
+// index page
+ONDXPage::ONDXPage(ODbaseIndex& rInd, sal_uInt32 nPos, ONDXPage* pParent)
+    : nRefCount(0)
+    , bNoDelete(1)
+    , nPagePos(nPos)
+    , bModified(false)
+    , nCount(0)
+    , aParent(pParent)
+    , rIndex(rInd)
+{
+    sal_uInt16 nT = rIndex.getHeader().db_maxkeys;
+    ppNodes.reset( new ONDXNode[nT] );
+}
+
+ONDXPage::~ONDXPage()
+{
+}
+
+void ONDXPage::ReleaseRef()
+{
+    assert( nRefCount >= 1);
+    if(--nRefCount == 0 && !bNoDelete)
+    {
+        QueryDelete();
+    }
+}
+
+void ONDXPage::QueryDelete()
+{
+    // Store in GarbageCollector
+    if (IsModified() && rIndex.m_pFileStream)
+        WriteONDXPage( *rIndex.m_pFileStream, *this );
+
+    bModified = false;
+    if (rIndex.UseCollector())
+    {
+        if (aChild.Is())
+            aChild->Release(false);
+
+        for (sal_uInt16 i = 0; i < rIndex.getHeader().db_maxkeys;i++)
+        {
+            if (ppNodes[i].GetChild().Is())
+                ppNodes[i].GetChild()->Release(false);
+
+            ppNodes[i] = ONDXNode();
+        }
+        bNoDelete = 1;
+
+        nCount = 0;
+        aParent.Clear();
+        rIndex.Collect(this);
+    }
+    else
+    {
+        // I'm not sure about the original purpose of this line, but right now
+        // it serves the purpose that anything that attempts to do an AddFirstRef()
+        // after an object is deleted will trip an assert.
+        nRefCount = 1 << 30;
+        delete this;
+    }
+}
+
+ONDXPagePtr& ONDXPage::GetChild(ODbaseIndex const * pIndex)
+{
+    if (!aChild.Is() && pIndex)
+    {
+        aChild = rIndex.CreatePage(aChild.GetPagePos(),this,aChild.HasPage());
+    }
+    return aChild;
+}
+
+
+sal_uInt16 ONDXPage::FindPos(const ONDXKey& rKey) const
+{
+    // searches the position for the given key in a page
+    sal_uInt16 i = 0;
+    while (i < nCount && rKey > ((*this)[i]).GetKey())
+           i++;
+
+    return i;
+}
+
+
+bool ONDXPage::Find(const ONDXKey& rKey)
+{
+    // searches the given key
+    // Speciality: At the end of the method
+    // the actual page and the position of the node, fulfilling the '<=' condition, are saved
+    // This is considered at insert.
+    sal_uInt16 i = 0;
+    while (i < nCount && rKey > ((*this)[i]).GetKey())
+           i++;
+
+    bool bResult = false;
+
+    if (!IsLeaf())
+    {
+        // descend further
+        ONDXPagePtr aPage = (i==0) ? GetChild(&rIndex) : ((*this)[i-1]).GetChild(&rIndex, this);
+        bResult = aPage.Is() && aPage->Find(rKey);
+    }
+    else if (i == nCount)
+    {
+        rIndex.m_aCurLeaf = this;
+        rIndex.m_nCurNode = i - 1;
+        bResult = false;
+    }
+    else
+    {
+        bResult = rKey == ((*this)[i]).GetKey();
+        rIndex.m_aCurLeaf = this;
+        rIndex.m_nCurNode = bResult ? i : i - 1;
+    }
+    return bResult;
+}
+
+
+bool ONDXPage::Insert(ONDXNode& rNode, sal_uInt32 nRowsLeft)
+{
+    // When creating an index there can be multiple nodes added,
+    // these are sorted ascending
+    bool bAppend = nRowsLeft > 0;
+    if (IsFull())
+    {
+        ONDXNode aSplitNode;
+        if (bAppend)
+            aSplitNode = rNode;
+        else
+        {
+            // Save the last node
+            aSplitNode = (*this)[nCount-1];
+            if(rNode.GetKey() <= aSplitNode.GetKey())
+            {
+                bool bResult = true;
+                // this practically reduces the number of nodes by 1
+                if (IsLeaf() && this == rIndex.m_aCurLeaf)
+                {
+                    // assumes, that the node, for which the condition (<=) holds, is stored in m_nCurNode
+                    --nCount;   // (otherwise we might get Assertions and GPFs - 60593)
+                    bResult = Insert(rIndex.m_nCurNode + 1, rNode);
+                }
+                else  // position unknown
+                {
+                    sal_uInt16 nPos = NODE_NOTFOUND;
+                    while (++nPos < nCount && rNode.GetKey() > ((*this)[nPos]).GetKey()) ;
+
+                    --nCount;   // (otherwise we might get Assertions and GPFs - 60593)
+                    bResult = Insert(nPos, rNode);
+                }
+
+                // can the new node be inserted
+                if (!bResult)
+                {
+                    nCount++;
+                    aSplitNode = rNode;
+                }
+            }
+            else
+                aSplitNode = rNode;
+        }
+
+        sal_uInt32 nNewPagePos = rIndex.GetPageCount();
+        sal_uInt32 nNewPageCount = nNewPagePos + 1;
+
+        // insert extracted node into parent node
+        if (!HasParent())
+        {
+            // No parent, then new root
+            ONDXPagePtr aNewRoot = rIndex.CreatePage(nNewPagePos + 1);
+            aNewRoot->SetChild(this);
+
+            rIndex.m_aRoot = aNewRoot;
+            rIndex.SetRootPos(nNewPagePos + 1);
+            rIndex.SetPageCount(++nNewPageCount);
+        }
+
+        // create new leaf and divide page
+        ONDXPagePtr aNewPage = rIndex.CreatePage(nNewPagePos,aParent);
+        rIndex.SetPageCount(nNewPageCount);
+
+        // How many nodes are being inserted?
+        // Enough, then we can fill the page to the brim
+        ONDXNode aInnerNode;
+        if (!IsLeaf() || nRowsLeft < o3tl::make_unsigned(rIndex.GetMaxNodes() / 2))
+            aInnerNode = Split(*aNewPage);
+        else
+        {
+            aInnerNode = (*this)[nCount - 1];
+
+            // Node points to the new page
+            aInnerNode.SetChild(aNewPage);
+
+            // Inner nodes have no record number
+            if (rIndex.isUnique())
+                aInnerNode.GetKey().ResetRecord();
+
+            // new page points to the page of the extracted node
+            if (!IsLeaf())
+                aNewPage->SetChild(aInnerNode.GetChild());
+        }
+
+        aNewPage->Append(aSplitNode);
+        ONDXPagePtr aTempParent = aParent;
+        if (IsLeaf())
+        {
+            rIndex.m_aCurLeaf = aNewPage;
+            rIndex.m_nCurNode = rIndex.m_aCurLeaf->Count() - 1;
+
+            // free not needed pages, there are no references to those on the page
+            // afterwards 'this' can't be valid anymore!!!
+            ReleaseFull();
+        }
+
+        // Insert extracted node
+        return aTempParent->Insert(aInnerNode);
+    }
+    else // Fill the page up
+    {
+        if (bAppend)
+        {
+            if (IsLeaf())
+                rIndex.m_nCurNode = nCount - 1;
+            return Append(rNode);
+        }
+        else
+        {
+            sal_uInt16 nNodePos = FindPos(rNode.GetKey());
+            if (IsLeaf())
+                rIndex.m_nCurNode = nNodePos;
+
+            return Insert(nNodePos, rNode);
+        }
+    }
+}
+
+
+bool ONDXPage::Insert(sal_uInt16 nPos, ONDXNode& rNode)
+{
+    sal_uInt16 nMaxCount = rIndex.getHeader().db_maxkeys;
+    if (nPos >= nMaxCount)
+        return false;
+
+    if (nCount)
+    {
+        ++nCount;
+        // shift right
+        for (sal_uInt16 i = std::min(static_cast<sal_uInt16>(nMaxCount-1), static_cast<sal_uInt16>(nCount-1)); nPos < i; --i)
+            (*this)[i] = (*this)[i-1];
+    }
+    else
+        if (nCount < nMaxCount)
+            nCount++;
+
+    // insert at the position
+    ONDXNode& rInsertNode = (*this)[nPos];
+    rInsertNode = rNode;
+    if (rInsertNode.GetChild().Is())
+    {
+        rInsertNode.GetChild()->SetParent(this);
+        rNode.GetChild()->SetParent(this);
+    }
+
+    bModified = true;
+
+    return true;
+}
+
+
+bool ONDXPage::Append(ONDXNode& rNode)
+{
+    DBG_ASSERT(!IsFull(), "no Append possible");
+    return Insert(nCount, rNode);
+}
+
+void ONDXPage::Release(bool bSave)
+{
+    // free pages
+    if (aChild.Is())
+        aChild->Release(bSave);
+
+    // free pointer
+    aChild.Clear();
+
+    for (sal_uInt16 i = 0; i < rIndex.getHeader().db_maxkeys;i++)
+    {
+        if (ppNodes[i].GetChild())
+            ppNodes[i].GetChild()->Release(bSave);
+
+        ppNodes[i].GetChild().Clear();
+    }
+    aParent.Clear();
+}
+
+void ONDXPage::ReleaseFull()
+{
+    ONDXPagePtr aTempParent = aParent;
+    Release();
+
+    if (aTempParent.Is())
+    {
+        // Free pages not needed, there will be no reference anymore to the pages
+        // afterwards 'this' can't be valid anymore!!!
+        sal_uInt16 nParentPos = aTempParent->Search(this);
+        if (nParentPos != NODE_NOTFOUND)
+            (*aTempParent)[nParentPos].GetChild().Clear();
+        else
+            aTempParent->GetChild().Clear();
+    }
+}
+
+void ONDXPage::Delete(sal_uInt16 nNodePos)
+{
+    if (IsLeaf())
+    {
+        // The last element will not be deleted
+        if (nNodePos == (nCount - 1))
+        {
+            ONDXNode aNode = (*this)[nNodePos];
+
+            // parent's KeyValue has to be replaced
+            if (HasParent())
+                aParent->SearchAndReplace(aNode.GetKey(),
+                                          (*this)[nNodePos-1].GetKey());
+        }
+    }
+
+    // Delete the node
+    Remove(nNodePos);
+
+    // Underflow
+    if (HasParent() && nCount < (rIndex.GetMaxNodes() / 2))
+    {
+        // determine, which node points to the page
+        sal_uInt16 nParentNodePos = aParent->Search(this);
+        // last element on parent-page -> merge with secondlast page
+        if (nParentNodePos == (aParent->Count() - 1))
+        {
+            if (!nParentNodePos)
+            // merge with left neighbour
+                Merge(nParentNodePos,aParent->GetChild(&rIndex));
+            else
+                Merge(nParentNodePos,(*aParent)[nParentNodePos-1].GetChild(&rIndex,aParent));
+        }
+        // otherwise merge page with next page
+        else
+        {
+            // merge with right neighbour
+            Merge(nParentNodePos + 1,((*aParent)[nParentNodePos + 1].GetChild(&rIndex,aParent)));
+            nParentNodePos++;
+        }
+        if (HasParent() && !(*aParent)[nParentNodePos].HasChild())
+            aParent->Delete(nParentNodePos);
+    }
+    else if (IsRoot())
+        // make sure that the position of the root is kept
+        rIndex.SetRootPos(nPagePos);
+}
+
+
+ONDXNode ONDXPage::Split(ONDXPage& rPage)
+{
+    DBG_ASSERT(IsFull(), "Incorrect Splitting");
+    /*  divide one page into two
+        leaf:
+            Page 1 is (n - (n/2))
+            Page 2 is (n/2)
+            Node n/2 will be duplicated
+        inner node:
+            Page 1 is (n+1)/2
+            Page 2 is (n/2-1)
+            Node ((n+1)/2 + 1) : will be taken out
+    */
+    ONDXNode aResultNode;
+    if (IsLeaf())
+    {
+        for (sal_uInt16 i = nCount - (nCount / 2), j = 0 ; i < nCount; i++)
+            rPage.Insert(j++,(*this)[i]);
+
+        // this node contains a key that already exists in the tree and must be replaced
+        ONDXNode aLastNode = (*this)[nCount - 1];
+        nCount = nCount - (nCount / 2);
+        aResultNode = (*this)[nCount - 1];
+
+        if (HasParent())
+            aParent->SearchAndReplace(aLastNode.GetKey(),
+                                      aResultNode.GetKey());
+    }
+    else
+    {
+        for (sal_uInt16 i = (nCount + 1) / 2 + 1, j = 0 ; i < nCount; i++)
+            rPage.Insert(j++,(*this)[i]);
+
+        aResultNode = (*this)[(nCount + 1) / 2];
+        nCount = (nCount + 1) / 2;
+
+        // new page points to page with extracted node
+        rPage.SetChild(aResultNode.GetChild());
+    }
+    // node points to new page
+    aResultNode.SetChild(&rPage);
+
+    // inner nodes have no record number
+    if (rIndex.isUnique())
+        aResultNode.GetKey().ResetRecord();
+    bModified = true;
+    return aResultNode;
+}
+
+
+void ONDXPage::Merge(sal_uInt16 nParentNodePos, const ONDXPagePtr& xPage)
+{
+    DBG_ASSERT(HasParent(), "no parent existing");
+    DBG_ASSERT(nParentNodePos != NODE_NOTFOUND, "Wrong index setup");
+
+    /*  Merge 2 pages   */
+    sal_uInt16 nMaxNodes = rIndex.GetMaxNodes(),
+           nMaxNodes_2 = nMaxNodes / 2;
+
+    // Determine if page is right or left neighbour
+    bool    bRight    = ((*xPage)[0].GetKey() > (*this)[0].GetKey()); // true when xPage is at the right side
+    sal_uInt16  nNewCount = (*xPage).Count() + Count();
+
+    if (IsLeaf())
+    {
+        // Condition for merge
+        if (nNewCount < (nMaxNodes_2 * 2))
+        {
+            sal_uInt16 nLastNode = bRight ? Count() - 1 : xPage->Count() - 1;
+            if (bRight)
+            {
+                DBG_ASSERT(xPage != this,"xPage and THIS must not be the same: infinite loop");
+                // shift all nodes from xPage to the left node (append)
+                while (xPage->Count())
+                {
+                    Append((*xPage)[0]);
+                    xPage->Remove(0);
+                }
+            }
+            else
+            {
+                DBG_ASSERT(xPage != this,"xPage and THIS must not be the same: infinite loop");
+                // xPage is the left page and THIS the right one
+                while (xPage->Count())
+                {
+                    Insert(0,(*xPage)[xPage->Count()-1]);
+                    xPage->Remove(xPage->Count()-1);
+                }
+                // replace old position of xPage in parent with this
+                if (nParentNodePos)
+                    (*aParent)[nParentNodePos-1].SetChild(this,aParent);
+                else // or set as right node
+                    aParent->SetChild(this);
+                aParent->SetModified(true);
+
+            }
+
+            // cancel Child-relationship at parent node
+            (*aParent)[nParentNodePos].SetChild();
+            // replace the Node-value, only if changed page is the left one, otherwise become
+            if(aParent->IsRoot() && aParent->Count() == 1)
+            {
+                (*aParent)[0].SetChild();
+                aParent->ReleaseFull();
+                aParent.Clear();
+                rIndex.SetRootPos(nPagePos);
+                rIndex.m_aRoot = this;
+                SetModified(true);
+            }
+            else
+                aParent->SearchAndReplace((*this)[nLastNode].GetKey(),(*this)[nCount-1].GetKey());
+
+            xPage->SetModified(false);
+            xPage->ReleaseFull(); // is not needed anymore
+        }
+        // balance the elements   nNewCount >= (nMaxNodes_2 * 2)
+        else
+        {
+            if (bRight)
+            {
+                // shift all nodes from xPage to the left node (append)
+                ONDXNode aReplaceNode = (*this)[nCount - 1];
+                while (nCount < nMaxNodes_2)
+                {
+                    Append((*xPage)[0]);
+                    xPage->Remove(0);
+                }
+                // Replace the node values: replace old last value by the last of xPage
+                aParent->SearchAndReplace(aReplaceNode.GetKey(),(*this)[nCount-1].GetKey());
+            }
+            else
+            {
+                // insert all nodes from this in front of the xPage nodes
+                ONDXNode aReplaceNode = (*this)[nCount - 1];
+                while (xPage->Count() < nMaxNodes_2)
+                {
+                    xPage->Insert(0,(*this)[nCount-1]);
+                    Remove(nCount-1);
+                }
+                // Replace the node value
+                aParent->SearchAndReplace(aReplaceNode.GetKey(),(*this)[Count()-1].GetKey());
+            }
+        }
+    }
+    else // !IsLeaf()
+    {
+        // Condition for merge
+        if (nNewCount < nMaxNodes_2 * 2)
+        {
+            if (bRight)
+            {
+                DBG_ASSERT(xPage != this,"xPage and THIS must not be the same: infinite loop");
+                // Parent node will be integrated; is initialized with Child from xPage
+                (*aParent)[nParentNodePos].SetChild(xPage->GetChild(),aParent);
+                Append((*aParent)[nParentNodePos]);
+                for (sal_uInt16 i = 0 ; i < xPage->Count(); i++)
+                    Append((*xPage)[i]);
+            }
+            else
+            {
+                DBG_ASSERT(xPage != this,"xPage and THIS must not be the same: infinite loop");
+                // Parent-node will be integrated; is initialized with child
+                (*aParent)[nParentNodePos].SetChild(GetChild(),aParent); // Parent memorizes my child
+                Insert(0,(*aParent)[nParentNodePos]); // insert parent node into myself
+                while (xPage->Count())
+                {
+                    Insert(0,(*xPage)[xPage->Count()-1]);
+                    xPage->Remove(xPage->Count()-1);
+                }
+                SetChild(xPage->GetChild());
+
+                if (nParentNodePos)
+                    (*aParent)[nParentNodePos-1].SetChild(this,aParent);
+                else
+                    aParent->SetChild(this);
+            }
+
+            // afterwards parent node will be reset
+            (*aParent)[nParentNodePos].SetChild();
+            aParent->SetModified(true);
+
+            if(aParent->IsRoot() && aParent->Count() == 1)
+            {
+                (*aParent).SetChild();
+                aParent->ReleaseFull();
+                aParent.Clear();
+                rIndex.SetRootPos(nPagePos);
+                rIndex.m_aRoot = this;
+                SetModified(true);
+            }
+            else if(nParentNodePos)
+                // replace the node value
+                // for Append the range will be enlarged, for Insert the old node from xPage will reference to this
+                // that's why the node must be updated here
+                aParent->SearchAndReplace((*aParent)[nParentNodePos-1].GetKey(),(*aParent)[nParentNodePos].GetKey());
+
+            xPage->SetModified(false);
+            xPage->ReleaseFull();
+        }
+        // balance the elements
+        else
+        {
+            if (bRight)
+            {
+                while (nCount < nMaxNodes_2)
+                {
+                    (*aParent)[nParentNodePos].SetChild(xPage->GetChild(),aParent);
+                    Append((*aParent)[nParentNodePos]);
+                    (*aParent)[nParentNodePos] = (*xPage)[0];
+                    xPage->Remove(0);
+                }
+                xPage->SetChild((*aParent)[nParentNodePos].GetChild());
+                (*aParent)[nParentNodePos].SetChild(xPage,aParent);
+            }
+            else
+            {
+                while (nCount < nMaxNodes_2)
+                {
+                    (*aParent)[nParentNodePos].SetChild(GetChild(),aParent);
+                    Insert(0,(*aParent)[nParentNodePos]);
+                    (*aParent)[nParentNodePos] = (*xPage)[xPage->Count()-1];
+                    xPage->Remove(xPage->Count()-1);
+                }
+                SetChild((*aParent)[nParentNodePos].GetChild());
+                (*aParent)[nParentNodePos].SetChild(this,aParent);
+
+            }
+            aParent->SetModified(true);
+        }
+    }
+}
+
+// ONDXNode
+
+
+void ONDXNode::Read(SvStream &rStream, ODbaseIndex const & rIndex)
+{
+    rStream.ReadUInt32( aKey.nRecord ); // key
+
+    if (rIndex.getHeader().db_keytype)
+    {
+        double aDbl;
+        rStream.ReadDouble( aDbl );
+        aKey = ONDXKey(aDbl,aKey.nRecord);
+    }
+    else
+    {
+        sal_uInt16 nLen = rIndex.getHeader().db_keylen;
+        OString aBuf = read_uInt8s_ToOString(rStream, nLen);
+        //get length minus trailing whitespace
+        sal_Int32 nContentLen = aBuf.getLength();
+        while (nContentLen && aBuf[nContentLen-1] == ' ')
+            --nContentLen;
+        aKey = ONDXKey(OUString(aBuf.getStr(), nContentLen, rIndex.m_pTable->getConnection()->getTextEncoding()) ,aKey.nRecord);
+    }
+    rStream >> aChild;
+}
+
+
+void ONDXNode::Write(SvStream &rStream, const ONDXPage& rPage) const
+{
+    const ODbaseIndex& rIndex = rPage.GetIndex();
+    if (!rIndex.isUnique() || rPage.IsLeaf())
+        rStream.WriteUInt32( aKey.nRecord ); // key
+    else
+        rStream.WriteUInt32( 0 );   // key
+
+    if (rIndex.getHeader().db_keytype) // double
+    {
+        if (sizeof(double) != rIndex.getHeader().db_keylen)
+        {
+            SAL_WARN("connectivity.dbase", "this key length cannot possibly be right?");
+        }
+        if (aKey.getValue().isNull())
+        {
+            sal_uInt8 buf[sizeof(double)] = {};
+            rStream.WriteBytes(&buf[0], sizeof(double));
+        }
+        else
+            rStream.WriteDouble( aKey.getValue().getDouble() );
+    }
+    else
+    {
+        sal_uInt16 const nLen(rIndex.getHeader().db_keylen);
+        std::unique_ptr<sal_uInt8[]> pBuf(new sal_uInt8[nLen]);
+        memset(&pBuf[0], 0x20, nLen);
+        if (!aKey.getValue().isNull())
+        {
+            OUString sValue = aKey.getValue().getString();
+            OString aText(OUStringToOString(sValue, rIndex.m_pTable->getConnection()->getTextEncoding()));
+            strncpy(reinterpret_cast<char *>(&pBuf[0]), aText.getStr(),
+                std::min<size_t>(nLen, aText.getLength()));
+        }
+        rStream.WriteBytes(&pBuf[0], nLen);
+    }
+    WriteONDXPagePtr( rStream, aChild );
+}
+
+
+ONDXPagePtr& ONDXNode::GetChild(ODbaseIndex* pIndex, ONDXPage* pParent)
+{
+    if (!aChild.Is() && pIndex)
+    {
+        aChild = pIndex->CreatePage(aChild.GetPagePos(),pParent,aChild.HasPage());
+    }
+    return aChild;
+}
+
+
+// ONDXKey
+
+
+bool ONDXKey::IsText(sal_Int32 eType)
+{
+    return eType == DataType::VARCHAR || eType == DataType::CHAR;
+}
+
+
+int ONDXKey::Compare(const ONDXKey& rKey) const
+{
+    sal_Int32 nRes;
+
+    if (getValue().isNull())
+    {
+        if (rKey.getValue().isNull() || (IsText(getDBType()) && rKey.getValue().getString().isEmpty()))
+            nRes = 0;
+        else
+            nRes = -1;
+    }
+    else if (rKey.getValue().isNull())
+    {
+        if (getValue().isNull() || (IsText(getDBType()) && getValue().getString().isEmpty()))
+            nRes = 0;
+        else
+            nRes = 1;
+    }
+    else if (IsText(getDBType()))
+    {
+        nRes = getValue().getString().compareTo(rKey.getValue().getString());
+    }
+    else
+    {
+        double m = getValue().getDouble();
+        double n = rKey.getValue().getDouble();
+        nRes = (m > n) ? 1 : ( m < n) ? -1 : 0;
+    }
+
+    // compare record, if index !Unique
+    if (nRes == 0 && nRecord && rKey.nRecord)
+    {
+        nRes = (nRecord > rKey.nRecord) ? 1 :
+            (nRecord == rKey.nRecord) ? 0 : -1;
+    }
+    return nRes;
+}
+
+void ONDXKey::setValue(const ORowSetValue& _rVal)
+{
+    xValue = _rVal;
+}
+
+const ORowSetValue& ONDXKey::getValue() const
+{
+    return xValue;
+}
+
+SvStream& connectivity::dbase::operator >> (SvStream &rStream, ONDXPagePtr& rPage)
+{
+    rStream.ReadUInt32( rPage.nPagePos );
+    return rStream;
+}
+
+SvStream& connectivity::dbase::WriteONDXPagePtr(SvStream &rStream, const ONDXPagePtr& rPage)
+{
+    rStream.WriteUInt32( rPage.nPagePos );
+    return rStream;
+}
+
+// ONDXPagePtr
+ONDXPagePtr::ONDXPagePtr()
+    : mpPage(nullptr)
+    , nPagePos(0)
+{
+}
+
+ONDXPagePtr::ONDXPagePtr(ONDXPagePtr&& rRef) noexcept
+{
+    mpPage = rRef.mpPage;
+    rRef.mpPage = nullptr;
+    nPagePos = rRef.nPagePos;
+}
+
+ONDXPagePtr::ONDXPagePtr(ONDXPagePtr const & rRef)
+    : mpPage(rRef.mpPage)
+    , nPagePos(rRef.nPagePos)
+{
+    if (mpPage != nullptr)
+        mpPage->AddNextRef();
+}
+
+ONDXPagePtr::ONDXPagePtr(ONDXPage* pRefPage)
+    : mpPage(pRefPage)
+    , nPagePos(0)
+{
+    if (mpPage != nullptr)
+        mpPage->AddFirstRef();
+    if (pRefPage)
+        nPagePos = pRefPage->GetPagePos();
+}
+
+ONDXPagePtr::~ONDXPagePtr()
+{
+    if (mpPage != nullptr) mpPage->ReleaseRef();
+}
+
+void ONDXPagePtr::Clear()
+{
+    if (mpPage != nullptr) {
+        ONDXPage * pRefObj = mpPage;
+        mpPage = nullptr;
+        pRefObj->ReleaseRef();
+    }
+}
+
+ONDXPagePtr& ONDXPagePtr::operator=(ONDXPagePtr const & rOther)
+{
+    ONDXPagePtr aTemp(rOther);
+    *this = std::move(aTemp);
+    return *this;
+}
+
+ONDXPagePtr& ONDXPagePtr::operator=(ONDXPagePtr && rOther)
+{
+    if (mpPage != nullptr) {
+        mpPage->ReleaseRef();
+    }
+    mpPage = rOther.mpPage;
+    nPagePos = rOther.nPagePos;
+    rOther.mpPage = nullptr;
+    return *this;
+}
+
+static sal_uInt32 nValue;
+
+SvStream& connectivity::dbase::operator >> (SvStream &rStream, ONDXPage& rPage)
+{
+    rStream.Seek(rPage.GetPagePos() * DINDEX_PAGE_SIZE);
+    rStream.ReadUInt32( nValue ) >> rPage.aChild;
+    rPage.nCount = sal_uInt16(nValue);
+
+    for (sal_uInt16 i = 0; i < rPage.nCount; i++)
+        rPage[i].Read(rStream, rPage.GetIndex());
+    return rStream;
+}
+
+
+SvStream& connectivity::dbase::WriteONDXPage(SvStream &rStream, const ONDXPage& rPage)
+{
+    // Page doesn't exist yet
+    std::size_t nSize = rPage.GetPagePos() + 1;
+    nSize *= DINDEX_PAGE_SIZE;
+    if (nSize > rStream.TellEnd())
+    {
+        rStream.SetStreamSize(nSize);
+        rStream.Seek(rPage.GetPagePos() * DINDEX_PAGE_SIZE);
+
+        char aEmptyData[DINDEX_PAGE_SIZE] = {};
+        rStream.WriteBytes(aEmptyData, DINDEX_PAGE_SIZE);
+    }
+    rStream.Seek(rPage.GetPagePos() * DINDEX_PAGE_SIZE);
+
+    nValue = rPage.nCount;
+    rStream.WriteUInt32( nValue );
+    WriteONDXPagePtr( rStream, rPage.aChild );
+
+    sal_uInt16 i = 0;
+    for (; i < rPage.nCount; i++)
+        rPage[i].Write(rStream, rPage);
+
+    // check if we have to fill the stream with '\0'
+    if(i < rPage.rIndex.getHeader().db_maxkeys)
+    {
+        std::size_t nTell = rStream.Tell() % DINDEX_PAGE_SIZE;
+        sal_uInt16 nBufferSize = rStream.GetBufferSize();
+        std::size_t nRemainSize = nBufferSize - nTell;
+        if ( nRemainSize <= nBufferSize )
+        {
+            std::unique_ptr<char[]> pEmptyData( new char[nRemainSize] );
+            memset(pEmptyData.get(), 0x00, nRemainSize);
+            rStream.WriteBytes(pEmptyData.get(), nRemainSize);
+            rStream.Seek(nTell);
+        }
+    }
+    return rStream;
+}
+
+#if OSL_DEBUG_LEVEL > 1
+
+void ONDXPage::PrintPage()
+{
+    SAL_WARN("connectivity.dbase", "SDB: -----------Page: " << nPagePos << "  Parent: " << (HasParent() ? aParent->GetPagePos() : 0)
+              << "  Count: " << nCount << "  Child: " << aChild.GetPagePos() << "-----");
+
+    for (sal_uInt16 i = 0; i < nCount; i++)
+    {
+        ONDXNode rNode = (*this)[i];
+        ONDXKey&  rKey = rNode.GetKey();
+        if (!IsLeaf())
+            rNode.GetChild(&rIndex, this);
+
+        if (rKey.getValue().isNull())
+        {
+            SAL_WARN("connectivity.dbase", "SDB: [" << rKey.GetRecord() << ",NULL," << rNode.GetChild().GetPagePos() << "]");
+        }
+        else if (rIndex.getHeader().db_keytype)
+        {
+            SAL_WARN("connectivity.dbase", "SDB: [" << rKey.GetRecord() << "," << rKey.getValue().getDouble()
+                                           << "," << rNode.GetChild().GetPagePos() << "]");
+        }
+        else
+        {
+            SAL_WARN("connectivity.dbase", "SDB: [" << rKey.GetRecord() << "," << rKey.getValue().getString()
+                                           << "," << rNode.GetChild().GetPagePos() << "]" );
+        }
+    }
+    SAL_WARN("connectivity.dbase", "SDB: -----------------------------------------------");
+    if (!IsLeaf())
+    {
+#if OSL_DEBUG_LEVEL > 1
+        GetChild(&rIndex)->PrintPage();
+        for (sal_uInt16 i = 0; i < nCount; i++)
+        {
+            ONDXNode rNode = (*this)[i];
+            rNode.GetChild(&rIndex,this)->PrintPage();
+        }
+#endif
+    }
+    SAL_WARN("connectivity.dbase", "SDB: ===============================================");
+}
+#endif
+
+bool ONDXPage::IsFull() const
+{
+    return Count() == rIndex.getHeader().db_maxkeys;
+}
+
+
+sal_uInt16 ONDXPage::Search(const ONDXKey& rSearch)
+{
+    // binary search later
+    sal_uInt16 i = NODE_NOTFOUND;
+    while (++i < Count())
+        if ((*this)[i].GetKey() == rSearch)
+            break;
+
+    return (i < Count()) ? i : NODE_NOTFOUND;
+}
+
+
+sal_uInt16 ONDXPage::Search(const ONDXPage* pPage)
+{
+    sal_uInt16 i = NODE_NOTFOUND;
+    while (++i < Count())
+        if (((*this)[i]).GetChild() == pPage)
+            break;
+
+    // if not found, then we assume, that the page itself points to the page
+    return (i < Count()) ? i : NODE_NOTFOUND;
+}
+
+// runs recursively
+void ONDXPage::SearchAndReplace(const ONDXKey& rSearch,
+                                  ONDXKey const & rReplace)
+{
+    OSL_ENSURE(rSearch != rReplace,"Invalid here:rSearch == rReplace");
+    if (rSearch == rReplace)
+        return;
+
+    sal_uInt16 nPos = NODE_NOTFOUND;
+    ONDXPage* pPage = this;
+
+    while (pPage)
+    {
+        nPos = pPage->Search(rSearch);
+        if (nPos != NODE_NOTFOUND)
+            break;
+        pPage = pPage->aParent;
+    }
+
+    if (pPage)
+    {
+        (*pPage)[nPos].GetKey() = rReplace;
+        pPage->SetModified(true);
+    }
+}
+
+ONDXNode& ONDXPage::operator[] (sal_uInt16 nPos)
+{
+    DBG_ASSERT(nCount > nPos, "incorrect index access");
+    return ppNodes[nPos];
+}
+
+
+const ONDXNode& ONDXPage::operator[] (sal_uInt16 nPos) const
+{
+    DBG_ASSERT(nCount > nPos, "incorrect index access");
+    return ppNodes[nPos];
+}
+
+void ONDXPage::Remove(sal_uInt16 nPos)
+{
+    DBG_ASSERT(nCount > nPos, "incorrect index access");
+
+    for (sal_uInt16 i = nPos; i < (nCount-1); i++)
+        (*this)[i] = (*this)[i+1];
+
+    nCount--;
+    bModified = true;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */