connectivity/source/drivers/flat/ETable.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <ctype.h>
  21 #include "flat/ETable.hxx"
  22 #include <com/sun/star/sdbc/ColumnValue.hpp>
  23 #include <com/sun/star/sdbc/DataType.hpp>
  24 #include <com/sun/star/ucb/XContentAccess.hpp>
  25 #include <svl/converter.hxx>
  26 #include "flat/EConnection.hxx"
  27 #include "flat/EColumns.hxx"
  28 #include <osl/thread.h>
  29 #include <svl/zforlist.hxx>
  30 #include <rtl/math.hxx>
  31 #include <cppuhelper/queryinterface.hxx>
  32 #include <comphelper/extract.hxx>
  33 #include <comphelper/numbers.hxx>
  34 #include <comphelper/processfactory.hxx>
  35 #include <comphelper/sequence.hxx>
  36 #include <comphelper/string.hxx>
  37 #include <comphelper/types.hxx>
  38 #include "flat/EDriver.hxx"
  39 #include <com/sun/star/util/NumberFormat.hpp>
  40 #include <com/sun/star/util/NumberFormatter.hpp>
  41 #include <com/sun/star/util/NumberFormatsSupplier.hpp>
  42 #include <unotools/configmgr.hxx>
  43 #include <i18nlangtag/languagetag.hxx>
  44 #include <connectivity/dbconversion.hxx>
  45 #include "file/quotedstring.hxx"
  46 #include <unotools/syslocale.hxx>
  47
  48 using namespace ::comphelper;
  49 using namespace connectivity;
  50 using namespace connectivity::flat;
  51 using namespace connectivity::file;
  52 using namespace ::cppu;
  53 using namespace utl;
  54 using namespace ::com::sun::star::uno;
  55 using namespace ::com::sun::star::ucb;
  56 using namespace ::com::sun::star::beans;
  57 using namespace ::com::sun::star::sdbcx;
  58 using namespace ::com::sun::star::sdbc;
  59 using namespace ::com::sun::star::container;
  60 using namespace ::com::sun::star::lang;
  61 using namespace ::com::sun::star::util;
  62 using std::vector;
  63 using std::lower_bound;
  64
  65
  66 void OFlatTable::fillColumns(const ::com::sun::star::lang::Locale& _aLocale)
  67 {
  68     m_bNeedToReadLine = true; // we overwrite m_aCurrentLine, seek the stream, ...
  69     m_pFileStream->Seek(0);
  70     m_aCurrentLine = QuotedTokenizedString();
  71     bool bRead = true;
  72
  73     const OFlatConnection* const pConnection = getFlatConnection();
  74     const bool bHasHeaderLine = pConnection->isHeaderLine();
  75
  76     QuotedTokenizedString aHeaderLine;
  77     TRowPositionInFile rowPos(0, 0);
  78     sal_Int32 rowNum(0);
  79     if ( bHasHeaderLine )
  80     {
  81         bRead = readLine(&rowPos.second, &rowPos.first, true);
  82         if(bRead)
  83             aHeaderLine = m_aCurrentLine;
  84     }
  85     setRowPos(rowNum++, rowPos);
  86
  87     // read first row
  88     QuotedTokenizedString aFirstLine;
  89     if(bRead)
  90     {
  91         bRead = readLine(&rowPos.second, &rowPos.first, false);
  92         if(bRead)
  93             setRowPos(rowNum++, rowPos);
  94     }
  95
  96     if ( !bHasHeaderLine || !aHeaderLine.Len())
  97     {
  98         // use first non-empty row as headerline because we need the number of columns
  99         while(bRead && m_aCurrentLine.Len() == 0)
 100         {
 101             bRead = readLine(&rowPos.second, &rowPos.first, false);
 102             if(bRead)
 103                 setRowPos(rowNum++, rowPos);
 104         }
 105         aHeaderLine = m_aCurrentLine;
 106     }
 107     // column count
 108     const sal_Int32 nFieldCount = aHeaderLine.GetTokenCount(m_cFieldDelimiter,m_cStringDelimiter);
 109
 110     if(!m_aColumns.is())
 111         m_aColumns = new OSQLColumns();
 112     else
 113         m_aColumns->get().clear();
 114
 115     m_aTypes.clear();
 116     m_aPrecisions.clear();
 117     m_aScales.clear();
 118     // reserve some space
 119     m_aColumns->get().reserve(nFieldCount+1);
 120     m_aTypes.assign(nFieldCount+1,DataType::SQLNULL);
 121     m_aPrecisions.assign(nFieldCount+1,-1);
 122     m_aScales.assign(nFieldCount+1,-1);
 123
 124     const bool bCase = m_pConnection->getMetaData()->supportsMixedCaseQuotedIdentifiers();
 125     CharClass aCharClass( pConnection->getDriver()->getComponentContext(), LanguageTag( _aLocale));
 126     // read description
 127     const sal_Unicode cDecimalDelimiter  = pConnection->getDecimalDelimiter();
 128     const sal_Unicode cThousandDelimiter = pConnection->getThousandDelimiter();
 129     ::comphelper::UStringMixEqual aCase(bCase);
 130     vector<OUString> aColumnNames;
 131     vector<OUString> m_aTypeNames;
 132     m_aTypeNames.resize(nFieldCount);
 133     const sal_Int32 nMaxRowsToScan = pConnection->getMaxRowsToScan();
 134     sal_Int32 nRowCount = 0;
 135
 136     do
 137     {
 138         sal_Int32 nStartPosHeaderLine = 0; // use for efficient way to get the tokens
 139         sal_Int32 nStartPosFirstLine = 0; // use for efficient way to get the tokens
 140         sal_Int32 nStartPosFirstLine2 = 0;
 141         for( sal_Int32 i = 0; i < nFieldCount; i++ )
 142         {
 143             if ( nRowCount == 0)
 144             {
 145                 OUString aColumnName;
 146                 if ( bHasHeaderLine )
 147                 {
 148                     aColumnName = aHeaderLine.GetTokenSpecial(nStartPosHeaderLine,m_cFieldDelimiter,m_cStringDelimiter);
 149                 }
 150                 if ( aColumnName.isEmpty() )
 151                 {
 152                     aColumnName = "C" + OUString::number(i+1);
 153                 }
 154                 aColumnNames.push_back(aColumnName);
 155             }
 156             if(bRead)
 157             {
 158                 impl_fillColumnInfo_nothrow(m_aCurrentLine, nStartPosFirstLine, nStartPosFirstLine2,
 159                                             m_aTypes[i], m_aPrecisions[i], m_aScales[i], m_aTypeNames[i],
 160                                             cDecimalDelimiter, cThousandDelimiter, aCharClass);
 161             }
 162         }
 163         ++nRowCount;
 164         bRead = readLine(&rowPos.second, &rowPos.first, false);
 165         if(bRead)
 166             setRowPos(rowNum++, rowPos);
 167     }
 168     while(nRowCount < nMaxRowsToScan && bRead);
 169
 170     for( sal_Int32 i = 0; i < nFieldCount; i++ )
 171     {
 172         // check if the columname already exists
 173         OUString aAlias(aColumnNames[i]);
 174         OSQLColumns::Vector::const_iterator aFind = connectivity::find(m_aColumns->get().begin(),m_aColumns->get().end(),aAlias,aCase);
 175         sal_Int32 nExprCnt = 0;
 176         while(aFind != m_aColumns->get().end())
 177         {
 178             aAlias = aColumnNames[i] + OUString::number(++nExprCnt);
 179             aFind = connectivity::find(m_aColumns->get().begin(),m_aColumns->get().end(),aAlias,aCase);
 180         }
 181
 182         sdbcx::OColumn* pColumn = new sdbcx::OColumn(aAlias,m_aTypeNames[i],OUString(),OUString(),
 183                                                 ColumnValue::NULLABLE,
 184                                                 m_aPrecisions[i],
 185                                                 m_aScales[i],
 186                                                 m_aTypes[i],
 187                                                 false,
 188                                                 false,
 189                                                 false,
 190                                                 bCase,
 191                                                 m_CatalogName, getSchema(), getName());
 192         Reference< XPropertySet> xCol = pColumn;
 193         m_aColumns->get().push_back(xCol);
 194     }
 195
 196     m_pFileStream->Seek(m_aRowPosToFilePos[0].second);
 197 }
 198
 199 void OFlatTable::impl_fillColumnInfo_nothrow(QuotedTokenizedString& aFirstLine, sal_Int32& nStartPosFirstLine, sal_Int32& nStartPosFirstLine2,
 200                                              sal_Int32& io_nType, sal_Int32& io_nPrecisions, sal_Int32& io_nScales, OUString& o_sTypeName,
 201                                              const sal_Unicode cDecimalDelimiter, const sal_Unicode cThousandDelimiter, const CharClass&  aCharClass)
 202 {
 203     if ( io_nType != DataType::VARCHAR )
 204     {
 205         bool bNumeric = io_nType == DataType::SQLNULL || io_nType == DataType::DOUBLE || io_nType == DataType::DECIMAL || io_nType == DataType::INTEGER;
 206         sal_uLong  nIndex = 0;
 207
 208         if ( bNumeric )
 209         {
 210             // first without fielddelimiter
 211             OUString aField = aFirstLine.GetTokenSpecial(nStartPosFirstLine,m_cFieldDelimiter,'\0');
 212             if (aField.isEmpty() ||
 213                 (m_cStringDelimiter && m_cStringDelimiter == aField[0]))
 214             {
 215                 bNumeric = false;
 216                 if ( m_cStringDelimiter != '\0' )
 217                     aField = aFirstLine.GetTokenSpecial(nStartPosFirstLine2,m_cFieldDelimiter,m_cStringDelimiter);
 218                 else
 219                     nStartPosFirstLine2 = nStartPosFirstLine;
 220             }
 221             else
 222             {
 223                 OUString aField2;
 224                 if ( m_cStringDelimiter != '\0' )
 225                     aField2 = aFirstLine.GetTokenSpecial(nStartPosFirstLine2,m_cFieldDelimiter,m_cStringDelimiter);
 226                 else
 227                     aField2 = aField;
 228
 229                 if (aField2.isEmpty())
 230                 {
 231                     bNumeric = false;
 232                 }
 233                 else
 234                 {
 235                     bNumeric = true;
 236                     sal_Int32 nDot = 0;
 237                     sal_Int32 nDecimalDelCount = 0;
 238                     sal_Int32 nSpaceCount = 0;
 239                     for( sal_Int32 j = 0; j < aField2.getLength(); j++ )
 240                     {
 241                         const sal_Unicode c = aField2[j];
 242                         if ( j == nSpaceCount && m_cFieldDelimiter != 32 && c == 32 )
 243                         {
 244                             ++nSpaceCount;
 245                             continue;
 246                         }
 247                         // just digits, decimal- and thousands-delimiter?
 248                         if ( ( !cDecimalDelimiter  || c != cDecimalDelimiter )  &&
 249                              ( !cThousandDelimiter || c != cThousandDelimiter ) &&
 250                             !aCharClass.isDigit(aField2,j)                      &&
 251                             ( j != 0 || (c != '+' && c != '-' ) ) )
 252                         {
 253                             bNumeric = false;
 254                             break;
 255                         }
 256                         if (cDecimalDelimiter && c == cDecimalDelimiter)
 257                         {
 258                             io_nPrecisions = 15; // we have an decimal value
 259                             io_nScales = 2;
 260                             ++nDecimalDelCount;
 261                         } // if (cDecimalDelimiter && c == cDecimalDelimiter)
 262                         if ( c == '.' )
 263                             ++nDot;
 264                     }
 265
 266                     if (nDecimalDelCount > 1 || nDot > 1 ) // if there is more than one dot it isn't a number
 267                         bNumeric = false;
 268                     if (bNumeric && cThousandDelimiter)
 269                     {
 270                         // Is the delimiter correct?
 271                         const OUString aValue = aField2.getToken(0,cDecimalDelimiter);
 272                         for( sal_Int32 j = aValue.getLength() - 4; j >= 0; j -= 4)
 273                         {
 274                             const sal_Unicode c = aValue[j];
 275                             // just digits, decimal- and thousands-delimiter?
 276                             if (c == cThousandDelimiter && j)
 277                                 continue;
 278                             else
 279                             {
 280                                 bNumeric = false;
 281                                 break;
 282                             }
 283                         }
 284                     }
 285
 286                     // now also check for a date field
 287                     if (!bNumeric)
 288                     {
 289                         try
 290                         {
 291                             nIndex = m_xNumberFormatter->detectNumberFormat(::com::sun::star::util::NumberFormat::ALL,aField2);
 292                         }
 293                         catch(Exception&)
 294                         {
 295                         }
 296                     }
 297                 }
 298             }
 299         }
 300         else if ( io_nType == DataType::DATE || io_nType == DataType::TIMESTAMP || io_nType == DataType::TIME)
 301         {
 302             OUString aField = aFirstLine.GetTokenSpecial(nStartPosFirstLine,m_cFieldDelimiter,'\0');
 303             if (aField.isEmpty() ||
 304                 (m_cStringDelimiter && m_cStringDelimiter == aField[0]))
 305             {
 306             }
 307             else
 308             {
 309                 OUString aField2;
 310                 if ( m_cStringDelimiter != '\0' )
 311                     aField2 = aFirstLine.GetTokenSpecial(nStartPosFirstLine2,m_cFieldDelimiter,m_cStringDelimiter);
 312                 else
 313                     aField2 = aField;
 314                 if (!aField2.isEmpty() )
 315                 {
 316                     try
 317                     {
 318                         nIndex = m_xNumberFormatter->detectNumberFormat(::com::sun::star::util::NumberFormat::ALL,aField2);
 319                     }
 320                     catch(Exception&)
 321                     {
 322                     }
 323                 }
 324             }
 325         }
 326
 327         sal_Int32 nFlags = 0;
 328         if (bNumeric)
 329         {
 330             if (cDecimalDelimiter)
 331             {
 332                 if(io_nPrecisions)
 333                 {
 334                     io_nType = DataType::DECIMAL;
 335                     o_sTypeName = "DECIMAL";
 336                 }
 337                 else
 338                 {
 339                     io_nType = DataType::DOUBLE;
 340                     o_sTypeName = "DOUBLE";
 341                 }
 342             }
 343             else
 344             {
 345                 io_nType = DataType::INTEGER;
 346                 io_nPrecisions = 0;
 347                 io_nScales = 0;
 348             }
 349             nFlags = ColumnSearch::BASIC;
 350         }
 351         else
 352         {
 353             switch (comphelper::getNumberFormatType(m_xNumberFormatter,nIndex))
 354             {
 355                 case css::util::NumberFormat::DATE:
 356                     io_nType = DataType::DATE;
 357                     o_sTypeName = "DATE";
 358                     break;
 359                 case css::util::NumberFormat::DATETIME:
 360                     io_nType = DataType::TIMESTAMP;
 361                     o_sTypeName = "TIMESTAMP";
 362                     break;
 363                 case css::util::NumberFormat::TIME:
 364                     io_nType = DataType::TIME;
 365                     o_sTypeName = "TIME";
 366                     break;
 367                 default:
 368                     io_nType = DataType::VARCHAR;
 369                     io_nPrecisions = 0; // nyi: Data can be longer!
 370                     io_nScales = 0;
 371                     o_sTypeName = "VARCHAR";
 372             };
 373             nFlags |= ColumnSearch::CHAR;
 374         }
 375     }
 376     else
 377     {
 378         OUString aField = aFirstLine.GetTokenSpecial(nStartPosFirstLine,m_cFieldDelimiter,'\0');
 379         if (aField.isEmpty() ||
 380                 (m_cStringDelimiter && m_cStringDelimiter == aField[0]))
 381         {
 382             if ( m_cStringDelimiter != '\0' )
 383                 aField = aFirstLine.GetTokenSpecial(nStartPosFirstLine2, m_cFieldDelimiter, m_cStringDelimiter);
 384             else
 385                 nStartPosFirstLine2 = nStartPosFirstLine;
 386         }
 387         else
 388         {
 389             if ( m_cStringDelimiter != '\0' )
 390                 aFirstLine.GetTokenSpecial(nStartPosFirstLine2, m_cFieldDelimiter, m_cStringDelimiter);
 391         }
 392     }
 393 }
 394
 395 OFlatTable::OFlatTable(sdbcx::OCollection* _pTables,OFlatConnection* _pConnection,
 396                     const OUString& _Name,
 397                     const OUString& _Type,
 398                     const OUString& _Description ,
 399                     const OUString& _SchemaName,
 400                     const OUString& _CatalogName
 401                 ) : OFlatTable_BASE(_pTables,_pConnection,_Name,
 402                                   _Type,
 403                                   _Description,
 404                                   _SchemaName,
 405                                   _CatalogName)
 406     ,m_nRowPos(0)
 407     ,m_nMaxRowCount(0)
 408     ,m_cStringDelimiter(_pConnection->getStringDelimiter())
 409     ,m_cFieldDelimiter(_pConnection->getFieldDelimiter())
 410     ,m_bNeedToReadLine(false)
 411 {
 412
 413 }
 414
 415 void OFlatTable::construct()
 416 {
 417     SvtSysLocale aLocale;
 418     ::com::sun::star::lang::Locale aAppLocale(aLocale.GetLanguageTag().getLocale());
 419
 420     Reference< XNumberFormatsSupplier > xSupplier = NumberFormatsSupplier::createWithLocale( m_pConnection->getDriver()->getComponentContext(), aAppLocale );
 421     m_xNumberFormatter.set( NumberFormatter::create( m_pConnection->getDriver()->getComponentContext()), UNO_QUERY_THROW);
 422     m_xNumberFormatter->attachNumberFormatsSupplier(xSupplier);
 423     Reference<XPropertySet> xProp(xSupplier->getNumberFormatSettings(),UNO_QUERY);
 424     xProp->getPropertyValue("NullDate") >>= m_aNullDate;
 425
 426     INetURLObject aURL;
 427     aURL.SetURL(getEntry());
 428
 429     if(aURL.getExtension() != OUString(m_pConnection->getExtension()))
 430         aURL.setExtension(m_pConnection->getExtension());
 431
 432     OUString aFileName = aURL.GetMainURL(INetURLObject::NO_DECODE);
 433
 434     m_pFileStream = createStream_simpleError( aFileName, STREAM_READWRITE | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
 435
 436     if(!m_pFileStream)
 437         m_pFileStream = createStream_simpleError( aFileName, StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYNONE);
 438
 439     if(m_pFileStream)
 440     {
 441         sal_uInt64 const nSize = m_pFileStream->remainingSize();
 442
 443         // Buffersize is dependent on the file-size
 444         m_pFileStream->SetBufferSize(nSize > 1000000 ? 32768 :
 445                                     nSize > 100000  ? 16384 :
 446                                     nSize > 10000   ? 4096  : 1024);
 447
 448         fillColumns(aAppLocale);
 449
 450         refreshColumns();
 451     }
 452 }
 453
 454 OUString OFlatTable::getEntry()
 455 {
 456     OUString sURL;
 457     try
 458     {
 459         Reference< XResultSet > xDir = m_pConnection->getDir()->getStaticResultSet();
 460         Reference< XRow> xRow(xDir,UNO_QUERY);
 461         OUString sName;
 462         OUString sExt;
 463
 464         INetURLObject aURL;
 465         xDir->beforeFirst();
 466         static const char s_sSeparator[] = "/";
 467         while(xDir->next())
 468         {
 469             sName = xRow->getString(1);
 470             aURL.SetSmartProtocol(INetProtocol::File);
 471             OUString sUrl = m_pConnection->getURL() +  s_sSeparator + sName;
 472             aURL.SetSmartURL( sUrl );
 473
 474             // cut the extension
 475             sExt = aURL.getExtension();
 476
 477             // name and extension have to coincide
 478             if ( m_pConnection->matchesExtension( sExt ) )
 479             {
 480                 if ( !sExt.isEmpty() )
 481                     sName = sName.replaceAt(sName.getLength() - (sExt.getLength() + 1), sExt.getLength()+1, OUString());
 482                 if ( sName == m_Name )
 483                 {
 484                     Reference< XContentAccess > xContentAccess( xDir, UNO_QUERY );
 485                     sURL = xContentAccess->queryContentIdentifierString();
 486                     break;
 487                 }
 488             }
 489         }
 490         xDir->beforeFirst(); // move back to before first record
 491     }
 492     catch(const Exception&)
 493     {
 494         OSL_ASSERT(false);
 495     }
 496     return sURL;
 497 }
 498
 499 void OFlatTable::refreshColumns()
 500 {
 501     ::osl::MutexGuard aGuard( m_aMutex );
 502
 503     TStringVector aVector;
 504     aVector.reserve(m_aColumns->get().size());
 505
 506     for(OSQLColumns::Vector::const_iterator aIter = m_aColumns->get().begin();aIter != m_aColumns->get().end();++aIter)
 507         aVector.push_back(Reference< XNamed>(*aIter,UNO_QUERY)->getName());
 508
 509     if(m_pColumns)
 510         m_pColumns->reFill(aVector);
 511     else
 512         m_pColumns  = new OFlatColumns(this,m_aMutex,aVector);
 513 }
 514
 515
 516 void SAL_CALL OFlatTable::disposing()
 517 {
 518     OFileTable::disposing();
 519     ::osl::MutexGuard aGuard(m_aMutex);
 520     m_aColumns = NULL;
 521 }
 522
 523 Sequence< Type > SAL_CALL OFlatTable::getTypes(  ) throw(RuntimeException, std::exception)
 524 {
 525     Sequence< Type > aTypes = OTable_TYPEDEF::getTypes();
 526     vector<Type> aOwnTypes;
 527     aOwnTypes.reserve(aTypes.getLength());
 528     const Type* pBegin = aTypes.getConstArray();
 529     const Type* pEnd = pBegin + aTypes.getLength();
 530     for(;pBegin != pEnd;++pBegin)
 531     {
 532         if(!(*pBegin == cppu::UnoType<XKeysSupplier>::get()||
 533             *pBegin == cppu::UnoType<XRename>::get()||
 534             *pBegin == cppu::UnoType<XIndexesSupplier>::get()||
 535             *pBegin == cppu::UnoType<XAlterTable>::get()||
 536             *pBegin == cppu::UnoType<XDataDescriptorFactory>::get()))
 537         {
 538             aOwnTypes.push_back(*pBegin);
 539         }
 540     }
 541     return Sequence< Type >(aOwnTypes.data(), aOwnTypes.size());
 542 }
 543
 544
 545 Any SAL_CALL OFlatTable::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
 546 {
 547     if( rType == cppu::UnoType<XKeysSupplier>::get()||
 548         rType == cppu::UnoType<XIndexesSupplier>::get()||
 549         rType == cppu::UnoType<XRename>::get()||
 550         rType == cppu::UnoType<XAlterTable>::get()||
 551         rType == cppu::UnoType<XDataDescriptorFactory>::get())
 552         return Any();
 553
 554     Any aRet = OTable_TYPEDEF::queryInterface(rType);
 555     return aRet.hasValue() ? aRet : ::cppu::queryInterface(rType,static_cast< ::com::sun::star::lang::XUnoTunnel*> (this));
 556 }
 557
 558
 559 Sequence< sal_Int8 > OFlatTable::getUnoTunnelImplementationId()
 560 {
 561     static ::cppu::OImplementationId * pId = 0;
 562     if (! pId)
 563     {
 564         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 565         if (! pId)
 566         {
 567             static ::cppu::OImplementationId aId;
 568             pId = &aId;
 569         }
 570     }
 571     return pId->getImplementationId();
 572 }
 573
 574 // com::sun::star::lang::XUnoTunnel
 575
 576 sal_Int64 OFlatTable::getSomething( const Sequence< sal_Int8 > & rId ) throw (RuntimeException, std::exception)
 577 {
 578     return (rId.getLength() == 16 && 0 == memcmp(getUnoTunnelImplementationId().getConstArray(),  rId.getConstArray(), 16 ) )
 579                 ? reinterpret_cast< sal_Int64 >( this )
 580                 : OFlatTable_BASE::getSomething(rId);
 581 }
 582
 583 bool OFlatTable::fetchRow(OValueRefRow& _rRow, const OSQLColumns & _rCols, bool bIsTable, bool bRetrieveData)
 584 {
 585     *(_rRow->get())[0] = m_nFilePos;
 586
 587     if (!bRetrieveData)
 588         return true;
 589
 590     bool result = false;
 591     if ( m_bNeedToReadLine )
 592     {
 593         m_pFileStream->Seek(m_nFilePos);
 594         TRowPositionInFile rowPos(0, 0);
 595         if(readLine(&rowPos.second, &rowPos.first))
 596         {
 597             setRowPos(m_nRowPos, rowPos);
 598             m_bNeedToReadLine = false;
 599             result = true;
 600         }
 601         // else let run through so that we set _rRow to all NULL
 602     }
 603
 604     const OFlatConnection * const pConnection = getFlatConnection();
 605     const sal_Unicode cDecimalDelimiter = pConnection->getDecimalDelimiter();
 606     const sal_Unicode cThousandDelimiter = pConnection->getThousandDelimiter();
 607     // Fields:
 608     sal_Int32 nStartPos = 0;
 609     OSQLColumns::Vector::const_iterator aIter = _rCols.get().begin();
 610     OSQLColumns::Vector::const_iterator aEnd = _rCols.get().end();
 611     const OValueRefVector::Vector::size_type nCount = _rRow->get().size();
 612     for (OValueRefVector::Vector::size_type i = 1;
 613          aIter != aEnd && i < nCount;
 614          ++aIter, i++)
 615     {
 616         OUString aStr = m_aCurrentLine.GetTokenSpecial(nStartPos,m_cFieldDelimiter,m_cStringDelimiter);
 617
 618         if (aStr.isEmpty())
 619         {
 620             (_rRow->get())[i]->setNull();
 621         }
 622         else
 623         {
 624             // lengths depending on data-type:
 625             sal_Int32   nLen;
 626             sal_Int32 nType = 0;
 627             if(bIsTable)
 628             {
 629                 nLen    = m_aPrecisions[i-1];
 630                 nType   = m_aTypes[i-1];
 631             }
 632             else
 633             {
 634                 Reference< XPropertySet> xColumn = *aIter;
 635                 xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))  >>= nLen;
 636                 xColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))       >>= nType;
 637             }
 638             switch(nType)
 639             {
 640                 case DataType::TIMESTAMP:
 641                 case DataType::DATE:
 642                 case DataType::TIME:
 643                 {
 644                     try
 645                     {
 646                         double nRes = m_xNumberFormatter->convertStringToNumber(::com::sun::star::util::NumberFormat::ALL,aStr);
 647
 648                         switch(nType)
 649                         {
 650                             case DataType::DATE:
 651                                 *(_rRow->get())[i] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDate(nRes,m_aNullDate));
 652                                 break;
 653                             case DataType::TIMESTAMP:
 654                                 *(_rRow->get())[i] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDateTime(nRes,m_aNullDate));
 655                                 break;
 656                             default:
 657                                 *(_rRow->get())[i] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toTime(nRes));
 658                         }
 659                     }
 660                     catch(Exception&)
 661                     {
 662                         (_rRow->get())[i]->setNull();
 663                     }
 664                 }   break;
 665                 case DataType::DOUBLE:
 666                 case DataType::INTEGER:
 667                 case DataType::DECIMAL:
 668                 case DataType::NUMERIC:
 669                 {
 670
 671                     OUString aStrConverted;
 672                     if ( DataType::INTEGER != nType )
 673                     {
 674                         OSL_ENSURE((cDecimalDelimiter && nType != DataType::INTEGER) ||
 675                                    (!cDecimalDelimiter && nType == DataType::INTEGER),
 676                                    "FalscherTyp");
 677
 678                         OUStringBuffer aBuf(aStr.getLength());
 679                         // convert to Standard-Notation (DecimalPOINT without thousands-comma):
 680                         for (sal_Int32 j = 0; j < aStr.getLength(); ++j)
 681                         {
 682                             const sal_Unicode cChar = aStr[j];
 683                             if (cDecimalDelimiter && cChar == cDecimalDelimiter)
 684                                 aBuf.append('.');
 685                             else if ( cChar == '.' ) // special case, if decimal separator isn't '.' we have to put the string after it
 686                                 continue;
 687                             else if (cThousandDelimiter && cChar == cThousandDelimiter)
 688                             {
 689                                 // leave out
 690                             }
 691                             else
 692                                 aBuf.append(cChar);
 693                         } // for (j = 0; j < aStr.getLength(); ++j)
 694                         aStrConverted = aBuf.makeStringAndClear();
 695                     } // if ( DataType::INTEGER != nType )
 696                     else
 697                     {
 698                         if ( cThousandDelimiter )
 699                             aStrConverted = comphelper::string::remove(aStr, cThousandDelimiter);
 700                         else
 701                             aStrConverted = aStr;
 702                     }
 703                     const double nVal = ::rtl::math::stringToDouble(aStrConverted,'.',',',NULL,NULL);
 704
 705                     // #99178# OJ
 706                     if ( DataType::DECIMAL == nType || DataType::NUMERIC == nType )
 707                         *(_rRow->get())[i] = OUString::number(nVal);
 708                     else
 709                         *(_rRow->get())[i] = nVal;
 710                 } break;
 711
 712                 default:
 713                 {
 714                     // Copy Value as String in Row-Variable
 715                     *(_rRow->get())[i] = ORowSetValue(aStr);
 716                 }
 717                 break;
 718             } // switch(nType)
 719             (_rRow->get())[i]->setTypeKind(nType);
 720         }
 721     }
 722     return result;
 723 }
 724
 725
 726 void OFlatTable::refreshHeader()
 727 {
 728     SAL_INFO( "connectivity.drivers", "flat lionel@mamane.lu OFlatTable::refreshHeader" );
 729 }
 730
 731
 732 namespace
 733 {
 734     template< typename Tp, typename Te> struct RangeBefore
 735     {
 736         bool operator() (const Tp &p, const Te &e)
 737         {
 738             assert(p.first <= p.second);
 739             return p.second <= e;
 740         }
 741     };
 742 }
 743
 744 bool OFlatTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_Int32 nOffset, sal_Int32& nCurPos)
 745 {
 746     OSL_ENSURE(m_pFileStream,"OFlatTable::seekRow: FileStream is NULL!");
 747
 748
 749     switch(eCursorPosition)
 750     {
 751         case IResultSetHelper::FIRST:
 752             m_nRowPos = 0;
 753             // run through
 754         case IResultSetHelper::NEXT:
 755             {
 756                 assert(m_nRowPos >= 0);
 757                 if(m_nMaxRowCount != 0 && m_nRowPos > m_nMaxRowCount)
 758                     return false;
 759                 ++m_nRowPos;
 760                 if(m_aRowPosToFilePos.size() > static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos))
 761                 {
 762                     m_bNeedToReadLine = true;
 763                     m_nFilePos  = m_aRowPosToFilePos[m_nRowPos].first;
 764                     nCurPos     = m_aRowPosToFilePos[m_nRowPos].second;
 765                 }
 766                 else
 767                 {
 768                     assert(m_aRowPosToFilePos.size() == static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos));
 769                     const TRowPositionInFile &lastRowPos(m_aRowPosToFilePos.back());
 770                     // Our ResultSet is allowed to disagree with us only
 771                     // on the position of the first line
 772                     // (because of the special case of the header...)
 773                     assert(m_nRowPos == 1 || nCurPos == lastRowPos.second);
 774
 775                     m_nFilePos = lastRowPos.second;
 776                     m_pFileStream->Seek(m_nFilePos);
 777
 778                     TRowPositionInFile newRowPos;
 779                     if(!readLine(&newRowPos.second, &newRowPos.first, false))
 780                     {
 781                         m_nMaxRowCount = m_nRowPos - 1;
 782                         return false;
 783                     }
 784
 785                     nCurPos = newRowPos.second;
 786                     setRowPos(m_nRowPos, newRowPos);
 787                 }
 788             }
 789
 790             break;
 791         case IResultSetHelper::PRIOR:
 792             assert(m_nRowPos >= 0);
 793
 794             if(m_nRowPos == 0)
 795                 return false;
 796
 797             --m_nRowPos;
 798             {
 799                 assert (m_nRowPos >= 0);
 800                 assert(m_aRowPosToFilePos.size() >= static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos));
 801                 const TRowPositionInFile &aPositions(m_aRowPosToFilePos[m_nRowPos]);
 802                 m_nFilePos = aPositions.first;
 803                 nCurPos = aPositions.second;
 804                 m_bNeedToReadLine = true;
 805             }
 806
 807             break;
 808         case IResultSetHelper::LAST:
 809             if (m_nMaxRowCount == 0)
 810             {
 811                 while(seekRow(IResultSetHelper::NEXT, 1, nCurPos)) ; // run through after last row
 812             }
 813             // m_nMaxRowCount can still be zero, but now it means there a genuinely zero rows in the table
 814             return seekRow(IResultSetHelper::ABSOLUTE1, m_nMaxRowCount, nCurPos);
 815             break;
 816         case IResultSetHelper::RELATIVE1:
 817             {
 818                 const sal_Int32 nNewRowPos = m_nRowPos + nOffset;
 819                 if (nNewRowPos < 0)
 820                     return false;
 821                 // ABSOLUTE will take care of case nNewRowPos > nMaxRowCount
 822                 return seekRow(IResultSetHelper::ABSOLUTE1, nNewRowPos, nCurPos);
 823             }
 824         case IResultSetHelper::ABSOLUTE1:
 825             {
 826                 if(nOffset < 0)
 827                 {
 828                     if (m_nMaxRowCount == 0)
 829                     {
 830                         if (!seekRow(IResultSetHelper::LAST, 0, nCurPos))
 831                             return false;
 832                     }
 833                     // m_nMaxRowCount can still be zero, but now it means there a genuinely zero rows in the table
 834                     nOffset = m_nMaxRowCount + nOffset;
 835                 }
 836                 if(nOffset < 0)
 837                 {
 838                     seekRow(IResultSetHelper::ABSOLUTE1, 0, nCurPos);
 839                     return false;
 840                 }
 841                 if(m_nMaxRowCount && nOffset > m_nMaxRowCount)
 842                 {
 843                     m_nRowPos = m_nMaxRowCount + 1;
 844                     const TRowPositionInFile &lastRowPos(m_aRowPosToFilePos.back());
 845                     m_nFilePos = lastRowPos.second;
 846                     nCurPos = lastRowPos.second;
 847                     return false;
 848                 }
 849
 850                 assert(m_nRowPos >=0);
 851                 assert(m_aRowPosToFilePos.size() > static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos));
 852                 assert(nOffset >= 0);
 853                 if(m_aRowPosToFilePos.size() > static_cast< vector< TRowPositionInFile >::size_type >(nOffset))
 854                 {
 855                     m_nFilePos  = m_aRowPosToFilePos[nOffset].first;
 856                     nCurPos     = m_aRowPosToFilePos[nOffset].second;
 857                     m_nRowPos   = nOffset;
 858                     m_bNeedToReadLine = true;
 859                 }
 860                 else
 861                 {
 862                     assert(m_nRowPos < nOffset);
 863                     while(m_nRowPos < nOffset)
 864                     {
 865                         if(!seekRow(IResultSetHelper::NEXT, 1, nCurPos))
 866                             return false;
 867                     }
 868                     assert(m_nRowPos == nOffset);
 869                 }
 870             }
 871
 872             break;
 873         case IResultSetHelper::BOOKMARK:
 874             {
 875                 vector< TRowPositionInFile >::const_iterator aFind = lower_bound(m_aRowPosToFilePos.begin(),
 876                                                                                  m_aRowPosToFilePos.end(),
 877                                                                                  nOffset,
 878                                                                                  RangeBefore< TRowPositionInFile, sal_Int32 >());
 879
 880                 if(aFind == m_aRowPosToFilePos.end() || aFind->first != nOffset)
 881                     //invalid bookmark
 882                     return false;
 883
 884                 m_bNeedToReadLine = true;
 885                 m_nFilePos  = aFind->first;
 886                 nCurPos     = aFind->second;
 887                 m_nRowPos = aFind - m_aRowPosToFilePos.begin();
 888                 break;
 889             }
 890     }
 891
 892     return true;
 893 }
 894
 895
 896 bool OFlatTable::readLine(sal_Int32 * const pEndPos, sal_Int32 * const pStartPos, const bool nonEmpty)
 897 {
 898     const rtl_TextEncoding nEncoding = m_pConnection->getTextEncoding();
 899     m_aCurrentLine = QuotedTokenizedString();
 900     do
 901     {
 902         if (pStartPos)
 903             *pStartPos = (sal_Int32)m_pFileStream->Tell();
 904         m_pFileStream->ReadByteStringLine(m_aCurrentLine, nEncoding);
 905         if (m_pFileStream->IsEof())
 906             return false;
 907
 908         QuotedTokenizedString sLine = m_aCurrentLine; // check if the string continues on next line
 909         while( (comphelper::string::getTokenCount(sLine.GetString(), m_cStringDelimiter) % 2) != 1 )
 910         {
 911             m_pFileStream->ReadByteStringLine(sLine,nEncoding);
 912             if ( !m_pFileStream->IsEof() )
 913             {
 914                 OUString aStr = m_aCurrentLine.GetString() + "\n" + sLine.GetString();
 915                 m_aCurrentLine.SetString(aStr);
 916                 sLine = m_aCurrentLine;
 917             }
 918             else
 919                 break;
 920         }
 921     }
 922     while(nonEmpty && m_aCurrentLine.Len() == 0);
 923
 924     if(pEndPos)
 925         *pEndPos = (sal_Int32)m_pFileStream->Tell();
 926     return true;
 927 }
 928
 929
 930 void OFlatTable::setRowPos(const vector<TRowPositionInFile>::size_type rowNum, const TRowPositionInFile &rowPos)
 931 {
 932     assert(m_aRowPosToFilePos.size() >= rowNum);
 933     if(m_aRowPosToFilePos.size() == rowNum)
 934         m_aRowPosToFilePos.push_back(rowPos);
 935     else
 936     {
 937         SAL_WARN_IF(m_aRowPosToFilePos[rowNum] != rowPos,
 938                     "connectivity.flat",
 939                     "Setting position for row " << rowNum << " to (" << rowPos.first << ", " << rowPos.second << "), "
 940                     "but already had different position (" << m_aRowPosToFilePos[rowNum].first << ", " << m_aRowPosToFilePos[rowNum].second << ")");
 941         m_aRowPosToFilePos[rowNum] = rowPos;
 942     }
 943 }
 944
 945 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */