/**************************************************************
 * 
 * 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_sc.hxx"


// INCLUDE ---------------------------------------------------------------

#include <stdio.h>
#include <tools/urlobj.hxx>
#include <svl/converter.hxx>
#include <svl/zforlist.hxx>
#include <comphelper/types.hxx>
#include <ucbhelper/content.hxx>
#include <unotools/sharedunocomponent.hxx>
#include <comphelper/processfactory.hxx>
#include <svx/txenctab.hxx>
#include <svx/dbcharsethelper.hxx>

#include <com/sun/star/sdb/CommandType.hpp>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/sdbc/XConnection.hpp>
#include <com/sun/star/sdbc/XDriver.hpp>
#include <com/sun/star/sdbc/XDriverAccess.hpp>
#include <com/sun/star/sdbc/XDriverManager.hpp>
#include <com/sun/star/sdbc/XResultSetUpdate.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/sdbc/XRowSet.hpp>
#include <com/sun/star/sdbc/XRowUpdate.hpp>
#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
#include <com/sun/star/sdbcx/XAppend.hpp>
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#include <com/sun/star/sdbcx/XDataDefinitionSupplier.hpp>
#include <com/sun/star/sdbcx/XDataDescriptorFactory.hpp>
#include <com/sun/star/sdbcx/XTablesSupplier.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/container/XEnumerationAccess.hpp>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/ucb/NameClash.hpp>
#include <com/sun/star/ucb/TransferInfo.hpp>
#include <com/sun/star/ucb/XCommandInfo.hpp>

#include "scerrors.hxx"
#include "docsh.hxx"
#include "filter.hxx"
#include "progress.hxx"
#include "collect.hxx"
#include "cell.hxx"
#include "editutil.hxx"
#include "cellform.hxx"
#include "dbdocutl.hxx"
#include "dociter.hxx"
#include "globstr.hrc"

using namespace com::sun::star;

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

#define SC_SERVICE_ROWSET			"com.sun.star.sdb.RowSet"
#define SC_SERVICE_DRVMAN			"com.sun.star.sdbc.DriverManager"

//!	move to a header file?
//#define SC_DBPROP_DATASOURCENAME	"DataSourceName"
#define SC_DBPROP_ACTIVECONNECTION	"ActiveConnection"
#define SC_DBPROP_COMMAND			"Command"
#define SC_DBPROP_COMMANDTYPE		"CommandType"

#define SC_DBPROP_NAME				"Name"
#define SC_DBPROP_TYPE				"Type"
#define SC_DBPROP_PRECISION			"Precision"
#define SC_DBPROP_SCALE				"Scale"

#define SC_DBPROP_EXTENSION			"Extension"
#define SC_DBPROP_CHARSET			"CharSet"

#define SC_ROWCOUNT_ERROR		(-1)

namespace
{
    sal_uLong lcl_getDBaseConnection(uno::Reference<sdbc::XDriverManager>& _rDrvMgr,uno::Reference<sdbc::XConnection>& _rConnection,String& _rTabName,const String& rFullFileName,rtl_TextEncoding eCharSet)
    {
        INetURLObject aURL;
	    aURL.SetSmartProtocol( INET_PROT_FILE );
	    aURL.SetSmartURL( rFullFileName );
        _rTabName = aURL.getBase( INetURLObject::LAST_SEGMENT, true,
                INetURLObject::DECODE_UNAMBIGUOUS );
	    String aExtension = aURL.getExtension();
	    aURL.removeSegment();
	    aURL.removeFinalSlash();
	    String aPath = aURL.GetMainURL(INetURLObject::NO_DECODE);
        uno::Reference<lang::XMultiServiceFactory> xFactory = comphelper::getProcessServiceFactory();
		if (!xFactory.is()) return SCERR_EXPORT_CONNECT;

		_rDrvMgr.set( xFactory->createInstance(
							rtl::OUString::createFromAscii( SC_SERVICE_DRVMAN ) ),
							uno::UNO_QUERY);
		DBG_ASSERT( _rDrvMgr.is(), "can't get DriverManager" );
		if (!_rDrvMgr.is()) return SCERR_EXPORT_CONNECT;

		// get connection

		String aConnUrl = String::CreateFromAscii("sdbc:dbase:");
		aConnUrl += aPath;

		svxform::ODataAccessCharsetHelper aHelper;
        ::std::vector< rtl_TextEncoding > aEncodings;
        aHelper.getSupportedTextEncodings( aEncodings );
        ::std::vector< rtl_TextEncoding >::iterator aIter = ::std::find(aEncodings.begin(),aEncodings.end(),(rtl_TextEncoding) eCharSet);
        if ( aIter == aEncodings.end() )
        {
            DBG_ERRORFILE( "DBaseImport: dbtools::OCharsetMap doesn't know text encoding" );
            return SCERR_IMPORT_CONNECT;
        } // if ( aIter == aMap.end() )
        rtl::OUString aCharSetStr;
        if ( RTL_TEXTENCODING_DONTKNOW != *aIter )
		{	// it's not the virtual "system charset"
			const char* pIanaName = rtl_getMimeCharsetFromTextEncoding( *aIter );
			OSL_ENSURE( pIanaName, "invalid mime name!" );
			if ( pIanaName )
				aCharSetStr = ::rtl::OUString::createFromAscii( pIanaName );
		}

		uno::Sequence<beans::PropertyValue> aProps(2);
		aProps[0].Name = rtl::OUString::createFromAscii(SC_DBPROP_EXTENSION);
		aProps[0].Value <<= rtl::OUString( aExtension );
		aProps[1].Name = rtl::OUString::createFromAscii(SC_DBPROP_CHARSET);
		aProps[1].Value <<= aCharSetStr;

		_rConnection = _rDrvMgr->getConnectionWithInfo( aConnUrl, aProps );
        return 0L;
    }
}
// -----------------------------------------------------------------------
// MoveFile/KillFile/IsDocument: similar to SfxContentHelper

// static
sal_Bool ScDocShell::MoveFile( const INetURLObject& rSourceObj, const INetURLObject& rDestObj )
{
	sal_Bool bMoveData = sal_True;
	sal_Bool bRet = sal_True, bKillSource = sal_False;
	if ( rSourceObj.GetProtocol() != rDestObj.GetProtocol() )
	{
		bMoveData = sal_False;
		bKillSource = sal_True;
	}
	String aName = rDestObj.getName();
	INetURLObject aDestPathObj = rDestObj;
	aDestPathObj.removeSegment();
	aDestPathObj.setFinalSlash();

	try
	{
		::ucbhelper::Content aDestPath( aDestPathObj.GetMainURL(INetURLObject::NO_DECODE),
							uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () );
		uno::Reference< ::com::sun::star::ucb::XCommandInfo > xInfo = aDestPath.getCommands();
		rtl::OUString aTransferName = rtl::OUString::createFromAscii( "transfer" );
		if ( xInfo->hasCommandByName( aTransferName ) )
		{
			aDestPath.executeCommand( aTransferName, uno::makeAny(
                ::com::sun::star::ucb::TransferInfo( bMoveData, rSourceObj.GetMainURL(INetURLObject::NO_DECODE), aName,
               										::com::sun::star::ucb::NameClash::ERROR ) ) );
		}
		else
		{
			DBG_ERRORFILE( "transfer command not available" );
		}
	}
	catch( uno::Exception& )
	{
		// ucb may throw different exceptions on failure now
		bRet = sal_False;
	}

	if ( bKillSource )
		KillFile( rSourceObj );

	return bRet;
}


// static
sal_Bool ScDocShell::KillFile( const INetURLObject& rURL )
{
	sal_Bool bRet = sal_True;
	try
	{
		::ucbhelper::Content aCnt( rURL.GetMainURL(INetURLObject::NO_DECODE),
						uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () );
		aCnt.executeCommand( rtl::OUString::createFromAscii( "delete" ),
								comphelper::makeBoolAny( sal_True ) );
	}
	catch( uno::Exception& )
	{
		// ucb may throw different exceptions on failure now
		bRet = sal_False;
	}

	return bRet;
}

// static
sal_Bool ScDocShell::IsDocument( const INetURLObject& rURL )
{
	sal_Bool bRet = sal_False;
	try
	{
		::ucbhelper::Content aCnt( rURL.GetMainURL(INetURLObject::NO_DECODE),
						uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () );
		bRet = aCnt.isDocument();
	}
    catch( uno::Exception& )
	{
		// ucb may throw different exceptions on failure now - warning only
		DBG_WARNING( "Any other exception" );
	}

	return bRet;
}

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

sal_uLong ScDocShell::DBaseImport( const String& rFullFileName, CharSet eCharSet,
								sal_Bool bSimpleColWidth[MAXCOLCOUNT] )
{
	sal_uLong nErr = eERR_OK;
	long i;
    long nColCount = 0;

	try
	{
		String aTabName;
        uno::Reference<sdbc::XDriverManager> xDrvMan;
        uno::Reference<sdbc::XConnection> xConnection;
		sal_uLong nRet = lcl_getDBaseConnection(xDrvMan,xConnection,aTabName,rFullFileName,eCharSet);
        if ( !xConnection.is() || !xDrvMan.is() )
            return nRet;
        ::utl::DisposableComponent aConnectionHelper(xConnection);
		
        ScProgress aProgress( this, ScGlobal::GetRscString( STR_LOAD_DOC ), 0 );
        uno::Reference<lang::XMultiServiceFactory> xFactory = comphelper::getProcessServiceFactory();
		uno::Reference<sdbc::XRowSet> xRowSet( xFactory->createInstance(
							rtl::OUString::createFromAscii( SC_SERVICE_ROWSET ) ),
							uno::UNO_QUERY);
        ::utl::DisposableComponent aRowSetHelper(xRowSet);
		uno::Reference<beans::XPropertySet> xRowProp( xRowSet, uno::UNO_QUERY );
		DBG_ASSERT( xRowProp.is(), "can't get RowSet" );
		if (!xRowProp.is()) return SCERR_IMPORT_CONNECT;

		sal_Int32 nType = sdb::CommandType::TABLE;
		uno::Any aAny;

		aAny <<= xConnection;
		xRowProp->setPropertyValue(
					rtl::OUString::createFromAscii(SC_DBPROP_ACTIVECONNECTION), aAny );

		aAny <<= nType;
		xRowProp->setPropertyValue(
					rtl::OUString::createFromAscii(SC_DBPROP_COMMANDTYPE), aAny );

		aAny <<= rtl::OUString( aTabName );
		xRowProp->setPropertyValue(
					rtl::OUString::createFromAscii(SC_DBPROP_COMMAND), aAny );

		xRowSet->execute();

		uno::Reference<sdbc::XResultSetMetaData> xMeta;
		uno::Reference<sdbc::XResultSetMetaDataSupplier> xMetaSupp( xRowSet, uno::UNO_QUERY );
		if ( xMetaSupp.is() )
			xMeta = xMetaSupp->getMetaData();
		if ( xMeta.is() )
			nColCount = xMeta->getColumnCount();	// this is the number of real columns

		if ( nColCount > MAXCOL+1 )
		{
			nColCount = MAXCOL+1;
			nErr = SCWARN_IMPORT_RANGE_OVERFLOW;	// warning
		}

		uno::Reference<sdbc::XRow> xRow( xRowSet, uno::UNO_QUERY );
		DBG_ASSERT( xRow.is(), "can't get Row" );
		if (!xRow.is()) return SCERR_IMPORT_CONNECT;

		// currency flag is not needed for dBase
		uno::Sequence<sal_Int32> aColTypes( nColCount );	// column types
		sal_Int32* pTypeArr = aColTypes.getArray();
		for (i=0; i<nColCount; i++)
			pTypeArr[i] = xMeta->getColumnType( i+1 );

		//	read column names
		//!	add type descriptions

        aProgress.SetState( 0 );
        ScColumn::bDoubleAlloc = sal_True;      // row count isn't readily available in advance

		for (i=0; i<nColCount; i++)
		{
			String aHeader = xMeta->getColumnLabel( i+1 );

			switch ( pTypeArr[i] )
			{
				case sdbc::DataType::BIT:
					aHeader.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",L" ));
					break;
				case sdbc::DataType::DATE:
					aHeader.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",D" ));
					break;
				case sdbc::DataType::LONGVARCHAR:
					aHeader.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",M" ));
					break;
				case sdbc::DataType::VARCHAR:
					aHeader.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",C," ));
					aHeader += String::CreateFromInt32( xMeta->getColumnDisplaySize( i+1 ) );
					break;
				case sdbc::DataType::DECIMAL:
					{
						long nPrec = xMeta->getPrecision( i+1 );
						long nScale = xMeta->getScale( i+1 );
						aHeader.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",N," ));
						aHeader += String::CreateFromInt32(
									SvDbaseConverter::ConvertPrecisionToDbase(
										nPrec, nScale ) );
						aHeader += ',';
						aHeader += String::CreateFromInt32( nScale );
					}
					break;
			}

			aDocument.SetString( static_cast<SCCOL>(i), 0, 0, aHeader );
		}

		SCROW nRow = 1;		// 0 is column titles
		sal_Bool bEnd = sal_False;
		while ( !bEnd && xRowSet->next() )
		{
			if ( nRow <= MAXROW )
			{
				SCCOL nCol = 0;
				for (i=0; i<nColCount; i++)
				{
					ScDatabaseDocUtil::PutData( &aDocument, nCol, nRow, 0,
												xRow, i+1, pTypeArr[i], sal_False,
												&bSimpleColWidth[nCol] );
					++nCol;
				}
				++nRow;
			}
			else		// past the end of the spreadsheet
			{
				bEnd = sal_True;							// don't continue
				nErr = SCWARN_IMPORT_RANGE_OVERFLOW;	// warning message
			}
		}
	}
	catch ( sdbc::SQLException& )
	{
		nErr = SCERR_IMPORT_CONNECT;
	}
	catch ( uno::Exception& )
	{
		DBG_ERROR("Unexpected exception in database");
		nErr = ERRCODE_IO_GENERAL;
	}

    ScColumn::bDoubleAlloc = sal_False;
    if ( nColCount > 0 )
        aDocument.DoColResize( 0, 0, static_cast<SCCOL>(nColCount) - 1, 0 );

	return nErr;
}

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

inline sal_Bool IsAsciiDigit( sal_Unicode c )
{
	return 0x30 <= c && c <= 0x39;
}

inline sal_Bool IsAsciiAlpha( sal_Unicode c )
{
	return (0x41 <= c && c <= 0x5a) || (0x61 <= c && c <= 0x7a);
}

void lcl_GetColumnTypes( ScDocShell& rDocShell,
							const ScRange& rDataRange, sal_Bool bHasFieldNames,
							rtl::OUString* pColNames, sal_Int32* pColTypes,
							sal_Int32* pColLengths, sal_Int32* pColScales,
							sal_Bool& bHasMemo, CharSet eCharSet )
{
	//	updating of column titles didn't work in 5.2 and isn't always wanted
	//	(saving normally shouldn't modify the document)
	//!	read flag from configuration
	sal_Bool bUpdateTitles = sal_False;

	ScDocument* pDoc = rDocShell.GetDocument();
	SvNumberFormatter* pNumFmt = pDoc->GetFormatTable();

	SCTAB nTab = rDataRange.aStart.Tab();
	SCCOL nFirstCol = rDataRange.aStart.Col();
	SCROW nFirstRow = rDataRange.aStart.Row();
	SCCOL nLastCol = rDataRange.aEnd.Col();
	SCROW nLastRow = rDataRange.aEnd.Row();

	ScStrCollection aFieldNamesCollection;

	long nField = 0;
	SCROW nFirstDataRow = ( bHasFieldNames ? nFirstRow + 1 : nFirstRow );
	for ( SCCOL nCol = nFirstCol; nCol <= nLastCol; nCol++ )
	{
		sal_Bool bTypeDefined = sal_False;
		sal_Bool bPrecDefined = sal_False;
		sal_Int32 nFieldLen = 0;
		sal_Int32 nPrecision = 0;
		sal_Int32 nDbType = sdbc::DataType::SQLNULL;
		String aFieldName, aString;

		// Feldname[,Type[,Width[,Prec]]]
		// Typ etc.: L; D; C[,W]; N[,W[,P]]
		if ( bHasFieldNames )
		{
			pDoc->GetString( nCol, nFirstRow, nTab, aString );
			aString.ToUpperAscii();
			xub_StrLen nToken = aString.GetTokenCount( ',' );
			if ( nToken > 1 )
			{
				aFieldName = aString.GetToken( 0, ',' );
				aString.EraseAllChars( ' ' );
				switch ( aString.GetToken( 1, ',' ).GetChar(0) )
				{
					case 'L' :
						nDbType = sdbc::DataType::BIT;
						nFieldLen = 1;
						bTypeDefined = sal_True;
						bPrecDefined = sal_True;
						break;
					case 'D' :
						nDbType = sdbc::DataType::DATE;
						nFieldLen = 8;
						bTypeDefined = sal_True;
						bPrecDefined = sal_True;
						break;
					case 'M' :
						nDbType = sdbc::DataType::LONGVARCHAR;
						nFieldLen = 10;
						bTypeDefined = sal_True;
						bPrecDefined = sal_True;
						bHasMemo = sal_True;
						break;
					case 'C' :
						nDbType = sdbc::DataType::VARCHAR;
						bTypeDefined = sal_True;
						bPrecDefined = sal_True;
						break;
					case 'N' :
						nDbType = sdbc::DataType::DECIMAL;
						bTypeDefined = sal_True;
						break;
				}
				if ( bTypeDefined && !nFieldLen && nToken > 2 )
				{
					nFieldLen = aString.GetToken( 2, ',' ).ToInt32();
					if ( !bPrecDefined && nToken > 3 )
					{
						String aTmp( aString.GetToken( 3, ',' ) );
						if ( CharClass::isAsciiNumeric(aTmp) )
						{
							nPrecision = aTmp.ToInt32();
							bPrecDefined = sal_True;
						}
					}
				}
			}
			else
				aFieldName = aString;

			// Feldnamen pruefen und ggbf. gueltigen Feldnamen erzeugen.
			// Erstes Zeichen muss Buchstabe sein,
			// weitere nur alphanumerisch und Unterstrich erlaubt,
			// "_DBASELOCK" ist reserviert (obsolet weil erstes Zeichen kein Buchstabe),
			// keine doppelten Namen.
			if ( !IsAsciiAlpha( aFieldName.GetChar(0) ) )
				aFieldName.Insert( 'N', 0 );
			String aTmpStr;
			sal_Unicode c;
            for ( const sal_Unicode* p = aFieldName.GetBuffer(); ( c = *p ) != 0; p++ )
			{
				if ( IsAsciiAlpha( c ) || IsAsciiDigit( c ) || c == '_' )
					aTmpStr += c;
				else
					aTmpStr += '_';
			}
			aFieldName = aTmpStr;
			if ( aFieldName.Len() > 10 )
				aFieldName.Erase( 10 );
			StrData* pStrData = new StrData( aFieldName );
			if ( !aFieldNamesCollection.Insert( pStrData ) )
			{	// doppelter Feldname, numerisch erweitern
				sal_uInt16 nSub = 1;
				String aFixPart( aFieldName );
				do
				{
					++nSub;
					String aVarPart = String::CreateFromInt32( nSub );
					if ( aFixPart.Len() + aVarPart.Len() > 10 )
						aFixPart.Erase( 10 - aVarPart.Len() );
					aFieldName = aFixPart;
					aFieldName += aVarPart;
					pStrData->SetString( aFieldName );
				} while ( !aFieldNamesCollection.Insert( pStrData ) );
			}
		}
		else
		{
			aFieldName = 'N';
			aFieldName += String::CreateFromInt32(nCol+1);
		}

		if ( !bTypeDefined )
		{	// Feldtyp
			ScBaseCell* pCell;
			pDoc->GetCell( nCol, nFirstDataRow, nTab, pCell );
			if ( !pCell || pCell->HasStringData() )
				nDbType = sdbc::DataType::VARCHAR;
			else
			{
				sal_uInt32 nFormat;
				pDoc->GetNumberFormat( nCol, nFirstDataRow, nTab, nFormat );
				if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA
				  && ((nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0) )
				{
					nFormat = ScGlobal::GetStandardFormat(
						((ScFormulaCell*)pCell)->GetValue(), *pNumFmt, nFormat,
						((ScFormulaCell*)pCell)->GetFormatType() );
				}
				switch ( pNumFmt->GetType( nFormat ) )
				{
					case NUMBERFORMAT_LOGICAL :
						nDbType = sdbc::DataType::BIT;
						nFieldLen = 1;
						break;
					case NUMBERFORMAT_DATE :
						nDbType = sdbc::DataType::DATE;
						nFieldLen = 8;
						break;
					case NUMBERFORMAT_TIME :
					case NUMBERFORMAT_DATETIME :
						nDbType = sdbc::DataType::VARCHAR;
						break;
					default:
						nDbType = sdbc::DataType::DECIMAL;
				}
			}
		}
		sal_Bool bSdbLenAdjusted = sal_False;
		sal_Bool bSdbLenBad = sal_False;
		// Feldlaenge
		if ( nDbType == sdbc::DataType::VARCHAR && !nFieldLen )
		{	// maximale Feldbreite bestimmen
			nFieldLen = pDoc->GetMaxStringLen( nTab, nCol, nFirstDataRow,
				nLastRow, eCharSet );
			if ( nFieldLen == 0 )
				nFieldLen = 1;
		}
        else if ( nDbType == sdbc::DataType::DECIMAL )
        {	// maximale Feldbreite und Nachkommastellen bestimmen
            xub_StrLen nLen;
            sal_uInt16 nPrec;
            nLen = pDoc->GetMaxNumberStringLen( nPrec, nTab, nCol,
                nFirstDataRow, nLastRow );
            // dBaseIII Limit Nachkommastellen: 15
			if ( nPrecision > 15 )
				nPrecision = 15;
			if ( nPrec > 15 )
				nPrec = 15;
			if ( bPrecDefined && nPrecision != nPrec )
			{	// Laenge auf vorgegebene Nachkommastellen anpassen
				if ( nPrecision )
                    nLen = sal::static_int_cast<xub_StrLen>( nLen + ( nPrecision - nPrec ) );
				else
					nLen -= nPrec+1;			// auch den . mit raus
			}
			if ( nLen > nFieldLen && !bTypeDefined )
				nFieldLen = nLen;
			if ( !bPrecDefined )
				nPrecision = nPrec;
			if ( nFieldLen == 0 )
				nFieldLen = 1;
			else if ( nFieldLen > 19 )
				nFieldLen = 19;		// dBaseIII Limit Feldlaenge numerisch: 19
			if ( nPrecision && nFieldLen < nPrecision + 2 )
				nFieldLen = nPrecision + 2;		// 0. muss mit reinpassen
			// 538 MUST: Sdb internal representation adds 2 to the field length!
			// To give the user what he wants we must substract it here.
 			//! CAVEAT! There is no way to define a numeric field with a length
 			//! of 1 and no decimals!
			if ( nFieldLen == 1 && nPrecision == 0 )
				bSdbLenBad = sal_True;
			nFieldLen = SvDbaseConverter::ConvertPrecisionToOdbc( nFieldLen, nPrecision );
			bSdbLenAdjusted = sal_True;
		}
		if ( nFieldLen > 254 )
		{
			if ( nDbType == sdbc::DataType::VARCHAR )
			{	// zu lang fuer normales Textfeld => Memofeld
				nDbType = sdbc::DataType::LONGVARCHAR;
				nFieldLen = 10;
				bHasMemo = sal_True;
			}
			else
				nFieldLen = 254;					// dumm gelaufen..
		}

		pColNames[nField] = aFieldName;
		pColTypes[nField] = nDbType;
		pColLengths[nField] = nFieldLen;
		pColScales[nField] = nPrecision;

		// undo change to field length, reflect reality
		if ( bSdbLenAdjusted )
		{
			nFieldLen = SvDbaseConverter::ConvertPrecisionToDbase( nFieldLen, nPrecision );
			if ( bSdbLenBad && nFieldLen == 1 )
				nFieldLen = 2;		// THIS is reality
		}
		if ( bUpdateTitles )
		{	// Angabe anpassen und ausgeben
			String aOutString = aFieldName;
			switch ( nDbType )
			{
				case sdbc::DataType::BIT :
					aOutString.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",L" ));
					break;
				case sdbc::DataType::DATE :
					aOutString.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",D" ));
					break;
				case sdbc::DataType::LONGVARCHAR :
					aOutString.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",M" ));
					break;
				case sdbc::DataType::VARCHAR :
					aOutString.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",C," ));
					aOutString += String::CreateFromInt32( nFieldLen );
					break;
				case sdbc::DataType::DECIMAL :
					aOutString.AppendAscii(RTL_CONSTASCII_STRINGPARAM( ",N," ));
					aOutString += String::CreateFromInt32( nFieldLen );
					aOutString += ',';
					aOutString += String::CreateFromInt32( nPrecision );
					break;
			}
			if ( !aOutString.EqualsIgnoreCaseAscii( aString ) )
			{
				pDoc->SetString( nCol, nFirstRow, nTab, aOutString );
				rDocShell.PostPaint( nCol, nFirstRow, nTab, nCol, nFirstRow, nTab, PAINT_GRID );
			}
		}
		++nField;
	}
}


inline void lcl_getLongVarCharEditString( String& rString,
        const ScBaseCell* pCell, ScFieldEditEngine& rEditEngine )
{
    rEditEngine.SetText( *((const ScEditCell*)pCell)->GetData() );
    rString = rEditEngine.GetText( LINEEND_CRLF );
}

inline void lcl_getLongVarCharString( String& rString, ScBaseCell* pCell,
        ScDocument& rDocument, SCCOL nCol, SCROW nRow, SCTAB nTab,
        SvNumberFormatter& rNumFmt )
{
    sal_uInt32 nFormat;
    Color* pColor;
    rDocument.GetNumberFormat( nCol, nRow, nTab, nFormat );
    ScCellFormat::GetString( pCell, nFormat, rString, &pColor, rNumFmt );
}


sal_uLong ScDocShell::DBaseExport( const String& rFullFileName, CharSet eCharSet, sal_Bool& bHasMemo )
{
	// remove the file so the dBase driver doesn't find an invalid file
	INetURLObject aDeleteObj( rFullFileName, INET_PROT_FILE );
	KillFile( aDeleteObj );

	sal_uLong nErr = eERR_OK;
	uno::Any aAny;

	SCCOL nFirstCol, nLastCol;
	SCROW  nFirstRow, nLastRow;
	SCTAB nTab = GetSaveTab();
	aDocument.GetDataStart( nTab, nFirstCol, nFirstRow );
	aDocument.GetCellArea( nTab, nLastCol, nLastRow );
    if ( nFirstCol > nLastCol )
        nFirstCol = nLastCol;
    if ( nFirstRow > nLastRow )
        nFirstRow = nLastRow;
	ScProgress aProgress( this, ScGlobal::GetRscString( STR_SAVE_DOC ),
													nLastRow - nFirstRow );
	SvNumberFormatter* pNumFmt = aDocument.GetFormatTable();

	sal_Bool bHasFieldNames = sal_True;
	for ( SCCOL nDocCol = nFirstCol; nDocCol <= nLastCol && bHasFieldNames; nDocCol++ )
	{	// nur Strings in erster Zeile => sind Feldnamen
		if ( !aDocument.HasStringData( nDocCol, nFirstRow, nTab ) )
			bHasFieldNames = sal_False;
	}

	long nColCount = nLastCol - nFirstCol + 1;
	uno::Sequence<rtl::OUString> aColNames( nColCount );
	uno::Sequence<sal_Int32> aColTypes( nColCount );
	uno::Sequence<sal_Int32> aColLengths( nColCount );
	uno::Sequence<sal_Int32> aColScales( nColCount );

	ScRange aDataRange( nFirstCol, nFirstRow, nTab, nLastCol, nLastRow, nTab );
	lcl_GetColumnTypes( *this, aDataRange, bHasFieldNames,
						aColNames.getArray(), aColTypes.getArray(),
						aColLengths.getArray(), aColScales.getArray(),
						bHasMemo, eCharSet );
    // also needed for exception catch
    SCROW nDocRow = 0;
    ScFieldEditEngine aEditEngine( aDocument.GetEditPool() );
    String aString;
    String aTabName;

	try
	{
        uno::Reference<sdbc::XDriverManager> xDrvMan;
        uno::Reference<sdbc::XConnection> xConnection;
		sal_uLong nRet = lcl_getDBaseConnection(xDrvMan,xConnection,aTabName,rFullFileName,eCharSet);
        if ( !xConnection.is() || !xDrvMan.is() )
            return nRet;
        ::utl::DisposableComponent aConnectionHelper(xConnection);

		// get dBase driver
        uno::Reference< sdbc::XDriverAccess> xAccess(xDrvMan,uno::UNO_QUERY);
        uno::Reference< sdbcx::XDataDefinitionSupplier > xDDSup( xAccess->getDriverByURL( xConnection->getMetaData()->getURL() ), uno::UNO_QUERY );
		if ( !xDDSup.is() ) 
            return SCERR_EXPORT_CONNECT;

		// create table
		uno::Reference<sdbcx::XTablesSupplier> xTablesSupp =xDDSup->getDataDefinitionByConnection( xConnection );
		DBG_ASSERT( xTablesSupp.is(), "can't get Data Definition" );
		if (!xTablesSupp.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<container::XNameAccess> xTables = xTablesSupp->getTables();
		DBG_ASSERT( xTables.is(), "can't get Tables" );
		if (!xTables.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<sdbcx::XDataDescriptorFactory> xTablesFact( xTables, uno::UNO_QUERY );
		DBG_ASSERT( xTablesFact.is(), "can't get tables factory" );
		if (!xTablesFact.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<sdbcx::XAppend> xTablesAppend( xTables, uno::UNO_QUERY );
		DBG_ASSERT( xTablesAppend.is(), "can't get tables XAppend" );
		if (!xTablesAppend.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<beans::XPropertySet> xTableDesc = xTablesFact->createDataDescriptor();
		DBG_ASSERT( xTableDesc.is(), "can't get table descriptor" );
		if (!xTableDesc.is()) return SCERR_EXPORT_CONNECT;

		aAny <<= rtl::OUString( aTabName );
		xTableDesc->setPropertyValue( rtl::OUString::createFromAscii(SC_DBPROP_NAME), aAny );

		// create columns

		uno::Reference<sdbcx::XColumnsSupplier> xColumnsSupp( xTableDesc, uno::UNO_QUERY );
		DBG_ASSERT( xColumnsSupp.is(), "can't get columns supplier" );
		if (!xColumnsSupp.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<container::XNameAccess> xColumns = xColumnsSupp->getColumns();
		DBG_ASSERT( xColumns.is(), "can't get columns" );
		if (!xColumns.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<sdbcx::XDataDescriptorFactory> xColumnsFact( xColumns, uno::UNO_QUERY );
		DBG_ASSERT( xColumnsFact.is(), "can't get columns factory" );
		if (!xColumnsFact.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<sdbcx::XAppend> xColumnsAppend( xColumns, uno::UNO_QUERY );
		DBG_ASSERT( xColumnsAppend.is(), "can't get columns XAppend" );
		if (!xColumnsAppend.is()) return SCERR_EXPORT_CONNECT;

		const rtl::OUString* pColNames = aColNames.getConstArray();
		const sal_Int32* pColTypes     = aColTypes.getConstArray();
		const sal_Int32* pColLengths   = aColLengths.getConstArray();
		const sal_Int32* pColScales    = aColScales.getConstArray();
		long nCol;

		for (nCol=0; nCol<nColCount; nCol++)
		{
			uno::Reference<beans::XPropertySet> xColumnDesc = xColumnsFact->createDataDescriptor();
			DBG_ASSERT( xColumnDesc.is(), "can't get column descriptor" );
			if (!xColumnDesc.is()) return SCERR_EXPORT_CONNECT;

			aAny <<= pColNames[nCol];
			xColumnDesc->setPropertyValue( rtl::OUString::createFromAscii(SC_DBPROP_NAME), aAny );

			aAny <<= pColTypes[nCol];
			xColumnDesc->setPropertyValue( rtl::OUString::createFromAscii(SC_DBPROP_TYPE), aAny );

			aAny <<= pColLengths[nCol];
			xColumnDesc->setPropertyValue( rtl::OUString::createFromAscii(SC_DBPROP_PRECISION), aAny );

			aAny <<= pColScales[nCol];
			xColumnDesc->setPropertyValue( rtl::OUString::createFromAscii(SC_DBPROP_SCALE), aAny );

			xColumnsAppend->appendByDescriptor( xColumnDesc );
		}

		xTablesAppend->appendByDescriptor( xTableDesc );

		// re-open connection
//		xConnection = xDrvMan->getConnectionWithInfo( aConnUrl, aProps );
//		DBG_ASSERT( xConnection.is(), "can't get Connection" );
//		if (!xConnection.is()) return SCERR_EXPORT_CONNECT;

		// get row set for writing
        uno::Reference<lang::XMultiServiceFactory> xFactory = comphelper::getProcessServiceFactory();
		uno::Reference<sdbc::XRowSet> xRowSet( xFactory->createInstance(
							rtl::OUString::createFromAscii( SC_SERVICE_ROWSET ) ),
							uno::UNO_QUERY);
        ::utl::DisposableComponent aRowSetHelper(xRowSet);
		uno::Reference<beans::XPropertySet> xRowProp( xRowSet, uno::UNO_QUERY );
		DBG_ASSERT( xRowProp.is(), "can't get RowSet" );
		if (!xRowProp.is()) return SCERR_EXPORT_CONNECT;

		aAny <<= xConnection;
		xRowProp->setPropertyValue(
					rtl::OUString::createFromAscii(SC_DBPROP_ACTIVECONNECTION), aAny );

		aAny <<= (sal_Int32) sdb::CommandType::TABLE;
		xRowProp->setPropertyValue(
					rtl::OUString::createFromAscii(SC_DBPROP_COMMANDTYPE), aAny );

		aAny <<= rtl::OUString( aTabName );
		xRowProp->setPropertyValue(
					rtl::OUString::createFromAscii(SC_DBPROP_COMMAND), aAny );

		xRowSet->execute();

		// write data rows

		uno::Reference<sdbc::XResultSetUpdate> xResultUpdate( xRowSet, uno::UNO_QUERY );
		DBG_ASSERT( xResultUpdate.is(), "can't get XResultSetUpdate" );
		if (!xResultUpdate.is()) return SCERR_EXPORT_CONNECT;

		uno::Reference<sdbc::XRowUpdate> xRowUpdate( xRowSet, uno::UNO_QUERY );
		DBG_ASSERT( xRowUpdate.is(), "can't get XRowUpdate" );
		if (!xRowUpdate.is()) return SCERR_EXPORT_CONNECT;

		SCROW nFirstDataRow = ( bHasFieldNames ? nFirstRow + 1 : nFirstRow );
		double fVal;

		for ( nDocRow = nFirstDataRow; nDocRow <= nLastRow; nDocRow++ )
		{
			xResultUpdate->moveToInsertRow();

			for (nCol=0; nCol<nColCount; nCol++)
			{
                SCCOL nDocCol = sal::static_int_cast<SCCOL>( nFirstCol + nCol );

				switch (pColTypes[nCol])
				{
					case sdbc::DataType::LONGVARCHAR:
						{
							ScBaseCell* pCell;
							aDocument.GetCell( nDocCol, nDocRow, nTab, pCell );
							if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE )
							{
								if ( pCell->GetCellType() == CELLTYPE_EDIT )
								{	// #60761# Paragraphs erhalten
                                    lcl_getLongVarCharEditString( aString,
                                            pCell, aEditEngine);
								}
								else
								{
                                    lcl_getLongVarCharString( aString, pCell,
                                            aDocument, nDocCol, nDocRow, nTab,
                                            *pNumFmt);
								}
								xRowUpdate->updateString( nCol+1, aString );
							}
							else
								xRowUpdate->updateNull( nCol+1 );
						}
						break;

					case sdbc::DataType::VARCHAR:
						aDocument.GetString( nDocCol, nDocRow, nTab, aString );
						xRowUpdate->updateString( nCol+1, aString );
						if ( nErr == eERR_OK && pColLengths[nCol] < aString.Len() )
							nErr = SCWARN_EXPORT_DATALOST;
						break;

					case sdbc::DataType::DATE:
						{
							aDocument.GetValue( nDocCol, nDocRow, nTab, fVal );
							// #39274# zwischen 0 Wert und 0 kein Wert unterscheiden
							sal_Bool bIsNull = (fVal == 0.0);
							if ( bIsNull )
								bIsNull = !aDocument.HasValueData( nDocCol, nDocRow, nTab );
							if ( bIsNull )
							{
								xRowUpdate->updateNull( nCol+1 );
								if ( nErr == eERR_OK &&
										aDocument.HasStringData( nDocCol, nDocRow, nTab ) )
									nErr = SCWARN_EXPORT_DATALOST;
							}
							else
							{
								Date aDate = *(pNumFmt->GetNullDate());		// tools date
								aDate += (long)fVal;						//! approxfloor?
								util::Date aUnoDate( aDate.GetDay(), aDate.GetMonth(), aDate.GetYear() );
								xRowUpdate->updateDate( nCol+1, aUnoDate );
							}
						}
						break;

					case sdbc::DataType::DECIMAL:
					case sdbc::DataType::BIT:
						aDocument.GetValue( nDocCol, nDocRow, nTab, fVal );
						if ( fVal == 0.0 && nErr == eERR_OK &&
											aDocument.HasStringData( nDocCol, nDocRow, nTab ) )
							nErr = SCWARN_EXPORT_DATALOST;
						if ( pColTypes[nCol] == sdbc::DataType::BIT )
							xRowUpdate->updateBoolean( nCol+1, ( fVal != 0.0 ) );
						else
							xRowUpdate->updateDouble( nCol+1, fVal );
						break;

					default:
						DBG_ERROR( "ScDocShell::DBaseExport: unknown FieldType" );
						if ( nErr == eERR_OK )
							nErr = SCWARN_EXPORT_DATALOST;
						aDocument.GetValue( nDocCol, nDocRow, nTab, fVal );
						xRowUpdate->updateDouble( nCol+1, fVal );
				}
			}

			xResultUpdate->insertRow();

			//!	error handling and recovery of old
			//!	ScDocShell::SbaSdbExport is still missing!

			if ( !aProgress.SetStateOnPercent( nDocRow - nFirstRow ) )
			{	// UserBreak
				nErr = SCERR_EXPORT_DATA;
				break;
			}
		}

		comphelper::disposeComponent( xRowSet );
		comphelper::disposeComponent( xConnection );
	}
	catch ( sdbc::SQLException& aException )
	{
        sal_Int32 nError = aException.ErrorCode;
#if OSL_DEBUG_LEVEL > 1
        fprintf( stderr, "ScDocShell::DBaseExport: SQLException ErrorCode: %d, SQLState: %s, Message: %s\n",
                (int)nError, OUStringToOString( aException.SQLState,
                    RTL_TEXTENCODING_UTF8).getStr(), OUStringToOString(
                        aException.Message, RTL_TEXTENCODING_UTF8).getStr());
#endif
        if (nError == 22018 || nError == 22001)
        {
            // SQL error 22018: Character not in target encoding.
            // SQL error 22001: String length exceeds field width (after encoding).
            bool bEncErr = (nError == 22018);
            bool bIsOctetTextEncoding = rtl_isOctetTextEncoding( eCharSet);
            DBG_ASSERT( !bEncErr || bIsOctetTextEncoding, "ScDocShell::DBaseExport: encoding error and not an octect textencoding");
            SCCOL nDocCol = nFirstCol;
            const sal_Int32* pColTypes = aColTypes.getConstArray();
            const sal_Int32* pColLengths = aColLengths.getConstArray();
            ScHorizontalCellIterator aIter( &aDocument, nTab, nFirstCol,
                    nDocRow, nLastCol, nDocRow);
            ScBaseCell* pCell = NULL;
            bool bTest = true;
            while (bTest && ((pCell = aIter.GetNext( nDocCol, nDocRow)) != NULL))
            {
                SCCOL nCol = nDocCol - nFirstCol;
                switch (pColTypes[nCol])
                {
                    case sdbc::DataType::LONGVARCHAR:
                        {
                            if ( pCell->GetCellType() != CELLTYPE_NOTE )
                            {
                                if ( pCell->GetCellType() == CELLTYPE_EDIT )
                                    lcl_getLongVarCharEditString( aString,
                                            pCell, aEditEngine);
                                else
                                    lcl_getLongVarCharString( aString,
                                            pCell, aDocument, nDocCol,
                                            nDocRow, nTab, *pNumFmt);
                            }
                        }
                        break;

                    case sdbc::DataType::VARCHAR:
                        aDocument.GetString( nDocCol, nDocRow, nTab, aString);
                        break;

                    // NOTE: length of DECIMAL fields doesn't need to be
                    // checked here, the database driver adjusts the field
                    // width accordingly.

                    default:
                        bTest = false;
                }
                if (bTest)
                {
                    sal_Int32 nLen;
                    if (bIsOctetTextEncoding)
                    {
                        rtl::OUString aOUString( aString);
                        rtl::OString aOString;
                        if (!aOUString.convertToString( &aOString, eCharSet,
                                    RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
                                    RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR))
                        {
                            bTest = false;
                            bEncErr = true;
                        }
                        nLen = aOString.getLength();
#if OSL_DEBUG_LEVEL > 1
                        if (!bTest)
                            fprintf( stderr, "ScDocShell::DBaseExport encoding error, string with default replacements: ``%s''\n",
                                    OUStringToOString( aOUString, eCharSet).getStr());
#endif
                    }
                    else
                        nLen = aString.Len() * sizeof(sal_Unicode);
                    if (!bEncErr &&
                            pColTypes[nCol] != sdbc::DataType::LONGVARCHAR &&
                            pColLengths[nCol] < nLen)
                    {
                        bTest = false;
#if OSL_DEBUG_LEVEL > 1
                        fprintf( stderr, "ScDocShell::DBaseExport: field width: %d, encoded length: %d\n",
                                (int)pColLengths[nCol], (int)nLen);
#endif
                    }
                }
                else
                    bTest = true;
            }
            String sPosition( ScAddress( nDocCol, nDocRow, nTab).GetColRowString());
            String sEncoding( SvxTextEncodingTable().GetTextString( eCharSet));
            nErr = *new TwoStringErrorInfo( (bEncErr ? SCERR_EXPORT_ENCODING :
                        SCERR_EXPORT_FIELDWIDTH), sPosition, sEncoding,
                    ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR);
        }
        else if ( aException.Message.getLength() )
            nErr = *new StringErrorInfo( (SCERR_EXPORT_SQLEXCEPTION), aException.Message, ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR);
        else
            nErr = SCERR_EXPORT_DATA;
	}
	catch ( uno::Exception& )
	{
		DBG_ERROR("Unexpected exception in database");
		nErr = ERRCODE_IO_GENERAL;
	}

	return nErr;
}