diff options
Diffstat (limited to 'connectivity/source/drivers/evoab/LTable.cxx')
| -rw-r--r-- | connectivity/source/drivers/evoab/LTable.cxx | 870 |
1 files changed, 870 insertions, 0 deletions
diff --git a/connectivity/source/drivers/evoab/LTable.cxx b/connectivity/source/drivers/evoab/LTable.cxx new file mode 100644 index 000000000000..6239765afe25 --- /dev/null +++ b/connectivity/source/drivers/evoab/LTable.cxx @@ -0,0 +1,870 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_connectivity.hxx" + +#include <ctype.h> +#include "LTable.hxx" +#include <com/sun/star/sdbc/ColumnValue.hpp> +#include <com/sun/star/sdbc/DataType.hpp> +#include <com/sun/star/ucb/XContentAccess.hpp> +#ifndef _COM_SUN_STAR_SQLC_XROW_HPP_ +//#include <com/sun/star/sdbc/XRow.hpp> +#endif +#include <svl/converter.hxx> +#include "LConnection.hxx" +#include "LColumns.hxx" +#include <osl/thread.h> +#include <tools/config.hxx> +#include <comphelper/sequence.hxx> +#include <svl/zforlist.hxx> +#include <rtl/math.hxx> +#include <stdio.h> //sprintf +#include <comphelper/extract.hxx> +#include <comphelper/numbers.hxx> +#include "LDriver.hxx" +#include <com/sun/star/util/NumberFormat.hpp> +#include <unotools/configmgr.hxx> +#include <i18npool/mslangid.hxx> +#include "connectivity/dbconversion.hxx" +#include <comphelper/types.hxx> +#include <unotools/syslocale.hxx> +#ifndef CONNECTIVITY_EVOAB_DEBUG_HELPER_HXX +#include "LDebug.hxx" +#endif +#include <map> + +using namespace ::comphelper; +using namespace connectivity; +using namespace connectivity::evoab; +using namespace connectivity::file; +using namespace ::cppu; +using namespace utl; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::ucb; +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; + +// ------------------------------------------------------------------------- +void OEvoabTable::fillColumns(const ::com::sun::star::lang::Locale& _aLocale) +{ + BOOL bRead = TRUE; + + QuotedTokenizedString aHeaderLine; + OEvoabConnection* pConnection = (OEvoabConnection*)m_pConnection; + if (pConnection->isHeaderLine()) + { + while(bRead && !aHeaderLine.Len()) + { + bRead = m_pFileStream->ReadByteStringLine(aHeaderLine,pConnection->getTextEncoding()); + } + } + + // read first row + QuotedTokenizedString aFirstLine; + bRead = m_pFileStream->ReadByteStringLine(aFirstLine,pConnection->getTextEncoding()); + + if (!pConnection->isHeaderLine() || !aHeaderLine.Len()) + { + while(bRead && !aFirstLine.Len()) + { + bRead = m_pFileStream->ReadByteStringLine(aFirstLine,pConnection->getTextEncoding()); + } + // use first row as headerline because we need the number of columns + aHeaderLine = aFirstLine; + } + // column count + xub_StrLen nFieldCount = aHeaderLine.GetTokenCount(pConnection->getFieldDelimiter(),pConnection->getStringDelimiter()); + + if(!m_aColumns.isValid()) + m_aColumns = new OSQLColumns(); + else + m_aColumns->get().clear(); + + m_aTypes.clear(); + m_aPrecisions.clear(); + m_aScales.clear(); + // reserve some space + m_aColumnRawNames.reserve(nFieldCount); + m_aColumns->get().reserve(nFieldCount); + m_aTypes.reserve(nFieldCount); + m_aPrecisions.reserve(nFieldCount); + m_aScales.reserve(nFieldCount); + + sal_Bool bCase = getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers(); + CharClass aCharClass(pConnection->getDriver()->getFactory(),_aLocale); + // read description + sal_Unicode cDecimalDelimiter = pConnection->getDecimalDelimiter(); + sal_Unicode cThousandDelimiter = pConnection->getThousandDelimiter(); + String aColumnName; + ::rtl::OUString aTypeName; + ::comphelper::UStringMixEqual aCase(bCase); + xub_StrLen nStartPosHeaderLine = 0; // use for eficient way to get the tokens + xub_StrLen nStartPosFirstLine = 0; // use for eficient way to get the tokens + xub_StrLen nStartPosFirstLine2 = 0; + for (xub_StrLen i = 0; i < nFieldCount; i++) + { + if (pConnection->isHeaderLine()) + { + aHeaderLine.GetTokenSpecial(aColumnName,nStartPosHeaderLine,pConnection->getFieldDelimiter(),pConnection->getStringDelimiter()); + } + else + { + // no column name so ... + aColumnName = 'C'; + aColumnName += String::CreateFromInt32(i+1); + } + //OSL_TRACE("OEvoabTable::aColumnName = %s\n", ((OUtoCStr(::rtl::OUString(aColumnName))) ? (OUtoCStr(::rtl::OUString(aColumnName))):("NULL")) ); + + sal_Int32 eType; + UINT16 nPrecision = 0; + UINT16 nScale = 0; + + BOOL bNumeric = FALSE; + ULONG nIndex = 0; + + // first without fielddelimiter + String aField; + aFirstLine.GetTokenSpecial(aField,nStartPosFirstLine,pConnection->getFieldDelimiter(),'\0'); + //OSL_TRACE("OEvoabTable::aField = %s\n", ((OUtoCStr(::rtl::OUString(aField))) ? (OUtoCStr(::rtl::OUString(aField))):("NULL")) ); + + if (aField.Len() == 0 || + (pConnection->getStringDelimiter() && pConnection->getStringDelimiter() == aField.GetChar(0))) + { + bNumeric = FALSE; + } + else + { + String aField2; + if ( pConnection->getStringDelimiter() != '\0' ) + aFirstLine.GetTokenSpecial(aField2,nStartPosFirstLine2,pConnection->getFieldDelimiter(),pConnection->getStringDelimiter()); + else + aField2 = aField; + + //OSL_TRACE("OEvoabTable::aField2 = %s\n", ((OUtoCStr(::rtl::OUString(aField2))) ? (OUtoCStr(::rtl::OUString(aField2))):("NULL")) ); + + if (aField2.Len() == 0) + { + bNumeric = FALSE; + } + else + { + bNumeric = TRUE; + xub_StrLen nDot = 0; + for (xub_StrLen j = 0; j < aField2.Len(); j++) + { + sal_Unicode c = aField2.GetChar(j); + // nur Ziffern und Dezimalpunkt und Tausender-Trennzeichen? + if ((!cDecimalDelimiter || c != cDecimalDelimiter) && + (!cThousandDelimiter || c != cThousandDelimiter) && + !aCharClass.isDigit(aField2,j)) + { + bNumeric = FALSE; + break; + } + if (cDecimalDelimiter && c == cDecimalDelimiter) + { + nPrecision = 15; // we have an decimal value + nScale = 2; + nDot++; + } + } + + if (nDot > 1) // if there is more than one dot it isn't a number + bNumeric = FALSE; + if (bNumeric && cThousandDelimiter) + { + // Ist der Trenner richtig angegeben? + String aValue = aField2.GetToken(0,cDecimalDelimiter); + for (sal_Int32 j = aValue.Len() - 4; j >= 0; j -= 4) + { + sal_Unicode c = aValue.GetChar(j); + // nur Ziffern und Dezimalpunkt und Tausender-Trennzeichen? + if (c == cThousandDelimiter && j) + continue; + else + { + bNumeric = FALSE; + break; + } + } + } + + // jetzt koennte es noch ein Datumsfeld sein + if (!bNumeric) + { + try + { + nIndex = m_xNumberFormatter->detectNumberFormat(::com::sun::star::util::NumberFormat::ALL,aField2); + } + catch(Exception&) + { + } + } + } + } + + sal_Int32 nFlags = 0; + if (bNumeric) + { + if (cDecimalDelimiter) + { + if(nPrecision) + { + eType = DataType::DECIMAL; + aTypeName = ::rtl::OUString::createFromAscii("DECIMAL"); + } + else + { + eType = DataType::DOUBLE; + aTypeName = ::rtl::OUString::createFromAscii("DOUBLE"); + } + } + else + eType = DataType::INTEGER; + nFlags = ColumnSearch::BASIC; + } + else + { + + switch (comphelper::getNumberFormatType(m_xNumberFormatter,nIndex)) + { + case NUMBERFORMAT_DATE: + eType = DataType::DATE; + aTypeName = ::rtl::OUString::createFromAscii("DATE"); + break; + case NUMBERFORMAT_DATETIME: + eType = DataType::TIMESTAMP; + aTypeName = ::rtl::OUString::createFromAscii("TIMESTAMP"); + break; + case NUMBERFORMAT_TIME: + eType = DataType::TIME; + aTypeName = ::rtl::OUString::createFromAscii("TIME"); + break; + default: + eType = DataType::VARCHAR; + nPrecision = 0; // nyi: Daten koennen aber laenger sein! + nScale = 0; + aTypeName = ::rtl::OUString::createFromAscii("VARCHAR"); + }; + nFlags |= ColumnSearch::CHAR; + } + + // check if the columname already exists + String aAlias(aColumnName); + OSQLColumns::Vector::const_iterator aFind = connectivity::find(m_aColumns->get().begin(),m_aColumns->get().end(),aAlias,aCase); + sal_Int32 nExprCnt = 0; + while(aFind != m_aColumns->get().end()) + { + (aAlias = aColumnName) += String::CreateFromInt32(++nExprCnt); + aFind = connectivity::find(m_aColumns->get().begin(),m_aColumns->get().end(),aAlias,aCase); + } + + m_aColumnRawNames.push_back(::rtl::OUString(aAlias)); + + //~ sdbcx::OColumn* pColumn = new sdbcx::OColumn(aAlias,aTypeName,::rtl::OUString(), + //~ ColumnValue::NULLABLE, + //~ nPrecision, + //~ nScale, + //~ eType, + //~ sal_False, + //~ sal_False, + //~ sal_False, + //~ bCase); + //~ Reference< XPropertySet> xCol = pColumn; + //~ m_aColumns->push_back(xCol); + m_aTypes.push_back(eType); + m_aPrecisions.push_back(nPrecision); + m_aScales.push_back(nScale); + } + setColumnAliases(); + m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN); +} +// ------------------------------------------------------------------------- +OEvoabTable::OEvoabTable(sdbcx::OCollection* _pTables,OEvoabConnection* _pConnection) : OEvoabTable_BASE(_pTables,_pConnection) +{ + +} +// ------------------------------------------------------------------------- +OEvoabTable::OEvoabTable(sdbcx::OCollection* _pTables,OEvoabConnection* _pConnection, + const ::rtl::OUString& _Name, + const ::rtl::OUString& _Type, + const ::rtl::OUString& _Description , + const ::rtl::OUString& _SchemaName, + const ::rtl::OUString& _CatalogName + ) : OEvoabTable_BASE(_pTables,_pConnection,_Name, + _Type, + _Description, + _SchemaName, + _CatalogName) + ,m_nRowPos(0) + ,m_nMaxRowCount(0) +{ + //~ OSL_TRACE("OEvoabTable::(in constructor)_Name = %s\n", ((OUtoCStr(_Name)) ? (OUtoCStr(_Name)):("NULL")) ); + //~ OSL_TRACE("OEvoabTable::(in constructor)_Type = %s\n", ((OUtoCStr(_Type)) ? (OUtoCStr(_Type)):("NULL")) ); + //~ OSL_TRACE("OEvoabTable::(in constructor)_Description = %s\n", ((OUtoCStr(_Description)) ? (OUtoCStr(_Description)):("NULL")) ); + //~ OSL_TRACE("OEvoabTable::(in constructor)_SchemaName = %s\n", ((OUtoCStr(_SchemaName)) ? (OUtoCStr(_SchemaName)):("NULL")) ); + //~ OSL_TRACE("OEvoabTable::(in constructor)_CatalogName = %s\n", ((OUtoCStr(_CatalogName)) ? (OUtoCStr(_CatalogName)):("NULL")) ); +} +// ----------------------------------------------------------------------------- +void OEvoabTable::construct() +{ + SvtSysLocale aLocale; + ::com::sun::star::lang::Locale aAppLocale(aLocale.GetLocaleDataPtr()->getLocale()); + Sequence< ::com::sun::star::uno::Any > aArg(1); + aArg[0] <<= aAppLocale; + + Reference< ::com::sun::star::util::XNumberFormatsSupplier > xSupplier(m_pConnection->getDriver()->getFactory()->createInstanceWithArguments(::rtl::OUString::createFromAscii("com.sun.star.util.NumberFormatsSupplier"),aArg),UNO_QUERY); + m_xNumberFormatter = Reference< ::com::sun::star::util::XNumberFormatter >(m_pConnection->getDriver()->getFactory()->createInstance(::rtl::OUString::createFromAscii("com.sun.star.util.NumberFormatter")),UNO_QUERY); + m_xNumberFormatter->attachNumberFormatsSupplier(xSupplier); + + INetURLObject aURL; + aURL.SetURL(getEntry()); + + if(aURL.getExtension() != rtl::OUString(m_pConnection->getExtension())) + aURL.setExtension(m_pConnection->getExtension()); + + String aFileName = aURL.GetMainURL(INetURLObject::NO_DECODE); + + m_pFileStream = createStream_simpleError( aFileName,STREAM_READWRITE | STREAM_NOCREATE | STREAM_SHARE_DENYWRITE); + + if(!m_pFileStream) + m_pFileStream = createStream_simpleError( aFileName,STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYNONE); + + if(m_pFileStream) + { + OSL_TRACE("OEvoabTable::construct()::m_pFileStream created\n" ); + m_pFileStream->Seek(STREAM_SEEK_TO_END); + sal_Int32 nSize = m_pFileStream->Tell(); + m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN); + + // Buffersize abhaengig von der Filegroesse + m_pFileStream->SetBufferSize(nSize > 1000000 ? 32768 : + nSize > 100000 ? 16384 : + nSize > 10000 ? 4096 : 1024); + OSL_TRACE("OEvoabTable::construct()::m_pFileStream->Tell() = %d\n", nSize ); + + fillColumns(aAppLocale); + + refreshColumns(); + } +} +// ------------------------------------------------------------------------- +String OEvoabTable::getEntry() +{ + ::rtl::OUString sURL; + try + { + Reference< XResultSet > xDir = m_pConnection->getDir()->getStaticResultSet(); + Reference< XRow> xRow(xDir,UNO_QUERY); + ::rtl::OUString sName; + ::rtl::OUString sExt; + + INetURLObject aURL; + xDir->beforeFirst(); + static const ::rtl::OUString s_sSeparator(RTL_CONSTASCII_USTRINGPARAM("/")); + while(xDir->next()) + { + sName = xRow->getString(1); + aURL.SetSmartProtocol(INET_PROT_FILE); + String sUrl = m_pConnection->getURL() + s_sSeparator + sName; + aURL.SetSmartURL( sUrl ); + + // cut the extension + sExt = aURL.getExtension(); + + // name and extension have to coincide + if ( m_pConnection->matchesExtension( sExt ) ) + { + sName = sName.replaceAt(sName.getLength()-(sExt.getLength()+1),sExt.getLength()+1,::rtl::OUString()); + if ( sName == m_Name ) + { + Reference< XContentAccess > xContentAccess( xDir, UNO_QUERY ); + sURL = xContentAccess->queryContentIdentifierString(); + break; + } + } + } + xDir->beforeFirst(); // move back to before first record + } + catch(Exception&) + { + OSL_ASSERT(0); + } + return sURL.getStr(); +} +// ------------------------------------------------------------------------- +void OEvoabTable::refreshColumns() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + TStringVector aVector; + aVector.reserve(m_aColumns->get().size()); + + for(OSQLColumns::Vector::const_iterator aIter = m_aColumns->get().begin();aIter != m_aColumns->get().end();++aIter) + aVector.push_back(Reference< XNamed>(*aIter,UNO_QUERY)->getName()); + + if(m_pColumns) + m_pColumns->reFill(aVector); + else + m_pColumns = new OEvoabColumns(this,m_aMutex,aVector); + + OSL_TRACE("OEvoabTable::refreshColumns()::end\n" ); +} + +// ------------------------------------------------------------------------- +void SAL_CALL OEvoabTable::disposing(void) +{ + OFileTable::disposing(); + ::osl::MutexGuard aGuard(m_aMutex); + m_aColumns = NULL; +} +// ------------------------------------------------------------------------- +Sequence< Type > SAL_CALL OEvoabTable::getTypes( ) throw(RuntimeException) +{ + Sequence< Type > aTypes = OTable_TYPEDEF::getTypes(); + ::std::vector<Type> aOwnTypes; + aOwnTypes.reserve(aTypes.getLength()); + const Type* pBegin = aTypes.getConstArray(); + const Type* pEnd = pBegin + aTypes.getLength(); + for(;pBegin != pEnd;++pBegin) + { + if(!(*pBegin == ::getCppuType((const Reference<XKeysSupplier>*)0) || + *pBegin == ::getCppuType((const Reference<XRename>*)0) || + *pBegin == ::getCppuType((const Reference<XIndexesSupplier>*)0) || + *pBegin == ::getCppuType((const Reference<XAlterTable>*)0) || + *pBegin == ::getCppuType((const Reference<XDataDescriptorFactory>*)0))) + { + aOwnTypes.push_back(*pBegin); + } + } + Type *pTypes = aOwnTypes.empty() ? 0 : &aOwnTypes[0]; + return Sequence< Type >(pTypes, aOwnTypes.size()); +} + +// ------------------------------------------------------------------------- +Any SAL_CALL OEvoabTable::queryInterface( const Type & rType ) throw(RuntimeException) +{ + if( rType == ::getCppuType((const Reference<XKeysSupplier>*)0) || + rType == ::getCppuType((const Reference<XIndexesSupplier>*)0) || + rType == ::getCppuType((const Reference<XRename>*)0) || + rType == ::getCppuType((const Reference<XAlterTable>*)0) || + rType == ::getCppuType((const Reference<XDataDescriptorFactory>*)0)) + return Any(); + + Any aRet = OTable_TYPEDEF::queryInterface(rType); + return aRet.hasValue() ? aRet : ::cppu::queryInterface(rType,static_cast< ::com::sun::star::lang::XUnoTunnel*> (this)); +} + +//-------------------------------------------------------------------------- +Sequence< sal_Int8 > OEvoabTable::getUnoTunnelImplementationId() +{ + static ::cppu::OImplementationId * pId = 0; + if (! pId) + { + ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); + if (! pId) + { + static ::cppu::OImplementationId aId; + pId = &aId; + } + } + return pId->getImplementationId(); +} + +// com::sun::star::lang::XUnoTunnel +//------------------------------------------------------------------ +sal_Int64 OEvoabTable::getSomething( const Sequence< sal_Int8 > & rId ) throw (RuntimeException) +{ + return (rId.getLength() == 16 && 0 == rtl_compareMemory(getUnoTunnelImplementationId().getConstArray(), rId.getConstArray(), 16 ) ) + ? reinterpret_cast< sal_Int64 >( this ) + : OEvoabTable_BASE::getSomething(rId); +} +//------------------------------------------------------------------ +sal_Bool OEvoabTable::fetchRow(OValueRefRow& _rRow,const OSQLColumns & _rCols,sal_Bool bIsTable,sal_Bool bRetrieveData) +{ + *(_rRow->get())[0] = m_nFilePos; + + if (!bRetrieveData) + return TRUE; + + OEvoabConnection* pConnection = (OEvoabConnection*)m_pConnection; + // Felder: + xub_StrLen nStartPos = 0; + String aStr; + OSQLColumns::Vector::const_iterator aIter = _rCols.get().begin(); + for (sal_Int32 i = 0; aIter != _rCols.get().end();++aIter, ++i) + { + m_aCurrentLine.GetTokenSpecial(aStr,nStartPos,pConnection->getFieldDelimiter(),pConnection->getStringDelimiter()); + //OSL_TRACE("OEvoabTable::fetchRow()::aStr = %s\n", ((OUtoCStr(::rtl::OUString(aStr))) ? (OUtoCStr(::rtl::OUString(aStr))):("NULL")) ); + + if (aStr.Len() == 0) + (_rRow->get())[i+1]->setNull(); + else + { + // Laengen je nach Datentyp: + sal_Int32 nLen, + nType = 0; + if(bIsTable) + { + nLen = m_aPrecisions[i]; + nType = m_aTypes[i]; + } + else + { + Reference< XPropertySet> xColumn = *aIter; + xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)) >>= nLen; + xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nType; + } + switch(nType) + { + case DataType::TIMESTAMP: + case DataType::DATE: + case DataType::TIME: + { + double nRes = 0.0; + try + { + nRes = m_xNumberFormatter->convertStringToNumber(::com::sun::star::util::NumberFormat::ALL,aStr); + Reference<XPropertySet> xProp(m_xNumberFormatter->getNumberFormatsSupplier()->getNumberFormatSettings(),UNO_QUERY); + com::sun::star::util::Date aDate; + xProp->getPropertyValue(::rtl::OUString::createFromAscii("NullDate")) >>= aDate; + + switch(nType) + { + case DataType::DATE: + *(_rRow->get())[i+1] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDate(nRes,aDate)); + break; + case DataType::TIMESTAMP: + *(_rRow->get())[i+1] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDateTime(nRes,aDate)); + break; + default: + *(_rRow->get())[i+1] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toTime(nRes)); + } + } + catch(Exception&) + { + (_rRow->get())[i+1]->setNull(); + } + } break; + case DataType::DOUBLE: + case DataType::INTEGER: + case DataType::DECIMAL: // #99178# OJ + case DataType::NUMERIC: + { + sal_Unicode cDecimalDelimiter = pConnection->getDecimalDelimiter(); + sal_Unicode cThousandDelimiter = pConnection->getThousandDelimiter(); + String aStrConverted; + + OSL_ENSURE(cDecimalDelimiter && nType != DataType::INTEGER || + !cDecimalDelimiter && nType == DataType::INTEGER, + "FalscherTyp"); + + // In Standard-Notation (DezimalPUNKT ohne Tausender-Komma) umwandeln: + for (xub_StrLen j = 0; j < aStr.Len(); ++j) + { + if (cDecimalDelimiter && aStr.GetChar(j) == cDecimalDelimiter) + aStrConverted += '.'; + else if ( aStr.GetChar(j) == '.' ) // special case, if decimal seperator isn't '.' we have to vut the string after it + break; // #99189# OJ + else if (cThousandDelimiter && aStr.GetChar(j) == cThousandDelimiter) + { + // weglassen + } + else + aStrConverted += aStr.GetChar(j) ; + } + double nVal = ::rtl::math::stringToDouble(aStrConverted.GetBuffer(),',','.',NULL,NULL); + + // #99178# OJ + if ( DataType::DECIMAL == nType || DataType::NUMERIC == nType ) + *(_rRow->get())[i+1] = ORowSetValue(String::CreateFromDouble(nVal)); + else + *(_rRow->get())[i+1] = nVal; + } break; + + default: + { + // Wert als String in Variable der Row uebernehmen + *(_rRow->get())[i+1] = ORowSetValue(aStr); + } + break; + } + } + } + return sal_True; +} +// ----------------------------------------------------------------------------- +sal_Bool OEvoabTable::setColumnAliases() +{ + + size_t nSize = m_aColumnRawNames.size(); + if(nSize == 0 || m_aPrecisions.size() != nSize || m_aScales.size() != nSize || m_aTypes.size() != nSize) + return sal_False; + m_aColumns->get().clear(); + m_aColumns->get().reserve(nSize); + ::rtl::OUString aColumnReadName; + ::rtl::OUString aColumnHeadlineName; + ::rtl::OUString aColumnDisplayName; + ::rtl::OUString aColumnFinalName; + String sColumnFinalName; + + const TStringVector& colAliasNames = ((OEvoabConnection*)m_pConnection)->getColumnAlias().getAlias(); + const ::std::map< ::rtl::OUString, ::rtl::OUString > & colMap = ((OEvoabConnection*)m_pConnection)->getColumnAlias().getAliasMap(); + ::osl::MutexGuard aGuard( m_aMutex ); + + for(size_t i = 0;i < nSize; ++i) + { + aColumnReadName = m_aColumnRawNames[i]; + //OSL_TRACE("OEvoabTable::getColumnRows()::aColumnReadName = %s\n", ((OUtoCStr(aColumnReadName)) ? (OUtoCStr(aColumnReadName)):("NULL")) ); + sal_Bool bFound = sal_False; + for ( size_t j = 0; j < colAliasNames.size(); ++j ) + { + aColumnDisplayName = colAliasNames[j]; + + ::std::map< ::rtl::OUString, ::rtl::OUString >::const_iterator aPos = colMap.find( aColumnDisplayName ); + if ( colMap.end() != aPos ) + { + aColumnHeadlineName = aPos->second; + EVO_TRACE_STRING( "OEvoabTable::getColumnRows()::aColumnDisplayName = %s\n", aColumnDisplayName ); + EVO_TRACE_STRING( "OEvoabTable::getColumnRows()::aColumnHeadlineName= %s\n", aColumnHeadlineName ); + if(aColumnReadName == aColumnHeadlineName) + { + //OSL_TRACE("OEvoabTable::getColumnRows()::aColumnHeadlineName = %s\n", ((OUtoCStr(aColumnHeadlineName)) ? (OUtoCStr(aColumnHeadlineName)):("NULL")) ); + //OSL_TRACE("OEvoabTable::getColumnRows()::aColumnDisplayName = %s\n", ((OUtoCStr(aColumnDisplayName)) ? (OUtoCStr(aColumnDisplayName)):("NULL")) ); + aColumnFinalName = aColumnDisplayName; + bFound = sal_True; + //OSL_TRACE("OEvoabTable::getColumnRows()::j = %d\n", j ); + + break; + } + } + else + OSL_ENSURE( sal_False, "OEvoabTable::setColumnAliases: did not find one of the aliases!" ); + } + if(!bFound) + aColumnFinalName = aColumnReadName; + sColumnFinalName = aColumnFinalName; + + sal_Bool bCase = getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers(); + ::rtl::OUString aTypeName; + aTypeName = ::rtl::OUString::createFromAscii("VARCHAR"); + sdbcx::OColumn* pColumn = new sdbcx::OColumn(sColumnFinalName,aTypeName,::rtl::OUString(), + ColumnValue::NULLABLE, + m_aPrecisions[i], + m_aScales[i], + m_aTypes[i], + sal_False, + sal_False, + sal_False, + bCase); + Reference< XPropertySet> xCol = pColumn; + m_aColumns->get().push_back(xCol); + } + return sal_True; +} +// ----------------------------------------------------------------------------- +void OEvoabTable::refreshIndexes() +{ +} +// ----------------------------------------------------------------------------- +sal_Bool OEvoabTable::checkHeaderLine() +{ + if (m_nFilePos == 0 && ((OEvoabConnection*)m_pConnection)->isHeaderLine()) + { + BOOL bRead2; + do + { + bRead2 = m_pFileStream->ReadByteStringLine(m_aCurrentLine,m_pConnection->getTextEncoding()); + } + while(bRead2 && !m_aCurrentLine.Len()); + + m_nFilePos = m_pFileStream->Tell(); + if (m_pFileStream->IsEof()) + return sal_False; + } + return sal_True; +} +//------------------------------------------------------------------ +sal_Bool OEvoabTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_Int32 nOffset, sal_Int32& nCurPos) +{ + //OSL_TRACE("OEvoabTable::(before SeekRow)m_aCurrentLine = %d\n", ((OUtoCStr(::rtl::OUString(m_aCurrentLine))) ? (OUtoCStr(::rtl::OUString(m_aCurrentLine))):("NULL")) ); + + if ( !m_pFileStream ) + return sal_False; + OEvoabConnection* pConnection = (OEvoabConnection*)m_pConnection; + // ---------------------------------------------------------- + // Positionierung vorbereiten: + //OSL_TRACE("OEvoabTable::(before SeekRow,m_pFileStriam Exist)m_aCurrentLine = %d\n", ((OUtoCStr(::rtl::OUString(m_aCurrentLine))) ? (OUtoCStr(::rtl::OUString(m_aCurrentLine))):("NULL")) ); + + m_nFilePos = nCurPos; + + switch(eCursorPosition) + { + case IResultSetHelper::FIRST: + m_nFilePos = 0; + m_nRowPos = 1; + // run through + case IResultSetHelper::NEXT: + if(eCursorPosition != IResultSetHelper::FIRST) + ++m_nRowPos; + m_pFileStream->Seek(m_nFilePos); + if (m_pFileStream->IsEof() || !checkHeaderLine()) + { + m_nMaxRowCount = m_nRowPos; + return sal_False; + } + + m_aRowToFilePos.insert(::std::map<sal_Int32,sal_Int32>::value_type(m_nRowPos,m_nFilePos)); + + m_pFileStream->ReadByteStringLine(m_aCurrentLine,pConnection->getTextEncoding()); + if (m_pFileStream->IsEof()) + { + m_nMaxRowCount = m_nRowPos; + return sal_False; + } + nCurPos = m_pFileStream->Tell(); + break; + case IResultSetHelper::PRIOR: + --m_nRowPos; + if(m_nRowPos > 0) + { + m_nFilePos = m_aRowToFilePos.find(m_nRowPos)->second; + m_pFileStream->Seek(m_nFilePos); + if (m_pFileStream->IsEof() || !checkHeaderLine()) + return sal_False; + m_pFileStream->ReadByteStringLine(m_aCurrentLine,pConnection->getTextEncoding()); + if (m_pFileStream->IsEof()) + return sal_False; + nCurPos = m_pFileStream->Tell(); + } + else + m_nRowPos = 0; + + break; + case IResultSetHelper::LAST: + if(m_nMaxRowCount) + { + m_nFilePos = m_aRowToFilePos.rbegin()->second; + m_nRowPos = m_aRowToFilePos.rbegin()->first; + m_pFileStream->Seek(m_nFilePos); + if (m_pFileStream->IsEof() || !checkHeaderLine()) + return sal_False; + m_pFileStream->ReadByteStringLine(m_aCurrentLine,pConnection->getTextEncoding()); + if (m_pFileStream->IsEof()) + return sal_False; + nCurPos = m_pFileStream->Tell(); + } + else + { + while(seekRow(IResultSetHelper::NEXT,1,nCurPos)) ; // run through after last row + // now I know all + seekRow(IResultSetHelper::PRIOR,1,nCurPos); + } + break; + case IResultSetHelper::RELATIVE: + if(nOffset > 0) + { + for(sal_Int32 i = 0;i<nOffset;++i) + seekRow(IResultSetHelper::NEXT,1,nCurPos); + } + else if(nOffset < 0) + { + for(sal_Int32 i = nOffset;i;++i) + seekRow(IResultSetHelper::PRIOR,1,nCurPos); + } + break; + case IResultSetHelper::ABSOLUTE: + { + if(nOffset < 0) + nOffset = m_nRowPos + nOffset; + ::std::map<sal_Int32,sal_Int32>::const_iterator aIter = m_aRowToFilePos.find(nOffset); + if(aIter != m_aRowToFilePos.end()) + { + m_nFilePos = aIter->second; + m_pFileStream->Seek(m_nFilePos); + if (m_pFileStream->IsEof() || !checkHeaderLine()) + return sal_False; + m_pFileStream->ReadByteStringLine(m_aCurrentLine,pConnection->getTextEncoding()); + if (m_pFileStream->IsEof()) + return sal_False; + nCurPos = m_pFileStream->Tell(); + } + else if(m_nMaxRowCount && nOffset > m_nMaxRowCount) // offset is outside the table + { + m_nRowPos = m_nMaxRowCount; + return sal_False; + } + else + { + aIter = m_aRowToFilePos.upper_bound(nOffset); + if(aIter == m_aRowToFilePos.end()) + { + m_nRowPos = m_aRowToFilePos.rbegin()->first; + nCurPos = m_nFilePos = m_aRowToFilePos.rbegin()->second; + while(m_nRowPos != nOffset) + seekRow(IResultSetHelper::NEXT,1,nCurPos); + } + else + { + --aIter; + m_nRowPos = aIter->first; + m_nFilePos = aIter->second; + m_pFileStream->Seek(m_nFilePos); + if (m_pFileStream->IsEof() || !checkHeaderLine()) + return sal_False; + m_pFileStream->ReadByteStringLine(m_aCurrentLine,pConnection->getTextEncoding()); + if (m_pFileStream->IsEof()) + return sal_False; + nCurPos = m_pFileStream->Tell(); + } + } + } + + break; + case IResultSetHelper::BOOKMARK: + m_pFileStream->Seek(nOffset); + if (m_pFileStream->IsEof()) + return sal_False; + + m_nFilePos = m_pFileStream->Tell(); // Byte-Position in der Datei merken (am ZeilenANFANG) + m_pFileStream->ReadByteStringLine(m_aCurrentLine,pConnection->getTextEncoding()); + if (m_pFileStream->IsEof()) + return sal_False; + nCurPos = m_pFileStream->Tell(); + break; + } + + //OSL_TRACE("OEvoabTable::(after SeekRow)m_aCurrentLine = %d\n", ((OUtoCStr(::rtl::OUString(m_aCurrentLine))) ? (OUtoCStr(::rtl::OUString(m_aCurrentLine))):("NULL")) ); + + return sal_True; +} +// ----------------------------------------------------------------------------- |