xref: /trunk/main/xmlhelp/source/cxxhelp/provider/db.cxx (revision 89dcb3da00a29b2b7b028d5bd430e2099844a09e)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmlhelp.hxx"

#include "db.hxx"

#include <rtl/alloc.h>
#include <cstring>

#include "com/sun/star/io/XSeekable.hpp"

#include "osl/file.hxx"
#include "osl/thread.hxx"
#ifdef TEST_DBHELP
#include <osl/time.h>
#endif

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

namespace berkeleydbproxy {

//----------------------------------------------------------------------------
namespace db_internal
{
    // static void raise_error(int dberr, const char * where);

    static inline int check_error(int dberr, const char * where)
    {
        (void)where;

        // if (dberr) raise_error(dberr,where);
        return dberr;
    }
}

void DBData::copyToBuffer( const char* pSrcData, int nSize )
{
    m_nSize = nSize;
    delete [] m_pBuffer;
    m_pBuffer = new char[m_nSize+1];
    memcpy( m_pBuffer, pSrcData, m_nSize );
    m_pBuffer[m_nSize] = 0;
}


// DBHelp

bool DBHelp::implReadLenAndData( const char* pData, int& riPos, DBData& rValue )
{
    bool bSuccess = false;

    // Read key len
    const char* pStartPtr = pData + riPos;
    char* pEndPtr;
    sal_Int32 nKeyLen = strtol( pStartPtr, &pEndPtr, 16 );
    if( pEndPtr == pStartPtr )
        return bSuccess;
    riPos += (pEndPtr - pStartPtr) + 1;

    const char* pKeySrc = pData + riPos;
    rValue.copyToBuffer( pKeySrc, nKeyLen );
    riPos += nKeyLen + 1;

    bSuccess = true;
    return bSuccess;
}

#ifdef TEST_DBHELP

typedef std::pair< rtl::OString, rtl::OString >     KeyValPair;
typedef std::vector< KeyValPair >                   KeyValPairVector;

void testWriteKeyValue( FILE* pFile, const KeyValPair& rKeyValPair )
{
    if( pFile == NULL )
        return;
    char cLF = 10;

    const rtl::OString& aKeyStr = rKeyValPair.first;
    const rtl::OString& aValueStr = rKeyValPair.second;
    int nKeyLen = aKeyStr.getLength();
    int nValueLen = aValueStr.getLength();
    fprintf( pFile, "%x ", nKeyLen );
    if( nKeyLen > 0 )
        fwrite( aKeyStr.getStr(), 1, nKeyLen, pFile );
    fprintf( pFile, " %x ", nValueLen );
    if( nValueLen > 0 )
        fwrite( aValueStr.getStr(), 1, nValueLen, pFile );
    fprintf( pFile, "%c", cLF );
}

bool DBHelp::testAgainstDb( const rtl::OUString& fileURL, bool bOldDbAccess )
{
    bool bSuccess = true;

    KeyValPairVector avKeyValPair;

    rtl::OUString aOutFileName = fileURL;
    aOutFileName += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("_TestOut"));
    if( bOldDbAccess )
        aOutFileName += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("_Old"));
#ifdef WNT
    FILE* pFile = _wfopen( aOutFileName.getStr(), L"wb" );
#else
    rtl::OString sFile = rtl::OUStringToOString(aOutFileName, osl_getThreadTextEncoding());
    FILE* pFile = fopen( sFile.getStr(), "wb" );
#endif
    // Get all values
    Db table;
    if( 0 == table.open( 0,fileURL,DB_BTREE,DB_RDONLY,0644 ) )
    {
        bool first = true;

        Dbc* cursor = 0;
        table.cursor( 0,&cursor,0 );
        Dbt key_,data;
        key_.set_flags( DB_DBT_MALLOC ); // Initially the cursor must allocate the necessary memory
        data.set_flags( DB_DBT_MALLOC );

        while( cursor && DB_NOTFOUND != cursor->get( &key_,&data,DB_NEXT ) )
        {
            rtl::OString keyword( static_cast<sal_Char*>(key_.get_data()),
                                  key_.get_size() );
            rtl::OString value( static_cast<sal_Char*>(data.get_data()),
                                data.get_size() );

            KeyValPair aPair( keyword, value );
            avKeyValPair.push_back( aPair );
            if( pFile != NULL )
                testWriteKeyValue( pFile, aPair );

            if( first )
            {
                key_.set_flags( DB_DBT_REALLOC );
                data.set_flags( DB_DBT_REALLOC );
                first = false;
            }
        }

        if( cursor ) cursor->close();
    }
    table.close( 0 );

    // TEST
    DBData aDBData;
    Db tableTest;
    Dbt data;

    int nOkCount = 0;
    int nErrCount = 0;

    bool bTestSuccess;
    const char* pTestReadData = NULL;
    int nTestReadDataSize = 0;

    sal_uInt32 starttime = osl_getGlobalTimer();
    sal_uInt32 afterfirsttime = starttime;

    if( pFile != NULL )
    {
        if( bOldDbAccess )
            fprintf( pFile, "\nTesting old access:\n" );
        else
            fprintf( pFile, "\nTesting new access:\n" );
    }

    KeyValPairVector::const_iterator it;
    bool bFirst = true;
    for( it = avKeyValPair.begin() ; it != avKeyValPair.end() ; ++it )
    {
        const KeyValPair& rKeyValPair = *it;

        const rtl::OString& aKeyStr = rKeyValPair.first;
        const rtl::OString& aValueStr = rKeyValPair.second;
        int nKeyLen = aKeyStr.getLength();
        int nValueLen = aValueStr.getLength();

        const sal_Char* ptr = aValueStr.getStr();

        bTestSuccess = false;
        pTestReadData = NULL;
        nTestReadDataSize = 0;
        if( bOldDbAccess )
        {
            if( bFirst )
            {
                if( tableTest.open( 0,fileURL, DB_BTREE,DB_RDONLY,0644 ) )
                {
                    if( pFile != NULL )
                        fprintf( pFile, "Cannot open database\n" );

                    break;
                }
            }

            Dbt key( static_cast< void* >( const_cast< sal_Char* >( aKeyStr.getStr() ) ), aKeyStr.getLength() );
            int err = tableTest.get( 0, &key, &data, 0 );
            if( err == 0 )
            {
                bTestSuccess = true;
                pTestReadData = static_cast< sal_Char* >( data.get_data() );
                nTestReadDataSize = data.get_size();
            }
        }
        else
        {
            bTestSuccess = getValueForKey( aKeyStr, aDBData );
            if( bTestSuccess )
            {
                pTestReadData = aDBData.getData();
                nTestReadDataSize = aDBData.getSize();
            }
        }
        if( bFirst )
        {
            afterfirsttime = osl_getGlobalTimer();
            bFirst = false;
        }
        int nError = 0;
        if( bTestSuccess && pTestReadData != NULL )
        {
            int nCmp = memcmp( ptr, pTestReadData, nValueLen );
            if( nCmp == 0 )
                ++nOkCount;
            else
                nError = 1;

            if( nValueLen != nTestReadDataSize )
                nError = 2;
        }
        else
            nError = 3;

        if( nError != 0 )
        {
            bSuccess = false;
            ++nErrCount;

            if( pFile != NULL )
            {
                fprintf( pFile, "ERROR, not found:\n" );
                testWriteKeyValue( pFile, rKeyValPair );
                fprintf( pFile, "\nError Code: %d\n", nError );
            }
        }
    }
    tableTest.close( 0 );

    sal_uInt32 endtime = osl_getGlobalTimer();
    double dDiffTime = (endtime-starttime) / 1000.0;
    double dDiffFirstTime = (afterfirsttime-starttime) / 1000.0;
    if( pFile != NULL )
    {
        int nCount = avKeyValPair.size();
        fprintf( pFile, "%d key/values in total, read %d correctly, %d errors\n",
            nCount, nOkCount, nErrCount );
        fprintf( pFile, "Time taken: %g s (First access %g s)\n", dDiffTime, dDiffFirstTime );
        fprintf( pFile, "Average time per access: %g s\n", dDiffTime / nCount );
    }

    if( pFile != NULL )
        fclose( pFile );

    return bSuccess;
}

#endif


void DBHelp::createHashMap( bool bOptimizeForPerformance )
{
    releaseHashMap();
    if( bOptimizeForPerformance )
    {
        if( m_pStringToDataMap != NULL )
            return;
        m_pStringToDataMap = new StringToDataMap();
    }
    else
    {
        if( m_pStringToValPosMap != NULL )
            return;
        m_pStringToValPosMap = new StringToValPosMap();
    }

    Reference< XInputStream > xIn = m_xSFA->openFileRead( m_aFileURL );
    if( xIn.is() )
    {
        Sequence< sal_Int8 > aData;
        sal_Int32 nSize = m_xSFA->getSize( m_aFileURL );
        sal_Int32 nRead = xIn->readBytes( aData, nSize );

        const char* pData = (const char*)aData.getConstArray();
        int iPos = 0;
        while( iPos < nRead )
        {
            DBData aDBKey;
            if( !implReadLenAndData( pData, iPos, aDBKey ) )
                break;

            rtl::OString aOKeyStr = aDBKey.getData();

            // Read val len
            const char* pStartPtr = pData + iPos;
            char* pEndPtr;
            sal_Int32 nValLen = strtol( pStartPtr, &pEndPtr, 16 );
            if( pEndPtr == pStartPtr )
                break;

            iPos += (pEndPtr - pStartPtr) + 1;

            if( bOptimizeForPerformance )
            {
                const char* pValSrc = pData + iPos;
                rtl::OString aValStr( pValSrc, nValLen );
                (*m_pStringToDataMap)[aOKeyStr] = aValStr;
            }
            else
            {
                // store value start position
                (*m_pStringToValPosMap)[aOKeyStr] = std::pair<int,int>( iPos, nValLen );
            }
            iPos += nValLen + 1;
        }

        xIn->closeInput();
    }
}

void DBHelp::releaseHashMap( void )
{
    if( m_pStringToDataMap != NULL )
    {
        delete m_pStringToDataMap;
        m_pStringToDataMap = NULL;
    }
    if( m_pStringToValPosMap != NULL )
    {
        delete m_pStringToValPosMap;
        m_pStringToValPosMap = NULL;
    }
}


bool DBHelp::getValueForKey( const rtl::OString& rKey, DBData& rValue )
{
    bool bSuccess = false;
    if( !m_xSFA.is() )
        return bSuccess;

    try
    {

    if( m_pStringToDataMap == NULL && m_pStringToValPosMap == NULL )
    {
        bool bOptimizeForPerformance = false;
        createHashMap( bOptimizeForPerformance );
    }

    if( m_pStringToValPosMap != NULL )
    {
        StringToValPosMap::const_iterator it = m_pStringToValPosMap->find( rKey );
        if( it != m_pStringToValPosMap->end() )
        {
            const std::pair<int,int>& rValPair = it->second;
            int iValuePos = rValPair.first;
            int nValueLen = rValPair.second;

            Reference< XInputStream > xIn = m_xSFA->openFileRead( m_aFileURL );
            if( xIn.is() )
            {
                Reference< XSeekable > xXSeekable( xIn, UNO_QUERY );
                if( xXSeekable.is() )
                {
                    xXSeekable->seek( iValuePos );

                    Sequence< sal_Int8 > aData;
                    sal_Int32 nRead = xIn->readBytes( aData, nValueLen );
                    if( nRead == nValueLen )
                    {
                        const char* pData = (const sal_Char*)aData.getConstArray();
                        rValue.copyToBuffer( pData, nValueLen );
                        bSuccess = true;
                    }
                }
                xIn->closeInput();
            }
        }
    }

    else if( m_pStringToDataMap != NULL )
    {
        StringToDataMap::const_iterator it = m_pStringToDataMap->find( rKey );
        if( it != m_pStringToDataMap->end() )
        {
            const rtl::OString& rValueStr = it->second;
            int nValueLen = rValueStr.getLength();
            const char* pData = rValueStr.getStr();
            rValue.copyToBuffer( pData, nValueLen );
            bSuccess = true;
        }
    }

    }
    catch( Exception & )
    {
        bSuccess = false;
    }

    return bSuccess;
}

bool DBHelp::startIteration( void )
{
    bool bSuccess = false;

    sal_Int32 nSize = m_xSFA->getSize( m_aFileURL );

    Reference< XInputStream > xIn = m_xSFA->openFileRead( m_aFileURL );
    if( xIn.is() )
    {
        m_nItRead = xIn->readBytes( m_aItData, nSize );
        if( m_nItRead == nSize )
        {
            bSuccess = true;
            m_pItData = (const char*)m_aItData.getConstArray();
            m_iItPos = 0;
        }
        else
        {
            stopIteration();
        }
    }

    return bSuccess;
}

bool DBHelp::getNextKeyAndValue( DBData& rKey, DBData& rValue )
{
    bool bSuccess = false;

    if( m_iItPos < m_nItRead )
    {
        if( implReadLenAndData( m_pItData, m_iItPos, rKey ) )
        {
            if( implReadLenAndData( m_pItData, m_iItPos, rValue ) )
                bSuccess = true;
        }
    }

    return bSuccess;
}

void DBHelp::stopIteration( void )
{
    m_aItData = Sequence<sal_Int8>();
    m_pItData = NULL;
    m_nItRead = -1;
    m_iItPos = -1;
}


Db::Db()
{
    db_internal::check_error( db_create(&m_pDBP,0,0),"Db::Db" );
    m_pDBHelp = NULL;
}


Db::~Db()
{
    if (m_pDBP)
    {
        // should not happen
        // TODO: add assert
    }

    delete m_pDBHelp;
}


int Db::close(u_int32_t flags)
{
    int error = m_pDBP->close(m_pDBP,flags);
    m_pDBP = 0;
    return db_internal::check_error(error,"Db::close");
}

int Db::open(DB_TXN *txnid,
             const char *file,
             const char *database,
             DBTYPE type,
             u_int32_t flags,
             int mode)
{
    int err = m_pDBP->open(m_pDBP,txnid,file,database,type,flags,mode);
    return db_internal::check_error( err,"Db::open" );
}

int Db::open(DB_TXN *txnid,
             ::rtl::OUString const & fileURL,
             DBTYPE type,
             u_int32_t flags,
             int mode)
{
    ::rtl::OUString ouPath;
    ::osl::FileBase::getSystemPathFromFileURL(fileURL, ouPath);
    const ::rtl::OString sPath = ::rtl::OUStringToOString(ouPath, osl_getThreadTextEncoding());
    return open(txnid, sPath.getStr(), 0, type, flags, mode);
}



int Db::get(DB_TXN *txnid, Dbt *key, Dbt *data, u_int32_t flags)
{
    int err = m_pDBP->get(m_pDBP,txnid,key,data,flags);

    // these are non-exceptional outcomes
    if (err != DB_NOTFOUND && err != DB_KEYEMPTY)
        db_internal::check_error( err,"Db::get" );

    return err;
}

int Db::cursor(DB_TXN *txnid, Dbc **cursorp, u_int32_t flags)
{
    DBC * dbc = 0;
    int error = m_pDBP->cursor(m_pDBP,txnid,&dbc,flags);

    if (!db_internal::check_error(error,"Db::cursor"))
        *cursorp = new Dbc(dbc);

    return error;
}

//----------------------------------------------------------------------------

Dbc::Dbc(DBC * dbc)
: m_pDBC(dbc)
{
}

Dbc::~Dbc()
{
}

int Dbc::close()
{
    int err = m_pDBC->c_close(m_pDBC);
    delete this;
    return db_internal::check_error( err,"Dbcursor::close" );
}

int Dbc::get(Dbt *key, Dbt *data, u_int32_t flags)
{
    int err = m_pDBC->c_get(m_pDBC,key,data,flags);

    // these are non-exceptional outcomes
    if (err != DB_NOTFOUND && err != DB_KEYEMPTY)
        db_internal::check_error( err, "Dbcursor::get" );

    return err;
}

//----------------------------------------------------------------------------


Dbt::Dbt()
{
    using namespace std;
    DBT * thispod = this;
    memset(thispod, 0, sizeof *thispod);
}


Dbt::Dbt(void *data_arg, u_int32_t size_arg)
{
    using namespace std;
    DBT * thispod = this;
    memset(thispod, 0, sizeof *thispod);
    this->set_data(data_arg);
    this->set_size(size_arg);
}

/*
Dbt::Dbt(const Dbt & other)
{
    using namespace std;
    const DBT *otherpod = &other;
    DBT *thispod = this;
    memcpy(thispod, otherpod, sizeof *thispod);
}

Dbt& Dbt::operator = (const Dbt & other)
{
    if (this != &other)
    {
        using namespace std;
        const DBT *otherpod = &other;
        DBT *thispod = this;
        memcpy(thispod, otherpod, sizeof *thispod);
    }
    return *this;
}
*/

Dbt::~Dbt()
{
}

void * Dbt::get_data() const
{
    return this->data;
}

void Dbt::set_data(void *value)
{
    this->data = value;
}

u_int32_t Dbt::get_size() const
{
    return this->size;
}

void Dbt::set_size(u_int32_t value)
{
    this->size = value;
}

void Dbt::set_flags(u_int32_t value)
{
    this->flags = value;
}

//----------------------------------------------------------------------------
/*
void db_internal::raise_error(int dberr, const char * where)
{
    if (!where) where = "<unknown>";

    const char * dberrmsg = db_strerror(dberr);
    if (!dberrmsg || !*dberrmsg) dberrmsg = "<unknown DB error>";

    rtl::OString msg = where;
    msg += ": ";
    msg += dberrmsg;

    throw DbException(msg);
}
*/

//----------------------------------------------------------------------------
} // namespace ecomp