?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
build fix
[LibreOffice.git] / connectivity / source / drivers / flat / ETable.cxx
blob54b93c825dee51ac83058ffb9baba4c6b4068546
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 css::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);
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);
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> aTypeNames;
132 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], aTypeNames[i],
160 cDecimalDelimiter, cThousandDelimiter, aCharClass);
161 }
162 }
163 ++nRowCount;
164 bRead = readLine(&rowPos.second, &rowPos.first);
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,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);
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(css::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);
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(css::util::NumberFormat::ALL,aField2);
319 }
320 catch(Exception&)
321 {
322 }
323 }
324 }
325 }
326
327 if (bNumeric)
328 {
329 if (cDecimalDelimiter)
330 {
331 if(io_nPrecisions)
332 {
333 io_nType = DataType::DECIMAL;
334 o_sTypeName = "DECIMAL";
335 }
336 else
337 {
338 io_nType = DataType::DOUBLE;
339 o_sTypeName = "DOUBLE";
340 }
341 }
342 else
343 {
344 io_nType = DataType::INTEGER;
345 io_nPrecisions = 0;
346 io_nScales = 0;
347 }
348 }
349 else
350 {
351 switch (comphelper::getNumberFormatType(m_xNumberFormatter,nIndex))
352 {
353 case css::util::NumberFormat::DATE:
354 io_nType = DataType::DATE;
355 o_sTypeName = "DATE";
356 break;
357 case css::util::NumberFormat::DATETIME:
358 io_nType = DataType::TIMESTAMP;
359 o_sTypeName = "TIMESTAMP";
360 break;
361 case css::util::NumberFormat::TIME:
362 io_nType = DataType::TIME;
363 o_sTypeName = "TIME";
364 break;
365 default:
366 io_nType = DataType::VARCHAR;
367 io_nPrecisions = 0; // nyi: Data can be longer!
368 io_nScales = 0;
369 o_sTypeName = "VARCHAR";
370 };
371 }
372 }
373 else
374 {
375 OUString aField = aFirstLine.GetTokenSpecial(nStartPosFirstLine,m_cFieldDelimiter);
376 if (aField.isEmpty() ||
377 (m_cStringDelimiter && m_cStringDelimiter == aField[0]))
378 {
379 if ( m_cStringDelimiter != '\0' )
380 aField = aFirstLine.GetTokenSpecial(nStartPosFirstLine2, m_cFieldDelimiter, m_cStringDelimiter);
381 else
382 nStartPosFirstLine2 = nStartPosFirstLine;
383 }
384 else
385 {
386 if ( m_cStringDelimiter != '\0' )
387 aFirstLine.GetTokenSpecial(nStartPosFirstLine2, m_cFieldDelimiter, m_cStringDelimiter);
388 }
389 }
390 }
391
392 OFlatTable::OFlatTable(sdbcx::OCollection* _pTables,OFlatConnection* _pConnection,
393 const OUString& Name,
394 const OUString& Type,
395 const OUString& Description ,
396 const OUString& SchemaName,
397 const OUString& CatalogName
398 ) : OFlatTable_BASE(_pTables,_pConnection,Name,
399 Type,
400 Description,
401 SchemaName,
402 CatalogName)
403 ,m_nRowPos(0)
404 ,m_nMaxRowCount(0)
405 ,m_cStringDelimiter(_pConnection->getStringDelimiter())
406 ,m_cFieldDelimiter(_pConnection->getFieldDelimiter())
407 ,m_bNeedToReadLine(false)
408 {
409
410 }
411
412 void OFlatTable::construct()
413 {
414 SvtSysLocale aLocale;
415 css::lang::Locale aAppLocale(aLocale.GetLanguageTag().getLocale());
416
417 Reference< XNumberFormatsSupplier > xSupplier = NumberFormatsSupplier::createWithLocale( m_pConnection->getDriver()->getComponentContext(), aAppLocale );
418 m_xNumberFormatter.set( NumberFormatter::create( m_pConnection->getDriver()->getComponentContext()), UNO_QUERY_THROW);
419 m_xNumberFormatter->attachNumberFormatsSupplier(xSupplier);
420 Reference<XPropertySet> xProp(xSupplier->getNumberFormatSettings(),UNO_QUERY);
421 xProp->getPropertyValue("NullDate") >>= m_aNullDate;
422
423 INetURLObject aURL;
424 aURL.SetURL(getEntry());
425
426 if(aURL.getExtension() != m_pConnection->getExtension())
427 aURL.setExtension(m_pConnection->getExtension());
428
429 OUString aFileName = aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE);
430
431 m_pFileStream = createStream_simpleError( aFileName, StreamMode::READWRITE | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
432
433 if(!m_pFileStream)
434 m_pFileStream = createStream_simpleError( aFileName, StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYNONE);
435
436 if(m_pFileStream)
437 {
438 sal_uInt64 const nSize = m_pFileStream->remainingSize();
439
440 // Buffersize is dependent on the file-size
441 m_pFileStream->SetBufferSize(nSize > 1000000 ? 32768 :
442 nSize > 100000 ? 16384 :
443 nSize > 10000 ? 4096 : 1024);
444
445 fillColumns(aAppLocale);
446
447 refreshColumns();
448 }
449 }
450
451 OUString OFlatTable::getEntry()
452 {
453 OUString sURL;
454 try
455 {
456 Reference< XResultSet > xDir = m_pConnection->getDir()->getStaticResultSet();
457 Reference< XRow> xRow(xDir,UNO_QUERY);
458 OUString sName;
459 OUString sExt;
460
461 INetURLObject aURL;
462 xDir->beforeFirst();
463 while(xDir->next())
464 {
465 sName = xRow->getString(1);
466 aURL.SetSmartProtocol(INetProtocol::File);
467 OUString sUrl = m_pConnection->getURL() + "/" + sName;
468 aURL.SetSmartURL( sUrl );
469
470 // cut the extension
471 sExt = aURL.getExtension();
472
473 // name and extension have to coincide
474 if ( m_pConnection->matchesExtension( sExt ) )
475 {
476 if ( !sExt.isEmpty() )
477 sName = sName.replaceAt(sName.getLength() - (sExt.getLength() + 1), sExt.getLength()+1, OUString());
478 if ( sName == m_Name )
479 {
480 Reference< XContentAccess > xContentAccess( xDir, UNO_QUERY );
481 sURL = xContentAccess->queryContentIdentifierString();
482 break;
483 }
484 }
485 }
486 xDir->beforeFirst(); // move back to before first record
487 }
488 catch(const Exception&)
489 {
490 OSL_ASSERT(false);
491 }
492 return sURL;
493 }
494
495 void OFlatTable::refreshColumns()
496 {
497 ::osl::MutexGuard aGuard( m_aMutex );
498
499 TStringVector aVector;
500 aVector.reserve(m_aColumns->get().size());
501
502 for(OSQLColumns::Vector::const_iterator aIter = m_aColumns->get().begin();aIter != m_aColumns->get().end();++aIter)
503 aVector.push_back(Reference< XNamed>(*aIter,UNO_QUERY)->getName());
504
505 if(m_pColumns)
506 m_pColumns->reFill(aVector);
507 else
508 m_pColumns = new OFlatColumns(this,m_aMutex,aVector);
509 }
510
511
512 void SAL_CALL OFlatTable::disposing()
513 {
514 OFileTable::disposing();
515 ::osl::MutexGuard aGuard(m_aMutex);
516 m_aColumns = nullptr;
517 }
518
519 Sequence< Type > SAL_CALL OFlatTable::getTypes( ) throw(RuntimeException, std::exception)
520 {
521 Sequence< Type > aTypes = OTable_TYPEDEF::getTypes();
522 vector<Type> aOwnTypes;
523 aOwnTypes.reserve(aTypes.getLength());
524 const Type* pBegin = aTypes.getConstArray();
525 const Type* pEnd = pBegin + aTypes.getLength();
526 for(;pBegin != pEnd;++pBegin)
527 {
528 if(!(*pBegin == cppu::UnoType<XKeysSupplier>::get()||
529 *pBegin == cppu::UnoType<XRename>::get()||
530 *pBegin == cppu::UnoType<XIndexesSupplier>::get()||
531 *pBegin == cppu::UnoType<XAlterTable>::get()||
532 *pBegin == cppu::UnoType<XDataDescriptorFactory>::get()))
533 {
534 aOwnTypes.push_back(*pBegin);
535 }
536 }
537 return Sequence< Type >(aOwnTypes.data(), aOwnTypes.size());
538 }
539
540
541 Any SAL_CALL OFlatTable::queryInterface( const Type & rType ) throw(RuntimeException, std::exception)
542 {
543 if( rType == cppu::UnoType<XKeysSupplier>::get()||
544 rType == cppu::UnoType<XIndexesSupplier>::get()||
545 rType == cppu::UnoType<XRename>::get()||
546 rType == cppu::UnoType<XAlterTable>::get()||
547 rType == cppu::UnoType<XDataDescriptorFactory>::get())
548 return Any();
549
550 Any aRet = OTable_TYPEDEF::queryInterface(rType);
551 return aRet.hasValue() ? aRet : ::cppu::queryInterface(rType,static_cast< css::lang::XUnoTunnel*> (this));
552 }
553
554
555 Sequence< sal_Int8 > OFlatTable::getUnoTunnelImplementationId()
556 {
557 static ::cppu::OImplementationId * pId = nullptr;
558 if (! pId)
559 {
560 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
561 if (! pId)
562 {
563 static ::cppu::OImplementationId aId;
564 pId = &aId;
565 }
566 }
567 return pId->getImplementationId();
568 }
569
570 // css::lang::XUnoTunnel
571
572 sal_Int64 OFlatTable::getSomething( const Sequence< sal_Int8 > & rId ) throw (RuntimeException, std::exception)
573 {
574 return (rId.getLength() == 16 && 0 == memcmp(getUnoTunnelImplementationId().getConstArray(), rId.getConstArray(), 16 ) )
575 ? reinterpret_cast< sal_Int64 >( this )
576 : OFlatTable_BASE::getSomething(rId);
577 }
578
579 bool OFlatTable::fetchRow(OValueRefRow& _rRow, const OSQLColumns & _rCols, bool bRetrieveData)
580 {
581 *(_rRow->get())[0] = m_nFilePos;
582
583 if (!bRetrieveData)
584 return true;
585
586 bool result = false;
587 if ( m_bNeedToReadLine )
588 {
589 m_pFileStream->Seek(m_nFilePos);
590 TRowPositionInFile rowPos(0, 0);
591 if(readLine(&rowPos.second, &rowPos.first))
592 {
593 setRowPos(m_nRowPos, rowPos);
594 m_bNeedToReadLine = false;
595 result = true;
596 }
597 // else let run through so that we set _rRow to all NULL
598 }
599
600 const OFlatConnection * const pConnection = getFlatConnection();
601 const sal_Unicode cDecimalDelimiter = pConnection->getDecimalDelimiter();
602 const sal_Unicode cThousandDelimiter = pConnection->getThousandDelimiter();
603 // Fields:
604 sal_Int32 nStartPos = 0;
605 OSQLColumns::Vector::const_iterator aIter = _rCols.get().begin();
606 OSQLColumns::Vector::const_iterator aEnd = _rCols.get().end();
607 const OValueRefVector::Vector::size_type nCount = _rRow->get().size();
608 for (OValueRefVector::Vector::size_type i = 1;
609 aIter != aEnd && i < nCount;
610 ++aIter, i++)
611 {
612 OUString aStr = m_aCurrentLine.GetTokenSpecial(nStartPos,m_cFieldDelimiter,m_cStringDelimiter);
613
614 if (aStr.isEmpty())
615 {
616 (_rRow->get())[i]->setNull();
617 }
618 else
619 {
620 sal_Int32 nType = m_aTypes[i-1];
621 switch(nType)
622 {
623 case DataType::TIMESTAMP:
624 case DataType::DATE:
625 case DataType::TIME:
626 {
627 try
628 {
629 double nRes = m_xNumberFormatter->convertStringToNumber(css::util::NumberFormat::ALL,aStr);
630
631 switch(nType)
632 {
633 case DataType::DATE:
634 *(_rRow->get())[i] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDate(nRes,m_aNullDate));
635 break;
636 case DataType::TIMESTAMP:
637 *(_rRow->get())[i] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toDateTime(nRes,m_aNullDate));
638 break;
639 default:
640 *(_rRow->get())[i] = ::dbtools::DBTypeConversion::toDouble(::dbtools::DBTypeConversion::toTime(nRes));
641 }
642 }
643 catch(Exception&)
644 {
645 (_rRow->get())[i]->setNull();
646 }
647 } break;
648 case DataType::DOUBLE:
649 case DataType::INTEGER:
650 case DataType::DECIMAL:
651 case DataType::NUMERIC:
652 {
653
654 OUString aStrConverted;
655 if ( DataType::INTEGER != nType )
656 {
657 OSL_ENSURE((cDecimalDelimiter && nType != DataType::INTEGER) ||
658 (!cDecimalDelimiter && nType == DataType::INTEGER),
659 "FalscherTyp");
660
661 OUStringBuffer aBuf(aStr.getLength());
662 // convert to Standard-Notation (DecimalPOINT without thousands-comma):
663 for (sal_Int32 j = 0; j < aStr.getLength(); ++j)
664 {
665 const sal_Unicode cChar = aStr[j];
666 if (cDecimalDelimiter && cChar == cDecimalDelimiter)
667 aBuf.append('.');
668 else if ( cChar == '.' ) // special case, if decimal separator isn't '.' we have to put the string after it
669 continue;
670 else if (cThousandDelimiter && cChar == cThousandDelimiter)
671 {
672 // leave out
673 }
674 else
675 aBuf.append(cChar);
676 } // for (j = 0; j < aStr.getLength(); ++j)
677 aStrConverted = aBuf.makeStringAndClear();
678 } // if ( DataType::INTEGER != nType )
679 else
680 {
681 if ( cThousandDelimiter )
682 aStrConverted = aStr.replaceAll(OUStringLiteral1(cThousandDelimiter), "");
683 else
684 aStrConverted = aStr;
685 }
686 const double nVal = ::rtl::math::stringToDouble(aStrConverted,'.',',');
687
688 // #99178# OJ
689 if ( DataType::DECIMAL == nType || DataType::NUMERIC == nType )
690 *(_rRow->get())[i] = OUString::number(nVal);
691 else
692 *(_rRow->get())[i] = nVal;
693 } break;
694
695 default:
696 {
697 // Copy Value as String in Row-Variable
698 *(_rRow->get())[i] = ORowSetValue(aStr);
699 }
700 break;
701 } // switch(nType)
702 (_rRow->get())[i]->setTypeKind(nType);
703 }
704 }
705 return result;
706 }
707
708
709 void OFlatTable::refreshHeader()
710 {
711 SAL_INFO( "connectivity.drivers", "flat lionel@mamane.lu OFlatTable::refreshHeader" );
712 }
713
714
715 namespace
716 {
717 template< typename Tp, typename Te> struct RangeBefore
718 {
719 bool operator() (const Tp &p, const Te &e)
720 {
721 assert(p.first <= p.second);
722 return p.second <= e;
723 }
724 };
725 }
726
727 bool OFlatTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_Int32 nOffset, sal_Int32& nCurPos)
728 {
729 OSL_ENSURE(m_pFileStream,"OFlatTable::seekRow: FileStream is NULL!");
730
731
732 switch(eCursorPosition)
733 {
734 case IResultSetHelper::FIRST:
735 m_nRowPos = 0;
736 SAL_FALLTHROUGH;
737 case IResultSetHelper::NEXT:
738 {
739 assert(m_nRowPos >= 0);
740 if(m_nMaxRowCount != 0 && m_nRowPos > m_nMaxRowCount)
741 return false;
742 ++m_nRowPos;
743 if(m_aRowPosToFilePos.size() > static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos))
744 {
745 m_bNeedToReadLine = true;
746 m_nFilePos = m_aRowPosToFilePos[m_nRowPos].first;
747 nCurPos = m_aRowPosToFilePos[m_nRowPos].second;
748 }
749 else
750 {
751 assert(m_aRowPosToFilePos.size() == static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos));
752 const TRowPositionInFile &lastRowPos(m_aRowPosToFilePos.back());
753 // Our ResultSet is allowed to disagree with us only
754 // on the position of the first line
755 // (because of the special case of the header...)
756 assert(m_nRowPos == 1 || nCurPos == lastRowPos.second);
757
758 m_nFilePos = lastRowPos.second;
759 m_pFileStream->Seek(m_nFilePos);
760
761 TRowPositionInFile newRowPos;
762 if(!readLine(&newRowPos.second, &newRowPos.first))
763 {
764 m_nMaxRowCount = m_nRowPos - 1;
765 return false;
766 }
767
768 nCurPos = newRowPos.second;
769 setRowPos(m_nRowPos, newRowPos);
770 }
771 }
772
773 break;
774 case IResultSetHelper::PRIOR:
775 assert(m_nRowPos >= 0);
776
777 if(m_nRowPos == 0)
778 return false;
779
780 --m_nRowPos;
781 {
782 assert (m_nRowPos >= 0);
783 assert(m_aRowPosToFilePos.size() >= static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos));
784 const TRowPositionInFile &aPositions(m_aRowPosToFilePos[m_nRowPos]);
785 m_nFilePos = aPositions.first;
786 nCurPos = aPositions.second;
787 m_bNeedToReadLine = true;
788 }
789
790 break;
791 case IResultSetHelper::LAST:
792 if (m_nMaxRowCount == 0)
793 {
794 while(seekRow(IResultSetHelper::NEXT, 1, nCurPos)) ; // run through after last row
795 }
796 // m_nMaxRowCount can still be zero, but now it means there a genuinely zero rows in the table
797 return seekRow(IResultSetHelper::ABSOLUTE1, m_nMaxRowCount, nCurPos);
798 break;
799 case IResultSetHelper::RELATIVE1:
800 {
801 const sal_Int32 nNewRowPos = m_nRowPos + nOffset;
802 if (nNewRowPos < 0)
803 return false;
804 // ABSOLUTE will take care of case nNewRowPos > nMaxRowCount
805 return seekRow(IResultSetHelper::ABSOLUTE1, nNewRowPos, nCurPos);
806 }
807 case IResultSetHelper::ABSOLUTE1:
808 {
809 if(nOffset < 0)
810 {
811 if (m_nMaxRowCount == 0)
812 {
813 if (!seekRow(IResultSetHelper::LAST, 0, nCurPos))
814 return false;
815 }
816 // m_nMaxRowCount can still be zero, but now it means there a genuinely zero rows in the table
817 nOffset = m_nMaxRowCount + nOffset;
818 }
819 if(nOffset < 0)
820 {
821 seekRow(IResultSetHelper::ABSOLUTE1, 0, nCurPos);
822 return false;
823 }
824 if(m_nMaxRowCount && nOffset > m_nMaxRowCount)
825 {
826 m_nRowPos = m_nMaxRowCount + 1;
827 const TRowPositionInFile &lastRowPos(m_aRowPosToFilePos.back());
828 m_nFilePos = lastRowPos.second;
829 nCurPos = lastRowPos.second;
830 return false;
831 }
832
833 assert(m_nRowPos >=0);
834 assert(m_aRowPosToFilePos.size() > static_cast< vector< TRowPositionInFile >::size_type >(m_nRowPos));
835 assert(nOffset >= 0);
836 if(m_aRowPosToFilePos.size() > static_cast< vector< TRowPositionInFile >::size_type >(nOffset))
837 {
838 m_nFilePos = m_aRowPosToFilePos[nOffset].first;
839 nCurPos = m_aRowPosToFilePos[nOffset].second;
840 m_nRowPos = nOffset;
841 m_bNeedToReadLine = true;
842 }
843 else
844 {
845 assert(m_nRowPos < nOffset);
846 while(m_nRowPos < nOffset)
847 {
848 if(!seekRow(IResultSetHelper::NEXT, 1, nCurPos))
849 return false;
850 }
851 assert(m_nRowPos == nOffset);
852 }
853 }
854
855 break;
856 case IResultSetHelper::BOOKMARK:
857 {
858 vector< TRowPositionInFile >::const_iterator aFind = lower_bound(m_aRowPosToFilePos.begin(),
859 m_aRowPosToFilePos.end(),
860 nOffset,
861 RangeBefore< TRowPositionInFile, sal_Int32 >());
862
863 if(aFind == m_aRowPosToFilePos.end() || aFind->first != nOffset)
864 //invalid bookmark
865 return false;
866
867 m_bNeedToReadLine = true;
868 m_nFilePos = aFind->first;
869 nCurPos = aFind->second;
870 m_nRowPos = aFind - m_aRowPosToFilePos.begin();
871 break;
872 }
873 }
874
875 return true;
876 }
877
878
879 bool OFlatTable::readLine(sal_Int32 * const pEndPos, sal_Int32 * const pStartPos, const bool nonEmpty)
880 {
881 const rtl_TextEncoding nEncoding = m_pConnection->getTextEncoding();
882 m_aCurrentLine = QuotedTokenizedString();
883 do
884 {
885 if (pStartPos)
886 *pStartPos = (sal_Int32)m_pFileStream->Tell();
887 m_pFileStream->ReadByteStringLine(m_aCurrentLine, nEncoding);
888 if (m_pFileStream->IsEof())
889 return false;
890
891 QuotedTokenizedString sLine = m_aCurrentLine; // check if the string continues on next line
892 sal_Int32 nLastOffset = 0;
893 bool isQuoted = false;
894 bool isFieldStarting = true;
895 while (true)
896 {
897 bool wasQuote = false;
898 const sal_Unicode *p = sLine.GetString().getStr() + nLastOffset;
899 while (*p)
900 {
901 if (isQuoted)
902 {
903 if (*p == m_cStringDelimiter)
904 wasQuote = !wasQuote;
905 else
906 {
907 if (wasQuote)
908 {
909 wasQuote = false;
910 isQuoted = false;
911 if (*p == m_cFieldDelimiter)
912 isFieldStarting = true;
913 }
914 }
915 }
916 else
917 {
918 if (isFieldStarting)
919 {
920 isFieldStarting = false;
921 if (*p == m_cStringDelimiter)
922 isQuoted = true;
923 else if (*p == m_cFieldDelimiter)
924 isFieldStarting = true;
925 }
926 else if (*p == m_cFieldDelimiter)
927 isFieldStarting = true;
928 }
929 ++p;
930 }
931
932 if (wasQuote)
933 isQuoted = false;
934
935 if (isQuoted)
936 {
937 nLastOffset = sLine.Len();
938 m_pFileStream->ReadByteStringLine(sLine,nEncoding);
939 if ( !m_pFileStream->IsEof() )
940 {
941 OUString aStr = m_aCurrentLine.GetString() + "\n" + sLine.GetString();
942 m_aCurrentLine.SetString(aStr);
943 sLine = m_aCurrentLine;
944 }
945 else
946 break;
947 }
948 else
949 break;
950 }
951 }
952 while(nonEmpty && m_aCurrentLine.Len() == 0);
953
954 if(pEndPos)
955 *pEndPos = (sal_Int32)m_pFileStream->Tell();
956 return true;
957 }
958
959
960 void OFlatTable::setRowPos(const vector<TRowPositionInFile>::size_type rowNum, const TRowPositionInFile &rowPos)
961 {
962 assert(m_aRowPosToFilePos.size() >= rowNum);
963 if(m_aRowPosToFilePos.size() == rowNum)
964 m_aRowPosToFilePos.push_back(rowPos);
965 else
966 {
967 SAL_WARN_IF(m_aRowPosToFilePos[rowNum] != rowPos,
968 "connectivity.flat",
969 "Setting position for row " << rowNum << " to (" << rowPos.first << ", " << rowPos.second << "), "
970 "but already had different position (" << m_aRowPosToFilePos[rowNum].first << ", " << m_aRowPosToFilePos[rowNum].second << ")");
971 m_aRowPosToFilePos[rowNum] = rowPos;
972 }
973 }
974
975 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE