/**************************************************************
*
* 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 "connectivity/dbconversion.hxx"
#include <connectivity/dbtools.hxx>
#include <com/sun/star/script/XTypeConverter.hpp>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/util/NumberFormat.hpp>
#include <com/sun/star/util/XNumberFormatTypes.hpp>
#include <com/sun/star/sdb/XColumnUpdate.hpp>
#include <com/sun/star/sdb/XColumn.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <comphelper/extract.hxx>
#include "TConnection.hxx"
#include "diagnose_ex.h"
#include <comphelper/numbers.hxx>
#include <rtl/ustrbuf.hxx>
#include <tools/diagnose_ex.h>
using namespace ::connectivity;
using namespace ::comphelper;
using namespace ::com::sun::star::script;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::sdbc;
using namespace ::dbtools;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::beans;
// -----------------------------------------------------------------------------
::rtl::OUString DBTypeConversion::toSQLString(sal_Int32 eType, const Any& _rVal, sal_Bool bQuote,
const Reference< XTypeConverter >& _rxTypeConverter)
{
::rtl::OUStringBuffer aRet;
if (_rVal.hasValue())
{
try
{
switch (eType)
{
case DataType::INTEGER:
case DataType::BIT:
case DataType::BOOLEAN:
case DataType::TINYINT:
case DataType::SMALLINT:
if (_rVal.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_BOOLEAN)
{
if (::cppu::any2bool(_rVal))
aRet.appendAscii("1");
else
aRet.appendAscii("0");
}
else
{
::rtl::OUString sTemp;
_rxTypeConverter->convertToSimpleType(_rVal, TypeClass_STRING) >>= sTemp;
aRet.append(sTemp);
}
break;
case DataType::CHAR:
case DataType::VARCHAR:
case DataType::LONGVARCHAR:
if (bQuote)
aRet.appendAscii("'");
{
::rtl::OUString aTemp;
_rxTypeConverter->convertToSimpleType(_rVal, TypeClass_STRING) >>= aTemp;
sal_Int32 nIndex = (sal_Int32)-1;
const ::rtl::OUString sQuot(RTL_CONSTASCII_USTRINGPARAM("\'"));
const ::rtl::OUString sQuotToReplace(RTL_CONSTASCII_USTRINGPARAM("\'\'"));
do
{
nIndex += 2;
nIndex = aTemp.indexOf(sQuot,nIndex);
if(nIndex != -1)
aTemp = aTemp.replaceAt(nIndex,sQuot.getLength(),sQuotToReplace);
} while (nIndex != -1);
aRet.append(aTemp);
}
if (bQuote)
aRet.appendAscii("'");
break;
case DataType::REAL:
case DataType::DOUBLE:
case DataType::DECIMAL:
case DataType::NUMERIC:
case DataType::BIGINT:
default:
{
::rtl::OUString sTemp;
_rxTypeConverter->convertToSimpleType(_rVal, TypeClass_STRING) >>= sTemp;
aRet.append(sTemp);
}
break;
case DataType::TIMESTAMP:
{
DateTime aDateTime;
bool bOk = false;
if (_rVal.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_DOUBLE)
{
double nValue = 0.0;
_rVal >>= nValue;
aDateTime = DBTypeConversion::toDateTime(nValue);
bOk = true;
}
else if (_rVal.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_STRING)
{
::rtl::OUString sValue;
_rVal >>= sValue;
aDateTime = DBTypeConversion::toDateTime(sValue);
bOk = true;
}
else
bOk = _rVal >>= aDateTime;
OSL_VERIFY_RES( bOk, "DBTypeConversion::toSQLString: _rVal is not datetime!");
// check if this is really a timestamp or only a date
if ( bOk )
{
if (bQuote)
aRet.appendAscii("{TS '");
aRet.append(DBTypeConversion::toDateTimeString(aDateTime));
if (bQuote)
aRet.appendAscii("'}");
break;
}
break;
}
case DataType::DATE:
{
Date aDate;
bool bOk = false;
if (_rVal.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_DOUBLE)
{
double nValue = 0.0;
_rVal >>= nValue;
aDate = DBTypeConversion::toDate(nValue);
bOk = true;
}
else if (_rVal.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_STRING)
{
::rtl::OUString sValue;
_rVal >>= sValue;
aDate = DBTypeConversion::toDate(sValue);
bOk = true;
}
else
bOk = _rVal >>= aDate;
OSL_VERIFY_RES( bOk, "DBTypeConversion::toSQLString: _rVal is not date!");
if (bQuote)
aRet.appendAscii("{D '");
aRet.append(DBTypeConversion::toDateString(aDate));
if (bQuote)
aRet.appendAscii("'}");
} break;
case DataType::TIME:
{
Time aTime;
bool bOk = false;
if (_rVal.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_DOUBLE)
{
double nValue = 0.0;
_rVal >>= nValue;
aTime = DBTypeConversion::toTime(nValue);
bOk = true;
}
else if (_rVal.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_STRING)
{
::rtl::OUString sValue;
_rVal >>= sValue;
aTime = DBTypeConversion::toTime(sValue);
bOk = true;
}
else
bOk = _rVal >>= aTime;
OSL_VERIFY_RES( bOk,"DBTypeConversion::toSQLString: _rVal is not time!");
if (bQuote)
aRet.appendAscii("{T '");
aRet.append(DBTypeConversion::toTimeString(aTime));
if (bQuote)
aRet.appendAscii("'}");
} break;
}
}
catch ( const Exception& )
{
OSL_ENSURE(0,"TypeConversion Error");
}
}
else
aRet.appendAscii(" NULL ");
return aRet.makeStringAndClear();
}
// -----------------------------------------------------------------------------
Date DBTypeConversion::getNULLDate(const Reference< XNumberFormatsSupplier > &xSupplier)
{
OSL_ENSURE(xSupplier.is(), "getNULLDate : the formatter doesn't implement a supplier !");
if (xSupplier.is())
{
try
{
// get the null date
Date aDate;
xSupplier->getNumberFormatSettings()->getPropertyValue(::rtl::OUString::createFromAscii("NullDate")) >>= aDate;
return aDate;
}
catch ( const Exception& )
{
}
}
return getStandardDate();
}
// -----------------------------------------------------------------------------
void DBTypeConversion::setValue(const Reference<XColumnUpdate>& xVariant,
const Reference<XNumberFormatter>& xFormatter,
const Date& rNullDate,
const ::rtl::OUString& rString,
sal_Int32 nKey,
sal_Int16 nFieldType,
sal_Int16 nKeyType) throw(::com::sun::star::lang::IllegalArgumentException)
{
double fValue = 0;
if (rString.getLength())
{
// Muss der String formatiert werden?
sal_Int16 nTypeClass = nKeyType & ~NumberFormat::DEFINED;
sal_Bool bTextFormat = nTypeClass == NumberFormat::TEXT;
sal_Int32 nKeyToUse = bTextFormat ? 0 : nKey;
sal_Int16 nRealUsedTypeClass = nTypeClass;
// bei einem Text-Format muessen wir dem Formatter etwas mehr Freiheiten einraeumen, sonst
// wirft convertStringToNumber eine NotNumericException
try
{
fValue = xFormatter->convertStringToNumber(nKeyToUse, rString);
sal_Int32 nRealUsedKey = xFormatter->detectNumberFormat(0, rString);
if (nRealUsedKey != nKeyToUse)
nRealUsedTypeClass = getNumberFormatType(xFormatter, nRealUsedKey) & ~NumberFormat::DEFINED;
// und noch eine Sonderbehandlung, diesmal fuer Prozent-Formate
if ((NumberFormat::NUMBER == nRealUsedTypeClass) && (NumberFormat::PERCENT == nTypeClass))
{ // die Formatierung soll eigentlich als Prozent erfolgen, aber der String stellt nur eine
// einfache Nummer dar -> anpassen
::rtl::OUString sExpanded(rString);
static ::rtl::OUString s_sPercentSymbol = ::rtl::OUString::createFromAscii("%");
// need a method to add a sal_Unicode to a string, 'til then we use a static string
sExpanded += s_sPercentSymbol;
fValue = xFormatter->convertStringToNumber(nKeyToUse, sExpanded);
}
switch (nRealUsedTypeClass)
{
case NumberFormat::DATE:
case NumberFormat::DATETIME:
case NumberFormat::TIME:
DBTypeConversion::setValue(xVariant,rNullDate,fValue,nRealUsedTypeClass);
// xVariant->updateDouble(toStandardDbDate(rNullDate, fValue));
break;
case NumberFormat::CURRENCY:
case NumberFormat::NUMBER:
case NumberFormat::SCIENTIFIC:
case NumberFormat::FRACTION:
case NumberFormat::PERCENT:
xVariant->updateDouble(fValue);
break;
default:
xVariant->updateString(rString);
}
}
catch(const Exception& )
{
xVariant->updateString(rString);
}
}
else
{
switch (nFieldType)
{
case ::com::sun::star::sdbc::DataType::CHAR:
case ::com::sun::star::sdbc::DataType::VARCHAR:
case ::com::sun::star::sdbc::DataType::LONGVARCHAR:
xVariant->updateString(rString);
break;
default:
xVariant->updateNull();
}
}
}
//------------------------------------------------------------------------------
void DBTypeConversion::setValue(const Reference<XColumnUpdate>& xVariant,
const Date& rNullDate,
const double& rValue,
sal_Int16 nKeyType) throw(::com::sun::star::lang::IllegalArgumentException)
{
switch (nKeyType & ~NumberFormat::DEFINED)
{
case NumberFormat::DATE:
xVariant->updateDate(toDate( rValue, rNullDate));
break;
case NumberFormat::DATETIME:
xVariant->updateTimestamp(toDateTime(rValue,rNullDate));
break;
case NumberFormat::TIME:
xVariant->updateTime(toTime(rValue));
break;
default:
{
double nValue = rValue;
// Reference<XPropertySet> xProp(xVariant,UNO_QUERY);
// if ( xProp.is()
// && xProp->getPropertySetInfo()->hasPropertyByName(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISSIGNED))
// && !::comphelper::getBOOL(xProp->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISSIGNED))) )
// {
// switch (::comphelper::getINT32(xProp->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))))
// {
// case DataType::TINYINT:
// nValue = static_cast<sal_uInt8>(rValue);
// break;
// case DataType::SMALLINT:
// nValue = static_cast<sal_uInt16>(rValue);
// break;
// case DataType::INTEGER:
// nValue = static_cast<sal_uInt32>(rValue);
// break;
// case DataType::BIGINT:
// nValue = static_cast<sal_uInt64>(rValue);
// break;
// }
// }
xVariant->updateDouble(nValue);
}
}
}
//------------------------------------------------------------------------------
double DBTypeConversion::getValue( const Reference< XColumn >& i_column, const Date& i_relativeToNullDate )
{
try
{
const Reference< XPropertySet > xProp( i_column, UNO_QUERY_THROW );
const sal_Int32 nColumnType = ::comphelper::getINT32( xProp->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_TYPE ) ) );
switch ( nColumnType )
{
case DataType::DATE:
return toDouble( i_column->getDate(), i_relativeToNullDate );
case DataType::TIME:
return toDouble( i_column->getTime() );
case DataType::TIMESTAMP:
return toDouble( i_column->getTimestamp(), i_relativeToNullDate );
default:
{
sal_Bool bIsSigned = sal_True;
OSL_VERIFY( xProp->getPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_ISSIGNED ) ) >>= bIsSigned );
if ( !bIsSigned )
{
switch ( nColumnType)
{
case DataType::TINYINT:
return static_cast<double>(static_cast<sal_uInt8>(i_column->getByte()));
case DataType::SMALLINT:
return static_cast<double>(static_cast<sal_uInt16>(i_column->getShort()));
case DataType::INTEGER:
return static_cast<double>(static_cast<sal_uInt32>(i_column->getInt()));
case DataType::BIGINT:
return static_cast<double>(static_cast<sal_uInt64>(i_column->getLong()));
}
}
}
return i_column->getDouble();
}
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
return 0.0;
}
}
//------------------------------------------------------------------------------
::rtl::OUString DBTypeConversion::getFormattedValue(const Reference< XPropertySet>& _xColumn,
const Reference<XNumberFormatter>& _xFormatter,
const ::com::sun::star::lang::Locale& _rLocale,
const Date& _rNullDate)
{
OSL_ENSURE(_xColumn.is() && _xFormatter.is(), "DBTypeConversion::getFormattedValue: invalid arg !");
if (!_xColumn.is() || !_xFormatter.is())
return ::rtl::OUString();
sal_Int32 nKey(0);
try
{
_xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FORMATKEY)) >>= nKey;
}
catch (const Exception& )
{
OSL_ENSURE(false, "DBTypeConversion::getFormattedValue: caught an exception while asking for the format key!");
}
if (!nKey)
{
Reference<XNumberFormats> xFormats( _xFormatter->getNumberFormatsSupplier()->getNumberFormats() );
Reference<XNumberFormatTypes> xTypeList(_xFormatter->getNumberFormatsSupplier()->getNumberFormats(), UNO_QUERY);
nKey = ::dbtools::getDefaultNumberFormat(_xColumn,
Reference< XNumberFormatTypes > (xFormats, UNO_QUERY),
_rLocale);
}
sal_Int16 nKeyType = getNumberFormatType(_xFormatter, nKey) & ~NumberFormat::DEFINED;
return DBTypeConversion::getFormattedValue(Reference< XColumn > (_xColumn, UNO_QUERY), _xFormatter, _rNullDate, nKey, nKeyType);
}
//------------------------------------------------------------------------------
::rtl::OUString DBTypeConversion::getFormattedValue(const Reference<XColumn>& xVariant,
const Reference<XNumberFormatter>& xFormatter,
const Date& rNullDate,
sal_Int32 nKey,
sal_Int16 nKeyType)
{
::rtl::OUString aString;
if (xVariant.is())
{
try
{
switch (nKeyType & ~NumberFormat::DEFINED)
{
case NumberFormat::DATE:
case NumberFormat::DATETIME:
{
// get a value which represents the given date, relative to the given null date
double fValue = getValue( xVariant, rNullDate );
if ( !xVariant->wasNull() )
{
// get the null date of the formatter
Date aFormatterNullDate( rNullDate );
try
{
Reference< XNumberFormatsSupplier > xSupplier( xFormatter->getNumberFormatsSupplier(), UNO_SET_THROW );
Reference< XPropertySet > xFormatterSettings( xSupplier->getNumberFormatSettings(), UNO_SET_THROW );
OSL_VERIFY( xFormatterSettings->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "NullDate" ) ) ) >>= aFormatterNullDate );
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
// get a value which represents the given date, relative to the null date of the formatter
fValue -= toDays( rNullDate, aFormatterNullDate );
// format this value
aString = xFormatter->convertNumberToString( nKey, fValue );
}
}
break;
case NumberFormat::TIME:
case NumberFormat::NUMBER:
case NumberFormat::SCIENTIFIC:
case NumberFormat::FRACTION:
case NumberFormat::PERCENT:
{
double fValue = xVariant->getDouble();
if (!xVariant->wasNull())
aString = xFormatter->convertNumberToString(nKey, fValue);
} break;
case NumberFormat::CURRENCY:
{
double fValue = xVariant->getDouble();
if (!xVariant->wasNull())
aString = xFormatter->getInputString(nKey, fValue);
} break;
case NumberFormat::TEXT:
aString = xFormatter->formatString(nKey, xVariant->getString());
break;
default:
aString = xVariant->getString();
}
}
catch(const Exception& )
{
aString = xVariant->getString();
}
}
return aString;
}
//------------------------------------------------------------------