xref: /aoo41x/main/connectivity/source/drivers/adabas/BDriver.cxx (revision 24c56ab9)

/**************************************************************
 *
 * 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
// -----------------------------------------------------------------------------