?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 4.3.0.0.beta1, tag libreoffice-4.3.0.0.beta1
[LibreOffice.git] / connectivity / source / drivers / mozab / MResultSet.cxx
bloba0d78de6bb11e378f64bc5d068244c722ce47c66
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 <com/sun/star/sdbc/DataType.hpp>
21 #include <com/sun/star/beans/PropertyAttribute.hpp>
22 #include <comphelper/property.hxx>
23 #include <comphelper/sequence.hxx>
24 #include <cppuhelper/typeprovider.hxx>
25 #include <cppuhelper/supportsservice.hxx>
26 #include <comphelper/extract.hxx>
27 #include <com/sun/star/lang/DisposedException.hpp>
28 #include <com/sun/star/sdbc/ResultSetType.hpp>
29 #include <com/sun/star/sdbc/FetchDirection.hpp>
30 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
31 #include <comphelper/types.hxx>
32 #include <connectivity/dbexception.hxx>
33 #include <connectivity/dbtools.hxx>
34
35 #include <TSortIndex.hxx>
36 #include <rtl/string.hxx>
37 #include <vector>
38 #include <algorithm>
39 #include "MResultSet.hxx"
40 #include "MResultSetMetaData.hxx"
41 #include "FDatabaseMetaDataResultSet.hxx"
42 #include "resource/mozab_res.hrc"
43 #include "resource/common_res.hrc"
44
45 #if OSL_DEBUG_LEVEL > 0
46 # define OUtoCStr( x ) ( OUStringToOString ( (x), RTL_TEXTENCODING_ASCII_US).getStr())
47 #else /* OSL_DEBUG_LEVEL */
48 # define OUtoCStr( x ) ("dummy")
49 #endif /* OSL_DEBUG_LEVEL */
50
51 using namespace ::comphelper;
52 using namespace connectivity;
53 using namespace connectivity::mozab;
54 using namespace ::cppu;
55 using namespace com::sun::star::uno;
56 using namespace com::sun::star::lang;
57 using namespace com::sun::star::beans;
58 using namespace com::sun::star::sdbc;
59 using namespace com::sun::star::container;
60 using namespace com::sun::star::io;
61 using namespace com::sun::star::util;
62
63
64 // IMPLEMENT_SERVICE_INFO(OResultSet,"com.sun.star.sdbcx.OResultSet","com.sun.star.sdbc.ResultSet");
65 OUString SAL_CALL OResultSet::getImplementationName( ) throw ( RuntimeException) \
66 {
67 return OUString("com.sun.star.sdbcx.mozab.ResultSet");
68 }
69
70 Sequence< OUString > SAL_CALL OResultSet::getSupportedServiceNames( ) throw( RuntimeException)
71 {
72 ::com::sun::star::uno::Sequence< OUString > aSupported(2);
73 aSupported[0] = "com.sun.star.sdbc.ResultSet";
74 aSupported[1] = "com.sun.star.sdbcx.ResultSet";
75 return aSupported;
76 }
77
78 sal_Bool SAL_CALL OResultSet::supportsService( const OUString& _rServiceName ) throw( RuntimeException)
79 {
80 return cppu::supportsService(this, _rServiceName);
81 }
82
83
84 OResultSet::OResultSet(OCommonStatement* pStmt, const ::boost::shared_ptr< connectivity::OSQLParseTreeIterator >& _pSQLIterator )
85 : OResultSet_BASE(m_aMutex)
86 ,OPropertySetHelper(OResultSet_BASE::rBHelper)
87 ,m_pStatement(pStmt)
88 ,m_xStatement(*pStmt)
89 ,m_xMetaData(NULL)
90 ,m_nRowPos(0)
91 ,m_nOldRowPos(0)
92 ,m_nFetchSize(0)
93 ,m_nResultSetType(ResultSetType::SCROLL_INSENSITIVE)
94 ,m_nFetchDirection(FetchDirection::FORWARD)
95 ,m_nResultSetConcurrency(ResultSetConcurrency::UPDATABLE)
96 ,m_pSQLIterator( _pSQLIterator )
97 ,m_pParseTree( _pSQLIterator->getParseTree() )
98 ,m_aQuery( pStmt->getOwnConnection()->getColumnAlias() )
99 ,m_pTable(NULL)
100 ,m_CurrentRowCount(0)
101 ,m_nParamIndex(0)
102 ,m_bIsAlwaysFalseQuery(sal_False)
103 ,m_pKeySet(NULL)
104 ,m_nNewRow(0)
105 ,m_nUpdatedRow(0)
106 ,m_RowStates(0)
107 ,m_bIsReadOnly(-1)
108 {
109
110 m_aQuery.setMaxNrOfReturns(pStmt->getOwnConnection()->getMaxResultRecords());
111 }
112
113 OResultSet::~OResultSet()
114 {
115 }
116
117
118 void OResultSet::disposing(void)
119 {
120 OPropertySetHelper::disposing();
121
122 ::osl::MutexGuard aGuard(m_aMutex);
123
124 m_xStatement.clear();
125 m_xMetaData.clear();
126 m_pParseTree = NULL;
127 m_xColumns = NULL;
128 m_xParamColumns = NULL;
129 m_pKeySet = NULL;
130 if(m_pTable)
131 {
132 m_pTable->release();
133 m_pTable = NULL;
134 }
135 }
136
137 Any SAL_CALL OResultSet::queryInterface( const Type & rType ) throw(RuntimeException)
138 {
139 Any aRet = OPropertySetHelper::queryInterface(rType);
140 if(!aRet.hasValue())
141 aRet = OResultSet_BASE::queryInterface(rType);
142 return aRet;
143 }
144
145 Sequence< Type > SAL_CALL OResultSet::getTypes( ) throw( RuntimeException)
146 {
147 OTypeCollection aTypes( ::getCppuType( (const Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
148 ::getCppuType( (const Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ),
149 ::getCppuType( (const Reference< ::com::sun::star::beans::XPropertySet > *)0 ));
150
151 return ::comphelper::concatSequences(aTypes.getTypes(),OResultSet_BASE::getTypes());
152 }
153
154 void OResultSet::methodEntry()
155 {
156 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
157 if ( !m_pTable )
158 {
159 OSL_FAIL( "OResultSet::methodEntry: looks like we're disposed, but how is this possible?" );
160 throw DisposedException( OUString(), *this );
161 }
162 }
163
164
165 sal_Int32 SAL_CALL OResultSet::findColumn( const OUString& columnName ) throw(SQLException, RuntimeException)
166 {
167 ResultSetEntryGuard aGuard( *this );
168
169 // find the first column with the name columnName
170 Reference< XResultSetMetaData > xMeta = getMetaData();
171 sal_Int32 nLen = xMeta->getColumnCount();
172 sal_Int32 i = 1;
173 for(;i<=nLen;++i)
174 {
175 if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
176 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
177 return i;
178 }
179
180 ::dbtools::throwInvalidColumnException( columnName, *this );
181 assert(false);
182 return 0; // Never reached
183 }
184
185 Reference< XInputStream > SAL_CALL OResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
186 {
187 return NULL;
188 }
189
190 Reference< XInputStream > SAL_CALL OResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
191 {
192 return NULL;
193 }
194
195
196 sal_Bool SAL_CALL OResultSet::getBoolean( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
197 {
198 ResultSetEntryGuard aGuard( *this );
199 m_bWasNull = sal_True;
200 return sal_False;
201 }
202
203
204 sal_Int8 SAL_CALL OResultSet::getByte( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
205 {
206 ResultSetEntryGuard aGuard( *this );
207 return 0;
208 }
209
210
211 Sequence< sal_Int8 > SAL_CALL OResultSet::getBytes( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
212 {
213 ResultSetEntryGuard aGuard( *this );
214 return Sequence< sal_Int8 >();
215 }
216
217
218 Date SAL_CALL OResultSet::getDate( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
219 {
220 ResultSetEntryGuard aGuard( *this );
221 return Date();
222 }
223
224
225 double SAL_CALL OResultSet::getDouble( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
226 {
227 ResultSetEntryGuard aGuard( *this );
228 return 0.0;
229 }
230
231
232 float SAL_CALL OResultSet::getFloat( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
233 {
234 ResultSetEntryGuard aGuard( *this );
235 return 0;
236 }
237
238
239 sal_Int32 SAL_CALL OResultSet::getInt( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
240 {
241 ResultSetEntryGuard aGuard( *this );
242 return 0;
243 }
244
245
246 sal_Int32 SAL_CALL OResultSet::getRow( ) throw(SQLException, RuntimeException)
247 {
248 ResultSetEntryGuard aGuard( *this );
249
250 OSL_TRACE("In/Out: OResultSet::getRow, return = %u", m_nRowPos );
251 return m_nRowPos;
252 }
253
254
255 sal_Int64 SAL_CALL OResultSet::getLong( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
256 {
257 ResultSetEntryGuard aGuard( *this );
258 return sal_Int64();
259 }
260
261
262 Reference< XResultSetMetaData > SAL_CALL OResultSet::getMetaData( ) throw(SQLException, RuntimeException)
263 {
264 ResultSetEntryGuard aGuard( *this );
265
266 if(!m_xMetaData.is())
267 m_xMetaData = new OResultSetMetaData(
268 m_pSQLIterator->getSelectColumns(), m_pSQLIterator->getTables().begin()->first ,m_pTable,determineReadOnly());
269 return m_xMetaData;
270 }
271
272 Reference< XArray > SAL_CALL OResultSet::getArray( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
273 {
274 return NULL;
275 }
276
277
278
279 Reference< XClob > SAL_CALL OResultSet::getClob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
280 {
281 return NULL;
282 }
283
284 Reference< XBlob > SAL_CALL OResultSet::getBlob( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
285 {
286 return NULL;
287 }
288
289
290 Reference< XRef > SAL_CALL OResultSet::getRef( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
291 {
292 return NULL;
293 }
294
295
296 Any SAL_CALL OResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ ) throw(SQLException, RuntimeException)
297 {
298 return Any();
299 }
300
301
302 sal_Int16 SAL_CALL OResultSet::getShort( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
303 {
304 return 0;
305 }
306
307
308 void OResultSet::checkIndex(sal_Int32 columnIndex ) throw(::com::sun::star::sdbc::SQLException)
309 {
310 if(columnIndex <= 0 || columnIndex > (sal_Int32)m_xColumns->get().size())
311 ::dbtools::throwInvalidIndexException(*this);
312 }
313
314 sal_uInt32 OResultSet::currentRowCount()
315 {
316 if ( m_bIsAlwaysFalseQuery )
317 return 0;
318 return m_aQuery.getRealRowCount() - deletedCount();
319 }
320
321
322
323 sal_Bool OResultSet::fetchCurrentRow( ) throw(SQLException, RuntimeException)
324 {
325 OSL_TRACE("fetchCurrentRow, m_nRowPos = %u", m_nRowPos );
326 return fetchRow(getCurrentCardNumber());
327 }
328
329
330 sal_Bool OResultSet::pushCard(sal_uInt32 cardNumber) throw(SQLException, RuntimeException)
331 {
332 if (cardNumber == 0)
333 return sal_True;
334 // Check whether we are storing the updated row
335 if ( (m_aRow->get())[0].isNull() || (sal_Int32)(m_aRow->get())[0] != (sal_Int32)cardNumber )
336 return sal_False;
337
338 sal_Int32 nCount = m_aColumnNames.getLength();
339 m_aQuery.setRowStates(cardNumber,m_RowStates);
340 for( sal_Int32 i = 1; i <= nCount; i++ )
341 {
342 if ( (m_aRow->get())[i].isBound() )
343 {
344
345 // Everything in the addressbook is a string!
346
347 if ( !m_aQuery.setRowValue( (m_aRow->get())[i], cardNumber, m_aColumnNames[i-1], DataType::VARCHAR ))
348 {
349 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
350 }
351 }
352 }
353 return sal_True;
354
355 }
356
357 sal_Bool OResultSet::fetchRow(sal_Int32 cardNumber,sal_Bool bForceReload) throw(SQLException, RuntimeException)
358 {
359 OSL_TRACE("fetchRow, cardNumber = %u", cardNumber );
360 if (!bForceReload)
361 {
362 // Check whether we've already fetched the row...
363 if ( !(m_aRow->get())[0].isNull() && (sal_Int32)(m_aRow->get())[0] == (sal_Int32)cardNumber )
364 return sal_True;
365 //Check whether the old row has been changed
366 if (cardNumber == m_nUpdatedRow)
367 {
368 //write back the changes first
369 if (!pushCard(cardNumber)) //error write back the changes
370 throw SQLException();
371 }
372 }
373 else
374 m_aQuery.resyncRow(cardNumber);
375
376 if ( validRow( cardNumber ) == sal_False )
377 return sal_False;
378
379 (m_aRow->get())[0] = (sal_Int32)cardNumber;
380 sal_Int32 nCount = m_aColumnNames.getLength();
381 m_RowStates = m_aQuery.getRowStates(cardNumber);
382 for( sal_Int32 i = 1; i <= nCount; i++ )
383 {
384 if ( (m_aRow->get())[i].isBound() )
385 {
386
387 // Everything in the addressbook is a string!
388
389 if ( !m_aQuery.getRowValue( (m_aRow->get())[i], cardNumber, m_aColumnNames[i-1], DataType::VARCHAR ))
390 {
391 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
392 }
393 }
394 }
395 return sal_True;
396 }
397
398
399 const ORowSetValue& OResultSet::getValue(sal_Int32 cardNumber, sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
400 {
401 if ( fetchRow( cardNumber ) == sal_False )
402 {
403 OSL_FAIL("fetchRow() returned False" );
404 m_bWasNull = sal_True;
405 return *ODatabaseMetaDataResultSet::getEmptyValue();
406 }
407
408 m_bWasNull = (m_aRow->get())[columnIndex].isNull();
409 return (m_aRow->get())[columnIndex];
410
411 }
412
413
414
415 OUString SAL_CALL OResultSet::getString( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
416 {
417 ResultSetEntryGuard aGuard( *this );
418
419 OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
420 OSL_ENSURE(columnIndex <= (sal_Int32)m_xColumns->get().size(), "Trying to access invalid columns number");
421 checkIndex( columnIndex );
422
423 // If this query was sorted then we should have a valid KeySet, so use it
424 return getValue(getCurrentCardNumber(), mapColumn( columnIndex ) );
425
426 }
427
428
429 Time SAL_CALL OResultSet::getTime( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
430 {
431 ResultSetEntryGuard aGuard( *this );
432 return Time();
433 }
434
435
436
437 DateTime SAL_CALL OResultSet::getTimestamp( sal_Int32 /*columnIndex*/ ) throw(SQLException, RuntimeException)
438 {
439 ResultSetEntryGuard aGuard( *this );
440 return DateTime();
441 }
442
443
444 sal_Bool SAL_CALL OResultSet::isBeforeFirst( ) throw(SQLException, RuntimeException)
445 {
446 ResultSetEntryGuard aGuard( *this );
447
448 // here you have to implement your movements
449 // return true means there is no data
450 OSL_TRACE("In/Out: OResultSet::isBeforeFirst" );
451 return( m_nRowPos < 1 );
452 }
453
454 sal_Bool SAL_CALL OResultSet::isAfterLast( ) throw(SQLException, RuntimeException)
455 {
456 ResultSetEntryGuard aGuard( *this );
457
458 OSL_TRACE("In/Out: OResultSet::isAfterLast" );
459 return m_nRowPos > currentRowCount() && m_aQuery.queryComplete();
460 }
461
462 sal_Bool SAL_CALL OResultSet::isFirst( ) throw(SQLException, RuntimeException)
463 {
464 ResultSetEntryGuard aGuard( *this );
465
466 OSL_TRACE("In/Out: OResultSet::isFirst" );
467 return m_nRowPos == 1;
468 }
469
470 sal_Bool SAL_CALL OResultSet::isLast( ) throw(SQLException, RuntimeException)
471 {
472 ResultSetEntryGuard aGuard( *this );
473
474 OSL_TRACE("In/Out: OResultSet::isLast" );
475 return m_nRowPos == currentRowCount() && m_aQuery.queryComplete();
476 }
477
478 void SAL_CALL OResultSet::beforeFirst( ) throw(SQLException, RuntimeException)
479 {
480 ResultSetEntryGuard aGuard( *this );
481
482 // move before the first row so that isBeforeFirst returns false
483 OSL_TRACE("In/Out: OResultSet::beforeFirst" );
484 if ( first() )
485 previous();
486 }
487
488 void SAL_CALL OResultSet::afterLast( ) throw(SQLException, RuntimeException)
489 {
490 ResultSetEntryGuard aGuard( *this );
491 OSL_TRACE("In/Out: OResultSet::afterLast" );
492
493 if(last())
494 next();
495 }
496
497
498 void SAL_CALL OResultSet::close( ) throw(SQLException, RuntimeException)
499 {
500 ResultSetEntryGuard aGuard( *this );
501 OSL_TRACE("In/Out: OResultSet::close" );
502 dispose();
503 }
504
505
506 sal_Bool SAL_CALL OResultSet::first( ) throw(SQLException, RuntimeException)
507 {
508 OSL_TRACE("In/Out: OResultSet::first" );
509 return seekRow( FIRST_POS );
510 }
511
512
513 sal_Bool SAL_CALL OResultSet::last( ) throw(SQLException, RuntimeException)
514 {
515 OSL_TRACE("In/Out: OResultSet::last" );
516 return seekRow( LAST_POS );
517 }
518
519 sal_Bool SAL_CALL OResultSet::absolute( sal_Int32 row ) throw(SQLException, RuntimeException)
520 {
521 OSL_TRACE("In/Out: OResultSet::absolute" );
522 return seekRow( ABSOLUTE_POS, row );
523 }
524
525 sal_Bool SAL_CALL OResultSet::relative( sal_Int32 row ) throw(SQLException, RuntimeException)
526 {
527 OSL_TRACE("In/Out: OResultSet::relative" );
528 return seekRow( RELATIVE_POS, row );
529 }
530
531 sal_Bool SAL_CALL OResultSet::previous( ) throw(SQLException, RuntimeException)
532 {
533 ResultSetEntryGuard aGuard( *this );
534 OSL_TRACE("In/Out: OResultSet::previous" );
535 return seekRow( PRIOR_POS );
536 }
537
538 Reference< XInterface > SAL_CALL OResultSet::getStatement( ) throw(SQLException, RuntimeException)
539 {
540 ResultSetEntryGuard aGuard( *this );
541
542 OSL_TRACE("In/Out: OResultSet::getStatement" );
543 return m_xStatement;
544 }
545
546
547 sal_Bool SAL_CALL OResultSet::rowDeleted( ) throw(SQLException, RuntimeException)
548 {
549 ResultSetEntryGuard aGuard( *this );
550 OSL_TRACE("In/Out: OResultSet::rowDeleted, m_RowStates=%u",m_RowStates );
551 return ((m_RowStates & RowStates_Deleted) == RowStates_Deleted) ;
552 }
553
554 sal_Bool SAL_CALL OResultSet::rowInserted( ) throw(SQLException, RuntimeException)
555 {
556 ResultSetEntryGuard aGuard( *this );
557 OSL_TRACE("In/Out: OResultSet::rowInserted,m_RowStates=%u",m_RowStates );
558 return ((m_RowStates & RowStates_Inserted) == RowStates_Inserted);
559 }
560
561 sal_Bool SAL_CALL OResultSet::rowUpdated( ) throw(SQLException, RuntimeException)
562 {
563 ResultSetEntryGuard aGuard( *this );
564 OSL_TRACE("In/Out: OResultSet::rowUpdated,m_RowStates=%u",m_RowStates );
565 return ((m_RowStates & RowStates_Updated) == RowStates_Updated) ;
566 }
567
568
569 sal_Bool SAL_CALL OResultSet::next( ) throw(SQLException, RuntimeException)
570 {
571 return seekRow( NEXT_POS );
572 }
573
574
575 sal_Bool SAL_CALL OResultSet::wasNull( ) throw(SQLException, RuntimeException)
576 {
577 ResultSetEntryGuard aGuard( *this );
578
579 return m_bWasNull;
580 }
581
582
583 void SAL_CALL OResultSet::cancel( ) throw(RuntimeException)
584 {
585 ResultSetEntryGuard aGuard( *this );
586 OSL_TRACE("In/Out: OResultSet::cancel" );
587
588 }
589
590 void SAL_CALL OResultSet::clearWarnings( ) throw(SQLException, RuntimeException)
591 {
592 OSL_TRACE("In/Out: OResultSet::clearWarnings" );
593 }
594
595 Any SAL_CALL OResultSet::getWarnings( ) throw(SQLException, RuntimeException)
596 {
597 OSL_TRACE("In/Out: OResultSet::getWarnings" );
598 return Any();
599 }
600
601 void SAL_CALL OResultSet::refreshRow( ) throw(SQLException, RuntimeException)
602 {
603 OSL_TRACE("In/Out: OResultSet::refreshRow" );
604 if (fetchRow(getCurrentCardNumber(),sal_True)) //force fetch current row will cause we lose all change to the current row
605 m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_REFRESH_ROW, *this );
606 }
607
608 IPropertyArrayHelper* OResultSet::createArrayHelper( ) const
609 {
610 Sequence< Property > aProps(5);
611 Property* pProperties = aProps.getArray();
612 sal_Int32 nPos = 0;
613 pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHDIRECTION),
614 PROPERTY_ID_FETCHDIRECTION, cppu::UnoType<sal_Int32>::get(), 0);
615
616 pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_FETCHSIZE),
617 PROPERTY_ID_FETCHSIZE, cppu::UnoType<sal_Int32>::get(), 0);
618
619 pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISBOOKMARKABLE),
620 PROPERTY_ID_ISBOOKMARKABLE, ::getBooleanCppuType(), PropertyAttribute::READONLY);
621
622 pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETCONCURRENCY),
623 PROPERTY_ID_RESULTSETCONCURRENCY, cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY);
624
625 pProperties[nPos++] = ::com::sun::star::beans::Property(::connectivity::OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_RESULTSETTYPE),
626 PROPERTY_ID_RESULTSETTYPE, cppu::UnoType<sal_Int32>::get(), PropertyAttribute::READONLY);
627
628 return new OPropertyArrayHelper(aProps);
629 }
630
631 IPropertyArrayHelper & OResultSet::getInfoHelper()
632 {
633 return *const_cast<OResultSet*>(this)->getArrayHelper();
634 }
635
636 sal_Bool OResultSet::convertFastPropertyValue(
637 Any & /*rConvertedValue*/,
638 Any & /*rOldValue*/,
639 sal_Int32 nHandle,
640 const Any& /*rValue*/ )
641 throw (::com::sun::star::lang::IllegalArgumentException)
642 {
643 OSL_FAIL( "OResultSet::convertFastPropertyValue: not implemented!" );
644 switch(nHandle)
645 {
646 case PROPERTY_ID_ISBOOKMARKABLE:
647 case PROPERTY_ID_RESULTSETCONCURRENCY:
648 case PROPERTY_ID_RESULTSETTYPE:
649 throw ::com::sun::star::lang::IllegalArgumentException();
650 case PROPERTY_ID_FETCHDIRECTION:
651 case PROPERTY_ID_FETCHSIZE:
652 default:
653 ;
654 }
655 return sal_False;
656 }
657
658 void OResultSet::setFastPropertyValue_NoBroadcast(
659 sal_Int32 nHandle,
660 const Any& /*rValue*/
661 )
662 throw (Exception)
663 {
664 OSL_FAIL( "OResultSet::setFastPropertyValue_NoBroadcast: not implemented!" );
665 switch(nHandle)
666 {
667 case PROPERTY_ID_ISBOOKMARKABLE:
668 case PROPERTY_ID_RESULTSETCONCURRENCY:
669 case PROPERTY_ID_RESULTSETTYPE:
670 throw Exception();
671 case PROPERTY_ID_FETCHDIRECTION:
672 break;
673 case PROPERTY_ID_FETCHSIZE:
674 break;
675 default:
676 ;
677 }
678 }
679
680 void OResultSet::getFastPropertyValue(
681 Any& rValue,
682 sal_Int32 nHandle
683 ) const
684 {
685 switch(nHandle)
686 {
687 case PROPERTY_ID_RESULTSETCONCURRENCY:
688 rValue <<= (sal_Int32)m_nResultSetConcurrency;
689 break;
690 case PROPERTY_ID_RESULTSETTYPE:
691 rValue <<= m_nResultSetType;
692 break;
693 case PROPERTY_ID_FETCHDIRECTION:
694 rValue <<= m_nFetchDirection;
695 break;
696 case PROPERTY_ID_FETCHSIZE:
697 rValue <<= m_nFetchSize;
698 break;
699 case PROPERTY_ID_ISBOOKMARKABLE:
700 const_cast< OResultSet* >( this )->determineReadOnly();
701 rValue <<= !m_bIsReadOnly;
702 break;
703 }
704 }
705
706 void SAL_CALL OResultSet::acquire() throw()
707 {
708 OResultSet_BASE::acquire();
709 }
710
711 void SAL_CALL OResultSet::release() throw()
712 {
713 OResultSet_BASE::release();
714 }
715
716 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OResultSet::getPropertySetInfo( ) throw(::com::sun::star::uno::RuntimeException)
717 {
718 return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
719 }
720
721
722 void OResultSet::parseParameter( const OSQLParseNode* pNode, OUString& rMatchString )
723 {
724 OSL_ENSURE(pNode->count() > 0,"Error parsing parameter in Parse Tree");
725 OSQLParseNode *pMark = pNode->getChild(0);
726
727 // Initialize to empty string
728 rMatchString = "";
729
730 OUString aParameterName;
731 if (SQL_ISPUNCTUATION(pMark,"?")) {
732 aParameterName = "?";
733 }
734 else if (SQL_ISPUNCTUATION(pMark,":")) {
735 aParameterName = pNode->getChild(1)->getTokenValue();
736 }
737 // XXX - Now we know name, what's value????
738 m_nParamIndex ++;
739 OSL_TRACE("Parameter name [%d]: %s", m_nParamIndex,OUtoCStr(aParameterName) );
740
741 if ( m_aParameterRow.is() ) {
742 OSL_ENSURE( m_nParamIndex < (sal_Int32)m_aParameterRow->get().size() + 1, "More parameters than values found" );
743 rMatchString = (m_aParameterRow->get())[(sal_uInt16)m_nParamIndex];
744 #if OSL_DEBUG_LEVEL > 0
745 OSL_TRACE("Prop Value : %s", OUtoCStr( rMatchString ) );
746 #endif
747 }
748 #if OSL_DEBUG_LEVEL > 0
749 else {
750 OSL_TRACE("Prop Value : Invalid ParameterRow!" );
751 }
752 #endif
753 }
754
755 #define WILDCARD "%"
756 #define ALT_WILDCARD "*"
757 static const sal_Unicode MATCHCHAR = '_';
758
759 void OResultSet::analyseWhereClause( const OSQLParseNode* parseTree,
760 MQueryExpression &queryExpression)
761 {
762 OUString columnName;
763 MQueryOp::cond_type op( MQueryOp::Is );
764 OUString matchString;
765
766 if ( parseTree == NULL )
767 return;
768
769 if ( m_pSQLIterator->getParseTree() != NULL ) {
770 ::rtl::Reference<OSQLColumns> xColumns = m_pSQLIterator->getParameters();
771 if(xColumns.is())
772 {
773 OUString aColName, aParameterValue;
774 OSQLColumns::Vector::iterator aIter = xColumns->get().begin();
775 sal_Int32 i = 1;
776 for(;aIter != xColumns->get().end();++aIter)
777 {
778 (*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
779 OSL_TRACE("Prop Column Name : %s", OUtoCStr( aColName ) );
780 if ( m_aParameterRow.is() ) {
781 aParameterValue = (m_aParameterRow->get())[(sal_uInt16)i];
782 #if OSL_DEBUG_LEVEL > 0
783 OSL_TRACE("Prop Value : %s", OUtoCStr( aParameterValue ) );
784 #endif
785 }
786 #if OSL_DEBUG_LEVEL > 0
787 else {
788 OSL_TRACE("Prop Value : Invalid ParameterRow!" );
789 }
790 #endif
791 i++;
792 }
793 }
794
795 }
796
797 if ( SQL_ISRULE(parseTree,where_clause) )
798 {
799 OSL_TRACE("analyseSQL : Got WHERE clause");
800 // Reset Parameter Counter
801 resetParameters();
802 analyseWhereClause( parseTree->getChild( 1 ), queryExpression );
803 }
804 else if ( parseTree->count() == 3 && // Handle ()'s
805 SQL_ISPUNCTUATION(parseTree->getChild(0),"(") &&
806 SQL_ISPUNCTUATION(parseTree->getChild(2),")"))
807 {
808
809 OSL_TRACE("analyseSQL : Got Punctuation ()");
810 MQueryExpression *subExpression = new MQueryExpression();
811 analyseWhereClause( parseTree->getChild( 1 ), *subExpression );
812 queryExpression.getExpressions().push_back( subExpression );
813 }
814 else if ((SQL_ISRULE(parseTree,search_condition) || (SQL_ISRULE(parseTree,boolean_term)))
815 && parseTree->count() == 3) // Handle AND/OR
816 {
817
818 OSL_TRACE("analyseSQL : Got AND/OR clause");
819
820 // TODO - Need to take care or AND, for now match is always OR
821 analyseWhereClause( parseTree->getChild( 0 ), queryExpression );
822 analyseWhereClause( parseTree->getChild( 2 ), queryExpression );
823
824 if (SQL_ISTOKEN(parseTree->getChild(1),OR)) { // OR-Operator
825 queryExpression.setExpressionCondition( MQueryExpression::OR );
826 }
827 else if (SQL_ISTOKEN(parseTree->getChild(1),AND)) { // AND-Operator
828 queryExpression.setExpressionCondition( MQueryExpression::AND );
829 }
830 else {
831 OSL_FAIL("analyseSQL: Error in Parse Tree");
832 }
833 }
834 else if (SQL_ISRULE(parseTree,comparison_predicate))
835 {
836 OSL_ENSURE(parseTree->count() == 3, "Error parsing COMPARE predicate");
837 if (!(SQL_ISRULE(parseTree->getChild(0),column_ref) ||
838 parseTree->getChild(2)->getNodeType() == SQL_NODE_STRING ||
839 parseTree->getChild(2)->getNodeType() == SQL_NODE_INTNUM ||
840 parseTree->getChild(2)->getNodeType() == SQL_NODE_APPROXNUM ||
841 SQL_ISTOKEN(parseTree->getChild(2),TRUE) ||
842 SQL_ISTOKEN(parseTree->getChild(2),FALSE) ||
843 SQL_ISRULE(parseTree->getChild(2),parameter) ||
844 // odbc date
845 (SQL_ISRULE(parseTree->getChild(2),set_fct_spec) && SQL_ISPUNCTUATION(parseTree->getChild(2)->getChild(0),"{"))))
846 {
847 m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
848 }
849
850 OSQLParseNode *pPrec = parseTree->getChild(1);
851 if (pPrec->getNodeType() == SQL_NODE_EQUAL)
852 op = MQueryOp::Is;
853 else if (pPrec->getNodeType() == SQL_NODE_NOTEQUAL)
854 op = MQueryOp::IsNot;
855
856 OUString sTableRange;
857 if(SQL_ISRULE(parseTree->getChild(0),column_ref))
858 m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange);
859 else if(parseTree->getChild(0)->isToken())
860 columnName = parseTree->getChild(0)->getTokenValue();
861
862 if ( SQL_ISRULE(parseTree->getChild(2),parameter) ) {
863 parseParameter( parseTree->getChild(2), matchString );
864 }
865 else {
866 matchString = parseTree->getChild(2)->getTokenValue();
867 }
868
869 if ( columnName.equalsAscii("0") && op == MQueryOp::Is &&
870 matchString.equalsAscii("1") ) {
871 OSL_TRACE("Query always evaluates to FALSE");
872 m_bIsAlwaysFalseQuery = sal_True;
873 }
874 queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op, matchString ));
875 }
876 else if (SQL_ISRULE(parseTree,like_predicate))
877 {
878 OSL_ENSURE(parseTree->count() == 2, "Error parsing LIKE predicate");
879
880 OSL_TRACE("analyseSQL : Got LIKE rule");
881
882 if ( !(SQL_ISRULE(parseTree->getChild(0), column_ref)) )
883 {
884 m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_COLUMN, *this );
885 }
886
887
888 OSQLParseNode *pColumn;
889 OSQLParseNode *pAtom;
890 OSQLParseNode *pOptEscape;
891 const OSQLParseNode* pPart2 = parseTree->getChild(1);
892 pColumn = parseTree->getChild(0); // Match Item
893 pAtom = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-2)); // Match String
894 pOptEscape = pPart2->getChild(static_cast<sal_uInt32>(pPart2->count()-1)); // Opt Escape Rule
895 (void)pOptEscape;
896 const bool bNot = SQL_ISTOKEN(pPart2->getChild(0), NOT);
897
898 if (!(pAtom->getNodeType() == SQL_NODE_STRING ||
899 pAtom->getNodeType() == SQL_NODE_NAME ||
900 SQL_ISRULE(pAtom,parameter) ||
901 ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQL_NODE_NAME ) ||
902 ( pAtom->getChild(0) && pAtom->getChild(0)->getNodeType() == SQL_NODE_STRING )
903 ) )
904 {
905 OSL_TRACE("analyseSQL : pAtom->count() = %d", pAtom->count() );
906
907 m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_LIKE_STRING, *this );
908 }
909
910 OUString sTableRange;
911 if(SQL_ISRULE(pColumn,column_ref))
912 m_pSQLIterator->getColumnRange(pColumn,columnName,sTableRange);
913
914 OSL_TRACE("ColumnName = %s", OUtoCStr( columnName ) );
915
916 if ( SQL_ISRULE(pAtom,parameter) ) {
917 parseParameter( pAtom, matchString );
918 // Replace all '*' with '%' : UI Usually does this but not with
919 // Parameters for some reason.
920 matchString = matchString.replaceAll( ALT_WILDCARD, WILDCARD );
921 }
922 else
923 {
924 matchString = pAtom->getTokenValue();
925 }
926
927 // Determine where '%' character is...
928
929 if ( matchString.equals( WILDCARD ) )
930 {
931 // String containing only a '%' and nothing else
932 op = MQueryOp::Exists;
933 // Will be ignored for Exists case, but clear anyway.
934 matchString = "";
935 }
936 else if ( matchString.indexOf ( WILDCARD ) == -1 &&
937 matchString.indexOf ( MATCHCHAR ) == -1 )
938 {
939 // Simple string , eg. "to match"
940 if ( bNot )
941 op = MQueryOp::DoesNotContain;
942 else
943 op = MQueryOp::Contains;
944 }
945 else if ( matchString.startsWith( WILDCARD )
946 && matchString.endsWith( WILDCARD )
947 && matchString.indexOf ( WILDCARD, 1 ) == matchString.lastIndexOf ( WILDCARD )
948 && matchString.indexOf( MATCHCHAR ) == -1
949 )
950 {
951 // Relatively simple "%string%" - ie, contains...
952 // Cut '%' from front and rear
953 matchString = matchString.replaceAt( 0, 1, OUString() );
954 matchString = matchString.replaceAt( matchString.getLength() -1 , 1, OUString() );
955
956 if (bNot)
957 op = MQueryOp::DoesNotContain;
958 else
959 op = MQueryOp::Contains;
960 }
961 else if ( bNot )
962 {
963 // We currently can't handle a 'NOT LIKE' when there are '%' or
964 // '_' dispersed throughout
965 m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_NOT_LIKE_TOO_COMPLEX, *this );
966 }
967 else
968 {
969 if ( (matchString.indexOf ( WILDCARD ) == matchString.lastIndexOf ( WILDCARD ))
970 && matchString.indexOf( MATCHCHAR ) == -1
971 )
972 {
973 // One occurrence of '%' - no '_' matches...
974 if ( matchString.startsWith( WILDCARD ) )
975 {
976 op = MQueryOp::EndsWith;
977 matchString = matchString.replaceAt( 0, 1, OUString());
978 }
979 else if ( matchString.endsWith( WILDCARD ) )
980 {
981 op = MQueryOp::BeginsWith;
982 matchString = matchString.replaceAt( matchString.getLength() -1, 1, OUString() );
983 }
984 else
985 {
986 sal_Int32 pos = matchString.indexOf ( WILDCARD );
987 matchString = matchString.replaceAt( pos, 1, ".*" );
988 op = MQueryOp::RegExp;
989 }
990
991 }
992 else
993 {
994 // Most Complex, need to use an RE
995 sal_Int32 pos;
996 while ( (pos = matchString.indexOf ( WILDCARD )) != -1 )
997 {
998 matchString = matchString.replaceAt( pos, 1, ".*" );
999 }
1000
1001 while ( (pos = matchString.indexOf( MATCHCHAR )) != -1 )
1002 {
1003 matchString = matchString.replaceAt( pos, 1, "." );
1004 }
1005
1006 op = MQueryOp::RegExp;
1007 }
1008 }
1009
1010 queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op, matchString ));
1011 }
1012 else if (SQL_ISRULE(parseTree,test_for_null))
1013 {
1014 OSL_ENSURE(parseTree->count() == 2,"Error in ParseTree");
1015 const OSQLParseNode* pPart2 = parseTree->getChild(1);
1016 OSL_ENSURE(SQL_ISTOKEN(pPart2->getChild(0),IS),"Error in ParseTree");
1017
1018 if (!SQL_ISRULE(parseTree->getChild(0),column_ref))
1019 {
1020 m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_INVALID_IS_NULL_COLUMN, *this );
1021 }
1022
1023 if (SQL_ISTOKEN(pPart2->getChild(1),NOT))
1024 {
1025 op = MQueryOp::Exists;
1026 }
1027 else
1028 op = MQueryOp::DoesNotExist;
1029
1030 OUString sTableRange;
1031 m_pSQLIterator->getColumnRange(parseTree->getChild(0),columnName,sTableRange);
1032
1033 queryExpression.getExpressions().push_back( new MQueryExpressionString( columnName, op ));
1034 }
1035 else
1036 {
1037 OSL_TRACE( "Unexpected statement!!!" );
1038
1039 m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
1040 }
1041 }
1042
1043
1044
1045
1046 void OResultSet::fillRowData()
1047 throw( ::com::sun::star::sdbc::SQLException )
1048 {
1049 OSL_ENSURE( m_pStatement, "Require a statement" );
1050
1051 MQueryExpression queryExpression;
1052
1053 OConnection* xConnection = static_cast<OConnection*>(m_pStatement->getConnection().get());
1054 m_xColumns = m_pSQLIterator->getSelectColumns();
1055
1056 OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
1057
1058 OSQLColumns::Vector::const_iterator aIter = m_xColumns->get().begin();
1059 const OUString sProprtyName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
1060 OUString sName;
1061 m_aAttributeStrings.clear();
1062 m_aAttributeStrings.reserve(m_xColumns->get().size());
1063 for (sal_Int32 i = 1; aIter != m_xColumns->get().end();++aIter, i++)
1064 {
1065 (*aIter)->getPropertyValue(sProprtyName) >>= sName;
1066 #if OSL_DEBUG_LEVEL > 0
1067 OSL_TRACE("Query Columns : (%d) %s", i, OUtoCStr(sName) );
1068 #endif
1069 m_aAttributeStrings.push_back( sName );
1070 }
1071
1072
1073 // Generate Match Conditions for Query
1074 const OSQLParseNode* pParseTree = m_pSQLIterator->getWhereTree();
1075
1076 // const OSQLParseNode* pParseTree = NULL;
1077
1078 m_bIsAlwaysFalseQuery = sal_False;
1079 if ( pParseTree != NULL )
1080 {
1081 // Extract required info
1082
1083 OSL_TRACE("\tHave a Where Clause");
1084
1085 analyseWhereClause( pParseTree, queryExpression );
1086 }
1087 else
1088 {
1089 OSL_TRACE("\tDon't have a Where Clause");
1090
1091 MQueryExpression::ExprVector eVector;
1092
1093 // LDAP does not allow a query without restriction, so we add a dummy
1094 // for PrimaryEmail
1095 // For other types we stick to the old behaviour of using
1096 // card:nsIAbCard.
1097 OSL_ENSURE(m_pStatement, "Cannot determine Parent Statement");
1098 OUString aStr;
1099 if (xConnection->isLDAP())
1100 aStr = "PrimaryEmail";
1101 else
1102 aStr = "card:nsIAbCard";
1103 eVector.push_back( new MQueryExpressionString(aStr, MQueryOp::Exists) );
1104
1105 queryExpression.setExpressions( eVector );
1106 }
1107
1108 // If the query is a 0=1 then set Row count to 0 and return
1109 if ( m_bIsAlwaysFalseQuery )
1110 {
1111 m_bIsReadOnly = 1;
1112 return;
1113 }
1114
1115 m_aQuery.setExpression( queryExpression );
1116
1117 OUString aStr( m_pTable->getName() );
1118 m_aQuery.setAddressbook( aStr );
1119
1120 sal_Int32 rv = m_aQuery.executeQuery(xConnection);
1121 if ( rv == -1 ) {
1122 m_pStatement->getOwnConnection()->throwSQLException( STR_ERR_EXECUTING_QUERY, *this );
1123 }
1124 //determine whether the address book is readonly
1125 determineReadOnly();
1126
1127 #if OSL_DEBUG_LEVEL > 0
1128 OSL_TRACE( "executeQuery returned %d", rv );
1129
1130 OSL_TRACE( "\tOUT OResultSet::fillRowData()" );
1131 #endif
1132 }
1133
1134
1135 static sal_Bool matchRow( OValueRow& row1, OValueRow& row2 )
1136 {
1137 OValueVector::Vector::iterator row1Iter = row1->get().begin();
1138 OValueVector::Vector::iterator row2Iter = row2->get().begin();
1139 for ( ++row1Iter,++row2Iter; // the first column is the bookmark column
1140 row1Iter != row1->get().end(); ++row1Iter,++row2Iter)
1141 {
1142 if ( row1Iter->isBound())
1143 {
1144 // Compare values, if at anytime there's a mismatch return false
1145 if ( !( (*row1Iter) == (*row2Iter) ) )
1146 return sal_False;
1147 }
1148 }
1149
1150 // If we get to here the rows match
1151 return sal_True;
1152 }
1153 sal_Int32 OResultSet::getRowForCardNumber(sal_Int32 nCardNum)
1154 {
1155 OSL_TRACE("In/Out: OResultSet::getRowForCardNumber, nCardNum = %u", nCardNum );
1156
1157 if ( m_pKeySet.is() )
1158 {
1159 sal_Int32 nPos;
1160 for(nPos=0;nPos < (sal_Int32)m_pKeySet->get().size();nPos++)
1161 {
1162 if (nCardNum == (m_pKeySet->get())[nPos])
1163 {
1164 OSL_TRACE("In/Out: OResultSet::getRowForCardNumber, return = %u", nPos+1 );
1165 return nPos+1;
1166 }
1167 }
1168 }
1169
1170 m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this );
1171 return 0;
1172 }
1173
1174
1175 void SAL_CALL OResultSet::executeQuery() throw( ::com::sun::star::sdbc::SQLException,
1176 ::com::sun::star::uno::RuntimeException)
1177 {
1178 ResultSetEntryGuard aGuard( *this );
1179
1180 OSL_ENSURE( m_pTable, "Need a Table object");
1181 if(!m_pTable)
1182 {
1183 const OSQLTables& xTabs = m_pSQLIterator->getTables();
1184 if ((xTabs.begin() == xTabs.end()) || !xTabs.begin()->second.is())
1185 m_pStatement->getOwnConnection()->throwSQLException( STR_QUERY_TOO_COMPLEX, *this );
1186
1187 m_pTable = static_cast< OTable* > ((xTabs.begin()->second).get());
1188
1189 }
1190
1191 m_nRowPos = 0;
1192
1193 fillRowData();
1194
1195 OSL_ENSURE(m_xColumns.is(), "Need the Columns!!");
1196
1197 switch( m_pSQLIterator->getStatementType() )
1198 {
1199 case SQL_STATEMENT_SELECT:
1200 {
1201 if(m_bIsAlwaysFalseQuery) {
1202 break;
1203 }
1204 else if(isCount())
1205 {
1206 m_pStatement->getOwnConnection()->throwSQLException( STR_NO_COUNT_SUPPORT, *this );
1207 }
1208 else
1209 {
1210 sal_Bool bDistinct = sal_False;
1211 OSQLParseNode *pDistinct = m_pParseTree->getChild(1);
1212 if (pDistinct && pDistinct->getTokenID() == SQL_TOKEN_DISTINCT)
1213 {
1214 if(!IsSorted())
1215 {
1216 m_aOrderbyColumnNumber.push_back(m_aColMapping[1]);
1217 m_aOrderbyAscending.push_back(SQL_DESC);
1218 }
1219 bDistinct = sal_True;
1220 }
1221
1222 OSortIndex::TKeyTypeVector eKeyType(m_aOrderbyColumnNumber.size());
1223 ::std::vector<sal_Int32>::iterator aOrderByIter = m_aOrderbyColumnNumber.begin();
1224 for ( ::std::vector<sal_Int16>::size_type i = 0; aOrderByIter != m_aOrderbyColumnNumber.end(); ++aOrderByIter,++i)
1225 {
1226 OSL_ENSURE((sal_Int32)m_aRow->get().size() > *aOrderByIter,"Invalid Index");
1227 switch ((m_aRow->get().begin()+*aOrderByIter)->getTypeKind())
1228 {
1229 case DataType::CHAR:
1230 case DataType::VARCHAR:
1231 eKeyType[i] = SQL_ORDERBYKEY_STRING;
1232 break;
1233
1234 case DataType::OTHER:
1235 case DataType::TINYINT:
1236 case DataType::SMALLINT:
1237 case DataType::INTEGER:
1238 case DataType::DECIMAL:
1239 case DataType::NUMERIC:
1240 case DataType::REAL:
1241 case DataType::DOUBLE:
1242 case DataType::DATE:
1243 case DataType::TIME:
1244 case DataType::TIMESTAMP:
1245 case DataType::BIT:
1246 eKeyType[i] = SQL_ORDERBYKEY_DOUBLE;
1247 break;
1248
1249 // Other types aren't implemented (so they are always FALSE)
1250 default:
1251 eKeyType[i] = SQL_ORDERBYKEY_NONE;
1252 OSL_FAIL("MResultSet::executeQuery: Order By Data Type not implemented");
1253 break;
1254 }
1255 }
1256
1257 if (IsSorted())
1258 {
1259 // Implement Sorting
1260
1261 // So that we can sort we need to wait until the executed
1262 // query to the mozilla addressbooks has returned all
1263 // values.
1264
1265 OSL_TRACE("Query is to be sorted");
1266 if( ! m_aQuery.queryComplete() )
1267 if ( !m_aQuery.waitForQueryComplete() )
1268 {
1269 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
1270 }
1271
1272 OSL_ENSURE( m_aQuery.queryComplete(), "Query not complete!!");
1273
1274 m_pSortIndex = new OSortIndex(eKeyType,m_aOrderbyAscending);
1275
1276 OSL_TRACE("OrderbyColumnNumber->size() = %d",m_aOrderbyColumnNumber.size());
1277 #if OSL_DEBUG_LEVEL > 0
1278 for ( ::std::vector<sal_Int32>::size_type i = 0; i < m_aColMapping.size(); i++ )
1279 OSL_TRACE("Mapped: %d -> %d", i, m_aColMapping[i] );
1280 #endif
1281 for ( sal_Int32 nRow = 1; nRow <= m_aQuery.getRowCount(); nRow++ ) {
1282
1283 OKeyValue* pKeyValue = OKeyValue::createKeyValue((nRow));
1284
1285 ::std::vector<sal_Int32>::iterator aIter = m_aOrderbyColumnNumber.begin();
1286 for (;aIter != m_aOrderbyColumnNumber.end(); ++aIter)
1287 {
1288 const ORowSetValue& value = getValue(nRow, *aIter);
1289
1290 OSL_TRACE( "Adding Value: (%d,%d) : %s", nRow, *aIter,OUtoCStr( value ));
1291
1292 pKeyValue->pushKey(new ORowSetValueDecorator(value));
1293 }
1294
1295 m_pSortIndex->AddKeyValue( pKeyValue );
1296 }
1297
1298 m_pKeySet = m_pSortIndex->CreateKeySet();
1299 m_CurrentRowCount = static_cast<sal_Int32>(m_pKeySet->get().size());
1300 #if OSL_DEBUG_LEVEL > 0
1301 for( OKeySet::Vector::size_type i = 0; i < m_pKeySet->get().size(); i++ )
1302 OSL_TRACE("Sorted: %d -> %d", i, (m_pKeySet->get())[i] );
1303 #endif
1304
1305 m_pSortIndex = NULL;
1306 beforeFirst(); // Go back to start
1307 }
1308 else //we always need m_pKeySet now
1309 m_pKeySet = new OKeySet();
1310
1311 // Handle the DISTINCT case
1312 if ( bDistinct && m_pKeySet.is() )
1313 {
1314 OValueRow aSearchRow = new OValueVector( m_aRow->get().size() );
1315
1316 for( OKeySet::Vector::size_type i = 0; i < m_pKeySet->get().size(); i++ )
1317 {
1318 fetchRow( (m_pKeySet->get())[i] ); // Fills m_aRow
1319 if ( matchRow( m_aRow, aSearchRow ) )
1320 {
1321 (m_pKeySet->get())[i] = 0; // Marker for later to be removed
1322 }
1323 else
1324 {
1325 // They don't match, so it's not a duplicate.
1326 // Use the current Row as the next one to match against
1327 *aSearchRow = *m_aRow;
1328 }
1329 }
1330 // Now remove any keys marked with a 0
1331 m_pKeySet->get().erase(::std::remove_if(m_pKeySet->get().begin(),m_pKeySet->get().end()
1332 ,::std::bind2nd(::std::equal_to<sal_Int32>(),0))
1333 ,m_pKeySet->get().end());
1334
1335 }
1336 }
1337 } break;
1338
1339 case SQL_STATEMENT_UPDATE:
1340 case SQL_STATEMENT_DELETE:
1341 case SQL_STATEMENT_INSERT:
1342 break;
1343 default:
1344 m_pStatement->getOwnConnection()->throwSQLException( STR_STMT_TYPE_NOT_SUPPORTED, *this );
1345 break;
1346 }
1347 }
1348
1349
1350
1351 void OResultSet::setBoundedColumns(const OValueRow& _rRow,
1352 const ::rtl::Reference<connectivity::OSQLColumns>& _rxColumns,
1353 const Reference<XIndexAccess>& _xNames,
1354 sal_Bool _bSetColumnMapping,
1355 const Reference<XDatabaseMetaData>& _xMetaData,
1356 ::std::vector<sal_Int32>& _rColMapping)
1357 {
1358 ::comphelper::UStringMixEqual aCase(_xMetaData->supportsMixedCaseQuotedIdentifiers());
1359
1360 Reference<XPropertySet> xTableColumn;
1361 OUString sTableColumnName, sSelectColumnRealName;
1362
1363 const OUString sName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
1364 const OUString sRealName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME);
1365
1366 ::std::vector< OUString> aColumnNames;
1367 aColumnNames.reserve(_rxColumns->get().size());
1368 OValueVector::Vector::iterator aRowIter = _rRow->get().begin()+1;
1369 for (sal_Int32 i=0; // the first column is the bookmark column
1370 aRowIter != _rRow->get().end();
1371 ++i, ++aRowIter
1372 )
1373 {
1374 try
1375 {
1376 // get the table column and its name
1377 _xNames->getByIndex(i) >>= xTableColumn;
1378 OSL_ENSURE(xTableColumn.is(), "OResultSet::setBoundedColumns: invalid table column!");
1379 if (xTableColumn.is())
1380 xTableColumn->getPropertyValue(sName) >>= sTableColumnName;
1381 else
1382 sTableColumnName = "";
1383
1384 // look if we have such a select column
1385 // TODO: would like to have a O(log n) search here ...
1386 sal_Int32 nColumnPos = 0;
1387 for ( OSQLColumns::Vector::iterator aIter = _rxColumns->get().begin();
1388 aIter != _rxColumns->get().end();
1389 ++aIter,++nColumnPos
1390 )
1391 {
1392 if ( nColumnPos < (sal_Int32)aColumnNames.size() )
1393 sSelectColumnRealName = aColumnNames[nColumnPos];
1394 else
1395 {
1396 if((*aIter)->getPropertySetInfo()->hasPropertyByName(sRealName))
1397 (*aIter)->getPropertyValue(sRealName) >>= sSelectColumnRealName;
1398 else
1399 (*aIter)->getPropertyValue(sName) >>= sSelectColumnRealName;
1400 aColumnNames.push_back(sSelectColumnRealName);
1401 }
1402
1403 if (aCase(sTableColumnName, sSelectColumnRealName))
1404 {
1405 if(_bSetColumnMapping)
1406 {
1407 sal_Int32 nSelectColumnPos = static_cast<sal_Int32>(aIter - _rxColumns->get().begin() + 1);
1408 // the getXXX methods are 1-based ...
1409 sal_Int32 nTableColumnPos = i + 1;
1410 // get first table column is the bookmark column
1411
1412 #if OSL_DEBUG_LEVEL > 0
1413 OSL_TRACE("Set Col Mapping: %d -> %d", nSelectColumnPos, nTableColumnPos );
1414 #endif
1415 _rColMapping[nSelectColumnPos] = nTableColumnPos;
1416 }
1417
1418 aRowIter->setBound(sal_True);
1419 aRowIter->setTypeKind(DataType::VARCHAR);
1420 }
1421 }
1422 }
1423 catch (Exception&)
1424 {
1425 OSL_FAIL("OResultSet::setBoundedColumns: caught an Exception!");
1426 }
1427 }
1428 }
1429
1430
1431
1432 sal_Bool OResultSet::isCount() const
1433 {
1434 return (m_pParseTree &&
1435 m_pParseTree->count() > 2 &&
1436 SQL_ISRULE(m_pParseTree->getChild(2),scalar_exp_commalist) &&
1437 SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0),derived_column) &&
1438 SQL_ISRULE(m_pParseTree->getChild(2)->getChild(0)->getChild(0),general_set_fct) &&
1439 m_pParseTree->getChild(2)->getChild(0)->getChild(0)->count() == 4
1440 );
1441 }
1442
1443
1444
1445 // Check for valid row in m_aQuery
1446
1447 sal_Bool OResultSet::validRow( sal_uInt32 nRow )
1448 {
1449 sal_Int32 nNumberOfRecords = m_aQuery.getRealRowCount();
1450
1451 while ( nRow > (sal_uInt32)nNumberOfRecords && !m_aQuery.queryComplete() ) {
1452 #if OSL_DEBUG_LEVEL > 0
1453 OSL_TRACE("validRow: waiting...");
1454 #endif
1455 m_aQuery.checkRowAvailable( nRow );
1456 if ( m_aQuery.hadError() )
1457 {
1458 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
1459 }
1460 nNumberOfRecords = m_aQuery.getRealRowCount();
1461 }
1462
1463 if (( nRow == 0 ) ||
1464 ( nRow > (sal_uInt32)nNumberOfRecords && m_aQuery.queryComplete()) ){
1465 OSL_TRACE("validRow(%u): return False", nRow);
1466 return sal_False;
1467 }
1468 #if OSL_DEBUG_LEVEL > 0
1469 OSL_TRACE("validRow(%u): return True", nRow);
1470 #endif
1471 return sal_True;
1472 }
1473 sal_Bool OResultSet::fillKeySet(sal_Int32 nMaxCardNumber)
1474 {
1475 impl_ensureKeySet();
1476 if (m_CurrentRowCount < nMaxCardNumber)
1477 {
1478 sal_Int32 nKeyValue;
1479 if ( (sal_Int32)m_pKeySet->get().capacity() < nMaxCardNumber )
1480 m_pKeySet->get().reserve(nMaxCardNumber + 20 );
1481
1482 for (nKeyValue = m_CurrentRowCount+1; nKeyValue <= nMaxCardNumber; nKeyValue ++)
1483 m_pKeySet->get().push_back( nKeyValue );
1484 m_CurrentRowCount = nMaxCardNumber;
1485 }
1486 return sal_True;
1487 }
1488
1489 sal_Int32 OResultSet::deletedCount()
1490 {
1491 impl_ensureKeySet();
1492 return m_CurrentRowCount - static_cast<sal_Int32>(m_pKeySet->get().size());
1493
1494 }
1495
1496 sal_Bool OResultSet::seekRow( eRowPosition pos, sal_Int32 nOffset )
1497 {
1498 ResultSetEntryGuard aGuard( *this );
1499 if ( !m_pKeySet.is() )
1500 m_pStatement->getOwnConnection()->throwSQLException( STR_ILLEGAL_MOVEMENT, *this );
1501
1502 sal_Int32 nNumberOfRecords = m_aQuery.getRealRowCount();
1503 sal_Int32 nRetrievedRows = currentRowCount();
1504 sal_Int32 nCurPos = m_nRowPos;
1505
1506 OSL_TRACE("seekRow: nCurPos = %d", nCurPos );
1507 switch( pos ) {
1508 case NEXT_POS:
1509 OSL_TRACE("seekRow: NEXT");
1510 nCurPos++;
1511 break;
1512 case PRIOR_POS:
1513 OSL_TRACE("seekRow: PRIOR");
1514 if ( nCurPos > 0 )
1515 nCurPos--;
1516 break;
1517
1518 case FIRST_POS:
1519 OSL_TRACE("seekRow: FIRST");
1520 nCurPos = 1;
1521 break;
1522
1523 case LAST_POS:
1524 OSL_TRACE("seekRow: LAST");
1525 nCurPos = nRetrievedRows;
1526 break;
1527 case ABSOLUTE_POS:
1528 OSL_TRACE("seekRow: ABSOLUTE : %d", nOffset);
1529 nCurPos = nOffset;
1530 break;
1531 case RELATIVE_POS:
1532 OSL_TRACE("seekRow: RELATIVE : %d", nOffset);
1533 nCurPos += sal_uInt32( nOffset );
1534 break;
1535 }
1536
1537 if ( nCurPos <= 0 ) {
1538 m_nRowPos = 0;
1539 OSL_TRACE("seekRow: return False, m_nRowPos = %u", m_nRowPos );
1540 return sal_False;
1541 }
1542 sal_Int32 nCurCard = nCurPos;
1543 if ( nCurPos < (sal_Int32)m_pKeySet->get().size() ) //The requested row is exist in m_pKeySet, so we just use it
1544 {
1545 nCurCard = (m_pKeySet->get())[nCurPos-1];
1546 }
1547 else //The requested row has not been retrieved until now. We should get the right card for it.
1548 nCurCard = nCurPos + deletedCount();
1549
1550 while ( nCurCard > nNumberOfRecords && !m_aQuery.queryComplete() ) {
1551 m_aQuery.checkRowAvailable( nCurCard );
1552 if ( m_aQuery.hadError() )
1553 {
1554 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
1555 }
1556 nNumberOfRecords = m_aQuery.getRealRowCount();
1557 }
1558
1559 if ( nCurCard > nNumberOfRecords && m_aQuery.queryComplete()) {
1560 fillKeySet(nNumberOfRecords);
1561 m_nRowPos = static_cast<sal_uInt32>(m_pKeySet->get().size() + 1);
1562 OSL_TRACE("seekRow: return False, m_nRowPos = %u", m_nRowPos );
1563 return sal_False;
1564 }
1565 //Insert new retrieved items for later use
1566 fillKeySet(nNumberOfRecords);
1567 m_nRowPos = (sal_uInt32)nCurPos;
1568 OSL_TRACE("seekRow: return True, m_nRowPos = %u", m_nRowPos );
1569 fetchCurrentRow();
1570 return sal_True;
1571 }
1572
1573 void OResultSet::setColumnMapping(const ::std::vector<sal_Int32>& _aColumnMapping)
1574 {
1575 m_aColMapping = _aColumnMapping;
1576 #if OSL_DEBUG_LEVEL > 0
1577 for ( sal_uInt32 i = 0; i < m_aColMapping.size(); i++ )
1578 OSL_TRACE("Set Mapped: %d -> %d", i, m_aColMapping[i] );
1579 #endif
1580 }
1581
1582
1583 ::com::sun::star::uno::Any OResultSet::getBookmark( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1584 {
1585 OSL_TRACE("getBookmark, m_nRowPos = %u", m_nRowPos );
1586 ResultSetEntryGuard aGuard( *this );
1587 if ( fetchCurrentRow() == sal_False )
1588 m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
1589
1590 OSL_ENSURE((!m_aRow->isDeleted()),"getBookmark called for deleted row");
1591 return makeAny((sal_Int32)(m_aRow->get())[0]);
1592 }
1593 sal_Bool OResultSet::moveToBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1594 {
1595 ResultSetEntryGuard aGuard( *this );
1596 OSL_TRACE("moveToBookmark, bookmark = %u", comphelper::getINT32(bookmark) );
1597 sal_Int32 nCardNum = comphelper::getINT32(bookmark);
1598 m_nRowPos = getRowForCardNumber(nCardNum);
1599 fetchCurrentRow();
1600 return sal_True;
1601 }
1602 sal_Bool OResultSet::moveRelativeToBookmark( const ::com::sun::star::uno::Any& bookmark, sal_Int32 rows ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1603 {
1604 ResultSetEntryGuard aGuard( *this );
1605 OSL_TRACE("moveRelativeToBookmark, bookmark = %u rows= %u", comphelper::getINT32(bookmark),rows );
1606 sal_Int32 nCardNum = comphelper::getINT32(bookmark);
1607 m_nRowPos = getRowForCardNumber(nCardNum);
1608 return seekRow(RELATIVE_POS,rows );
1609 }
1610 sal_Int32 OResultSet::compareBookmarks( const ::com::sun::star::uno::Any& lhs, const ::com::sun::star::uno::Any& rhs ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1611 {
1612 ResultSetEntryGuard aGuard( *this );
1613 OSL_TRACE("compareBookmarks, m_nRowPos = %u", m_nRowPos );
1614 sal_Int32 nFirst=0;
1615 sal_Int32 nSecond=0;
1616 sal_Int32 nResult=0;
1617
1618 if ( !( lhs >>= nFirst ) || !( rhs >>= nSecond ) )
1619 m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_BOOKMARK, *this );
1620
1621 if(nFirst < nSecond)
1622 nResult = -1;
1623 else if(nFirst > nSecond)
1624 nResult = 1;
1625 else
1626 nResult = 0;
1627
1628 return nResult;
1629 }
1630 sal_Bool OResultSet::hasOrderedBookmarks( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1631 {
1632 ResultSetEntryGuard aGuard( *this );
1633 OSL_TRACE("hasOrderedBookmarks, m_nRowPos = %u", m_nRowPos );
1634 return sal_True;
1635 }
1636 sal_Int32 OResultSet::hashBookmark( const ::com::sun::star::uno::Any& bookmark ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1637 {
1638 ResultSetEntryGuard aGuard( *this );
1639 OSL_TRACE("hashBookmark, m_nRowPos = %u", m_nRowPos );
1640 return comphelper::getINT32(bookmark);
1641 }
1642
1643 sal_Int32 OResultSet::getCurrentCardNumber()
1644 {
1645 if ( ( m_nRowPos == 0 ) || !m_pKeySet.is() )
1646 return 0;
1647 if (m_pKeySet->get().size() < m_nRowPos)
1648 return 0;
1649 return (m_pKeySet->get())[m_nRowPos-1];
1650 }
1651 void OResultSet::checkPendingUpdate() throw(SQLException, RuntimeException)
1652 {
1653 OSL_TRACE("checkPendingUpdate, m_nRowPos = %u", m_nRowPos );
1654 const sal_Int32 nCurrentRow = getCurrentCardNumber();
1655
1656 if ((m_nNewRow && nCurrentRow != m_nNewRow)
1657 || ( m_nUpdatedRow && m_nUpdatedRow != nCurrentRow))
1658 {
1659 const OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
1660 STR_COMMIT_ROW,
1661 "$position$", OUString::number(nCurrentRow)
1662 ) );
1663 ::dbtools::throwGenericSQLException(sError,*this);
1664 }
1665
1666 }
1667 void OResultSet::updateValue(sal_Int32 columnIndex ,const ORowSetValue& x) throw(SQLException, RuntimeException)
1668 {
1669 OSL_TRACE("updateValue, m_nRowPos = %u", m_nRowPos );
1670 ResultSetEntryGuard aGuard( *this );
1671 if ( fetchCurrentRow() == sal_False )
1672 m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
1673
1674
1675 checkPendingUpdate();
1676
1677 checkIndex(columnIndex );
1678 columnIndex = mapColumn(columnIndex);
1679
1680 (m_aRow->get())[columnIndex].setBound(sal_True);
1681 (m_aRow->get())[columnIndex] = x;
1682 m_nUpdatedRow = getCurrentCardNumber();
1683 m_RowStates = m_RowStates | RowStates_Updated;
1684 }
1685
1686
1687 void SAL_CALL OResultSet::updateNull( sal_Int32 columnIndex ) throw(SQLException, RuntimeException)
1688 {
1689 OSL_TRACE("updateNull, m_nRowPos = %u", m_nRowPos );
1690 ResultSetEntryGuard aGuard( *this );
1691 if ( fetchCurrentRow() == sal_False )
1692 m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
1693
1694 checkPendingUpdate();
1695 checkIndex(columnIndex );
1696 columnIndex = mapColumn(columnIndex);
1697
1698 (m_aRow->get())[columnIndex].setBound(sal_True);
1699 (m_aRow->get())[columnIndex].setNull();
1700 m_nUpdatedRow = getCurrentCardNumber();
1701 m_RowStates = m_RowStates | RowStates_Updated;
1702 }
1703
1704
1705 void SAL_CALL OResultSet::updateBoolean( sal_Int32 columnIndex, sal_Bool x ) throw(SQLException, RuntimeException)
1706 {
1707 updateValue(columnIndex, static_cast<bool>(x));
1708 }
1709
1710 void SAL_CALL OResultSet::updateByte( sal_Int32 columnIndex, sal_Int8 x ) throw(SQLException, RuntimeException)
1711 {
1712 updateValue(columnIndex,x);
1713 }
1714
1715
1716 void SAL_CALL OResultSet::updateShort( sal_Int32 columnIndex, sal_Int16 x ) throw(SQLException, RuntimeException)
1717 {
1718 updateValue(columnIndex,x);
1719 }
1720
1721 void SAL_CALL OResultSet::updateInt( sal_Int32 columnIndex, sal_Int32 x ) throw(SQLException, RuntimeException)
1722 {
1723 updateValue(columnIndex,x);
1724 }
1725
1726 void SAL_CALL OResultSet::updateLong( sal_Int32 /*columnIndex*/, sal_Int64 /*x*/ ) throw(SQLException, RuntimeException)
1727 {
1728 ::dbtools::throwFeatureNotImplementedException( "XRowUpdate::updateLong", *this );
1729 }
1730
1731 void SAL_CALL OResultSet::updateFloat( sal_Int32 columnIndex, float x ) throw(SQLException, RuntimeException)
1732 {
1733 updateValue(columnIndex,x);
1734 }
1735
1736
1737 void SAL_CALL OResultSet::updateDouble( sal_Int32 columnIndex, double x ) throw(SQLException, RuntimeException)
1738 {
1739 updateValue(columnIndex,x);
1740 }
1741
1742 void SAL_CALL OResultSet::updateString( sal_Int32 columnIndex, const OUString& x ) throw(SQLException, RuntimeException)
1743 {
1744 updateValue(columnIndex,x);
1745 }
1746
1747 void SAL_CALL OResultSet::updateBytes( sal_Int32 columnIndex, const Sequence< sal_Int8 >& x ) throw(SQLException, RuntimeException)
1748 {
1749 updateValue(columnIndex,x);
1750 }
1751
1752 void SAL_CALL OResultSet::updateDate( sal_Int32 columnIndex, const ::com::sun::star::util::Date& x ) throw(SQLException, RuntimeException)
1753 {
1754 updateValue(columnIndex,x);
1755 }
1756
1757
1758 void SAL_CALL OResultSet::updateTime( sal_Int32 columnIndex, const ::com::sun::star::util::Time& x ) throw(SQLException, RuntimeException)
1759 {
1760 updateValue(columnIndex,x);
1761 }
1762
1763
1764 void SAL_CALL OResultSet::updateTimestamp( sal_Int32 columnIndex, const ::com::sun::star::util::DateTime& x ) throw(SQLException, RuntimeException)
1765 {
1766 updateValue(columnIndex,x);
1767 }
1768
1769
1770 void SAL_CALL OResultSet::updateBinaryStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
1771 {
1772 ResultSetEntryGuard aGuard( *this );
1773
1774 if(!x.is())
1775 ::dbtools::throwFunctionSequenceException(*this);
1776
1777 Sequence<sal_Int8> aSeq;
1778 x->readBytes(aSeq,length);
1779 updateValue(columnIndex,aSeq);
1780 }
1781
1782 void SAL_CALL OResultSet::updateCharacterStream( sal_Int32 columnIndex, const Reference< ::com::sun::star::io::XInputStream >& x, sal_Int32 length ) throw(SQLException, RuntimeException)
1783 {
1784 updateBinaryStream(columnIndex,x,length);
1785 }
1786
1787 void SAL_CALL OResultSet::updateObject( sal_Int32 columnIndex, const Any& x ) throw(SQLException, RuntimeException)
1788 {
1789 if (!::dbtools::implUpdateObject(this, columnIndex, x))
1790 {
1791 const OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
1792 STR_COLUMN_NOT_UPDATEABLE,
1793 "$position$", OUString::number(columnIndex)
1794 ) );
1795 ::dbtools::throwGenericSQLException(sError,*this);
1796 } // if (!::dbtools::implUpdateObject(this, columnIndex, x))
1797 }
1798
1799
1800 void SAL_CALL OResultSet::updateNumericObject( sal_Int32 columnIndex, const Any& x, sal_Int32 /*scale*/ ) throw(SQLException, RuntimeException)
1801 {
1802 if (!::dbtools::implUpdateObject(this, columnIndex, x))
1803 {
1804 const OUString sError( m_pStatement->getOwnConnection()->getResources().getResourceStringWithSubstitution(
1805 STR_COLUMN_NOT_UPDATEABLE,
1806 "$position$", OUString::number(columnIndex)
1807 ) );
1808 ::dbtools::throwGenericSQLException(sError,*this);
1809 }
1810 }
1811
1812 // XResultSetUpdate
1813
1814 void SAL_CALL OResultSet::insertRow( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1815 {
1816 ResultSetEntryGuard aGuard( *this );
1817 OSL_TRACE("insertRow in, m_nRowPos = %u", m_nRowPos );
1818 m_RowStates = RowStates_Inserted;
1819 updateRow();
1820 m_nOldRowPos = 0;
1821 m_nNewRow = 0;
1822 m_aQuery.setRowStates(getCurrentCardNumber(),m_RowStates);
1823 OSL_TRACE("insertRow out, m_nRowPos = %u", m_nRowPos );
1824 }
1825
1826 void SAL_CALL OResultSet::updateRow( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1827 {
1828 OSL_TRACE("updateRow in, m_nRowPos = %u", m_nRowPos );
1829 ResultSetEntryGuard aGuard( *this );
1830 impl_ensureKeySet();
1831
1832 if (!m_nRowPos || m_pKeySet->get().size() < m_nRowPos )
1833 m_pStatement->getOwnConnection()->throwSQLException( STR_INVALID_ROW_UPDATE, *this );
1834
1835 const sal_Int32 nCurrentCard = getCurrentCardNumber();
1836
1837 if (!pushCard(nCurrentCard))
1838 {
1839 m_RowStates = RowStates_Error;
1840 m_pStatement->getOwnConnection()->throwSQLException( STR_ROW_CAN_NOT_SAVE, *this );
1841 }
1842
1843 if (!m_aQuery.commitRow(nCurrentCard))
1844 {
1845 m_RowStates = RowStates_Error;
1846 m_nUpdatedRow = 0;
1847 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
1848 }
1849
1850 m_nUpdatedRow = 0;
1851 fetchCurrentRow();
1852 OSL_TRACE("updateRow out, m_nRowPos = %u", m_nRowPos );
1853 }
1854
1855 void SAL_CALL OResultSet::deleteRow( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1856 {
1857 OSL_TRACE("deleteRow, m_nRowPos = %u", m_nRowPos );
1858 ResultSetEntryGuard aGuard( *this );
1859 if (rowDeleted())
1860 m_pStatement->getOwnConnection()->throwSQLException( STR_ROW_ALREADY_DELETED, *this );
1861
1862 const sal_Int32 nCurrentRow = getCurrentCardNumber();
1863 //fetchRow(nCurrentRow);
1864 if (!nCurrentRow)
1865 m_pStatement->getOwnConnection()->throwSQLException( STR_ERROR_GET_ROW, *this );
1866
1867 sal_Bool m_bRowDeleted = ( m_aQuery.deleteRow( nCurrentRow ) > 0 );
1868 if (!m_bRowDeleted)
1869 m_pStatement->getOwnConnection()->throwSQLException( m_aQuery.getError(), *this );
1870
1871 m_aQuery.setRowStates(nCurrentRow,RowStates_Deleted);
1872 m_pKeySet->get().erase(m_pKeySet->get().begin() + m_nRowPos -1);
1873 m_RowStates = RowStates_Deleted;
1874 OSL_TRACE("deleteRow out, m_nRowPos = %u", m_nRowPos );
1875 }
1876
1877 void SAL_CALL OResultSet::cancelRowUpdates( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1878 {
1879 ResultSetEntryGuard aGuard( *this );
1880 OSL_TRACE("cancelRowUpdates, m_nRowPos = %u", m_nRowPos );
1881 if (fetchRow(getCurrentCardNumber(),sal_True)) //force fetch current row will cause we lose all change to the current row
1882 m_pStatement->getOwnConnection()->throwSQLException( STR_CAN_NOT_CANCEL_ROW_UPDATE, *this );
1883 }
1884
1885 void SAL_CALL OResultSet::moveToInsertRow( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1886 {
1887 OSL_TRACE("moveToInsertRow in, m_nRowPos = %u", m_nRowPos );
1888 ResultSetEntryGuard aGuard( *this );
1889 m_nOldRowPos = m_nRowPos;
1890
1891 if (!m_nNewRow) //no new row now, insert one
1892 {
1893 checkDisposed(OResultSet_BASE::rBHelper.bDisposed);
1894 checkPendingUpdate();
1895 if (rowUpdated())
1896 {
1897 if (m_nRowPos && !pushCard(getCurrentCardNumber()))
1898 throw SQLException();
1899 }
1900 m_nNewRow = m_aQuery.createNewCard();
1901 if (!m_nNewRow)
1902 m_pStatement->getOwnConnection()->throwSQLException( STR_CAN_NOT_CREATE_ROW, *this );
1903
1904 m_RowStates = RowStates_Normal;
1905 fillKeySet(m_nNewRow);
1906 }
1907 else
1908 m_nUpdatedRow = 0;
1909
1910 m_nRowPos = static_cast<sal_uInt32>(m_pKeySet->get().size());
1911 fetchCurrentRow();
1912 OSL_TRACE("moveToInsertRow out, m_nRowPos = %u", m_nRowPos );
1913 }
1914
1915 void SAL_CALL OResultSet::moveToCurrentRow( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
1916 {
1917 ResultSetEntryGuard aGuard( *this );
1918 OSL_TRACE("moveToCurrentRow, m_nRowPos = %u", m_nRowPos );
1919 if (rowInserted())
1920 {
1921 m_nRowPos = m_nOldRowPos;
1922 fetchCurrentRow();
1923 }
1924 }
1925
1926 sal_Bool OResultSet::determineReadOnly()
1927 {
1928 if (m_bIsReadOnly == -1)
1929 {
1930 OConnection* xConnection = static_cast<OConnection*>(m_pStatement->getConnection().get());
1931 m_bIsReadOnly = !m_aQuery.isWritable(xConnection) || m_bIsAlwaysFalseQuery;
1932 }
1933
1934 return m_bIsReadOnly != 0;
1935 }
1936
1937 void OResultSet::setTable(OTable* _rTable)
1938 {
1939 OSL_TRACE("In : setTable");
1940 m_pTable = _rTable;
1941 m_pTable->acquire();
1942 m_xTableColumns = m_pTable->getColumns();
1943 if(m_xTableColumns.is())
1944 m_aColumnNames = m_xTableColumns->getElementNames();
1945 OSL_TRACE("Out : setTable");
1946 }
1947
1948 void OResultSet::setOrderByColumns(const ::std::vector<sal_Int32>& _aColumnOrderBy)
1949 {
1950 m_aOrderbyColumnNumber = _aColumnOrderBy;
1951 }
1952
1953 void OResultSet::setOrderByAscending(const ::std::vector<TAscendingOrder>& _aOrderbyAsc)
1954 {
1955 m_aOrderbyAscending = _aOrderbyAsc;
1956 }
1957 Sequence< sal_Int32 > SAL_CALL OResultSet::deleteRows( const Sequence< Any >& /*rows*/ ) throw(SQLException, RuntimeException)
1958 {
1959 ::dbtools::throwFeatureNotImplementedException( "XDeleteRows::deleteRows", *this );
1960 return Sequence< sal_Int32 >();
1961 };
1962
1963 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE