xref: /trunk/main/connectivity/source/drivers/adabas/BDriver.cxx (revision 6bcc9fe0e9ad8e3adcad10b35c622961480f57f3)

/**************************************************************
 *
 * 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_connectivity.hxx"
#include <unotools/tempfile.hxx>
#include "adabas/BDriver.hxx"
#include "adabas/BConnection.hxx"
#include "odbc/OFunctions.hxx"
#include <com/sun/star/lang/DisposedException.hpp>
#include "odbc/OTools.hxx"
#include "connectivity/dbexception.hxx"
#include "TConnection.hxx"
#include "diagnose_ex.h"
#include <vos/process.hxx>
#include <osl/process.h>
#include <unotools/ucbhelper.hxx>
#include <unotools/ucbstreamhelper.hxx>
#include <unotools/localfilehelper.hxx>
#include "resource/adabas_res.hrc"
#include "resource/sharedresources.hxx"


#include <memory>
#include <sys/stat.h>

inline SvStream& operator<<( SvStream& s, const rtl::OString r) { return (s << r.getStr()); }
inline SvStream& operator<<( SvStream& s, const rtl::OUString r) { return (s << ::rtl::OUStringToOString(r,gsl_getSystemTextEncoding())); }

#if defined(UNX)
const char sNewLine = '\012';
#else
const char sNewLine[] = "\015\012"; // \015\012 and not \n
#endif
#define ADABAS_DB_11            "11.02.00"
#define ADABAS_KERNEL_11        "11.02"
#define ADABAS_DB_12            "12.01.00"
#define ADABAS_KERNEL_12        "12.01"
#define CURRENT_DB_VERSION      "13.01.00"
#define CURRENT_KERNEL_VERSION  "13.01"

#define OPROCESS_ADABAS     (OProcess::TOption_Hidden | OProcess::TOption_Wait | OProcess::TOption_SearchPath)
#define OPROCESS_ADABAS_DBG (OProcess::TOption_Wait | OProcess::TOption_SearchPath)


using namespace connectivity;
namespace connectivity
{
    namespace adabas
    {
        // extern declaration of the function pointer
    extern T3SQLAllocHandle pODBC3SQLAllocHandle;
    extern T3SQLConnect pODBC3SQLConnect;
    extern T3SQLDriverConnect pODBC3SQLDriverConnect;
    extern T3SQLBrowseConnect pODBC3SQLBrowseConnect;
    extern T3SQLDataSources pODBC3SQLDataSources;
    extern T3SQLDrivers pODBC3SQLDrivers;
    extern T3SQLGetInfo pODBC3SQLGetInfo;
    extern T3SQLGetFunctions pODBC3SQLGetFunctions;
    extern T3SQLGetTypeInfo pODBC3SQLGetTypeInfo;
    extern T3SQLSetConnectAttr pODBC3SQLSetConnectAttr;
    extern T3SQLGetConnectAttr pODBC3SQLGetConnectAttr;
    extern T3SQLSetEnvAttr pODBC3SQLSetEnvAttr;
    extern T3SQLGetEnvAttr pODBC3SQLGetEnvAttr;
    extern T3SQLSetStmtAttr pODBC3SQLSetStmtAttr;
    extern T3SQLGetStmtAttr pODBC3SQLGetStmtAttr;
    //extern T3SQLSetDescField pODBC3SQLSetDescField;
    //extern T3SQLGetDescField pODBC3SQLGetDescField;
    //extern T3SQLGetDescRec pODBC3SQLGetDescRec;
    //extern T3SQLSetDescRec pODBC3SQLSetDescRec;
    extern T3SQLPrepare pODBC3SQLPrepare;
    extern T3SQLBindParameter pODBC3SQLBindParameter;
    //extern T3SQLGetCursorName pODBC3SQLGetCursorName;
    extern T3SQLSetCursorName pODBC3SQLSetCursorName;
    extern T3SQLExecute pODBC3SQLExecute;
    extern T3SQLExecDirect pODBC3SQLExecDirect;
    //extern T3SQLNativeSql pODBC3SQLNativeSql;
    extern T3SQLDescribeParam pODBC3SQLDescribeParam;
    extern T3SQLNumParams pODBC3SQLNumParams;
    extern T3SQLParamData pODBC3SQLParamData;
    extern T3SQLPutData pODBC3SQLPutData;
    extern T3SQLRowCount pODBC3SQLRowCount;
    extern T3SQLNumResultCols pODBC3SQLNumResultCols;
    extern T3SQLDescribeCol pODBC3SQLDescribeCol;
    extern T3SQLColAttribute pODBC3SQLColAttribute;
    extern T3SQLBindCol pODBC3SQLBindCol;
    extern T3SQLFetch pODBC3SQLFetch;
    extern T3SQLFetchScroll pODBC3SQLFetchScroll;
    extern T3SQLGetData pODBC3SQLGetData;
    extern T3SQLSetPos pODBC3SQLSetPos;
    extern T3SQLBulkOperations pODBC3SQLBulkOperations;
    extern T3SQLMoreResults pODBC3SQLMoreResults;
    //extern T3SQLGetDiagField pODBC3SQLGetDiagField;
    extern T3SQLGetDiagRec pODBC3SQLGetDiagRec;
    extern T3SQLColumnPrivileges pODBC3SQLColumnPrivileges;
    extern T3SQLColumns pODBC3SQLColumns;
    extern T3SQLForeignKeys pODBC3SQLForeignKeys;
    extern T3SQLPrimaryKeys pODBC3SQLPrimaryKeys;
    extern T3SQLProcedureColumns pODBC3SQLProcedureColumns;
    extern T3SQLProcedures pODBC3SQLProcedures;
    extern T3SQLSpecialColumns pODBC3SQLSpecialColumns;
    extern T3SQLStatistics pODBC3SQLStatistics;
    extern T3SQLTablePrivileges pODBC3SQLTablePrivileges;
    extern T3SQLTables pODBC3SQLTables;
    extern T3SQLFreeStmt pODBC3SQLFreeStmt;
    extern T3SQLCloseCursor pODBC3SQLCloseCursor;
    extern T3SQLCancel pODBC3SQLCancel;
    extern T3SQLEndTran pODBC3SQLEndTran;
    extern T3SQLDisconnect pODBC3SQLDisconnect;
    extern T3SQLFreeHandle pODBC3SQLFreeHandle;
    extern T3SQLGetCursorName pODBC3SQLGetCursorName;
    extern T3SQLNativeSql pODBC3SQLNativeSql;

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;
using namespace utl;
using namespace osl;
using namespace vos;
using namespace ::dbtools;

    sal_Bool LoadFunctions(oslModule pODBCso);
    sal_Bool LoadLibrary_ADABAS(::rtl::OUString &_rPath);
    // --------------------------------------------------------------------------------
void ODriver::fillInfo(const Sequence< PropertyValue >& info, TDatabaseStruct& _rDBInfo)
{
    const PropertyValue* pIter = info.getConstArray();
    const PropertyValue* pEnd = pIter + info.getLength();
    for(;pIter != pEnd;++pIter)
    {
        if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DatabaseName"))))
        {
            pIter->Value >>= _rDBInfo.sDBName;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlUser"))))
        {
            pIter->Value >>= _rDBInfo.sControlUser;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlPassword"))))
        {
            pIter->Value >>= _rDBInfo.sControlPassword;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataCacheSizeIncrement"))))
            pIter->Value >>= _rDBInfo.nDataIncrement;
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShutdownDatabase"))))
            pIter->Value >>= _rDBInfo.bShutDown;
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("User"))))
        {
            pIter->Value >>= _rDBInfo.sSysUser;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Password"))))
        {
            pIter->Value >>= _rDBInfo.sSysPassword;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DomainPassword"))))
        {
            pIter->Value >>= _rDBInfo.sDomainPassword;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CacheSize"))))
        {
            pIter->Value >>= _rDBInfo.sCacheSize;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RestoreDatabase"))))
        {
            pIter->Value >>= _rDBInfo.bRestoreDatabase;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Backup"))))
        {
            pIter->Value >>= _rDBInfo.sBackupFile;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataDevSpace"))))
        {
            pIter->Value >>= _rDBInfo.sDataDevName;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SYSDEVSPACE"))))
        {
            pIter->Value >>= _rDBInfo.sSysDevSpace;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TRANSACTION_LOG"))))
        {
            pIter->Value >>= _rDBInfo.sTransLogName;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataDevSize"))))
        {
            pIter->Value >>= _rDBInfo.nDataSize;
        }
        else if(pIter->Name.equalsIgnoreAsciiCase(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LogDevSize"))))
        {
            pIter->Value >>= _rDBInfo.nLogSize;
        }
    }
}


// --------------------------------------------------------------------------------
ODriver::ODriver(const Reference< XMultiServiceFactory >& _rxFactory) : ODBCDriver(_rxFactory)
{
    osl_incrementInterlockedCount(&m_refCount);
    fillEnvironmentVariables();
    Reference< XComponent >  xComponent(m_xORB, UNO_QUERY);
    if (xComponent.is())
    {
        Reference< ::com::sun::star::lang::XEventListener> xEvtL((::cppu::OWeakObject*)this,UNO_QUERY);
        xComponent->addEventListener(xEvtL);
    }
    osl_decrementInterlockedCount(&m_refCount);
}
//------------------------------------------------------------------------------
void ODriver::disposing()
{
    ::osl::MutexGuard aGuard(m_aMutex);
    ODriver_BASE::disposing();
    Reference< XComponent >  xComponent(m_xORB, UNO_QUERY);
    if (xComponent.is())
    {
        Reference< XEventListener> xEvtL((::cppu::OWeakObject*)this,UNO_QUERY);
        xComponent->removeEventListener(xEvtL);
    }
    m_xORB.clear();
}

// static ServiceInfo
//------------------------------------------------------------------------------
rtl::OUString ODriver::getImplementationName_Static(  ) throw(RuntimeException)
{
    return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.sdbcx.adabas.ODriver"));
}
//------------------------------------------------------------------------------
Sequence< ::rtl::OUString > ODriver::getSupportedServiceNames_Static(  ) throw (RuntimeException)
{
    Sequence< ::rtl::OUString > aSNS( 2 );
    aSNS[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbc.Driver"));
    aSNS[1] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdbcx.Driver"));
    return aSNS;
}
//------------------------------------------------------------------
::rtl::OUString SAL_CALL ODriver::getImplementationName(  ) throw(RuntimeException)
{
    return getImplementationName_Static();
}

//------------------------------------------------------------------
sal_Bool SAL_CALL ODriver::supportsService( const ::rtl::OUString& _rServiceName ) throw(RuntimeException)
{
    const Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
    const ::rtl::OUString* pSupported = aSupported.getConstArray();
    const ::rtl::OUString* pEnd = pSupported + aSupported.getLength();
    for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported)
        ;

    return pSupported != pEnd;
}
//------------------------------------------------------------------
Sequence< ::rtl::OUString > SAL_CALL ODriver::getSupportedServiceNames(  ) throw(RuntimeException)
{
    return getSupportedServiceNames_Static();
}
//------------------------------------------------------------------
Any SAL_CALL ODriver::queryInterface( const Type & rType ) throw(RuntimeException)
{
    Any aRet = ::cppu::queryInterface(rType, static_cast<XDataDefinitionSupplier*>(this));
    if ( !aRet.hasValue() )
        aRet = ODriver_BASE::queryInterface(rType);
    return aRet.hasValue() ? aRet : ODriver_BASE2::queryInterface(rType);
}
//------------------------------------------------------------------
Reference< XInterface >  SAL_CALL ODriver_CreateInstance(const Reference< ::com::sun::star::lang::XMultiServiceFactory >& _rxFac) throw( Exception )
{
    return *(new ODriver(_rxFac));
}
// -----------------------------------------------------------------------------
void SAL_CALL ODriver::disposing( const EventObject& Source ) throw(RuntimeException)
{
    ::osl::MutexGuard aGuard( m_aMutex );

    if(m_xORB.is() && Reference< XMultiServiceFactory >(Source.Source,UNO_QUERY) == m_xORB)
    {
        TDatabaseMap::iterator aIter = m_aDatabaseMap.begin();
        for(;aIter != m_aDatabaseMap.end();++aIter)
        {
            if(aIter->second.bShutDown)
            {
                ::rtl::OUString sName;
                if(getDBName(aIter->first,sName))
                {
                    XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SHUTDOWN QUICK")),sName,aIter->second.sControlUser,aIter->second.sControlPassword);
                    X_STOP(sName);
                }
            }
        }
    m_xORB.clear();
    }
}
// --------------------------------------------------------------------------------
Reference< XConnection > SAL_CALL ODriver::connect( const ::rtl::OUString& url, const Sequence< PropertyValue >& info ) throw(SQLException, RuntimeException)
{
    if ( ! acceptsURL(url) )
        return NULL;

    ::osl::MutexGuard aGuard( m_aMutex );
    if (ODriver_BASE::rBHelper.bDisposed)
        throw DisposedException();

    TDatabaseStruct aDBInfo;
    aDBInfo.bShutDown = sal_False;
    fillInfo(info,aDBInfo);
    aDBInfo.sControlUser = aDBInfo.sControlUser.toAsciiUpperCase();
    aDBInfo.sControlPassword = aDBInfo.sControlPassword.toAsciiUpperCase();
    aDBInfo.sSysUser = aDBInfo.sSysUser.toAsciiUpperCase();
    aDBInfo.sSysPassword = aDBInfo.sSysPassword.toAsciiUpperCase();


    TDatabaseMap::iterator aFind = m_aDatabaseMap.find(url);
    if(aFind == m_aDatabaseMap.end()) // only when not found yet
        m_aDatabaseMap[url] = aDBInfo;
    else
    {
        if(aFind->second.bShutDown != aDBInfo.bShutDown)
            aFind->second.bShutDown &= aDBInfo.bShutDown;
    }

    ::rtl::OUString sName;
    if(aDBInfo.sControlPassword.getLength() && aDBInfo.sControlUser.getLength() && getDBName(url,sName))
    {
        // check if we have to add a new data dev space
        checkAndInsertNewDevSpace(sName,aDBInfo);

        convertOldVersion(sName,aDBInfo);
        // check if we must restart the database
        checkAndRestart(sName,aDBInfo);
    }


    if(!m_pDriverHandle)
    {
        ::rtl::OUString aPath;
        if(!EnvironmentHandle(aPath))
            throw SQLException(aPath,*this,::rtl::OUString(),1000,Any());
    }
    OAdabasConnection* pCon = new OAdabasConnection(m_pDriverHandle,this);
    Reference< XConnection > xCon = pCon;
    SQLRETURN nSQLRETURN = pCon->Construct(url,info);

    if (nSQLRETURN == SQL_ERROR || nSQLRETURN == SQL_NO_DATA)
    {
        odbc::OTools::ThrowException(pCon,nSQLRETURN,pCon->getConnection(),SQL_HANDLE_DBC,*this);
    }

    m_xConnections.push_back(WeakReferenceHelper(*pCon));

    return xCon;
}
// -----------------------------------------------------------------------------
sal_Bool ODriver::getDBName(const ::rtl::OUString& _rName,::rtl::OUString& sDBName) const
{
    sDBName = ::rtl::OUString();
    ::rtl::OUString sName = _rName.copy(12);
    sal_Int32 nPos = sName.indexOf(':');
    if(nPos != -1 && nPos < 1)
        sDBName = sName.copy(1);
    return (nPos != -1 && nPos < 1);
}
// --------------------------------------------------------------------------------
sal_Bool SAL_CALL ODriver::acceptsURL( const ::rtl::OUString& url )
        throw(SQLException, RuntimeException)
{
    return (!url.compareTo(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("sdbc:adabas:")),12));
}
// --------------------------------------------------------------------------------
Sequence< DriverPropertyInfo > SAL_CALL ODriver::getPropertyInfo( const ::rtl::OUString& url, const Sequence< PropertyValue >& /*info*/) throw(SQLException, RuntimeException)
{
    if ( acceptsURL(url) )
    {
        ::std::vector< DriverPropertyInfo > aDriverInfo;

        aDriverInfo.push_back(DriverPropertyInfo(
                ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShutdownDatabase"))
                ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Shut down service when closing."))
                ,sal_False
                ,::rtl::OUString()
                ,Sequence< ::rtl::OUString >())
                );
        aDriverInfo.push_back(DriverPropertyInfo(
                ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlUser"))
                ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Control user name."))
                ,sal_False
                ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("0"))
                ,Sequence< ::rtl::OUString >())
                );
        aDriverInfo.push_back(DriverPropertyInfo(
                ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ControlPassword"))
                ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Control password."))
                ,sal_False
                ,::rtl::OUString()
                ,Sequence< ::rtl::OUString >())
                );
        aDriverInfo.push_back(DriverPropertyInfo(
                ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DataCacheSizeIncrement"))
                ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Data increment (MB)."))
                ,sal_False
                ,::rtl::OUString()
                ,Sequence< ::rtl::OUString >())
                );
        aDriverInfo.push_back(DriverPropertyInfo(
                ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CharSet"))
                ,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CharSet of the database."))
                ,sal_False
                ,::rtl::OUString()
                ,Sequence< ::rtl::OUString >())
                );
        return Sequence< DriverPropertyInfo >(&aDriverInfo[0],aDriverInfo.size());
    }

    SharedResources aResources;
    const ::rtl::OUString sMessage = aResources.getResourceString(STR_URI_SYNTAX_ERROR);
    ::dbtools::throwGenericSQLException(sMessage ,*this);
    return Sequence< DriverPropertyInfo >();
}
// --------------------------------------------------------------------------------
sal_Int32 SAL_CALL ODriver::getMajorVersion(  ) throw(RuntimeException)
{
    return 1;
}
// --------------------------------------------------------------------------------
sal_Int32 SAL_CALL ODriver::getMinorVersion(  ) throw(RuntimeException)
{
    return 0;
}
// -----------------------------------------------------------------------------
// XCreateCatalog
void SAL_CALL ODriver::createCatalog( const Sequence< PropertyValue >& info ) throw(SQLException, ElementExistException, RuntimeException)
{
    ::osl::MutexGuard aGuard( m_aMutex );
    if (ODriver_BASE::rBHelper.bDisposed)
        throw DisposedException();

    try
    {
        TDatabaseStruct aDBInfo;
        fillInfo(info,aDBInfo);

        ::rtl::OUString envVar(RTL_CONSTASCII_USTRINGPARAM("DBSERVICE"));
        ::rtl::OUString envData(RTL_CONSTASCII_USTRINGPARAM("0"));
        osl_setEnvironment(envVar.pData, envData.pData);

        m_sDbRunDir = m_sDbWorkURL + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/wrk/")) + aDBInfo.sDBName;
        String sTemp;
        LocalFileHelper::ConvertURLToPhysicalName(m_sDbRunDir,sTemp);
        m_sDbRunDir = sTemp;

        createNeededDirs(aDBInfo.sDBName);
        if(CreateFiles(aDBInfo))
        {
            ::connectivity::SharedResources aResources;
            const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
                    STR_NO_DISK_SPACE,
                    "$filename$",aDBInfo.sDBName
                 ) );
            ::dbtools::throwGenericSQLException(sError,*this);
        } // if(CreateFiles(aDBInfo))

        createDb(aDBInfo);
    }
    catch( SQLException&)
    {
        throw;
    }
    catch(Exception&)
    {
        throw SQLException();
    }

}
// -----------------------------------------------------------------------------
// XDropCatalog
void SAL_CALL ODriver::dropCatalog( const ::rtl::OUString& /*catalogName*/, const Sequence< PropertyValue >& /*info*/ ) throw(SQLException, NoSuchElementException, RuntimeException)
{
    ::osl::MutexGuard aGuard( m_aMutex );
    if (ODriver_BASE::rBHelper.bDisposed)
        throw DisposedException();

    ::dbtools::throwFeatureNotImplementedException( "!XDropCatalog::dropCatalog", *this );
}
//-----------------------------------------------------------------------------
// ODBC Environment (gemeinsam fuer alle Connections):
SQLHANDLE ODriver::EnvironmentHandle(::rtl::OUString &_rPath)
{
    // Ist (fuer diese Instanz) bereits ein Environment erzeugt worden?
    if (!m_pDriverHandle)
    {
        SQLHANDLE h = SQL_NULL_HANDLE;
        // Environment allozieren

        // ODBC-DLL jetzt laden:
        if (! LoadLibrary_ADABAS(_rPath))
            return SQL_NULL_HANDLE;

        if (N3SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&h) != SQL_SUCCESS)
            return SQL_NULL_HANDLE;

        // In globaler Struktur merken ...
        m_pDriverHandle = h;
        SQLRETURN nError = N3SQLSetEnvAttr(h, SQL_ATTR_ODBC_VERSION,(SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER);
        OSL_UNUSED( nError );
        //N3SQLSetEnvAttr(h, SQL_ATTR_CONNECTION_POOLING,(SQLPOINTER) SQL_CP_ONE_PER_HENV, SQL_IS_INTEGER);
    }

    return m_pDriverHandle;
}
// --------------------------------------------------------------------------------
// XDataDefinitionSupplier
Reference< XTablesSupplier > SAL_CALL ODriver::getDataDefinitionByConnection( const Reference< ::com::sun::star::sdbc::XConnection >& connection ) throw(::com::sun::star::sdbc::SQLException, RuntimeException)
{
    ::osl::MutexGuard aGuard( m_aMutex );
    if (ODriver_BASE::rBHelper.bDisposed)
        throw DisposedException();

    Reference< XTablesSupplier > xTab;
    Reference< ::com::sun::star::lang::XUnoTunnel> xTunnel(connection,UNO_QUERY);
    if ( xTunnel.is() )
    {

        OAdabasConnection* pConnection = NULL;
        OAdabasConnection* pSearchConnection = reinterpret_cast< OAdabasConnection* >( xTunnel->getSomething(OAdabasConnection::getUnoTunnelImplementationId()) );
        for (OWeakRefArray::iterator i = m_xConnections.begin(); m_xConnections.end() != i; ++i)
        {
            if ( (OAdabasConnection*) Reference< XConnection >::query(i->get().get()).get() == pSearchConnection )
            {
                pConnection = pSearchConnection;
                break;
            }
        }


        if ( pConnection )
            xTab = pConnection->createCatalog();
    }
    return xTab;
}

// --------------------------------------------------------------------------------
Reference< XTablesSupplier > SAL_CALL ODriver::getDataDefinitionByURL( const ::rtl::OUString& url, const Sequence< PropertyValue >& info ) throw(::com::sun::star::sdbc::SQLException, RuntimeException)
{
    if ( ! acceptsURL(url) )
    {
        SharedResources aResources;
        const ::rtl::OUString sMessage = aResources.getResourceString(STR_URI_SYNTAX_ERROR);
        ::dbtools::throwGenericSQLException(sMessage ,*this);
    } // if ( ! acceptsURL(url) )

    return getDataDefinitionByConnection(connect(url,info));
}
// -----------------------------------------------------------------------------
void SAL_CALL ODriver::acquire() throw()
{
    ODriver_BASE::acquire();
}
// -----------------------------------------------------------------------------
void SAL_CALL ODriver::release() throw()
{
    ODriver_BASE::release();
}
ODriver::~ODriver()
{
}
// -----------------------------------------------------------------------------
oslGenericFunction ODriver::getOdbcFunction(sal_Int32 _nIndex) const
{
    oslGenericFunction pFunction = NULL;
    switch(_nIndex)
    {
        case ODBC3SQLAllocHandle:
            pFunction = (oslGenericFunction)pODBC3SQLAllocHandle;
            break;
        case ODBC3SQLConnect:
            pFunction = (oslGenericFunction)pODBC3SQLConnect;
            break;
        case ODBC3SQLDriverConnect:
            pFunction = (oslGenericFunction)pODBC3SQLDriverConnect;
            break;
        case ODBC3SQLBrowseConnect:
            pFunction = (oslGenericFunction)pODBC3SQLBrowseConnect;
            break;
        case ODBC3SQLDataSources:
            pFunction = (oslGenericFunction)pODBC3SQLDataSources;
            break;
        case ODBC3SQLDrivers:
            pFunction = (oslGenericFunction)pODBC3SQLDrivers;
            break;
        case ODBC3SQLGetInfo:

            pFunction = (oslGenericFunction)pODBC3SQLGetInfo;
            break;
        case ODBC3SQLGetFunctions:

            pFunction = (oslGenericFunction)pODBC3SQLGetFunctions;
            break;
        case ODBC3SQLGetTypeInfo:

            pFunction = (oslGenericFunction)pODBC3SQLGetTypeInfo;
            break;
        case ODBC3SQLSetConnectAttr:

            pFunction = (oslGenericFunction)pODBC3SQLSetConnectAttr;
            break;
        case ODBC3SQLGetConnectAttr:

            pFunction = (oslGenericFunction)pODBC3SQLGetConnectAttr;
            break;
        case ODBC3SQLSetEnvAttr:

            pFunction = (oslGenericFunction)pODBC3SQLSetEnvAttr;
            break;
        case ODBC3SQLGetEnvAttr:

            pFunction = (oslGenericFunction)pODBC3SQLGetEnvAttr;
            break;
        case ODBC3SQLSetStmtAttr:

            pFunction = (oslGenericFunction)pODBC3SQLSetStmtAttr;
            break;
        case ODBC3SQLGetStmtAttr:

            pFunction = (oslGenericFunction)pODBC3SQLGetStmtAttr;
            break;
        case ODBC3SQLPrepare:

            pFunction = (oslGenericFunction)pODBC3SQLPrepare;
            break;
        case ODBC3SQLBindParameter:

            pFunction = (oslGenericFunction)pODBC3SQLBindParameter;
            break;
        case ODBC3SQLSetCursorName:

            pFunction = (oslGenericFunction)pODBC3SQLSetCursorName;
            break;
        case ODBC3SQLExecute:

            pFunction = (oslGenericFunction)pODBC3SQLExecute;
            break;
        case ODBC3SQLExecDirect:

            pFunction = (oslGenericFunction)pODBC3SQLExecDirect;
            break;
        case ODBC3SQLDescribeParam:

            pFunction = (oslGenericFunction)pODBC3SQLDescribeParam;
            break;
        case ODBC3SQLNumParams:

            pFunction = (oslGenericFunction)pODBC3SQLNumParams;
            break;
        case ODBC3SQLParamData:

            pFunction = (oslGenericFunction)pODBC3SQLParamData;
            break;
        case ODBC3SQLPutData:

            pFunction = (oslGenericFunction)pODBC3SQLPutData;
            break;
        case ODBC3SQLRowCount:

            pFunction = (oslGenericFunction)pODBC3SQLRowCount;
            break;
        case ODBC3SQLNumResultCols:

            pFunction = (oslGenericFunction)pODBC3SQLNumResultCols;
            break;
        case ODBC3SQLDescribeCol:

            pFunction = (oslGenericFunction)pODBC3SQLDescribeCol;
            break;
        case ODBC3SQLColAttribute:

            pFunction = (oslGenericFunction)pODBC3SQLColAttribute;
            break;
        case ODBC3SQLBindCol:

            pFunction = (oslGenericFunction)pODBC3SQLBindCol;
            break;
        case ODBC3SQLFetch:

            pFunction = (oslGenericFunction)pODBC3SQLFetch;
            break;
        case ODBC3SQLFetchScroll:

            pFunction = (oslGenericFunction)pODBC3SQLFetchScroll;
            break;
        case ODBC3SQLGetData:

            pFunction = (oslGenericFunction)pODBC3SQLGetData;
            break;
        case ODBC3SQLSetPos:

            pFunction = (oslGenericFunction)pODBC3SQLSetPos;
            break;
        case ODBC3SQLBulkOperations:

            pFunction = (oslGenericFunction)pODBC3SQLBulkOperations;
            break;
        case ODBC3SQLMoreResults:

            pFunction = (oslGenericFunction)pODBC3SQLMoreResults;
            break;
        case ODBC3SQLGetDiagRec:

            pFunction = (oslGenericFunction)pODBC3SQLGetDiagRec;
            break;
        case ODBC3SQLColumnPrivileges:

            pFunction = (oslGenericFunction)pODBC3SQLColumnPrivileges;
            break;
        case ODBC3SQLColumns:

            pFunction = (oslGenericFunction)pODBC3SQLColumns;
            break;
        case ODBC3SQLForeignKeys:

            pFunction = (oslGenericFunction)pODBC3SQLForeignKeys;
            break;
        case ODBC3SQLPrimaryKeys:

            pFunction = (oslGenericFunction)pODBC3SQLPrimaryKeys;
            break;
        case ODBC3SQLProcedureColumns:

            pFunction = (oslGenericFunction)pODBC3SQLProcedureColumns;
            break;
        case ODBC3SQLProcedures:

            pFunction = (oslGenericFunction)pODBC3SQLProcedures;
            break;
        case ODBC3SQLSpecialColumns:

            pFunction = (oslGenericFunction)pODBC3SQLSpecialColumns;
            break;
        case ODBC3SQLStatistics:

            pFunction = (oslGenericFunction)pODBC3SQLStatistics;
            break;
        case ODBC3SQLTablePrivileges:

            pFunction = (oslGenericFunction)pODBC3SQLTablePrivileges;
            break;
        case ODBC3SQLTables:

            pFunction = (oslGenericFunction)pODBC3SQLTables;
            break;
        case ODBC3SQLFreeStmt:

            pFunction = (oslGenericFunction)pODBC3SQLFreeStmt;
            break;
        case ODBC3SQLCloseCursor:

            pFunction = (oslGenericFunction)pODBC3SQLCloseCursor;
            break;
        case ODBC3SQLCancel:

            pFunction = (oslGenericFunction)pODBC3SQLCancel;
            break;
        case ODBC3SQLEndTran:

            pFunction = (oslGenericFunction)pODBC3SQLEndTran;
            break;
        case ODBC3SQLDisconnect:

            pFunction = (oslGenericFunction)pODBC3SQLDisconnect;
            break;
        case ODBC3SQLFreeHandle:

            pFunction = (oslGenericFunction)pODBC3SQLFreeHandle;
            break;
        case ODBC3SQLGetCursorName:

            pFunction = (oslGenericFunction)pODBC3SQLGetCursorName;
            break;
        case ODBC3SQLNativeSql:

            pFunction = (oslGenericFunction)pODBC3SQLNativeSql;
            break;
        default:
            OSL_ENSURE(0,"Function unknown!");
    }
    return pFunction;
}
// -----------------------------------------------------------------------------
void ODriver::createNeededDirs(const ::rtl::OUString& sDBName)
{
    ::rtl::OUString sDbWork,sDBConfig,sTemp;

    if(m_sDbWork.getLength())
    {
        sDbWork = m_sDbWorkURL;
        if(!UCBContentHelper::IsFolder(m_sDbWorkURL))
            UCBContentHelper::MakeFolder(m_sDbWorkURL);

        sDbWork += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
        sDbWork += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("wrk"));
        if(!UCBContentHelper::IsFolder(sDbWork))
            UCBContentHelper::MakeFolder(sDbWork);

        sDbWork += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));

        sTemp = sDbWork;
        sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("config"));
        if(!UCBContentHelper::IsFolder(sTemp))
            UCBContentHelper::MakeFolder(sTemp);

        sTemp = sDbWork;
        sTemp += sDBName;
        if(!UCBContentHelper::IsFolder(sTemp))
            UCBContentHelper::MakeFolder(sTemp);
    }

    if(m_sDbConfig.getLength())
    {
        sDBConfig = m_sDbConfigURL;
        if(!UCBContentHelper::IsFolder(sDBConfig))
            UCBContentHelper::MakeFolder(sDBConfig);

        sDBConfig += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
        sTemp = sDBConfig;
        sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("config"));
        if(!UCBContentHelper::IsFolder(sTemp))
            UCBContentHelper::MakeFolder(sTemp);

        sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
        sTemp += sDBName;
        if(UCBContentHelper::Exists(sTemp))
            UCBContentHelper::Kill(sTemp);

#if !(defined(WNT))
        sTemp = sDBConfig;
        sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("diag"));
        if(!UCBContentHelper::IsFolder(sTemp))
            UCBContentHelper::MakeFolder(sTemp);

        sTemp = sDBConfig;
        sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ipc"));
        if(!UCBContentHelper::IsFolder(sTemp))
            UCBContentHelper::MakeFolder(sTemp);

        sTemp = sDBConfig;
        sTemp += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("spool"));
        if(!UCBContentHelper::IsFolder(sTemp))
            UCBContentHelper::MakeFolder(sTemp);
#endif
    }
}
// -----------------------------------------------------------------------------
void ODriver::clearDatabase(const ::rtl::OUString& sDBName)
{ // stop the database
    ::rtl::OUString sCommand;
#if defined(WNT)
    ::rtl::OUString sStop = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("stop"));
    OArgumentList aArgs(2,&sDBName,&sStop);
    sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_cons.exe"));
#else
    OArgumentList aArgs(1,&sDBName);
    sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_clear"));
#endif

    OProcess aApp( sCommand,m_sDbWorkURL);
#if OSL_DEBUG_LEVEL > 0
    OProcess::TProcessError eError =
#endif
        aApp.execute( (OProcess::TProcessOption) OPROCESS_ADABAS, aArgs );
    OSL_ENSURE( eError == OProcess::E_None, "ODriver::clearDatabase: calling the executable failed!" );
}
// -----------------------------------------------------------------------------
void ODriver::createDb( const TDatabaseStruct& _aInfo)
{

    clearDatabase(_aInfo.sDBName);

    X_PARAM(_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword,String::CreateFromAscii("BINIT"));

    String sTemp;
    LocalFileHelper::ConvertURLToPhysicalName(_aInfo.sSysDevSpace,sTemp);

    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SYSDEVSPACE")),sTemp);

    sTemp.Erase();
    LocalFileHelper::ConvertURLToPhysicalName(_aInfo.sTransLogName,sTemp);
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TRANSACTION_LOG")),sTemp);
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXUSERTASKS")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("3")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXDEVSPACES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("7")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXDATADEVSPACES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("5")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXDATAPAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("25599")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXBACKUPDEVS")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MAXSERVERDB")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DATA_CACHE_PAGES")),_aInfo.sCacheSize);
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONV_CACHE_PAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("23")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PROC_DATA_PAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("40")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RUNDIRECTORY")),m_sDbRunDir);
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("KERNELTRACESIZE")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("100")));
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LOG_QUEUE_PAGES")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("10")));

#if !defined(WNT)
    PutParam(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("OPMSG1")),::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/dev/null")));
#endif

    X_PARAM(_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BCHECK")));

    X_START(_aInfo.sDBName);

    //  SHOW_STATE()
    //  %m_sDbRoot%\bin\xutil -d %_aInfo.sDBName% -u %CONUSR%,%CONPWD% -b %INITCMD%
    ::rtl::OUString aBatch2 =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-b "));

//  if(!bBsp && INITCMD.Len() >= 40)
//  {
//      DirEntry aTmp(INITCMD);
//      aTmp.CopyTo(aInitFile, FSYS_ACTION_COPYFILE);
//      INITCMD = aInitFile.GetFull();
//  }
    // generate the init file for the database
    String sInitFile = getDatabaseInitFile(_aInfo);

    LocalFileHelper::ConvertURLToPhysicalName(sInitFile,sTemp);
    aBatch2 += sTemp;
    XUTIL(aBatch2,_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sInitFile))
        UCBContentHelper::Kill(sInitFile);
#endif

    // install system tables
    installSystemTables(_aInfo);
    // now we have to make our SYSDBA user "NOT EXCLUSIVE"
    {
        String sExt;
        sExt.AssignAscii(".sql");

        String sWorkUrl(m_sDbWorkURL);
        ::utl::TempFile aInitFile(String::CreateFromAscii("Init"),&sExt,&sWorkUrl);
        aInitFile.EnableKillingFile();
        {
            ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(aInitFile.GetURL(),STREAM_WRITE) );
            (*pFileStream)  << "ALTER USER \""
                            << _aInfo.sSysUser
                            << "\" NOT EXCLUSIVE "
                            << sNewLine;
            pFileStream->Flush();
        }
        { // just to get sure that the tempfile still lives
            sTemp.Erase();
            LocalFileHelper::ConvertURLToPhysicalName(aInitFile.GetURL(),sTemp);
            LoadBatch(_aInfo.sDBName,_aInfo.sSysUser,_aInfo.sSysPassword,sTemp);
        }
    }
}


//-------------------------------------------------------------------------------------------------
int ODriver::X_PARAM(const ::rtl::OUString& _DBNAME,
            const ::rtl::OUString& _USR,
            const ::rtl::OUString& _PWD,
            const ::rtl::OUString& _CMD)
{
    //  %XPARAM% -u %CONUSR%,%CONPWD% BINIT
    String sCommandFile = generateInitFile();
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);
        (*pFileStream)  << "x_param"
#if defined(WNT)
                        << ".exe"
#endif
                        << " -d "
                        << _DBNAME
                        << " -u "
                        << _USR
                        << ","
                        << _PWD
                        << " "
                        << _CMD
#if defined(WNT)
#if (OSL_DEBUG_LEVEL > 1) || defined(DBG_UTIL)
                        << " >> %DBWORK%\\create.log 2>&1"
#endif
#else
#if (OSL_DEBUG_LEVEL > 1) || defined(DBG_UTIL)
                        << " >> /tmp/kstart.log"
#else
                        << " > /dev/null"
#endif
#endif
                        << " "
                        << sNewLine
                        << sNewLine;

        pFileStream->Flush();
    }

    OProcess aApp(sCommandFile ,m_sDbWorkURL);
#if OSL_DEBUG_LEVEL > 0
    OProcess::TProcessError eError =
#endif
        aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
    OSL_ENSURE( eError == OProcess::E_None, "ODriver::X_PARAM: calling the executable failed!" );
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif

    return 0;
}
// -----------------------------------------------------------------------------
sal_Int32 ODriver::CreateFiles(const TDatabaseStruct& _aInfo)
{
    int nRet = CreateFile(_aInfo.sSysDevSpace,_aInfo.nDataSize/50) ? 0 : -9;
    if(!nRet)
        nRet = CreateFile(_aInfo.sTransLogName,_aInfo.nLogSize) ? 0 : -10;
    if(!nRet)
        nRet = CreateFile(_aInfo.sDataDevName,_aInfo.nDataSize) ? 0 : -11;

    return nRet;

}
// -----------------------------------------------------------------------------
void ODriver::PutParam(const ::rtl::OUString& sDBName,
                      const ::rtl::OUString& rWhat,
                      const ::rtl::OUString& rHow)
{
    OArgumentList aArgs(3,&sDBName,&rWhat,&rHow);
    ::rtl::OUString sCommand = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("putparam"));
#if defined(WNT)
    sCommand += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(".exe"));
#endif

    OProcess aApp(sCommand,m_sDbWorkURL);
#if OSL_DEBUG_LEVEL > 0
    OProcess::TProcessError eError =
#endif
        aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS,aArgs );
    OSL_ENSURE( eError == OProcess::E_None, "ODriver::PutParam: calling the executable failed!" );
}
// -----------------------------------------------------------------------------
sal_Bool ODriver::CreateFile(const ::rtl::OUString &_FileName,
                sal_Int32 _nSize)
{
OSL_TRACE("CreateFile %d",_nSize);
    sal_Bool bOK = sal_True;
    try
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(_FileName,STREAM_WRITE));
        if( !pFileStream.get())
        {
            ::connectivity::SharedResources aResources;
            const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
                    STR_NO_DISK_SPACE,
                    "$filename$",_FileName
                 ) );
            ::dbtools::throwGenericSQLException(sError,*this);
        }
        (*pFileStream).SetFiller('\0');
        sal_Int32 nNewSize = 0;
        sal_Int32 nCount = _nSize /2;
        for(sal_Int32 i=0; bOK && i < nCount; ++i)
        {
            nNewSize += 8192;//4096;
            bOK = (*pFileStream).SetStreamSize(nNewSize);
            pFileStream->Flush();
        }

        bOK = bOK && static_cast<sal_Int32>(pFileStream->Seek(STREAM_SEEK_TO_END)) == nNewSize;
    }
    catch(Exception&)
    {
    OSL_TRACE("Exception");
    }
    if(!bOK)
    {
        ::connectivity::SharedResources aResources;
        const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
                STR_NO_DISK_SPACE,
                "$filename$",_FileName
             ) );
        ::dbtools::throwGenericSQLException(sError,*this);
    }

    return bOK;
    // dd if=/dev/zero bs=4k of=$DEV_NAME count=$2
}
// -----------------------------------------------------------------------------
int ODriver::X_START(const ::rtl::OUString& sDBName)
{
    ::rtl::OUString sCommand;
#if defined(WNT)

    ::rtl::OUString sArg1 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-d"));
    ::rtl::OUString sArg3 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-NoDBService"));
    ::rtl::OUString sArg4 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-NoDBWindow"));

    OArgumentList aArgs(4,&sArg1,&sDBName,&sArg3,&sArg4);
    sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("strt.exe"));
#else
    OArgumentList aArgs(1,&sDBName);
    sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_start"));
#endif

    OProcess aApp( sCommand ,m_sDbWorkURL);
    OProcess::TProcessError eError = aApp.execute((OProcess::TProcessOption)OPROCESS_ADABAS,aArgs);

    if(eError == OProcess::E_NotFound)
    {
        ::connectivity::SharedResources aResources;
        const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
                STR_COMMAND_NOT_FOUND,
                "$databasename$",sDBName,
                "$progname$",sCommand
             ) );
        ::dbtools::throwGenericSQLException(sError,*this);
    }
    OSL_ASSERT(eError == OProcess::E_None);

    OProcess::TProcessInfo aInfo;
    if(aApp.getInfo(OProcess::TData_ExitCode,&aInfo) == OProcess::E_None && aInfo.Code)
        return aInfo.Code;

    return 0;
}
// -----------------------------------------------------------------------------
int ODriver::X_STOP(const ::rtl::OUString& sDBName)
{
    ::rtl::OUString sCommand;
#if defined(WNT)

    ::rtl::OUString sArg1 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-d"));
    ::rtl::OUString sArg2 = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-NoDBService"));

    OArgumentList aArgs(3,&sArg1,&sDBName,&sArg2);
    sCommand =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("stp.exe"));
#else
    OArgumentList aArgs(1,&sDBName);
    sCommand = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("x_stop"));
#endif
    OProcess aApp( sCommand ,m_sDbWorkURL);

    OProcess::TProcessError eError = aApp.execute((OProcess::TProcessOption)OPROCESS_ADABAS,aArgs);


    OSL_ASSERT(eError == OProcess::E_None);
    if(eError != OProcess::E_None)
        return 1;
        OProcess::TProcessInfo aInfo;
    if(aApp.getInfo(OProcess::TData_ExitCode,&aInfo) == OProcess::E_None && aInfo.Code)
        return aInfo.Code;

    return 0;
}
// -----------------------------------------------------------------------------
void ODriver::XUTIL(const ::rtl::OUString& _rParam,
           const ::rtl::OUString& _DBNAME,
           const ::rtl::OUString& _USRNAME,
           const ::rtl::OUString& _USRPWD)
{
    String sWorkUrl(m_sDbWorkURL);
    String sExt = String::CreateFromAscii(".log");
    ::utl::TempFile aCmdFile(String::CreateFromAscii("xutil"),&sExt,&sWorkUrl);
    aCmdFile.EnableKillingFile();

    String sPhysicalPath;
    LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);

    String sCommandFile = generateInitFile();

    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);
        (*pFileStream)  <<
#if defined(WNT)
                            "xutil.exe"
#else
                            "utility"
#endif
                        << " -u "
                        << _USRNAME
                        << ","
                        << _USRPWD
                        << " -d "
                        << _DBNAME
                        << " "
                        << _rParam
                        << " > "
                        << sPhysicalPath
                        << " 2>&1"
                        << sNewLine;
        pFileStream->Flush();
    }

    OProcess aApp(sCommandFile ,m_sDbWorkURL);
#if OSL_DEBUG_LEVEL > 0
    OProcess::TProcessError eError =
#endif
        aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
    OSL_ENSURE( eError == OProcess::E_None, "ODriver::XUTIL: calling the executable failed!" );
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif
}
// -----------------------------------------------------------------------------
void ODriver::LoadBatch(const ::rtl::OUString& sDBName,
               const ::rtl::OUString& _rUSR,
               const ::rtl::OUString& _rPWD,
               const ::rtl::OUString& _rBatch)
{
    OSL_ENSURE(_rBatch.getLength(),"No batch file given!");
    String sWorkUrl(m_sDbWorkURL);
    String sExt = String::CreateFromAscii(".log");
    ::utl::TempFile aCmdFile(String::CreateFromAscii("LoadBatch"),&sExt,&sWorkUrl);
#if OSL_DEBUG_LEVEL < 2
    aCmdFile.EnableKillingFile();
#endif

    String sPhysicalPath;
    LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);

    String sCommandFile = generateInitFile();
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);
        (*pFileStream)  << "xload"
#if defined(WNT)
                        << ".exe"
#endif
                        << " -d "
                        << sDBName
                        << " -u "
                        << _rUSR
                        << ","
                        << _rPWD;

        if ( !isKernelVersion(CURRENT_DB_VERSION) )
            (*pFileStream) << " -S adabas -b ";
        else
            (*pFileStream) << " -S NATIVE -b ";

        (*pFileStream)  << _rBatch
                        << " > "
                        << sPhysicalPath
                        << " 2>&1"
                        << sNewLine;

        pFileStream->Flush();
    }

    OProcess aApp(sCommandFile ,m_sDbWorkURL);
#if OSL_DEBUG_LEVEL > 0
    OProcess::TProcessError eError =
#endif
        aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
    OSL_ENSURE( eError == OProcess::E_None, "ODriver::LoadBatch: calling the executable failed!" );
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif
}
// -----------------------------------------------------------------------------
void ODriver::fillEnvironmentVariables()
{
    // read the environment vars
    struct env_data
    {
        const sal_Char*     pAsciiEnvName;
        ::rtl::OUString*    pValue;
        ::rtl::OUString*    pValueURL;
    } EnvData[] = {
        { "DBWORK",     &m_sDbWork,     &m_sDbWorkURL },
        { "DBCONFIG",   &m_sDbConfig,   &m_sDbConfigURL },
        { "DBROOT",     &m_sDbRoot,     &m_sDbRootURL }
    };

    for ( size_t i = 0; i < sizeof( EnvData ) / sizeof( EnvData[0] ); ++i )
    {
        ::rtl::OUString sVarName = ::rtl::OUString::createFromAscii( EnvData[i].pAsciiEnvName );
        ::rtl::OUString sEnvValue;
        if(osl_getEnvironment( sVarName.pData, &sEnvValue.pData ) == osl_Process_E_None )
        {
            *EnvData[i].pValue = sEnvValue;
            String sURL;
            LocalFileHelper::ConvertPhysicalNameToURL( *EnvData[i].pValue, sURL );
            *EnvData[i].pValueURL = sURL;
        }
    }

    m_sDelimit =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
}
// -----------------------------------------------------------------------------
::rtl::OUString ODriver::generateInitFile() const
{
    String sExt;
#if !defined(WNT)
    sExt = String::CreateFromAscii(".sh");
#else
    sExt = String::CreateFromAscii(".bat");
#endif

    String sWorkUrl(m_sDbWorkURL);
    ::utl::TempFile aCmdFile(String::CreateFromAscii("Init"),&sExt,&sWorkUrl);
#if !defined(WNT)
    String sPhysicalPath;
    LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);
    chmod(ByteString(sPhysicalPath,gsl_getSystemTextEncoding()).GetBuffer(),S_IRUSR|S_IWUSR|S_IXUSR);
#endif

#if !defined(WNT)
    SvStream* pFileStream = aCmdFile.GetStream(STREAM_WRITE);
    (*pFileStream)  << "#!/bin/sh"
                    << sNewLine
                    << "cd \"$DBWORK\""
                    << sNewLine
                    << sNewLine;
    pFileStream->Flush();
#endif

    return aCmdFile.GetURL();
}
// -----------------------------------------------------------------------------
::rtl::OUString ODriver::getDatabaseInitFile(  const TDatabaseStruct& _aDBInfo)
{
    String sExt;
    sExt.AssignAscii(".ins");


    String sWorkUrl(m_sDbWorkURL);
    ::utl::TempFile aInitFile(String::CreateFromAscii("Init"),&sExt,&sWorkUrl);
    {
        SvStream* pFileStream = aInitFile.GetStream(STREAM_WRITE);
        (*pFileStream) << "* @(#)init.cmd  6.1.1   1994-11-10\n";
        (*pFileStream) << "init config\n";
        (*pFileStream) << "* default code:\n";
        (*pFileStream) << "ascii\n";
        (*pFileStream) << "* date time format\n";
        (*pFileStream) << "internal\n";
        (*pFileStream) << "* command timeout:\n";
        (*pFileStream) << "900\n";
        (*pFileStream) << "* lock timeout:\n";
        (*pFileStream) << "360\n";
        (*pFileStream) << "* request timeout:\n";
        (*pFileStream) << "180\n";
        (*pFileStream) << "* log mode:\n";
        (*pFileStream) << "demo\n";
        (*pFileStream) << "* log segment size:\n";
        (*pFileStream) << "0\n";
        (*pFileStream) << "* no of archive logs:\n";
        (*pFileStream) << "0\n";
        (*pFileStream) << "* no of data devspaces:\n";
        (*pFileStream) << "1\n";
        (*pFileStream) << "* mirror devspaces:\n";
        (*pFileStream) << "n\n";
        (*pFileStream) << "if $rc <> 0 then stop\n";
        (*pFileStream) << "*---  device description ---\n";
        (*pFileStream) << "* sys devspace name:\n";
        {
            String sTemp;
            LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sSysDevSpace,sTemp);
            (*pFileStream) << sTemp;
        }
        (*pFileStream) << "\n* log devspace size:\n";
        (*pFileStream) << ::rtl::OString::valueOf(_aDBInfo.nLogSize);
        (*pFileStream) << "\n* log devspace name:\n";
        {
            String sTemp;
            LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sTransLogName,sTemp);
            (*pFileStream) << sTemp;
        }
        (*pFileStream) << "\n* data devspace size:\n";
        (*pFileStream) << ::rtl::OString::valueOf(_aDBInfo.nDataSize);
        (*pFileStream) << "\n* data devspace name:\n";
        {
            String sTemp;
            LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sDataDevName,sTemp);
            (*pFileStream) << sTemp;
        }

        (*pFileStream) << "\n* END INIT CONFIG\n";
        (*pFileStream) << "if $rc <> 0 then stop\n";
        if(_aDBInfo.bRestoreDatabase)
        {
            (*pFileStream) << "RESTORE DATA QUICK FROM '";
            {
                String sTemp;
                LocalFileHelper::ConvertURLToPhysicalName(_aDBInfo.sBackupFile,sTemp);
                (*pFileStream) << sTemp;
            }
            (*pFileStream) << "' BLOCKSIZE 8\n";
            (*pFileStream) << "if $rc <> 0 then stop\n";
            (*pFileStream) << "RESTART\n";

        }
        else
        {
            (*pFileStream) << "ACTIVATE SERVERDB SYSDBA \"";
            (*pFileStream) << _aDBInfo.sSysUser;
            (*pFileStream) << "\" PASSWORD \"";
            (*pFileStream) << _aDBInfo.sSysPassword;
            (*pFileStream) << "\"\n";
        }
        (*pFileStream) << "if $rc <> 0 then stop\n";
        (*pFileStream) << "exit\n";
    }
    return aInitFile.GetURL();
}
// -----------------------------------------------------------------------------
void ODriver::X_CONS(const ::rtl::OUString& sDBName,const ::rtl::OString& _ACTION,const ::rtl::OUString& _FILENAME)
{
    String sPhysicalPath;
    LocalFileHelper::ConvertURLToPhysicalName(_FILENAME,sPhysicalPath);

    String sCommandFile = generateInitFile();
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);

        (*pFileStream)  << "x_cons"
#if defined(WNT)
                        << ".exe"
#endif
                        << " "
                        << sDBName
                        << " SHOW "
                        << _ACTION
                        << " > "
                        << sPhysicalPath
                        << sNewLine;
        pFileStream->Flush();
    }

    OProcess aApp(sCommandFile ,m_sDbWorkURL);
    aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif
}
// -----------------------------------------------------------------------------
void ODriver::checkAndRestart(const ::rtl::OUString& sDBName,const TDatabaseStruct& _rDbInfo)
{
    String sWorkUrl(m_sDbWorkURL);
    String sExt = String::CreateFromAscii(".st");
    ::utl::TempFile aCmdFile(String::CreateFromAscii("State"),&sExt,&sWorkUrl);
    aCmdFile.EnableKillingFile();

    X_CONS(sDBName,"STATE",aCmdFile.GetURL());
    SvStream* pFileStream = aCmdFile.GetStream(STREAM_SHARE_DENYALL);
    if ( pFileStream )
    {
        ByteString sStateLine;
        sal_Bool bRead = sal_True;
        sal_Int32 nStart = 2;
        while(bRead && !pFileStream->IsEof())
        {
            String aLine;
            bRead = pFileStream->ReadLine(sStateLine);
            if(bRead)
            {
                if(sStateLine.Search("WARM") != STRING_NOTFOUND)
                {   // nothing to do
                    nStart = 0;
                    break;
                }
                else if(sStateLine.Search("COLD") != STRING_NOTFOUND)
                {
                    nStart = 1;
                    break;
                }
            }
        }
        switch(nStart)
        {
            case 2:
                clearDatabase(sDBName);
                X_START(sDBName);
                // don't break here
            case 1:
                XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RESTART")),sDBName,_rDbInfo.sControlUser,_rDbInfo.sControlPassword);
            case 0:
                break;
        }
    }
}
// -----------------------------------------------------------------------------
sal_Bool ODriver::isVersion(const ::rtl::OUString& sDBName, const char* _pVersion)
{
    String sWorkUrl(m_sDbWorkURL);
    String sExt = String::CreateFromAscii(".st");
    ::utl::TempFile aCmdFile(String::CreateFromAscii("DevSpaces"),&sExt,&sWorkUrl);
    aCmdFile.EnableKillingFile();

    String sPhysicalPath;
    LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);

    String sCommandFile = generateInitFile();
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);

        (*pFileStream)  << "getparam"
#if defined(WNT)
                        << ".exe"
#endif
                        << " "
                        << sDBName
                        << " KERNELVERSION > "
                        << sPhysicalPath
                        << sNewLine;
    }

    OProcess aApp(sCommandFile ,m_sDbWorkURL);
    aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS);
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif
    SvStream* pFileStream = aCmdFile.GetStream(STREAM_STD_READWRITE);
    ByteString sStateLine;
    sal_Bool bRead = sal_True;
    sal_Bool bIsVersion = sal_False;
    while ( pFileStream && bRead && !pFileStream->IsEof() )
    {
        bRead = pFileStream->ReadLine(sStateLine);
        if ( bRead )
        {
            bIsVersion = sStateLine.GetToken(1,' ').Equals(_pVersion) != 0;
            break;
        }
    }
    return bIsVersion;
}
// -----------------------------------------------------------------------------
void ODriver::checkAndInsertNewDevSpace(const ::rtl::OUString& sDBName,
                                        const TDatabaseStruct& _rDBInfo)
{
    //  %DBROOT%\pgm\getparam %2 DATA_CACHE_PAGES > %3
    String sWorkUrl(m_sDbWorkURL);
    String sExt = String::CreateFromAscii(".st");
    ::utl::TempFile aCmdFile(String::CreateFromAscii("DevSpaces"),&sExt,&sWorkUrl);
    aCmdFile.EnableKillingFile();

    String sPhysicalPath;
    LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);

    String sCommandFile = generateInitFile();
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);

        (*pFileStream)  << "getparam"
#if defined(WNT)
                        << ".exe"
#endif
                        << " "
                        << sDBName
                        << " DATA_CACHE_PAGES > "
                        << sPhysicalPath
                        << sNewLine;
    }

    OProcess aApp(sCommandFile ,m_sDbWorkURL);
    aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS);
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif
    SvStream* pFileStream = aCmdFile.GetStream(STREAM_STD_READWRITE);
    ByteString sStateLine;
    sal_Bool bRead = sal_True;
    sal_Int32 nDataPages = 0;
    while(pFileStream && bRead && !pFileStream->IsEof())
    {
        bRead = pFileStream->ReadLine(sStateLine);
        if(bRead)
        {
            nDataPages = sStateLine.ToInt32();
            if(nDataPages && nDataPages < 100)
            {
                // the space isn't big enough anymore so we increment it
                PutParam(sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DATA_CACHE_PAGES")),::rtl::OUString::valueOf(nDataPages));
                X_PARAM(sDBName,_rDBInfo.sControlUser,_rDBInfo.sControlPassword,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BCHECK")));
            }
        }
    }
}
// -----------------------------------------------------------------------------
sal_Bool ODriver::isKernelVersion(const char* _pVersion)
{
    ::utl::TempFile aCmdFile(String::CreateFromAscii("KernelVersion"));
    aCmdFile.EnableKillingFile();

    String sPhysicalPath;
    LocalFileHelper::ConvertURLToPhysicalName(aCmdFile.GetURL(),sPhysicalPath);

    String sCommandFile = generateInitFile();
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);

        (*pFileStream)  << "dbversion"
                        << " > "
                        << sPhysicalPath
                        << sNewLine;
    }

    OProcess aApp(sCommandFile ,m_sDbWorkURL);
    aApp.execute( (OProcess::TProcessOption)OPROCESS_ADABAS);
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif
    SvStream* pFileStream = aCmdFile.GetStream(STREAM_STD_READWRITE);
    ByteString sStateLine;
    sal_Bool bRead = sal_True;
    sal_Bool bIsVersion = sal_True;
    while ( pFileStream && bRead && !pFileStream->IsEof() )
    {
        bRead = pFileStream->ReadLine(sStateLine);
        if ( bRead )
        {
            // convert a 11.02.00 to a 12.01.30 version
            bIsVersion = sStateLine.GetToken(0).Equals(_pVersion) != 0;
            break;
        }
    }
    return bIsVersion;
}
// -----------------------------------------------------------------------------
void ODriver::installSystemTables(  const TDatabaseStruct& _aInfo)
{
#if defined(WNT)
    //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD% -b %m_sDbRoot%\env\TERMCHAR.ind
    ::rtl::OUString aBatch =  ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-b "));
    ::rtl::OUString sTemp2 = m_sDbRootURL   + m_sDelimit
                                            + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
                                            + m_sDelimit
                                            + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TERMCHAR.ind"));
    String sTemp;
    sal_Bool bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
    aBatch += sTemp;

    XUTIL(aBatch,_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);

    //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD% DIAGNOSE TRIGGER OFF
    XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DIAGNOSE TRIGGER OFF")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
    //  xload -d %_DBNAME% -u %_SYSDBA_USER%,%_SYSDBA_PWD% -S NATIVE -b %m_sDbRoot%\env\DBS.ins %_DOMAINPWD%
    {
        sTemp2 = m_sDbRootURL
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
                                + m_sDelimit
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DBS.ins"));
        sTemp.Erase();
        bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
        OSL_ENSURE(bOk,"File could be converted into file system path!");
        sTemp.AppendAscii(" ");
        sTemp += String(_aInfo.sDomainPassword);

        LoadBatch(_aInfo.sDBName,_aInfo.sSysUser,_aInfo.sSysPassword,sTemp);
    }
    //  xload -d %_DBNAME% -u DOMAIN,%_DOMAINPWD% -S NATIVE -b %m_sDbRoot%\env\XDD.ins
    {
        sTemp2 = m_sDbRootURL
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
                                + m_sDelimit
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("XDD.ins"));
        sTemp.Erase();
        bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
        OSL_ENSURE(bOk,"File could be converted into file system path!");

        LoadBatch(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOMAIN")),_aInfo.sDomainPassword,sTemp);
    }
    //  xload -d %_DBNAME% -u %_SYSDBA_USER%,%_SYSDBA_PWD% -S NATIVE -b %m_sDbRoot%\env\QP.ins
    {
        sTemp2 = m_sDbRootURL
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
                                + m_sDelimit
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("QP.ins"));
        sTemp.Erase();
        bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
        OSL_ENSURE(bOk,"File could be converted into file system path!");
        LoadBatch(_aInfo.sDBName,_aInfo.sSysUser,_aInfo.sSysPassword,sTemp);
    }
    //  xload  -d %_DBNAME% -u DOMAIN,%_DOMAINPWD% -S NATIVE -b %m_sDbRoot%\env\SPROC.ins
    {
        sTemp2 = m_sDbRootURL
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("env"))
                                + m_sDelimit
                                + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SPROC.ins"));
        sTemp.Erase();
        bOk = LocalFileHelper::ConvertURLToPhysicalName(sTemp2,sTemp);
        OSL_ENSURE(bOk,"File could be converted into file system path!");

        LoadBatch(_aInfo.sDBName,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOMAIN")),_aInfo.sDomainPassword,sTemp);
    }

    //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  DIAGNOSE TRIGGER ON
    XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DIAGNOSE TRIGGER ON")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
    //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  SET NOLOG OFF
    XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SET NOLOG OFF")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
    //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  SHUTDOWN QUICK
    XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SHUTDOWN QUICK")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);
    //  xutil -d %_DBNAME% -u %_CONTROL_USER%,%_CONTROL_PWD%  RESTART
    XUTIL(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RESTART")),_aInfo.sDBName,_aInfo.sControlUser,_aInfo.sControlPassword);

#else // UNX
    String sCommandFile = generateInitFile();
    {
        ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READWRITE));
        pFileStream->Seek(STREAM_SEEK_TO_END);
        (*pFileStream)  << "x_dbinst"
                        << " -d "
                        << _aInfo.sDBName
                        << " -u "
                        << _aInfo.sSysUser
                        << ","
                        << _aInfo.sSysPassword
                        << " -w "
                        << _aInfo.sDomainPassword
                        << " -b ";

        if ( isKernelVersion(ADABAS_KERNEL_11) )
            (*pFileStream) << "-i all";
        (*pFileStream)
#if (OSL_DEBUG_LEVEL > 1) || defined(DBG_UTIL)
                    << " >> /tmp/kstart.log"
#else
                    << " > /dev/null"
#endif
                        << sNewLine
                        << sNewLine;
        pFileStream->Flush();
    }
    // now execute the command
    OProcess aApp(sCommandFile ,m_sDbWorkURL);
    aApp.execute( (OProcess::TProcessOption)(OProcess::TOption_Hidden | OProcess::TOption_Wait));
#if OSL_DEBUG_LEVEL < 2
    if(UCBContentHelper::Exists(sCommandFile))
        UCBContentHelper::Kill(sCommandFile);
#endif

#endif //WNT,UNX
}
// -----------------------------------------------------------------------------
void ODriver::convertOldVersion(const ::rtl::OUString& sDBName,const TDatabaseStruct& _rDbInfo)
{
    // first we have to check if this databse is a old version and we have to update the system tables
    if ( !isVersion(sDBName,CURRENT_DB_VERSION) && isKernelVersion(CURRENT_DB_VERSION) )
    {
        if (    !_rDbInfo.sControlUser.getLength()
            ||  !_rDbInfo.sControlPassword.getLength())
        {
            ::connectivity::SharedResources aResources;
            const ::rtl::OUString sError( aResources.getResourceString(STR_DATABASE_NEEDS_CONVERTING) );
            ::dbtools::throwGenericSQLException(sError,*this);
        }
        String sCommandFile = m_sDbWorkURL;
        sCommandFile += String::CreateFromAscii("/xparam.prt");
        if ( UCBContentHelper::Exists(sCommandFile) )
            UCBContentHelper::Kill(sCommandFile);
        X_PARAM(sDBName,_rDbInfo.sControlUser,_rDbInfo.sControlPassword,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BCHECK")));

        if ( UCBContentHelper::Exists(sCommandFile) )
        {
            {
                ::std::auto_ptr<SvStream> pFileStream( UcbStreamHelper::CreateStream(sCommandFile,STREAM_STD_READ) );
                ByteString sStateLine;
                sal_Bool bRead = sal_True;
                static ByteString s_ErrorId("-21100");
                while ( pFileStream.get() && bRead && !pFileStream->IsEof() )
                {
                    bRead = pFileStream->ReadLine(sStateLine);
                    if ( bRead && s_ErrorId == sStateLine.GetToken(0,' ') )
                    {
                        UCBContentHelper::Kill(sCommandFile);
                        ::rtl::OUString sError(::rtl::OUString::createFromAscii(sStateLine.GetBuffer()));
                        throw SQLException(sError,*this,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000")),1000,Any());
                    }
                }
            }

            UCBContentHelper::Kill(sCommandFile);
        }
    }
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
    } // namespace adabas
}// namespace connectivity
// -----------------------------------------------------------------------------