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