1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_ado.hxx"
26 #include <comphelper/sequence.hxx>
27 #include "ado/ADatabaseMetaDataResultSet.hxx"
28 #include "ado/ADatabaseMetaDataResultSetMetaData.hxx"
29 #include <com/sun/star/sdbc/DataType.hpp>
30 #include <com/sun/star/sdbc/ColumnValue.hpp>
31 #include <com/sun/star/sdbc/KeyRule.hpp>
32 #include <com/sun/star/sdbc/ProcedureResult.hpp>
33 #include <com/sun/star/sdbc/IndexType.hpp>
34 #include <comphelper/property.hxx>
35 #include <com/sun/star/lang/DisposedException.hpp>
36 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
37 #include <com/sun/star/sdbc/ResultSetType.hpp>
38 #include <com/sun/star/sdbc/FetchDirection.hpp>
39 #include <cppuhelper/typeprovider.hxx>
40 #include <comphelper/seqstream.hxx>
41 #include "connectivity/dbexception.hxx"
42
43
44 #include <oledb.h>
45
46 using namespace dbtools;
47 using namespace connectivity::ado;
48 using namespace cppu;
49 using namespace ::comphelper;
50 //------------------------------------------------------------------------------
51 using namespace ::com::sun::star::lang;
52 using namespace com::sun::star::uno;
53 using namespace com::sun::star::lang;
54 using namespace com::sun::star::beans;
55 using namespace com::sun::star::sdbc;
56
57 // -------------------------------------------------------------------------
ODatabaseMetaDataResultSet(ADORecordset * _pRecordSet)58 ODatabaseMetaDataResultSet::ODatabaseMetaDataResultSet(ADORecordset* _pRecordSet)
59 :ODatabaseMetaDataResultSet_BASE(m_aMutex)
60 ,OPropertySetHelper(ODatabaseMetaDataResultSet_BASE::rBHelper)
61 ,m_aStatement(NULL)
62 ,m_xMetaData(NULL)
63 ,m_pRecordSet(_pRecordSet)
64 ,m_bEOF(sal_False)
65 {
66 osl_incrementInterlockedCount( &m_refCount );
67 m_aColMapping.push_back(-1);
68 if(_pRecordSet)
69 {
70 m_pRecordSet->AddRef();
71 VARIANT_BOOL bIsAtBOF;
72 m_pRecordSet->get_BOF(&bIsAtBOF);
73 m_bOnFirstAfterOpen = bIsAtBOF != VARIANT_TRUE;
74 }
75 else
76 m_bOnFirstAfterOpen = sal_False;
77 osl_decrementInterlockedCount( &m_refCount );
78 // allocBuffer();
79 }
80
81 // -------------------------------------------------------------------------
~ODatabaseMetaDataResultSet()82 ODatabaseMetaDataResultSet::~ODatabaseMetaDataResultSet()
83 {
84 if(m_pRecordSet)
85 m_pRecordSet->Release();
86 }
87 // -------------------------------------------------------------------------
disposing(void)88 void ODatabaseMetaDataResultSet::disposing(void)
89 {
90 OPropertySetHelper::disposing();
91
92 ::osl::MutexGuard aGuard(m_aMutex);
93 if(m_pRecordSet)
94 m_pRecordSet->Close();
95 m_aStatement = NULL;
96 m_xMetaData.clear();
97 }
98 // -------------------------------------------------------------------------
queryInterface(const Type & rType)99 Any SAL_CALL ODatabaseMetaDataResultSet::queryInterface( const Type & rType )
100 {
101 Any aRet = OPropertySetHelper::queryInterface(rType);
102 return aRet.hasValue() ? aRet : ODatabaseMetaDataResultSet_BASE::queryInterface(rType);
103 }
104 // -------------------------------------------------------------------------
getTypes()105 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL ODatabaseMetaDataResultSet::getTypes( )
106 {
107 ::cppu::OTypeCollection aTypes( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XMultiPropertySet > *)0 ),
108 ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XFastPropertySet > *)0 ),
109 ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > *)0 ));
110
111 return ::comphelper::concatSequences(aTypes.getTypes(),ODatabaseMetaDataResultSet_BASE::getTypes());
112 }
113 // -----------------------------------------------------------------------------
checkRecordSet()114 void ODatabaseMetaDataResultSet::checkRecordSet()
115 {
116 if(!m_pRecordSet)
117 throwFunctionSequenceException(*this);
118 }
119 // -------------------------------------------------------------------------
120
findColumn(const::rtl::OUString & columnName)121 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::findColumn( const ::rtl::OUString& columnName )
122 {
123 ::osl::MutexGuard aGuard( m_aMutex );
124 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed );
125
126
127 Reference< XResultSetMetaData > xMeta = getMetaData();
128 sal_Int32 nLen = xMeta->getColumnCount();
129 sal_Int32 i = 1;
130 for(;i<=nLen;++i)
131 if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
132 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
133 break;
134 return i;
135 }
136 #define BLOCK_SIZE 256
137 // -------------------------------------------------------------------------
getBinaryStream(sal_Int32 columnIndex)138 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getBinaryStream( sal_Int32 columnIndex )
139 {
140 ::osl::MutexGuard aGuard( m_aMutex );
141 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
142
143 checkRecordSet();
144
145
146 columnIndex = mapColumn(columnIndex);
147 WpADOField aField = ADOS::getField(m_pRecordSet,columnIndex);
148 if((aField.GetAttributes() & adFldLong) == adFldLong)
149 {
150 //Copy the data only up to the Actual Size of Field.
151 sal_Int32 nSize = aField.GetActualSize();
152 Sequence<sal_Int8> aData(nSize);
153 long index = 0;
154 while(index < nSize)
155 {
156 m_aValue = aField.GetChunk(BLOCK_SIZE);
157 if(m_aValue.isNull())
158 break;
159 UCHAR chData;
160 for(long index2 = 0;index2 < BLOCK_SIZE;++index2)
161 {
162 HRESULT hr = ::SafeArrayGetElement(m_aValue.parray,&index2,&chData);
163 if(SUCCEEDED(hr))
164 {
165 //Take BYTE by BYTE and advance Memory Location
166 aData.getArray()[index++] = chData;
167 }
168 else
169 break;
170 }
171 }
172 return index ? Reference< ::com::sun::star::io::XInputStream >(new SequenceInputStream(aData)) : Reference< ::com::sun::star::io::XInputStream >();
173 }
174 // else we ask for a bytesequence
175 aField.get_Value(m_aValue);
176 if(m_aValue.isNull())
177 return NULL;
178 return new SequenceInputStream(m_aValue);
179 }
180 // -------------------------------------------------------------------------
getCharacterStream(sal_Int32)181 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ )
182 {
183 ::dbtools::throwFeatureNotImplementedException( "XRow::getCharacterStream", *this );
184 return NULL;
185 }
186
187 // -------------------------------------------------------------------------
getBoolean(sal_Int32 columnIndex)188 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::getBoolean( sal_Int32 columnIndex )
189 {
190 ::osl::MutexGuard aGuard( m_aMutex );
191
192 if ( !m_aValueRange.empty() && columnIndex == 11 && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end() )
193 {
194 getValue(2);
195 if ( static_cast<sal_Int16>(m_aValue) != adCurrency )
196 return sal_False;
197 }
198 return getValue(columnIndex);
199 }
200 // -------------------------------------------------------------------------
201
getByte(sal_Int32 columnIndex)202 sal_Int8 SAL_CALL ODatabaseMetaDataResultSet::getByte( sal_Int32 columnIndex )
203 {
204 ::osl::MutexGuard aGuard( m_aMutex );
205
206 getValue(columnIndex);
207
208 columnIndex = mapColumn(columnIndex);
209
210 if(m_aValue.isNull())
211 return 0;
212 if ( !m_aValueRange.empty() && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end())
213 return (sal_Int8)(*m_aValueRangeIter).second[(sal_Int32)m_aValue];
214 else if(m_aStrValueRange.size() && (m_aStrValueRangeIter = m_aStrValueRange.find(columnIndex)) != m_aStrValueRange.end())
215 return (sal_Int8)(*m_aStrValueRangeIter).second[m_aValue];
216
217 return m_aValue;
218 }
219 // -------------------------------------------------------------------------
220
getBytes(sal_Int32 columnIndex)221 Sequence< sal_Int8 > SAL_CALL ODatabaseMetaDataResultSet::getBytes( sal_Int32 columnIndex )
222 {
223 return getValue(columnIndex);
224 }
225 // -------------------------------------------------------------------------
226
getDate(sal_Int32 columnIndex)227 ::com::sun::star::util::Date SAL_CALL ODatabaseMetaDataResultSet::getDate( sal_Int32 columnIndex )
228 {
229 return getValue(columnIndex);
230 }
231 // -------------------------------------------------------------------------
232
getDouble(sal_Int32 columnIndex)233 double SAL_CALL ODatabaseMetaDataResultSet::getDouble( sal_Int32 columnIndex )
234 {
235 return getValue(columnIndex);
236 }
237 // -------------------------------------------------------------------------
238
getFloat(sal_Int32 columnIndex)239 float SAL_CALL ODatabaseMetaDataResultSet::getFloat( sal_Int32 columnIndex )
240 {
241 return getValue(columnIndex);
242 }
243 // -------------------------------------------------------------------------
244
getInt(sal_Int32 columnIndex)245 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getInt( sal_Int32 columnIndex )
246 {
247 ::osl::MutexGuard aGuard( m_aMutex );
248
249
250 getValue(columnIndex);
251
252 columnIndex = mapColumn(columnIndex);
253 if(m_aValue.isNull())
254 return 0;
255
256 if(m_aValueRange.size() && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end())
257 return (*m_aValueRangeIter).second[(sal_Int32)m_aValue];
258 else if(m_aStrValueRange.size() && (m_aStrValueRangeIter = m_aStrValueRange.find(columnIndex)) != m_aStrValueRange.end())
259 return (*m_aStrValueRangeIter).second[m_aValue];
260
261 return m_aValue;
262 }
263 // -------------------------------------------------------------------------
264
getRow()265 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getRow( )
266 {
267 ::dbtools::throwFeatureNotImplementedException( "XResultSet::getRow", *this );
268 return 0;
269 }
270 // -------------------------------------------------------------------------
271
getLong(sal_Int32)272 sal_Int64 SAL_CALL ODatabaseMetaDataResultSet::getLong( sal_Int32 /*columnIndex*/ )
273 {
274 ::dbtools::throwFeatureNotImplementedException( "XRow::getLong", *this );
275 return sal_Int64(0);
276 }
277 // -------------------------------------------------------------------------
278
getMetaData()279 Reference< XResultSetMetaData > SAL_CALL ODatabaseMetaDataResultSet::getMetaData( )
280 {
281 ::osl::MutexGuard aGuard( m_aMutex );
282 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
283
284 checkRecordSet();
285
286
287 if(!m_xMetaData.is())
288 m_xMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
289
290 return m_xMetaData;
291 }
292 // -------------------------------------------------------------------------
getArray(sal_Int32)293 Reference< XArray > SAL_CALL ODatabaseMetaDataResultSet::getArray( sal_Int32 /*columnIndex*/ )
294 {
295 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this );
296 return NULL;
297 }
298
299 // -------------------------------------------------------------------------
300
getClob(sal_Int32)301 Reference< XClob > SAL_CALL ODatabaseMetaDataResultSet::getClob( sal_Int32 /*columnIndex*/ )
302 {
303 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this );
304 return NULL;
305 }
306 // -------------------------------------------------------------------------
getBlob(sal_Int32)307 Reference< XBlob > SAL_CALL ODatabaseMetaDataResultSet::getBlob( sal_Int32 /*columnIndex*/ )
308 {
309 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this );
310 return NULL;
311 }
312 // -------------------------------------------------------------------------
313
getRef(sal_Int32)314 Reference< XRef > SAL_CALL ODatabaseMetaDataResultSet::getRef( sal_Int32 /*columnIndex*/ )
315 {
316 ::dbtools::throwFeatureNotImplementedException( "XRow::getRow", *this );
317 return NULL;
318 }
319 // -------------------------------------------------------------------------
320
getObject(sal_Int32 columnIndex,const Reference<::com::sun::star::container::XNameAccess> &)321 Any SAL_CALL ODatabaseMetaDataResultSet::getObject( sal_Int32 columnIndex, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ )
322 {
323 ::osl::MutexGuard aGuard( m_aMutex );
324 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
325
326 checkRecordSet();
327
328
329 columnIndex = mapColumn(columnIndex);
330 return Any();
331 }
332 // -------------------------------------------------------------------------
333
getShort(sal_Int32 columnIndex)334 sal_Int16 SAL_CALL ODatabaseMetaDataResultSet::getShort( sal_Int32 columnIndex )
335 {
336 ::osl::MutexGuard aGuard( m_aMutex );
337
338 getValue(columnIndex);
339
340 columnIndex = mapColumn(columnIndex);
341 if(m_aValue.isNull())
342 return 0;
343
344 if(m_aValueRange.size() && (m_aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end())
345 return (sal_Int16)(*m_aValueRangeIter).second[(sal_Int32)m_aValue];
346 else if(m_aStrValueRange.size() && (m_aStrValueRangeIter = m_aStrValueRange.find(columnIndex)) != m_aStrValueRange.end())
347 return (sal_Int16)(*m_aStrValueRangeIter).second[m_aValue];
348
349 return m_aValue;
350 }
351 // -------------------------------------------------------------------------
352
getString(sal_Int32 columnIndex)353 ::rtl::OUString SAL_CALL ODatabaseMetaDataResultSet::getString( sal_Int32 columnIndex )
354 {
355 ::osl::MutexGuard aGuard( m_aMutex );
356
357 getValue(columnIndex);
358
359
360 columnIndex = mapColumn(columnIndex);
361 if(m_aValue.isNull())
362 return ::rtl::OUString();
363 if(m_aIntValueRange.size() && (m_aIntValueRangeIter = m_aIntValueRange.find(columnIndex)) != m_aIntValueRange.end())
364 return (*m_aIntValueRangeIter).second[m_aValue];
365
366 return m_aValue;
367 }
368
369 // -------------------------------------------------------------------------
370
371
getTime(sal_Int32 columnIndex)372 ::com::sun::star::util::Time SAL_CALL ODatabaseMetaDataResultSet::getTime( sal_Int32 columnIndex )
373 {
374 return getValue(columnIndex);
375 }
376 // -------------------------------------------------------------------------
377
378
getTimestamp(sal_Int32 columnIndex)379 ::com::sun::star::util::DateTime SAL_CALL ODatabaseMetaDataResultSet::getTimestamp( sal_Int32 columnIndex )
380 {
381 return getValue(columnIndex);
382 }
383 // -------------------------------------------------------------------------
384
isAfterLast()385 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isAfterLast( )
386 {
387 ::osl::MutexGuard aGuard( m_aMutex );
388 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
389
390 checkRecordSet();
391
392
393 VARIANT_BOOL bIsAtEOF;
394 m_pRecordSet->get_EOF(&bIsAtEOF);
395 return bIsAtEOF == VARIANT_TRUE;
396 }
397 // -------------------------------------------------------------------------
isFirst()398 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isFirst( )
399 {
400 ::osl::MutexGuard aGuard( m_aMutex );
401 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
402
403 checkRecordSet();
404
405
406 return m_nRowPos == 1;
407 }
408 // -------------------------------------------------------------------------
isLast()409 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isLast( )
410 {
411 ::osl::MutexGuard aGuard( m_aMutex );
412 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
413
414 checkRecordSet();
415
416
417 return sal_True;
418 }
419 // -------------------------------------------------------------------------
beforeFirst()420 void SAL_CALL ODatabaseMetaDataResultSet::beforeFirst( )
421 {
422 ::osl::MutexGuard aGuard( m_aMutex );
423 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
424
425 checkRecordSet();
426
427
428 if(first())
429 previous();
430 }
431 // -------------------------------------------------------------------------
afterLast()432 void SAL_CALL ODatabaseMetaDataResultSet::afterLast( )
433 {
434 ::osl::MutexGuard aGuard( m_aMutex );
435 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
436
437 checkRecordSet();
438
439
440 if(last())
441 next();
442 m_bEOF = sal_True;
443 }
444 // -------------------------------------------------------------------------
445
close()446 void SAL_CALL ODatabaseMetaDataResultSet::close( )
447 {
448 {
449 ::osl::MutexGuard aGuard( m_aMutex );
450 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
451
452 }
453 dispose();
454 }
455 // -------------------------------------------------------------------------
456
first()457 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::first( )
458 {
459 ::osl::MutexGuard aGuard( m_aMutex );
460 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
461
462
463 if(!m_pRecordSet)
464 return sal_False;
465
466 sal_Bool bRet = SUCCEEDED(m_pRecordSet->MoveFirst());
467 if ( bRet )
468 m_nRowPos = 1;
469 return bRet;
470 }
471 // -------------------------------------------------------------------------
472
last()473 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::last( )
474 {
475 ::osl::MutexGuard aGuard( m_aMutex );
476 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed );
477
478
479 return m_pRecordSet && SUCCEEDED(m_pRecordSet->MoveLast()) ? sal_True : sal_False;
480 }
481 // -------------------------------------------------------------------------
absolute(sal_Int32 row)482 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::absolute( sal_Int32 row )
483 {
484 ::osl::MutexGuard aGuard( m_aMutex );
485 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
486
487
488 if(first())
489 {
490 OLEVariant aEmpty;
491 aEmpty.setNoArg();
492 sal_Bool bRet = SUCCEEDED(m_pRecordSet->Move(row,aEmpty));
493 if(bRet)
494 m_nRowPos = row;
495 return bRet;
496 }
497 return sal_False;
498 }
499 // -------------------------------------------------------------------------
relative(sal_Int32 row)500 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::relative( sal_Int32 row )
501 {
502 ::osl::MutexGuard aGuard( m_aMutex );
503 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
504
505
506 if(!m_pRecordSet)
507 return sal_False;
508
509 OLEVariant aEmpty;
510 aEmpty.setNoArg();
511 sal_Bool bRet = SUCCEEDED(m_pRecordSet->Move(row,aEmpty));
512 if(bRet)
513 m_nRowPos += row;
514 return bRet;
515 }
516 // -------------------------------------------------------------------------
previous()517 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::previous( )
518 {
519 ::osl::MutexGuard aGuard( m_aMutex );
520 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
521
522
523 if(!m_pRecordSet)
524 return sal_False;
525
526 sal_Bool bRet = SUCCEEDED(m_pRecordSet->MovePrevious());
527 if(bRet)
528 --m_nRowPos;
529 return bRet;
530 }
531 // -------------------------------------------------------------------------
getStatement()532 Reference< XInterface > SAL_CALL ODatabaseMetaDataResultSet::getStatement( )
533 {
534 return m_aStatement.get();
535 }
536 // -------------------------------------------------------------------------
537
rowDeleted()538 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowDeleted( )
539 {
540 ::osl::MutexGuard aGuard( m_aMutex );
541 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
542
543 checkRecordSet();
544
545
546 RecordStatusEnum eRec;
547 m_pRecordSet->get_Status((sal_Int32*)&eRec);
548 return (eRec & adRecDeleted) == adRecDeleted;
549 }
550 // -------------------------------------------------------------------------
rowInserted()551 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowInserted( )
552 { ::osl::MutexGuard aGuard( m_aMutex );
553 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
554
555 checkRecordSet();
556
557
558 RecordStatusEnum eRec;
559 m_pRecordSet->get_Status((sal_Int32*)&eRec);
560 return (eRec & adRecNew) == adRecNew;
561 }
562 // -------------------------------------------------------------------------
rowUpdated()563 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowUpdated( )
564 {
565 ::osl::MutexGuard aGuard( m_aMutex );
566 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
567
568 checkRecordSet();
569
570
571 RecordStatusEnum eRec;
572 m_pRecordSet->get_Status((sal_Int32*)&eRec);
573 return (eRec & adRecModified) == adRecModified;
574 }
575 // -------------------------------------------------------------------------
576
isBeforeFirst()577 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isBeforeFirst( )
578 {
579 ::osl::MutexGuard aGuard( m_aMutex );
580 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
581
582
583 if(!m_pRecordSet)
584 return sal_True;
585
586 VARIANT_BOOL bIsAtBOF;
587 m_pRecordSet->get_BOF(&bIsAtBOF);
588 return bIsAtBOF == VARIANT_TRUE;
589 }
590 // -------------------------------------------------------------------------
591
next()592 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::next( )
593 {
594 ::osl::MutexGuard aGuard( m_aMutex );
595 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
596
597
598 if(!m_pRecordSet)
599 return sal_False;
600
601 if(m_bOnFirstAfterOpen)
602 {
603 m_bOnFirstAfterOpen = sal_False;
604 return sal_True;
605 }
606 else
607 return SUCCEEDED(m_pRecordSet->MoveNext());
608 }
609 // -------------------------------------------------------------------------
610
wasNull()611 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::wasNull( )
612 {
613 ::osl::MutexGuard aGuard( m_aMutex );
614 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
615
616 checkRecordSet();
617
618
619 return m_aValue.isNull();
620 }
621 // -------------------------------------------------------------------------
refreshRow()622 void SAL_CALL ODatabaseMetaDataResultSet::refreshRow( )
623 {
624 ::osl::MutexGuard aGuard( m_aMutex );
625 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
626
627 checkRecordSet();
628
629
630 m_pRecordSet->Resync(adAffectCurrent,adResyncAllValues);
631 }
632 // -------------------------------------------------------------------------
633
cancel()634 void SAL_CALL ODatabaseMetaDataResultSet::cancel( )
635 {
636 ::osl::MutexGuard aGuard( m_aMutex );
637 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
638
639 checkRecordSet();
640
641
642 m_pRecordSet->Cancel();
643 }
644 // -------------------------------------------------------------------------
clearWarnings()645 void SAL_CALL ODatabaseMetaDataResultSet::clearWarnings( )
646 {
647 }
648 // -------------------------------------------------------------------------
getWarnings()649 Any SAL_CALL ODatabaseMetaDataResultSet::getWarnings( )
650 {
651 return Any();
652 }
653 //------------------------------------------------------------------------------
getResultSetConcurrency() const654 sal_Int32 ODatabaseMetaDataResultSet::getResultSetConcurrency() const
655 {
656 return ResultSetConcurrency::READ_ONLY;
657 }
658 //------------------------------------------------------------------------------
getResultSetType() const659 sal_Int32 ODatabaseMetaDataResultSet::getResultSetType() const
660 {
661 return ResultSetType::FORWARD_ONLY;
662 }
663 //------------------------------------------------------------------------------
getFetchDirection() const664 sal_Int32 ODatabaseMetaDataResultSet::getFetchDirection() const
665 {
666 return FetchDirection::FORWARD;
667 }
668 //------------------------------------------------------------------------------
getFetchSize() const669 sal_Int32 ODatabaseMetaDataResultSet::getFetchSize() const
670 {
671 sal_Int32 nValue=-1;
672 if(m_pRecordSet)
673 m_pRecordSet->get_CacheSize(&nValue);
674 return nValue;
675 }
676 //------------------------------------------------------------------------------
getCursorName() const677 ::rtl::OUString ODatabaseMetaDataResultSet::getCursorName() const
678 {
679 return ::rtl::OUString();
680 }
681
682 //------------------------------------------------------------------------------
setFetchDirection(sal_Int32)683 void ODatabaseMetaDataResultSet::setFetchDirection(sal_Int32 /*_par0*/)
684 {
685 ::dbtools::throwFeatureNotImplementedException( "ResultSet::FetchDirection", *this );
686 }
687 //------------------------------------------------------------------------------
setFetchSize(sal_Int32 _par0)688 void ODatabaseMetaDataResultSet::setFetchSize(sal_Int32 _par0)
689 {
690 if(m_pRecordSet)
691 m_pRecordSet->put_CacheSize(_par0);
692 }
693 // -------------------------------------------------------------------------
createArrayHelper() const694 ::cppu::IPropertyArrayHelper* ODatabaseMetaDataResultSet::createArrayHelper( ) const
695 {
696
697 Sequence< com::sun::star::beans::Property > aProps(5);
698 com::sun::star::beans::Property* pProperties = aProps.getArray();
699 sal_Int32 nPos = 0;
700 DECL_PROP0(CURSORNAME, ::rtl::OUString);
701 DECL_PROP0(FETCHDIRECTION, sal_Int32);
702 DECL_PROP0(FETCHSIZE, sal_Int32);
703 DECL_PROP0(RESULTSETCONCURRENCY,sal_Int32);
704 DECL_PROP0(RESULTSETTYPE, sal_Int32);
705
706 return new ::cppu::OPropertyArrayHelper(aProps);
707 }
708 // -------------------------------------------------------------------------
getInfoHelper()709 ::cppu::IPropertyArrayHelper & ODatabaseMetaDataResultSet::getInfoHelper()
710 {
711 return *const_cast<ODatabaseMetaDataResultSet*>(this)->getArrayHelper();
712 }
713 // -------------------------------------------------------------------------
convertFastPropertyValue(Any & rConvertedValue,Any & rOldValue,sal_Int32 nHandle,const Any & rValue)714 sal_Bool ODatabaseMetaDataResultSet::convertFastPropertyValue(
715 Any & rConvertedValue,
716 Any & rOldValue,
717 sal_Int32 nHandle,
718 const Any& rValue )
719 {
720 switch(nHandle)
721 {
722 case PROPERTY_ID_CURSORNAME:
723 case PROPERTY_ID_RESULTSETCONCURRENCY:
724 case PROPERTY_ID_RESULTSETTYPE:
725 throw ::com::sun::star::lang::IllegalArgumentException();
726 break;
727 case PROPERTY_ID_FETCHDIRECTION:
728 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
729 case PROPERTY_ID_FETCHSIZE:
730 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
731 default:
732 ;
733 }
734 return sal_False;
735 }
736 // -------------------------------------------------------------------------
setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any &)737 void ODatabaseMetaDataResultSet::setFastPropertyValue_NoBroadcast(
738 sal_Int32 nHandle,
739 const Any& /*rValue*/
740 )
741 {
742 switch(nHandle)
743 {
744 case PROPERTY_ID_CURSORNAME:
745 case PROPERTY_ID_RESULTSETCONCURRENCY:
746 case PROPERTY_ID_RESULTSETTYPE:
747 case PROPERTY_ID_FETCHDIRECTION:
748 case PROPERTY_ID_FETCHSIZE:
749 throw Exception();
750 break;
751 default:
752 OSL_ENSURE(0,"setFastPropertyValue_NoBroadcast: Illegal handle value!");
753 }
754 }
755 // -------------------------------------------------------------------------
getFastPropertyValue(Any & rValue,sal_Int32 nHandle) const756 void ODatabaseMetaDataResultSet::getFastPropertyValue(
757 Any& rValue,
758 sal_Int32 nHandle
759 ) const
760 {
761 switch(nHandle)
762 {
763 case PROPERTY_ID_CURSORNAME:
764 rValue <<= getCursorName();
765 break;
766 case PROPERTY_ID_RESULTSETCONCURRENCY:
767 rValue <<= getResultSetConcurrency();
768 break;
769 case PROPERTY_ID_RESULTSETTYPE:
770 rValue <<= getResultSetType();
771 break;
772 case PROPERTY_ID_FETCHDIRECTION:
773 rValue <<= getFetchDirection();
774 break;
775 case PROPERTY_ID_FETCHSIZE:
776 rValue <<= getFetchSize();
777 break;
778 }
779 }
780 // -------------------------------------------------------------------------
setProceduresMap()781 void ODatabaseMetaDataResultSet::setProceduresMap()
782 {
783
784 for(sal_Int32 i=1;i<4;i++)
785 m_aColMapping.push_back(i);
786 m_aColMapping.push_back(5);
787 m_aColMapping.push_back(7);
788 m_aColMapping.push_back(8);
789 m_aColMapping.push_back(6);
790 m_aColMapping.push_back(4);
791
792 TInt2IntMap aMap;
793 aMap[DB_PT_UNKNOWN] = ProcedureResult::UNKNOWN;
794 aMap[DB_PT_PROCEDURE] = ProcedureResult::NONE;
795 aMap[DB_PT_FUNCTION] = ProcedureResult::RETURN;
796 m_aValueRange[4] = aMap;
797
798 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
799 pMetaData->setProceduresMap();
800 m_xMetaData = pMetaData;
801 }
802 // -------------------------------------------------------------------------
setCatalogsMap()803 void ODatabaseMetaDataResultSet::setCatalogsMap()
804 {
805 m_aColMapping.push_back(1);
806
807 m_xMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
808 }
809 // -------------------------------------------------------------------------
setSchemasMap()810 void ODatabaseMetaDataResultSet::setSchemasMap()
811 {
812 m_aColMapping.push_back(2);
813
814 m_xMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
815 }
816 // -------------------------------------------------------------------------
setColumnPrivilegesMap()817 void ODatabaseMetaDataResultSet::setColumnPrivilegesMap()
818 {
819
820 m_aColMapping.push_back(3);
821 m_aColMapping.push_back(4);
822 m_aColMapping.push_back(5);
823 m_aColMapping.push_back(6);
824 m_aColMapping.push_back(2);
825 m_aColMapping.push_back(9);
826 m_aColMapping.push_back(10);
827
828 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
829 pMetaData->setColumnPrivilegesMap();
830 m_xMetaData = pMetaData;
831 }
832 // -------------------------------------------------------------------------
setColumnsMap()833 void ODatabaseMetaDataResultSet::setColumnsMap()
834 {
835
836 for(sal_Int32 i=1;i<5;++i)
837 m_aColMapping.push_back(i);
838
839 m_aColMapping.push_back(12);
840 m_aColMapping.push_back(12); // is used as TYPE_NAME
841
842 m_aColMapping.push_back(14);
843 m_aColMapping.push_back(6);
844 m_aColMapping.push_back(17);
845 m_aColMapping.push_back(18);
846
847 m_aColMapping.push_back(11);
848 m_aColMapping.push_back(29);
849 m_aColMapping.push_back(9);
850 m_aColMapping.push_back(18);
851 m_aColMapping.push_back(18);
852
853 m_aColMapping.push_back(15);
854 m_aColMapping.push_back(7);
855 m_aColMapping.push_back(11);
856
857 TInt2IntMap aMap;
858 aMap[adEmpty] = ADOS::MapADOType2Jdbc(adEmpty);
859 aMap[adTinyInt] = ADOS::MapADOType2Jdbc(adTinyInt);
860 aMap[adSmallInt] = ADOS::MapADOType2Jdbc(adSmallInt);
861 aMap[adInteger] = ADOS::MapADOType2Jdbc(adInteger);
862 aMap[adBigInt] = ADOS::MapADOType2Jdbc(adBigInt);
863 aMap[adUnsignedTinyInt] = ADOS::MapADOType2Jdbc(adUnsignedTinyInt);
864 aMap[adUnsignedSmallInt]= ADOS::MapADOType2Jdbc(adUnsignedSmallInt);
865 aMap[adUnsignedInt] = ADOS::MapADOType2Jdbc(adUnsignedInt);
866 aMap[adUnsignedBigInt] = ADOS::MapADOType2Jdbc(adUnsignedBigInt);
867 aMap[adSingle] = ADOS::MapADOType2Jdbc(adSingle);
868 aMap[adDouble] = ADOS::MapADOType2Jdbc(adDouble);
869 aMap[adCurrency] = ADOS::MapADOType2Jdbc(adCurrency);
870 aMap[adDecimal] = ADOS::MapADOType2Jdbc(adDecimal);
871 aMap[adNumeric] = ADOS::MapADOType2Jdbc(adNumeric);
872 aMap[adBoolean] = ADOS::MapADOType2Jdbc(adBoolean);
873 aMap[adError] = ADOS::MapADOType2Jdbc(adError);
874 aMap[adUserDefined] = ADOS::MapADOType2Jdbc(adUserDefined);
875 aMap[adVariant] = ADOS::MapADOType2Jdbc(adVariant);
876 aMap[adIDispatch] = ADOS::MapADOType2Jdbc(adIDispatch);
877 aMap[adIUnknown] = ADOS::MapADOType2Jdbc(adIUnknown);
878 aMap[adGUID] = ADOS::MapADOType2Jdbc(adGUID);
879 aMap[adDate] = ADOS::MapADOType2Jdbc(adDate);
880 aMap[adDBDate] = ADOS::MapADOType2Jdbc(adDBDate);
881 aMap[adDBTime] = ADOS::MapADOType2Jdbc(adDBTime);
882 aMap[adDBTimeStamp] = ADOS::MapADOType2Jdbc(adDBTimeStamp);
883 aMap[adBSTR] = ADOS::MapADOType2Jdbc(adBSTR);
884 aMap[adChar] = ADOS::MapADOType2Jdbc(adChar);
885 aMap[adVarChar] = ADOS::MapADOType2Jdbc(adVarChar);
886 aMap[adLongVarChar] = ADOS::MapADOType2Jdbc(adLongVarChar);
887 aMap[adWChar] = ADOS::MapADOType2Jdbc(adWChar);
888 aMap[adVarWChar] = ADOS::MapADOType2Jdbc(adVarWChar);
889 aMap[adLongVarWChar] = ADOS::MapADOType2Jdbc(adLongVarWChar);
890 aMap[adBinary] = ADOS::MapADOType2Jdbc(adBinary);
891 aMap[adVarBinary] = ADOS::MapADOType2Jdbc(adVarBinary);
892 aMap[adLongVarBinary] = ADOS::MapADOType2Jdbc(adLongVarBinary);
893 aMap[adChapter] = ADOS::MapADOType2Jdbc(adChapter);
894 aMap[adFileTime] = ADOS::MapADOType2Jdbc(adFileTime);
895 aMap[adPropVariant] = ADOS::MapADOType2Jdbc(adPropVariant);
896 aMap[adVarNumeric] = ADOS::MapADOType2Jdbc(adVarNumeric);
897 // aMap[adArray] = ADOS::MapADOType2Jdbc(adArray);
898
899 m_aValueRange[12] = aMap;
900
901 ::std::map< sal_Int32,::rtl::OUString> aMap2;
902 aMap2[0] = ::rtl::OUString::createFromAscii("YES");
903 aMap2[1] = ::rtl::OUString::createFromAscii("NO");
904 m_aIntValueRange[18] = aMap2;
905
906 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
907 pMetaData->setColumnsMap();
908 m_xMetaData = pMetaData;
909 }
910 // -------------------------------------------------------------------------
setTablesMap()911 void ODatabaseMetaDataResultSet::setTablesMap()
912 {
913
914 for(sal_Int32 i=1;i<5;i++)
915 m_aColMapping.push_back(i);
916 m_aColMapping.push_back(6);
917
918 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
919 pMetaData->setTablesMap();
920 m_xMetaData = pMetaData;
921 }
922 // -------------------------------------------------------------------------
setProcedureColumnsMap()923 void ODatabaseMetaDataResultSet::setProcedureColumnsMap()
924 {
925
926 for(sal_Int32 i=1;i<5;i++)
927 m_aColMapping.push_back(i);
928 m_aColMapping.push_back(6);
929 m_aColMapping.push_back(10);
930 m_aColMapping.push_back(16);
931 m_aColMapping.push_back(13);
932 m_aColMapping.push_back(11);
933 m_aColMapping.push_back(12);
934
935 m_aColMapping.push_back(9);
936 m_aColMapping.push_back(14);
937
938 TInt2IntMap aMap;
939 aMap[DBTYPE_EMPTY] = DataType::SQLNULL;
940 aMap[DBTYPE_NULL] = DataType::SQLNULL;
941 aMap[DBTYPE_I2] = DataType::SMALLINT;
942 aMap[DBTYPE_I4] = DataType::INTEGER;
943 aMap[DBTYPE_R4] = DataType::FLOAT;
944 aMap[DBTYPE_R8] = DataType::DOUBLE;
945 aMap[DBTYPE_CY] = DataType::BIGINT;
946 aMap[DBTYPE_DATE] = DataType::DATE;
947 aMap[DBTYPE_BSTR] = DataType::VARCHAR;
948 aMap[DBTYPE_IDISPATCH] = DataType::OBJECT;
949 aMap[DBTYPE_ERROR] = DataType::OTHER;
950 aMap[DBTYPE_BOOL] = DataType::BIT;
951 aMap[DBTYPE_VARIANT] = DataType::STRUCT;
952 aMap[DBTYPE_IUNKNOWN] = DataType::OTHER;
953 aMap[DBTYPE_DECIMAL] = DataType::DECIMAL;
954 aMap[DBTYPE_UI1] = DataType::TINYINT;
955 aMap[DBTYPE_ARRAY] = DataType::ARRAY;
956 aMap[DBTYPE_BYREF] = DataType::REF;
957 aMap[DBTYPE_I1] = DataType::CHAR;
958 aMap[DBTYPE_UI2] = DataType::SMALLINT;
959 aMap[DBTYPE_UI4] = DataType::INTEGER;
960
961 // aMap[The] = ;
962 // aMap[in] = ;
963 aMap[DBTYPE_I8] = DataType::BIGINT;
964 aMap[DBTYPE_UI8] = DataType::BIGINT;
965 aMap[DBTYPE_GUID] = DataType::OTHER;
966 aMap[DBTYPE_VECTOR] = DataType::OTHER;
967 aMap[DBTYPE_FILETIME] = DataType::OTHER;
968 aMap[DBTYPE_RESERVED] = DataType::OTHER;
969
970 // aMap[The] = ;
971 aMap[DBTYPE_BYTES] = DataType::VARBINARY;
972 aMap[DBTYPE_STR] = DataType::LONGVARCHAR;
973 aMap[DBTYPE_WSTR] = DataType::LONGVARCHAR;
974 aMap[DBTYPE_NUMERIC] = DataType::NUMERIC;
975 aMap[DBTYPE_UDT] = DataType::OTHER;
976 aMap[DBTYPE_DBDATE] = DataType::DATE;
977 aMap[DBTYPE_DBTIME] = DataType::TIME;
978 aMap[DBTYPE_DBTIMESTAMP] = DataType::TIMESTAMP;
979 aMap[DBTYPE_HCHAPTER] = DataType::OTHER;
980 aMap[DBTYPE_PROPVARIANT] = DataType::OTHER;
981 aMap[DBTYPE_VARNUMERIC] = DataType::NUMERIC;
982
983 m_aValueRange[10] = aMap;
984
985 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
986 pMetaData->setProcedureColumnsMap();
987 m_xMetaData = pMetaData;
988 }
989 // -------------------------------------------------------------------------
setPrimaryKeysMap()990 void ODatabaseMetaDataResultSet::setPrimaryKeysMap()
991 {
992
993 sal_Int32 i=1;
994 for(;i<5;i++)
995 m_aColMapping.push_back(i);
996 m_aColMapping.push_back(7);
997 m_aColMapping.push_back(8);
998
999 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
1000 pMetaData->setProcedureColumnsMap();
1001 m_xMetaData = pMetaData;
1002 }
1003 // -------------------------------------------------------------------------
setIndexInfoMap()1004 void ODatabaseMetaDataResultSet::setIndexInfoMap()
1005 {
1006
1007 sal_Int32 i=1;
1008 for(;i<4;i++)
1009 m_aColMapping.push_back(i);
1010 m_aColMapping.push_back(8);
1011 m_aColMapping.push_back(4);
1012 m_aColMapping.push_back(6);
1013 m_aColMapping.push_back(10);
1014 m_aColMapping.push_back(17);
1015 m_aColMapping.push_back(18);
1016 m_aColMapping.push_back(21);
1017 m_aColMapping.push_back(22);
1018 m_aColMapping.push_back(23);
1019 m_aColMapping.push_back(24);
1020
1021 TInt2IntMap aMap;
1022 aMap[DBPROPVAL_IT_HASH] = IndexType::HASHED;
1023 aMap[DBPROPVAL_IT_CONTENT] = IndexType::OTHER;
1024 aMap[DBPROPVAL_IT_OTHER] = IndexType::OTHER;
1025 aMap[DBPROPVAL_IT_BTREE] = IndexType::OTHER;
1026
1027 m_aValueRange[10] = aMap;
1028
1029 TInt2IntMap aMap2;
1030 aMap[0] = 1;
1031 aMap[1] = 0;
1032 m_aValueRange[8] = aMap2;
1033
1034 ::std::map< sal_Int32,::rtl::OUString> aMap3;
1035 aMap3[0] = ::rtl::OUString();
1036 aMap3[DB_COLLATION_ASC] = ::rtl::OUString::createFromAscii("A");
1037 aMap3[DB_COLLATION_DESC] = ::rtl::OUString::createFromAscii("D");
1038
1039 m_aIntValueRange[21] = aMap3;
1040
1041 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
1042 pMetaData->setIndexInfoMap();
1043 m_xMetaData = pMetaData;
1044 }
1045 // -------------------------------------------------------------------------
setTablePrivilegesMap()1046 void ODatabaseMetaDataResultSet::setTablePrivilegesMap()
1047 {
1048
1049 sal_Int32 i=3;
1050 for(;i<6;i++)
1051 m_aColMapping.push_back(i);
1052 m_aColMapping.push_back(1);
1053 m_aColMapping.push_back(2);
1054 m_aColMapping.push_back(6);
1055 m_aColMapping.push_back(7);
1056
1057 ::std::map< sal_Int32,::rtl::OUString> aMap;
1058 aMap[0] = ::rtl::OUString::createFromAscii("YES");
1059 aMap[1] = ::rtl::OUString::createFromAscii("NO");
1060 m_aIntValueRange[7] = aMap;
1061
1062
1063 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
1064 pMetaData->setTablePrivilegesMap();
1065 m_xMetaData = pMetaData;
1066 }
1067 // -------------------------------------------------------------------------
setCrossReferenceMap()1068 void ODatabaseMetaDataResultSet::setCrossReferenceMap()
1069 {
1070
1071 sal_Int32 i=1;
1072 for(;i<5;i++)
1073 m_aColMapping.push_back(i);
1074 for(i=7;i<11;i++)
1075 m_aColMapping.push_back(i);
1076
1077 m_aColMapping.push_back(13);
1078 m_aColMapping.push_back(14);
1079 m_aColMapping.push_back(15);
1080 m_aColMapping.push_back(17);
1081 m_aColMapping.push_back(16);
1082 m_aColMapping.push_back(18);
1083
1084 ::std::map< ::rtl::OUString,sal_Int32> aMap;
1085 aMap[ ::rtl::OUString::createFromAscii("CASCADE")] = KeyRule::CASCADE;
1086 aMap[ ::rtl::OUString::createFromAscii("RESTRICT")] = KeyRule::RESTRICT;
1087 aMap[ ::rtl::OUString::createFromAscii("SET NULL")] = KeyRule::SET_NULL;
1088 aMap[ ::rtl::OUString::createFromAscii("SET DEFAULT")] = KeyRule::SET_DEFAULT;
1089 aMap[ ::rtl::OUString::createFromAscii("NO ACTION")] = KeyRule::NO_ACTION;
1090
1091 m_aStrValueRange[14] = aMap;
1092 m_aStrValueRange[15] = aMap;
1093
1094 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
1095 pMetaData->setCrossReferenceMap();
1096 m_xMetaData = pMetaData;
1097 }
1098 // -------------------------------------------------------------------------
setTypeInfoMap(sal_Bool _bJetEngine)1099 void ODatabaseMetaDataResultSet::setTypeInfoMap(sal_Bool _bJetEngine)
1100 {
1101 sal_Int32 i=1;
1102 for(;i<19;i++)
1103 m_aColMapping.push_back(i);
1104
1105 ::std::map< ::rtl::OUString,sal_Int32> aMap1;
1106 aMap1[ ::rtl::OUString()] = 10;
1107
1108 m_aStrValueRange[18] = aMap1;
1109
1110 TInt2IntMap aMap;
1111 aMap[adEmpty] = ADOS::MapADOType2Jdbc(adEmpty);
1112 aMap[adTinyInt] = ADOS::MapADOType2Jdbc(adTinyInt);
1113 aMap[adSmallInt] = ADOS::MapADOType2Jdbc(adSmallInt);
1114 aMap[adInteger] = ADOS::MapADOType2Jdbc(adInteger);
1115 aMap[adBigInt] = ADOS::MapADOType2Jdbc(adBigInt);
1116 aMap[adUnsignedTinyInt] = ADOS::MapADOType2Jdbc(adUnsignedTinyInt);
1117 aMap[adUnsignedSmallInt]= ADOS::MapADOType2Jdbc(adUnsignedSmallInt);
1118 aMap[adUnsignedInt] = ADOS::MapADOType2Jdbc(adUnsignedInt);
1119 aMap[adUnsignedBigInt] = ADOS::MapADOType2Jdbc(adUnsignedBigInt);
1120 aMap[adSingle] = ADOS::MapADOType2Jdbc(adSingle);
1121 aMap[adDouble] = ADOS::MapADOType2Jdbc(adDouble);
1122 aMap[adCurrency] = ADOS::MapADOType2Jdbc(adCurrency);
1123 aMap[adDecimal] = ADOS::MapADOType2Jdbc(adDecimal);
1124 aMap[adNumeric] = ADOS::MapADOType2Jdbc(adNumeric);
1125 aMap[adBoolean] = ADOS::MapADOType2Jdbc(adBoolean);
1126 aMap[adError] = ADOS::MapADOType2Jdbc(adError);
1127 aMap[adUserDefined] = ADOS::MapADOType2Jdbc(adUserDefined);
1128 aMap[adVariant] = ADOS::MapADOType2Jdbc(adVariant);
1129 aMap[adIDispatch] = ADOS::MapADOType2Jdbc(adIDispatch);
1130 aMap[adIUnknown] = ADOS::MapADOType2Jdbc(adIUnknown);
1131 aMap[adGUID] = ADOS::MapADOType2Jdbc(adGUID);
1132 aMap[adDate] = _bJetEngine ? ADOS::MapADOType2Jdbc(adDBTimeStamp) : ADOS::MapADOType2Jdbc(adDate);
1133 aMap[adDBDate] = ADOS::MapADOType2Jdbc(adDBDate);
1134 aMap[adDBTime] = ADOS::MapADOType2Jdbc(adDBTime);
1135 aMap[adDBTimeStamp] = ADOS::MapADOType2Jdbc(adDBTimeStamp);
1136 aMap[adBSTR] = ADOS::MapADOType2Jdbc(adBSTR);
1137 aMap[adChar] = ADOS::MapADOType2Jdbc(adChar);
1138 aMap[adVarChar] = ADOS::MapADOType2Jdbc(adVarChar);
1139 aMap[adLongVarChar] = ADOS::MapADOType2Jdbc(adLongVarChar);
1140 aMap[adWChar] = ADOS::MapADOType2Jdbc(adWChar);
1141 aMap[adVarWChar] = ADOS::MapADOType2Jdbc(adVarWChar);
1142 aMap[adLongVarWChar] = ADOS::MapADOType2Jdbc(adLongVarWChar);
1143 aMap[adBinary] = ADOS::MapADOType2Jdbc(adBinary);
1144 aMap[adVarBinary] = ADOS::MapADOType2Jdbc(adVarBinary);
1145 aMap[adLongVarBinary] = ADOS::MapADOType2Jdbc(adLongVarBinary);
1146 aMap[adChapter] = ADOS::MapADOType2Jdbc(adChapter);
1147 aMap[adFileTime] = ADOS::MapADOType2Jdbc(adFileTime);
1148 aMap[adPropVariant] = ADOS::MapADOType2Jdbc(adPropVariant);
1149 aMap[adVarNumeric] = ADOS::MapADOType2Jdbc(adVarNumeric);
1150 // aMap[adArray] = ADOS::MapADOType2Jdbc(adArray);
1151
1152 m_aValueRange[2] = aMap;
1153
1154 TInt2IntMap aColumnValueMapping;
1155 aColumnValueMapping[VARIANT_FALSE] = ColumnValue::NO_NULLS;
1156 aColumnValueMapping[VARIANT_TRUE] = ColumnValue::NULLABLE;
1157 m_aValueRange[7] = aColumnValueMapping;
1158
1159 // now adjust the column mapping
1160 // OJ 24.01.2002 96860
1161 TInt2IntMap aSerachMapping;
1162 aSerachMapping[DB_UNSEARCHABLE] = ColumnSearch::NONE;
1163 aSerachMapping[DB_LIKE_ONLY] = ColumnSearch::CHAR;
1164 aSerachMapping[DB_ALL_EXCEPT_LIKE] = ColumnSearch::BASIC;
1165 aSerachMapping[DB_SEARCHABLE] = ColumnSearch::FULL;
1166
1167 m_aValueRange[9] = aSerachMapping;
1168
1169 TInt2IntMap aCurrencyMapping;
1170 m_aValueRange[11] = aCurrencyMapping;
1171
1172 ODatabaseMetaDataResultSetMetaData* pMetaData = new ODatabaseMetaDataResultSetMetaData(m_pRecordSet,this);
1173 pMetaData->setTypeInfoMap();
1174 m_xMetaData = pMetaData;
1175 }
1176 // -----------------------------------------------------------------------------
acquire()1177 void SAL_CALL ODatabaseMetaDataResultSet::acquire() throw()
1178 {
1179 ODatabaseMetaDataResultSet_BASE::acquire();
1180 }
1181 // -----------------------------------------------------------------------------
release()1182 void SAL_CALL ODatabaseMetaDataResultSet::release() throw()
1183 {
1184 ODatabaseMetaDataResultSet_BASE::release();
1185 }
1186 // -----------------------------------------------------------------------------
getPropertySetInfo()1187 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL ODatabaseMetaDataResultSet::getPropertySetInfo( )
1188 {
1189 return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
1190 }
1191 // -----------------------------------------------------------------------------
getValue(sal_Int32 columnIndex)1192 OLEVariant ODatabaseMetaDataResultSet::getValue(sal_Int32 columnIndex )
1193 {
1194 ::osl::MutexGuard aGuard( m_aMutex );
1195 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
1196
1197 checkRecordSet();
1198
1199 WpADOField aField = ADOS::getField(m_pRecordSet,columnIndex);
1200 aField.get_Value(m_aValue);
1201 return m_aValue;
1202 }
1203 // -----------------------------------------------------------------------------
1204