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