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