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_odbcbase.hxx"
26 #include "TConnection.hxx"
27
28 #ifndef _CONNECTIVITY_ADO_ADATABASEMETADATARESULTSET_HXX_
29 #include "odbc/ODatabaseMetaDataResultSet.hxx"
30 #endif
31 #include <com/sun/star/sdbc/DataType.hpp>
32 #include <com/sun/star/sdbc/KeyRule.hpp>
33 #include <com/sun/star/sdbc/ProcedureResult.hpp>
34 #include <com/sun/star/sdbc/IndexType.hpp>
35 #include <comphelper/property.hxx>
36 #include <com/sun/star/lang/DisposedException.hpp>
37 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
38 #include <com/sun/star/sdbc/ResultSetType.hpp>
39 #include <com/sun/star/sdbc/FetchDirection.hpp>
40 #include <cppuhelper/typeprovider.hxx>
41 #include <comphelper/sequence.hxx>
42 #include "odbc/OResultSetMetaData.hxx"
43 #include "odbc/OTools.hxx"
44 #include <comphelper/types.hxx>
45 #include "FDatabaseMetaDataResultSetMetaData.hxx"
46 #include <connectivity/dbexception.hxx>
47
48 using namespace ::comphelper;
49
50
51 using namespace connectivity::odbc;
52 using namespace cppu;
53 //------------------------------------------------------------------------------
54 using namespace ::com::sun::star::lang;
55 using namespace com::sun::star::uno;
56 using namespace com::sun::star::beans;
57 using namespace com::sun::star::sdbc;
58 using namespace com::sun::star::util;
59
60 // -------------------------------------------------------------------------
ODatabaseMetaDataResultSet(OConnection * _pConnection)61 ODatabaseMetaDataResultSet::ODatabaseMetaDataResultSet(OConnection* _pConnection)
62 :ODatabaseMetaDataResultSet_BASE(m_aMutex)
63 ,OPropertySetHelper(ODatabaseMetaDataResultSet_BASE::rBHelper)
64
65 ,m_aStatementHandle(_pConnection->createStatementHandle())
66 ,m_aStatement(NULL)
67 ,m_xMetaData(NULL)
68 ,m_pRowStatusArray(NULL)
69 ,m_pConnection(_pConnection)
70 ,m_nTextEncoding(_pConnection->getTextEncoding())
71 ,m_nRowPos(-1)
72 ,m_nLastColumnPos(0)
73 ,m_nDriverColumnCount(0)
74 ,m_nCurrentFetchState(0)
75 ,m_bWasNull(sal_True)
76 ,m_bEOF(sal_False)
77 ,m_bFreeHandle(sal_False)
78 {
79 OSL_ENSURE(m_pConnection,"ODatabaseMetaDataResultSet::ODatabaseMetaDataResultSet: No parent set!");
80 osl_incrementInterlockedCount( &m_refCount );
81 m_pConnection->acquire();
82 m_pRowStatusArray = new SQLUSMALLINT[1]; // the default value
83 osl_decrementInterlockedCount( &m_refCount );
84 // allocBuffer();
85 }
86
87 // -------------------------------------------------------------------------
~ODatabaseMetaDataResultSet()88 ODatabaseMetaDataResultSet::~ODatabaseMetaDataResultSet()
89 {
90 OSL_ENSURE(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed,"Object wasn't disposed!");
91 if(!ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed)
92 {
93 osl_incrementInterlockedCount( &m_refCount );
94 dispose();
95 }
96 delete [] m_pRowStatusArray;
97 }
98 // -------------------------------------------------------------------------
disposing(void)99 void ODatabaseMetaDataResultSet::disposing(void)
100 {
101 OPropertySetHelper::disposing();
102
103 ::osl::MutexGuard aGuard(m_aMutex);
104 if(m_bFreeHandle)
105 m_pConnection->freeStatementHandle(m_aStatementHandle);
106
107 m_aStatement = NULL;
108 m_xMetaData.clear();
109 m_pConnection->release();
110 }
111 // -------------------------------------------------------------------------
queryInterface(const Type & rType)112 Any SAL_CALL ODatabaseMetaDataResultSet::queryInterface( const Type & rType )
113 {
114 Any aRet = OPropertySetHelper::queryInterface(rType);
115 return aRet.hasValue() ? aRet : ODatabaseMetaDataResultSet_BASE::queryInterface(rType);
116 }
117 // -----------------------------------------------------------------------------
getPropertySetInfo()118 Reference< XPropertySetInfo > SAL_CALL ODatabaseMetaDataResultSet::getPropertySetInfo( )
119 {
120 return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
121 }
122 // -----------------------------------------------------------------------------
acquire()123 void SAL_CALL ODatabaseMetaDataResultSet::acquire() throw()
124 {
125 ODatabaseMetaDataResultSet_BASE::acquire();
126 }
127 // -----------------------------------------------------------------------------
release()128 void SAL_CALL ODatabaseMetaDataResultSet::release() throw()
129 {
130 ODatabaseMetaDataResultSet_BASE::release();
131 }
132 // -------------------------------------------------------------------------
getTypes()133 Sequence< Type > SAL_CALL ODatabaseMetaDataResultSet::getTypes( )
134 {
135 ::cppu::OTypeCollection aTypes( ::getCppuType( (const Reference< XMultiPropertySet > *)0 ),
136 ::getCppuType( (const Reference< XFastPropertySet > *)0 ),
137 ::getCppuType( (const Reference< XPropertySet > *)0 ));
138
139 return ::comphelper::concatSequences(aTypes.getTypes(),ODatabaseMetaDataResultSet_BASE::getTypes());
140 }
141 // -----------------------------------------------------------------------------
mapColumn(sal_Int32 column)142 sal_Int32 ODatabaseMetaDataResultSet::mapColumn (sal_Int32 column)
143 {
144 sal_Int32 map = column;
145
146 if (!m_aColMapping.empty())
147 {
148 // Validate column number
149 map = m_aColMapping[column];
150 }
151
152 return map;
153 }
154 // -------------------------------------------------------------------------
155
findColumn(const::rtl::OUString & columnName)156 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::findColumn( const ::rtl::OUString& columnName )
157 {
158
159 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
160 ::osl::MutexGuard aGuard( m_aMutex );
161
162
163 Reference< XResultSetMetaData > xMeta = getMetaData();
164 sal_Int32 nLen = xMeta->getColumnCount();
165 sal_Int32 i = 1;
166 for(;i<=nLen;++i)
167 if(xMeta->isCaseSensitive(i) ? columnName == xMeta->getColumnName(i) :
168 columnName.equalsIgnoreAsciiCase(xMeta->getColumnName(i)))
169 break;
170 return i;
171 }
172 // -------------------------------------------------------------------------
getBinaryStream(sal_Int32)173 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getBinaryStream( sal_Int32 /*columnIndex*/ )
174 {
175 ::dbtools::throwFunctionNotSupportedException( "XRow::getBinaryStream", *this );
176 return NULL;
177 }
178 // -------------------------------------------------------------------------
getCharacterStream(sal_Int32)179 Reference< ::com::sun::star::io::XInputStream > SAL_CALL ODatabaseMetaDataResultSet::getCharacterStream( sal_Int32 /*columnIndex*/ )
180 {
181 ::dbtools::throwFunctionNotSupportedException( "XRow::getCharacterStream", *this );
182 return NULL;
183 }
184
185 // -------------------------------------------------------------------------
getBoolean(sal_Int32 columnIndex)186 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::getBoolean( sal_Int32 columnIndex )
187 {
188
189 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
190 ::osl::MutexGuard aGuard( m_aMutex );
191
192 columnIndex = mapColumn(columnIndex);
193
194 sal_Bool bRet = sal_False;
195 if(columnIndex <= m_nDriverColumnCount)
196 {
197 sal_Int32 nType = getMetaData()->getColumnType(columnIndex);
198 switch(nType)
199 {
200 case DataType::BIT:
201 {
202 sal_Int8 nValue = 0;
203 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_BIT,m_bWasNull,**this,&nValue,sizeof nValue);
204 bRet = nValue != 0;
205 }
206 break;
207 default:
208 bRet = getInt(columnIndex) != 0;
209 }
210 }
211 return bRet;
212 }
213 // -------------------------------------------------------------------------
214
getByte(sal_Int32 columnIndex)215 sal_Int8 SAL_CALL ODatabaseMetaDataResultSet::getByte( sal_Int32 columnIndex )
216 {
217
218 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
219 ::osl::MutexGuard aGuard( m_aMutex );
220
221
222 columnIndex = mapColumn(columnIndex);
223 sal_Int8 nVal = 0;
224 if(columnIndex <= m_nDriverColumnCount)
225 {
226 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_TINYINT,m_bWasNull,**this,&nVal,sizeof nVal);
227
228 ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter;
229 if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end())
230 return sal_Int8((*aValueRangeIter).second[(sal_Int32)nVal]);
231 }
232 else
233 m_bWasNull = sal_True;
234 return nVal;
235 }
236 // -------------------------------------------------------------------------
237
getBytes(sal_Int32 columnIndex)238 Sequence< sal_Int8 > SAL_CALL ODatabaseMetaDataResultSet::getBytes( sal_Int32 columnIndex )
239 {
240
241 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
242 ::osl::MutexGuard aGuard( m_aMutex );
243
244
245 columnIndex = mapColumn(columnIndex);
246 if(columnIndex <= m_nDriverColumnCount)
247 {
248 sal_Int32 nType = getMetaData()->getColumnType(columnIndex);
249 switch(nType)
250 {
251 case DataType::VARCHAR:
252 case DataType::LONGVARCHAR:
253 {
254 ::rtl::OUString aRet = OTools::getStringValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_BINARY,m_bWasNull,**this,m_nTextEncoding);
255 return Sequence<sal_Int8>(reinterpret_cast<const sal_Int8*>(aRet.getStr()),sizeof(sal_Unicode)*aRet.getLength());
256 }
257 }
258 return OTools::getBytesValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_BINARY,m_bWasNull,**this);
259 }
260 else
261 m_bWasNull = sal_True;
262 return Sequence<sal_Int8>();
263 }
264 // -------------------------------------------------------------------------
265
getDate(sal_Int32 columnIndex)266 ::com::sun::star::util::Date SAL_CALL ODatabaseMetaDataResultSet::getDate( sal_Int32 columnIndex )
267 {
268 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
269 ::osl::MutexGuard aGuard( m_aMutex );
270
271
272 columnIndex = mapColumn(columnIndex);
273 if(columnIndex <= m_nDriverColumnCount)
274 {
275 DATE_STRUCT aDate;
276 aDate.day = 0;
277 aDate.month = 0;
278 aDate.year = 0;
279 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,m_pConnection->useOldDateFormat() ? SQL_C_DATE : SQL_C_TYPE_DATE,m_bWasNull,**this,&aDate,sizeof aDate);
280 return Date(aDate.day,aDate.month,aDate.year);
281 }
282 else
283 m_bWasNull = sal_True;
284 return Date();
285 }
286 // -------------------------------------------------------------------------
287
getDouble(sal_Int32 columnIndex)288 double SAL_CALL ODatabaseMetaDataResultSet::getDouble( sal_Int32 columnIndex )
289 {
290
291 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
292 ::osl::MutexGuard aGuard( m_aMutex );
293
294
295 columnIndex = mapColumn(columnIndex);
296 double nValue(0.0);
297 if(columnIndex <= m_nDriverColumnCount)
298 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_DOUBLE,m_bWasNull,**this,&nValue,sizeof nValue);
299 else
300 m_bWasNull = sal_True;
301 return nValue;
302 }
303 // -------------------------------------------------------------------------
304
getFloat(sal_Int32 columnIndex)305 float SAL_CALL ODatabaseMetaDataResultSet::getFloat( sal_Int32 columnIndex )
306 {
307
308 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
309 ::osl::MutexGuard aGuard( m_aMutex );
310
311
312 columnIndex = mapColumn(columnIndex);
313 float nVal(0);
314 if(columnIndex <= m_nDriverColumnCount)
315 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_FLOAT,m_bWasNull,**this,&nVal,sizeof nVal);
316 else
317 m_bWasNull = sal_True;
318 return nVal;
319 }
320 // -------------------------------------------------------------------------
321
getInt(sal_Int32 columnIndex)322 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getInt( sal_Int32 columnIndex )
323 {
324
325 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
326 ::osl::MutexGuard aGuard( m_aMutex );
327
328
329 columnIndex = mapColumn(columnIndex);
330 sal_Int32 nVal = 0;
331 if(columnIndex <= m_nDriverColumnCount)
332 {
333 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_LONG,m_bWasNull,**this,&nVal,sizeof nVal);
334
335 ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter;
336 if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end())
337 return (*aValueRangeIter).second[(sal_Int32)nVal];
338 }
339 else
340 m_bWasNull = sal_True;
341 return nVal;
342 }
343 // -------------------------------------------------------------------------
344
getRow()345 sal_Int32 SAL_CALL ODatabaseMetaDataResultSet::getRow( )
346 {
347 return 0;
348 }
349 // -------------------------------------------------------------------------
350
getLong(sal_Int32)351 sal_Int64 SAL_CALL ODatabaseMetaDataResultSet::getLong( sal_Int32 /*columnIndex*/ )
352 {
353 ::dbtools::throwFunctionNotSupportedException( "XRow::getLong", *this );
354 return 0;
355 }
356 // -------------------------------------------------------------------------
357
getMetaData()358 Reference< XResultSetMetaData > SAL_CALL ODatabaseMetaDataResultSet::getMetaData( )
359 {
360 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
361 ::osl::MutexGuard aGuard( m_aMutex );
362 return m_xMetaData.is() ? m_xMetaData : (m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle));
363 }
364 // -------------------------------------------------------------------------
getArray(sal_Int32)365 Reference< XArray > SAL_CALL ODatabaseMetaDataResultSet::getArray( sal_Int32 /*columnIndex*/ )
366 {
367 ::dbtools::throwFunctionNotSupportedException( "XRow::getArray", *this );
368 return NULL;
369 }
370 // -------------------------------------------------------------------------
getClob(sal_Int32)371 Reference< XClob > SAL_CALL ODatabaseMetaDataResultSet::getClob( sal_Int32 /*columnIndex*/ )
372 {
373 ::dbtools::throwFunctionNotSupportedException( "XRow::getClob", *this );
374 return NULL;
375 }
376 // -------------------------------------------------------------------------
getBlob(sal_Int32)377 Reference< XBlob > SAL_CALL ODatabaseMetaDataResultSet::getBlob( sal_Int32 /*columnIndex*/ )
378 {
379 ::dbtools::throwFunctionNotSupportedException( "XRow::getBlob", *this );
380 return NULL;
381 }
382 // -------------------------------------------------------------------------
383
getRef(sal_Int32)384 Reference< XRef > SAL_CALL ODatabaseMetaDataResultSet::getRef( sal_Int32 /*columnIndex*/ )
385 {
386 ::dbtools::throwFunctionNotSupportedException( "XRow::getRef", *this );
387 return NULL;
388 }
389 // -------------------------------------------------------------------------
390
getObject(sal_Int32,const Reference<::com::sun::star::container::XNameAccess> &)391 Any SAL_CALL ODatabaseMetaDataResultSet::getObject( sal_Int32 /*columnIndex*/, const Reference< ::com::sun::star::container::XNameAccess >& /*typeMap*/ )
392 {
393 ::dbtools::throwFunctionNotSupportedException( "XRow::getObject", *this );
394 return Any();
395 }
396 // -------------------------------------------------------------------------
397
getShort(sal_Int32 columnIndex)398 sal_Int16 SAL_CALL ODatabaseMetaDataResultSet::getShort( sal_Int32 columnIndex )
399 {
400
401 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
402 ::osl::MutexGuard aGuard( m_aMutex );
403
404 columnIndex = mapColumn(columnIndex);
405 sal_Int16 nVal = 0;
406 if(columnIndex <= m_nDriverColumnCount)
407 {
408 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,SQL_C_SHORT,m_bWasNull,**this,&nVal,sizeof nVal);
409
410 ::std::map<sal_Int32, ::connectivity::TInt2IntMap >::iterator aValueRangeIter;
411 if ( !m_aValueRange.empty() && (aValueRangeIter = m_aValueRange.find(columnIndex)) != m_aValueRange.end())
412 return sal_Int16((*aValueRangeIter).second[(sal_Int32)nVal]);
413 }
414 else
415 m_bWasNull = sal_True;
416 return nVal;
417 }
418 // -------------------------------------------------------------------------
419
getString(sal_Int32 columnIndex)420 ::rtl::OUString SAL_CALL ODatabaseMetaDataResultSet::getString( sal_Int32 columnIndex )
421 {
422
423 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
424 ::osl::MutexGuard aGuard( m_aMutex );
425
426
427 columnIndex = mapColumn(columnIndex);
428 ::rtl::OUString aVal;
429 if(columnIndex <= m_nDriverColumnCount)
430 aVal = OTools::getStringValue(m_pConnection,m_aStatementHandle,columnIndex,impl_getColumnType_nothrow(columnIndex),m_bWasNull,**this,m_nTextEncoding);
431 else
432 m_bWasNull = sal_True;
433
434 return aVal;
435 }
436
437 // -------------------------------------------------------------------------
438
439
getTime(sal_Int32 columnIndex)440 ::com::sun::star::util::Time SAL_CALL ODatabaseMetaDataResultSet::getTime( sal_Int32 columnIndex )
441 {
442
443 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
444 ::osl::MutexGuard aGuard( m_aMutex );
445
446
447 columnIndex = mapColumn(columnIndex);
448 TIME_STRUCT aTime={0,0,0};
449 if(columnIndex <= m_nDriverColumnCount)
450 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,m_pConnection->useOldDateFormat() ? SQL_C_TIME : SQL_C_TYPE_TIME,m_bWasNull,**this,&aTime,sizeof aTime);
451 else
452 m_bWasNull = sal_True;
453 return Time(0,aTime.second,aTime.minute,aTime.hour);
454 }
455 // -------------------------------------------------------------------------
456
457
getTimestamp(sal_Int32 columnIndex)458 ::com::sun::star::util::DateTime SAL_CALL ODatabaseMetaDataResultSet::getTimestamp( sal_Int32 columnIndex )
459 {
460
461 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
462 ::osl::MutexGuard aGuard( m_aMutex );
463
464
465 columnIndex = mapColumn(columnIndex);
466 TIMESTAMP_STRUCT aTime={0,0,0,0,0,0,0};
467 if(columnIndex <= m_nDriverColumnCount)
468 OTools::getValue(m_pConnection,m_aStatementHandle,columnIndex,m_pConnection->useOldDateFormat() ? SQL_C_TIMESTAMP : SQL_C_TYPE_TIMESTAMP,m_bWasNull,**this,&aTime,sizeof aTime);
469 else
470 m_bWasNull = sal_True;
471 return DateTime((sal_uInt16)aTime.fraction*1000,aTime.second,aTime.minute,aTime.hour,aTime.day,aTime.month,aTime.year);
472 }
473 // -------------------------------------------------------------------------
474
isAfterLast()475 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isAfterLast( )
476 {
477
478 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
479 ::osl::MutexGuard aGuard( m_aMutex );
480
481
482 return m_nCurrentFetchState == SQL_NO_DATA;
483 }
484 // -------------------------------------------------------------------------
isFirst()485 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isFirst( )
486 {
487
488 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
489 ::osl::MutexGuard aGuard( m_aMutex );
490
491
492 return m_nRowPos == 1;
493 }
494 // -------------------------------------------------------------------------
isLast()495 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isLast( )
496 {
497
498 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
499 ::osl::MutexGuard aGuard( m_aMutex );
500
501
502 return m_bEOF && m_nCurrentFetchState != SQL_NO_DATA;
503 }
504 // -------------------------------------------------------------------------
beforeFirst()505 void SAL_CALL ODatabaseMetaDataResultSet::beforeFirst( )
506 {
507
508 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
509 ::osl::MutexGuard aGuard( m_aMutex );
510
511
512 if(first())
513 previous();
514 m_nCurrentFetchState = SQL_SUCCESS;
515 }
516 // -------------------------------------------------------------------------
afterLast()517 void SAL_CALL ODatabaseMetaDataResultSet::afterLast( )
518 {
519
520 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
521 ::osl::MutexGuard aGuard( m_aMutex );
522
523
524 if(last())
525 next();
526 m_bEOF = sal_True;
527 }
528 // -------------------------------------------------------------------------
529
close()530 void SAL_CALL ODatabaseMetaDataResultSet::close( )
531 {
532 {
533
534 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
535 ::osl::MutexGuard aGuard( m_aMutex );
536
537 }
538 dispose();
539 }
540 // -------------------------------------------------------------------------
541
first()542 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::first( )
543 {
544
545 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
546 ::osl::MutexGuard aGuard( m_aMutex );
547
548
549 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_FIRST,0);
550 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this);
551 sal_Bool bRet = ( m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO );
552 if( bRet )
553 m_nRowPos = 1;
554 return bRet;
555 }
556 // -------------------------------------------------------------------------
557
last()558 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::last( )
559 {
560 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed );
561 ::osl::MutexGuard aGuard( m_aMutex );
562
563
564 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_LAST,0);
565 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this);
566 // here I know definitely that I stand on the last record
567 return (m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO);
568 }
569 // -------------------------------------------------------------------------
absolute(sal_Int32 row)570 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::absolute( sal_Int32 row )
571 {
572
573 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
574 ::osl::MutexGuard aGuard( m_aMutex );
575
576
577 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_ABSOLUTE,row);
578 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this);
579 sal_Bool bRet = m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO;
580 if(bRet)
581 m_nRowPos = row;
582 return bRet;
583 }
584 // -------------------------------------------------------------------------
relative(sal_Int32 row)585 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::relative( sal_Int32 row )
586 {
587
588 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
589 ::osl::MutexGuard aGuard( m_aMutex );
590
591
592 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_RELATIVE,row);
593 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this);
594 sal_Bool bRet = m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO;
595 if(bRet)
596 m_nRowPos += row;
597 return bRet;
598 }
599 // -------------------------------------------------------------------------
previous()600 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::previous( )
601 {
602
603 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
604 ::osl::MutexGuard aGuard( m_aMutex );
605
606
607 m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_PRIOR,0);
608 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this);
609 sal_Bool bRet = m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO;
610 if(bRet)
611 --m_nRowPos;
612 return bRet;
613 }
614 // -------------------------------------------------------------------------
getStatement()615 Reference< XInterface > SAL_CALL ODatabaseMetaDataResultSet::getStatement( )
616 {
617 return NULL;
618 }
619 // -------------------------------------------------------------------------
620
rowDeleted()621 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowDeleted( )
622 {
623
624 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
625 ::osl::MutexGuard aGuard( m_aMutex );
626
627
628 return m_pRowStatusArray[0] == SQL_ROW_DELETED;
629 }
630 // -------------------------------------------------------------------------
rowInserted()631 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowInserted( )
632 {
633 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
634 ::osl::MutexGuard aGuard( m_aMutex );
635
636
637 return m_pRowStatusArray[0] == SQL_ROW_ADDED;
638 }
639 // -------------------------------------------------------------------------
rowUpdated()640 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::rowUpdated( )
641 {
642
643 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
644 ::osl::MutexGuard aGuard( m_aMutex );
645
646
647 return m_pRowStatusArray[0] == SQL_ROW_UPDATED;
648 }
649 // -------------------------------------------------------------------------
650
isBeforeFirst()651 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::isBeforeFirst( )
652 {
653
654 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
655 ::osl::MutexGuard aGuard( m_aMutex );
656
657
658 return m_nRowPos == 0;
659 }
660 // -------------------------------------------------------------------------
661
next()662 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::next( )
663 {
664
665 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
666 ::osl::MutexGuard aGuard( m_aMutex );
667
668
669 // m_nCurrentFetchState = N3SQLFetchScroll(m_aStatementHandle,SQL_FETCH_NEXT,0);
670 m_nCurrentFetchState = N3SQLFetch(m_aStatementHandle);
671 OTools::ThrowException(m_pConnection,m_nCurrentFetchState,m_aStatementHandle,SQL_HANDLE_STMT,*this);
672 return m_nCurrentFetchState == SQL_SUCCESS || m_nCurrentFetchState == SQL_SUCCESS_WITH_INFO;
673 }
674 // -------------------------------------------------------------------------
675
wasNull()676 sal_Bool SAL_CALL ODatabaseMetaDataResultSet::wasNull( )
677 {
678
679 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
680 ::osl::MutexGuard aGuard( m_aMutex );
681
682
683 return m_bWasNull;
684 }
685 // -------------------------------------------------------------------------
refreshRow()686 void SAL_CALL ODatabaseMetaDataResultSet::refreshRow( )
687 {
688
689 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
690 ::osl::MutexGuard aGuard( m_aMutex );
691
692 }
693 // -------------------------------------------------------------------------
694
cancel()695 void SAL_CALL ODatabaseMetaDataResultSet::cancel( )
696 {
697
698 checkDisposed(ODatabaseMetaDataResultSet_BASE::rBHelper.bDisposed);
699 ::osl::MutexGuard aGuard( m_aMutex );
700
701
702 OTools::ThrowException(m_pConnection,N3SQLCancel(m_aStatementHandle),m_aStatementHandle,SQL_HANDLE_STMT,*this);
703 }
704 // -------------------------------------------------------------------------
clearWarnings()705 void SAL_CALL ODatabaseMetaDataResultSet::clearWarnings( )
706 {
707 }
708 // -------------------------------------------------------------------------
getWarnings()709 Any SAL_CALL ODatabaseMetaDataResultSet::getWarnings( )
710 {
711 return Any();
712 }
713 //------------------------------------------------------------------------------
getResultSetConcurrency() const714 sal_Int32 ODatabaseMetaDataResultSet::getResultSetConcurrency() const
715 {
716 return ResultSetConcurrency::READ_ONLY;
717 }
718 //------------------------------------------------------------------------------
getResultSetType() const719 sal_Int32 ODatabaseMetaDataResultSet::getResultSetType() const
720 {
721 return ResultSetType::FORWARD_ONLY;
722 }
723 //------------------------------------------------------------------------------
getFetchDirection() const724 sal_Int32 ODatabaseMetaDataResultSet::getFetchDirection() const
725 {
726 return FetchDirection::FORWARD;
727 }
728 //------------------------------------------------------------------------------
getFetchSize() const729 sal_Int32 ODatabaseMetaDataResultSet::getFetchSize() const
730 {
731 sal_Int32 nValue=1;
732 return nValue;
733 }
734 //------------------------------------------------------------------------------
getCursorName() const735 ::rtl::OUString ODatabaseMetaDataResultSet::getCursorName() const
736 {
737 return ::rtl::OUString();
738 }
739
740 // -------------------------------------------------------------------------
createArrayHelper() const741 ::cppu::IPropertyArrayHelper* ODatabaseMetaDataResultSet::createArrayHelper( ) const
742 {
743
744 Sequence< com::sun::star::beans::Property > aProps(5);
745 com::sun::star::beans::Property* pProperties = aProps.getArray();
746 sal_Int32 nPos = 0;
747 DECL_PROP0(CURSORNAME, ::rtl::OUString);
748 DECL_PROP0(FETCHDIRECTION, sal_Int32);
749 DECL_PROP0(FETCHSIZE, sal_Int32);
750 DECL_PROP0(RESULTSETCONCURRENCY,sal_Int32);
751 DECL_PROP0(RESULTSETTYPE, sal_Int32);
752
753 return new ::cppu::OPropertyArrayHelper(aProps);
754 }
755 // -------------------------------------------------------------------------
getInfoHelper()756 ::cppu::IPropertyArrayHelper & ODatabaseMetaDataResultSet::getInfoHelper()
757 {
758 return *const_cast<ODatabaseMetaDataResultSet*>(this)->getArrayHelper();
759 }
760 // -------------------------------------------------------------------------
convertFastPropertyValue(Any & rConvertedValue,Any & rOldValue,sal_Int32 nHandle,const Any & rValue)761 sal_Bool ODatabaseMetaDataResultSet::convertFastPropertyValue(
762 Any & rConvertedValue,
763 Any & rOldValue,
764 sal_Int32 nHandle,
765 const Any& rValue )
766 {
767 switch(nHandle)
768 {
769 case PROPERTY_ID_CURSORNAME:
770 case PROPERTY_ID_RESULTSETCONCURRENCY:
771 case PROPERTY_ID_RESULTSETTYPE:
772 throw ::com::sun::star::lang::IllegalArgumentException();
773 case PROPERTY_ID_FETCHDIRECTION:
774 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchDirection());
775 case PROPERTY_ID_FETCHSIZE:
776 return ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, getFetchSize());
777 default:
778 ;
779 }
780 return sal_False;
781 }
782 // -------------------------------------------------------------------------
setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any &)783 void ODatabaseMetaDataResultSet::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& /*rValue*/ )
784 {
785 switch(nHandle)
786 {
787 case PROPERTY_ID_CURSORNAME:
788 case PROPERTY_ID_RESULTSETCONCURRENCY:
789 case PROPERTY_ID_RESULTSETTYPE:
790 case PROPERTY_ID_FETCHDIRECTION:
791 case PROPERTY_ID_FETCHSIZE:
792 throw Exception();
793 default:
794 OSL_ENSURE(0,"setFastPropertyValue_NoBroadcast: Illegal handle value!");
795 }
796 }
797 // -------------------------------------------------------------------------
getFastPropertyValue(Any & rValue,sal_Int32 nHandle) const798 void ODatabaseMetaDataResultSet::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
799 {
800 switch(nHandle)
801 {
802 case PROPERTY_ID_CURSORNAME:
803 rValue <<= getCursorName();
804 break;
805 case PROPERTY_ID_RESULTSETCONCURRENCY:
806 rValue <<= getResultSetConcurrency();
807 break;
808 case PROPERTY_ID_RESULTSETTYPE:
809 rValue <<= getResultSetType();
810 break;
811 case PROPERTY_ID_FETCHDIRECTION:
812 rValue <<= getFetchDirection();
813 break;
814 case PROPERTY_ID_FETCHSIZE:
815 rValue <<= getFetchSize();
816 break;
817 }
818 }
819 // -------------------------------------------------------------------------
openTypeInfo()820 void ODatabaseMetaDataResultSet::openTypeInfo()
821 {
822 TInt2IntMap aMap;
823 aMap[SQL_BIT] = DataType::BIT;
824 aMap[SQL_TINYINT] = DataType::TINYINT;
825 aMap[SQL_SMALLINT] = DataType::SMALLINT;
826 aMap[SQL_INTEGER] = DataType::INTEGER;
827 aMap[SQL_FLOAT] = DataType::FLOAT;
828 aMap[SQL_REAL] = DataType::REAL;
829 aMap[SQL_DOUBLE] = DataType::DOUBLE;
830 aMap[SQL_BIGINT] = DataType::BIGINT;
831
832 aMap[SQL_CHAR] = DataType::CHAR;
833 aMap[SQL_WCHAR] = DataType::CHAR;
834 aMap[SQL_VARCHAR] = DataType::VARCHAR;
835 aMap[SQL_WVARCHAR] = DataType::VARCHAR;
836 aMap[SQL_LONGVARCHAR] = DataType::LONGVARCHAR;
837 aMap[SQL_WLONGVARCHAR] = DataType::LONGVARCHAR;
838
839 aMap[SQL_TYPE_DATE] = DataType::DATE;
840 aMap[SQL_DATE] = DataType::DATE;
841 aMap[SQL_TYPE_TIME] = DataType::TIME;
842 aMap[SQL_TIME] = DataType::TIME;
843 aMap[SQL_TYPE_TIMESTAMP] = DataType::TIMESTAMP;
844 aMap[SQL_TIMESTAMP] = DataType::TIMESTAMP;
845
846 aMap[SQL_DECIMAL] = DataType::DECIMAL;
847 aMap[SQL_NUMERIC] = DataType::NUMERIC;
848
849 aMap[SQL_BINARY] = DataType::BINARY;
850 aMap[SQL_VARBINARY] = DataType::VARBINARY;
851 aMap[SQL_LONGVARBINARY] = DataType::LONGVARBINARY;
852
853 aMap[SQL_GUID] = DataType::VARBINARY;
854
855
856 m_aValueRange[2] = aMap;
857
858 OTools::ThrowException(m_pConnection,N3SQLGetTypeInfo(m_aStatementHandle, SQL_ALL_TYPES),m_aStatementHandle,SQL_HANDLE_STMT,*this);
859 checkColumnCount();
860 }
861 //-----------------------------------------------------------------------------
openTables(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & tableNamePattern,const Sequence<::rtl::OUString> & types)862 void ODatabaseMetaDataResultSet::openTables(const Any& catalog, const ::rtl::OUString& schemaPattern,
863 const ::rtl::OUString& tableNamePattern,
864 const Sequence< ::rtl::OUString >& types )
865 {
866 m_bFreeHandle = sal_True;
867 ::rtl::OString aPKQ,aPKO,aPKN,aCOL;
868 const ::rtl::OUString *pSchemaPat = NULL;
869
870 if(schemaPattern.toChar() != '%')
871 pSchemaPat = &schemaPattern;
872 else
873 pSchemaPat = NULL;
874
875 if ( catalog.hasValue() )
876 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
877 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding);
878
879 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
880 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
881 *pPKN = (aPKN = ::rtl::OUStringToOString(tableNamePattern,m_nTextEncoding)).getStr();
882
883
884 const char *pCOL = NULL;
885 const char* pComma = ",";
886 const ::rtl::OUString* pBegin = types.getConstArray();
887 const ::rtl::OUString* pEnd = pBegin + types.getLength();
888 for(;pBegin != pEnd;++pBegin)
889 {
890 aCOL += ::rtl::OUStringToOString(*pBegin,m_nTextEncoding);
891 aCOL += pComma;
892 }
893 if ( aCOL.getLength() )
894 {
895 aCOL = aCOL.replaceAt(aCOL.getLength()-1,1,pComma);
896 pCOL = aCOL.getStr();
897 }
898 else
899 pCOL = SQL_ALL_TABLE_TYPES;
900
901 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle,
902 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
903 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0,
904 (SDB_ODBC_CHAR *) pPKN, SQL_NTS,
905 (SDB_ODBC_CHAR *) pCOL, pCOL ? SQL_NTS : 0);
906 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
907 checkColumnCount();
908
909 }
910 //-----------------------------------------------------------------------------
openTablesTypes()911 void ODatabaseMetaDataResultSet::openTablesTypes( )
912 {
913 m_bFreeHandle = sal_True;
914 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle,
915 0,0,
916 0,0,
917 0,0,
918 (SDB_ODBC_CHAR *) SQL_ALL_TABLE_TYPES,SQL_NTS);
919 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
920
921 m_aColMapping.clear();
922 m_aColMapping.push_back(-1);
923 m_aColMapping.push_back(4);
924 m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle,m_aColMapping);
925 checkColumnCount();
926 }
927 // -------------------------------------------------------------------------
openCatalogs()928 void ODatabaseMetaDataResultSet::openCatalogs()
929 {
930 m_bFreeHandle = sal_True;
931 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle,
932 (SDB_ODBC_CHAR *) SQL_ALL_CATALOGS,SQL_NTS,
933 (SDB_ODBC_CHAR *) "",SQL_NTS,
934 (SDB_ODBC_CHAR *) "",SQL_NTS,
935 (SDB_ODBC_CHAR *) "",SQL_NTS);
936
937 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
938
939 m_aColMapping.clear();
940 m_aColMapping.push_back(-1);
941 m_aColMapping.push_back(1);
942 m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle,m_aColMapping);
943 checkColumnCount();
944 }
945 // -------------------------------------------------------------------------
openSchemas()946 void ODatabaseMetaDataResultSet::openSchemas()
947 {
948 m_bFreeHandle = sal_True;
949 SQLRETURN nRetcode = N3SQLTables(m_aStatementHandle,
950 (SDB_ODBC_CHAR *) "",SQL_NTS,
951 (SDB_ODBC_CHAR *) SQL_ALL_SCHEMAS,SQL_NTS,
952 (SDB_ODBC_CHAR *) "",SQL_NTS,
953 (SDB_ODBC_CHAR *) "",SQL_NTS);
954 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
955
956 m_aColMapping.clear();
957 m_aColMapping.push_back(-1);
958 m_aColMapping.push_back(2);
959 m_xMetaData = new OResultSetMetaData(m_pConnection,m_aStatementHandle,m_aColMapping);
960 checkColumnCount();
961 }
962 // -------------------------------------------------------------------------
openColumnPrivileges(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table,const::rtl::OUString & columnNamePattern)963 void ODatabaseMetaDataResultSet::openColumnPrivileges( const Any& catalog, const ::rtl::OUString& schema,
964 const ::rtl::OUString& table, const ::rtl::OUString& columnNamePattern )
965 {
966 const ::rtl::OUString *pSchemaPat = NULL;
967
968 if(schema.toChar() != '%')
969 pSchemaPat = &schema;
970 else
971 pSchemaPat = NULL;
972
973 m_bFreeHandle = sal_True;
974 ::rtl::OString aPKQ,aPKO,aPKN,aCOL;
975
976 if ( catalog.hasValue() )
977 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
978 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding);
979
980 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
981 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
982 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr(),
983 *pCOL = (aCOL = ::rtl::OUStringToOString(columnNamePattern,m_nTextEncoding)).getStr();
984
985
986 SQLRETURN nRetcode = N3SQLColumnPrivileges(m_aStatementHandle,
987 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
988 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 ,
989 (SDB_ODBC_CHAR *) pPKN, SQL_NTS,
990 (SDB_ODBC_CHAR *) pCOL, SQL_NTS);
991 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
992
993 checkColumnCount();
994 }
995 // -------------------------------------------------------------------------
openColumns(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & tableNamePattern,const::rtl::OUString & columnNamePattern)996 void ODatabaseMetaDataResultSet::openColumns( const Any& catalog, const ::rtl::OUString& schemaPattern,
997 const ::rtl::OUString& tableNamePattern, const ::rtl::OUString& columnNamePattern )
998 {
999 const ::rtl::OUString *pSchemaPat = NULL;
1000
1001 if(schemaPattern.toChar() != '%')
1002 pSchemaPat = &schemaPattern;
1003 else
1004 pSchemaPat = NULL;
1005
1006 m_bFreeHandle = sal_True;
1007 ::rtl::OString aPKQ,aPKO,aPKN,aCOL;
1008 if ( catalog.hasValue() )
1009 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1010 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding);
1011
1012 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1013 *pPKO = pSchemaPat && pSchemaPat->getLength() && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
1014 *pPKN = (aPKN = ::rtl::OUStringToOString(tableNamePattern,m_nTextEncoding)).getStr(),
1015 *pCOL = (aCOL = ::rtl::OUStringToOString(columnNamePattern,m_nTextEncoding)).getStr();
1016
1017
1018 SQLRETURN nRetcode = N3SQLColumns(m_aStatementHandle,
1019 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1020 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0,
1021 (SDB_ODBC_CHAR *) pPKN, SQL_NTS,
1022 (SDB_ODBC_CHAR *) pCOL, SQL_NTS);
1023
1024 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1025 TInt2IntMap aMap;
1026 aMap[SQL_BIT] = DataType::BIT;
1027 aMap[SQL_TINYINT] = DataType::TINYINT;
1028 aMap[SQL_SMALLINT] = DataType::SMALLINT;
1029 aMap[SQL_INTEGER] = DataType::INTEGER;
1030 aMap[SQL_FLOAT] = DataType::FLOAT;
1031 aMap[SQL_REAL] = DataType::REAL;
1032 aMap[SQL_DOUBLE] = DataType::DOUBLE;
1033 aMap[SQL_BIGINT] = DataType::BIGINT;
1034
1035 aMap[SQL_CHAR] = DataType::CHAR;
1036 aMap[SQL_WCHAR] = DataType::CHAR;
1037 aMap[SQL_VARCHAR] = DataType::VARCHAR;
1038 aMap[SQL_WVARCHAR] = DataType::VARCHAR;
1039 aMap[SQL_LONGVARCHAR] = DataType::LONGVARCHAR;
1040 aMap[SQL_WLONGVARCHAR] = DataType::LONGVARCHAR;
1041
1042 aMap[SQL_TYPE_DATE] = DataType::DATE;
1043 aMap[SQL_DATE] = DataType::DATE;
1044 aMap[SQL_TYPE_TIME] = DataType::TIME;
1045 aMap[SQL_TIME] = DataType::TIME;
1046 aMap[SQL_TYPE_TIMESTAMP] = DataType::TIMESTAMP;
1047 aMap[SQL_TIMESTAMP] = DataType::TIMESTAMP;
1048
1049 aMap[SQL_DECIMAL] = DataType::DECIMAL;
1050 aMap[SQL_NUMERIC] = DataType::NUMERIC;
1051
1052 aMap[SQL_BINARY] = DataType::BINARY;
1053 aMap[SQL_VARBINARY] = DataType::VARBINARY;
1054 aMap[SQL_LONGVARBINARY] = DataType::LONGVARBINARY;
1055
1056 aMap[SQL_GUID] = DataType::VARBINARY;
1057
1058 m_aValueRange[5] = aMap;
1059 checkColumnCount();
1060 }
1061 // -------------------------------------------------------------------------
openProcedureColumns(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & procedureNamePattern,const::rtl::OUString & columnNamePattern)1062 void ODatabaseMetaDataResultSet::openProcedureColumns( const Any& catalog, const ::rtl::OUString& schemaPattern,
1063 const ::rtl::OUString& procedureNamePattern,const ::rtl::OUString& columnNamePattern )
1064 {
1065 const ::rtl::OUString *pSchemaPat = NULL;
1066
1067 if(schemaPattern.toChar() != '%')
1068 pSchemaPat = &schemaPattern;
1069 else
1070 pSchemaPat = NULL;
1071
1072 m_bFreeHandle = sal_True;
1073 ::rtl::OString aPKQ,aPKO,aPKN,aCOL;
1074 if ( catalog.hasValue() )
1075 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1076 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding);
1077
1078 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1079 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
1080 *pPKN = (aPKN = ::rtl::OUStringToOString(procedureNamePattern,m_nTextEncoding)).getStr(),
1081 *pCOL = (aCOL = ::rtl::OUStringToOString(columnNamePattern,m_nTextEncoding)).getStr();
1082
1083
1084 SQLRETURN nRetcode = N3SQLProcedureColumns(m_aStatementHandle,
1085 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1086 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 ,
1087 (SDB_ODBC_CHAR *) pPKN, SQL_NTS,
1088 (SDB_ODBC_CHAR *) pCOL, SQL_NTS);
1089
1090 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1091 checkColumnCount();
1092 }
1093 // -------------------------------------------------------------------------
openProcedures(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & procedureNamePattern)1094 void ODatabaseMetaDataResultSet::openProcedures(const Any& catalog, const ::rtl::OUString& schemaPattern,
1095 const ::rtl::OUString& procedureNamePattern)
1096 {
1097 const ::rtl::OUString *pSchemaPat = NULL;
1098
1099 if(schemaPattern.toChar() != '%')
1100 pSchemaPat = &schemaPattern;
1101 else
1102 pSchemaPat = NULL;
1103
1104 m_bFreeHandle = sal_True;
1105 ::rtl::OString aPKQ,aPKO,aPKN,aCOL;
1106
1107 if ( catalog.hasValue() )
1108 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1109 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding);
1110
1111 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1112 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
1113 *pPKN = (aPKN = ::rtl::OUStringToOString(procedureNamePattern,m_nTextEncoding)).getStr();
1114
1115
1116 SQLRETURN nRetcode = N3SQLProcedures(m_aStatementHandle,
1117 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1118 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 ,
1119 (SDB_ODBC_CHAR *) pPKN, SQL_NTS);
1120 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1121 checkColumnCount();
1122 }
1123 // -------------------------------------------------------------------------
openSpecialColumns(sal_Bool _bRowVer,const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table,sal_Int32 scope,sal_Bool nullable)1124 void ODatabaseMetaDataResultSet::openSpecialColumns(sal_Bool _bRowVer,const Any& catalog, const ::rtl::OUString& schema,
1125 const ::rtl::OUString& table,sal_Int32 scope, sal_Bool nullable )
1126 {
1127 const ::rtl::OUString *pSchemaPat = NULL;
1128
1129 if(schema.toChar() != '%')
1130 pSchemaPat = &schema;
1131 else
1132 pSchemaPat = NULL;
1133
1134 m_bFreeHandle = sal_True;
1135 ::rtl::OString aPKQ,aPKO,aPKN,aCOL;
1136 if ( catalog.hasValue() )
1137 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1138 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding);
1139
1140 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1141 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
1142 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr();
1143
1144
1145 SQLRETURN nRetcode = N3SQLSpecialColumns(m_aStatementHandle,_bRowVer ? SQL_ROWVER : SQL_BEST_ROWID,
1146 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1147 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 ,
1148 (SDB_ODBC_CHAR *) pPKN, SQL_NTS,
1149 (SQLSMALLINT)scope,
1150 nullable ? SQL_NULLABLE : SQL_NO_NULLS);
1151 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1152 checkColumnCount();
1153 }
1154 // -------------------------------------------------------------------------
openVersionColumns(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)1155 void ODatabaseMetaDataResultSet::openVersionColumns(const Any& catalog, const ::rtl::OUString& schema,
1156 const ::rtl::OUString& table)
1157 {
1158 openSpecialColumns(sal_True,catalog,schema,table,SQL_SCOPE_TRANSACTION,sal_False);
1159 }
1160 // -------------------------------------------------------------------------
openBestRowIdentifier(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table,sal_Int32 scope,sal_Bool nullable)1161 void ODatabaseMetaDataResultSet::openBestRowIdentifier( const Any& catalog, const ::rtl::OUString& schema,
1162 const ::rtl::OUString& table,sal_Int32 scope,sal_Bool nullable )
1163 {
1164 openSpecialColumns(sal_False,catalog,schema,table,scope,nullable);
1165 }
1166 // -------------------------------------------------------------------------
openForeignKeys(const Any & catalog,const::rtl::OUString * schema,const::rtl::OUString * table,const Any & catalog2,const::rtl::OUString * schema2,const::rtl::OUString * table2)1167 void ODatabaseMetaDataResultSet::openForeignKeys( const Any& catalog, const ::rtl::OUString* schema,
1168 const ::rtl::OUString* table,
1169 const Any& catalog2, const ::rtl::OUString* schema2,
1170 const ::rtl::OUString* table2)
1171 {
1172 m_bFreeHandle = sal_True;
1173
1174 ::rtl::OString aPKQ,aPKO,aPKN, aFKQ, aFKO, aFKN;
1175 if ( catalog.hasValue() )
1176 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1177 if ( catalog2.hasValue() )
1178 aFKQ = ::rtl::OUStringToOString(comphelper::getString(catalog2),m_nTextEncoding);
1179
1180 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1181 *pPKO = schema && schema->getLength() ? ::rtl::OUStringToOString(*schema,m_nTextEncoding).getStr() : NULL,
1182 *pPKN = table ? (aPKN = ::rtl::OUStringToOString(*table,m_nTextEncoding)).getStr(): NULL,
1183 *pFKQ = catalog2.hasValue() && aFKQ.getLength() ? aFKQ.getStr() : NULL,
1184 *pFKO = schema2 && schema2->getLength() ? (aFKO = ::rtl::OUStringToOString(*schema2,m_nTextEncoding)).getStr() : NULL,
1185 *pFKN = table2 ? (aFKN = ::rtl::OUStringToOString(*table2,m_nTextEncoding)).getStr() : NULL;
1186
1187
1188 SQLRETURN nRetcode = N3SQLForeignKeys(m_aStatementHandle,
1189 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1190 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0,
1191 (SDB_ODBC_CHAR *) pPKN, pPKN ? SQL_NTS : 0,
1192 (SDB_ODBC_CHAR *) pFKQ, (catalog2.hasValue() && aFKQ.getLength()) ? SQL_NTS : 0,
1193 (SDB_ODBC_CHAR *) pFKO, pFKO ? SQL_NTS : 0,
1194 (SDB_ODBC_CHAR *) pFKN, SQL_NTS
1195 );
1196 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1197 checkColumnCount();
1198 }
1199 // -------------------------------------------------------------------------
openImportedKeys(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)1200 void ODatabaseMetaDataResultSet::openImportedKeys(const Any& catalog, const ::rtl::OUString& schema,
1201 const ::rtl::OUString& table)
1202 {
1203
1204 openForeignKeys(Any(),NULL,NULL,catalog,!schema.compareToAscii("%") ? &schema : NULL,&table);
1205 }
1206 // -------------------------------------------------------------------------
openExportedKeys(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)1207 void ODatabaseMetaDataResultSet::openExportedKeys(const Any& catalog, const ::rtl::OUString& schema,
1208 const ::rtl::OUString& table)
1209 {
1210 openForeignKeys(catalog,!schema.compareToAscii("%") ? &schema : NULL,&table,Any(),NULL,NULL);
1211 }
1212 // -------------------------------------------------------------------------
openPrimaryKeys(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)1213 void ODatabaseMetaDataResultSet::openPrimaryKeys(const Any& catalog, const ::rtl::OUString& schema,
1214 const ::rtl::OUString& table)
1215 {
1216 const ::rtl::OUString *pSchemaPat = NULL;
1217
1218 if(schema.toChar() != '%')
1219 pSchemaPat = &schema;
1220 else
1221 pSchemaPat = NULL;
1222
1223 m_bFreeHandle = sal_True;
1224 ::rtl::OString aPKQ,aPKO,aPKN,aCOL;
1225
1226 if ( catalog.hasValue() )
1227 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1228 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding);
1229
1230 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1231 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
1232 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr();
1233
1234
1235 SQLRETURN nRetcode = N3SQLPrimaryKeys(m_aStatementHandle,
1236 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1237 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 ,
1238 (SDB_ODBC_CHAR *) pPKN, SQL_NTS);
1239 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1240 checkColumnCount();
1241 }
1242 // -------------------------------------------------------------------------
openTablePrivileges(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & tableNamePattern)1243 void ODatabaseMetaDataResultSet::openTablePrivileges(const Any& catalog, const ::rtl::OUString& schemaPattern,
1244 const ::rtl::OUString& tableNamePattern)
1245 {
1246 const ::rtl::OUString *pSchemaPat = NULL;
1247
1248 if(schemaPattern.toChar() != '%')
1249 pSchemaPat = &schemaPattern;
1250 else
1251 pSchemaPat = NULL;
1252
1253 m_bFreeHandle = sal_True;
1254 ::rtl::OString aPKQ,aPKO,aPKN;
1255
1256 if ( catalog.hasValue() )
1257 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1258 aPKO = ::rtl::OUStringToOString(schemaPattern,m_nTextEncoding);
1259
1260 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1261 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
1262 *pPKN = (aPKN = ::rtl::OUStringToOString(tableNamePattern,m_nTextEncoding)).getStr();
1263
1264
1265 SQLRETURN nRetcode = N3SQLTablePrivileges(m_aStatementHandle,
1266 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1267 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 ,
1268 (SDB_ODBC_CHAR *) pPKN, SQL_NTS);
1269 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1270 checkColumnCount();
1271 }
1272 // -------------------------------------------------------------------------
openIndexInfo(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table,sal_Bool unique,sal_Bool approximate)1273 void ODatabaseMetaDataResultSet::openIndexInfo( const Any& catalog, const ::rtl::OUString& schema,
1274 const ::rtl::OUString& table,sal_Bool unique,sal_Bool approximate )
1275 {
1276 const ::rtl::OUString *pSchemaPat = NULL;
1277
1278 if(schema.toChar() != '%')
1279 pSchemaPat = &schema;
1280 else
1281 pSchemaPat = NULL;
1282
1283 m_bFreeHandle = sal_True;
1284 ::rtl::OString aPKQ,aPKO,aPKN;
1285
1286 if ( catalog.hasValue() )
1287 aPKQ = ::rtl::OUStringToOString(comphelper::getString(catalog),m_nTextEncoding);
1288 aPKO = ::rtl::OUStringToOString(schema,m_nTextEncoding);
1289
1290 const char *pPKQ = catalog.hasValue() && aPKQ.getLength() ? aPKQ.getStr() : NULL,
1291 *pPKO = pSchemaPat && pSchemaPat->getLength() ? aPKO.getStr() : NULL,
1292 *pPKN = (aPKN = ::rtl::OUStringToOString(table,m_nTextEncoding)).getStr();
1293
1294
1295 SQLRETURN nRetcode = N3SQLStatistics(m_aStatementHandle,
1296 (SDB_ODBC_CHAR *) pPKQ, (catalog.hasValue() && aPKQ.getLength()) ? SQL_NTS : 0,
1297 (SDB_ODBC_CHAR *) pPKO, pPKO ? SQL_NTS : 0 ,
1298 (SDB_ODBC_CHAR *) pPKN, SQL_NTS,
1299 unique ? SQL_INDEX_UNIQUE : SQL_INDEX_ALL,
1300 approximate);
1301 OTools::ThrowException(m_pConnection,nRetcode,m_aStatementHandle,SQL_HANDLE_STMT,*this);
1302 checkColumnCount();
1303 }
1304 // -------------------------------------------------------------------------
checkColumnCount()1305 void ODatabaseMetaDataResultSet::checkColumnCount()
1306 {
1307 sal_Int16 nNumResultCols=0;
1308 OTools::ThrowException(m_pConnection,N3SQLNumResultCols(m_aStatementHandle,&nNumResultCols),m_aStatementHandle,SQL_HANDLE_STMT,*this);
1309 m_nDriverColumnCount = nNumResultCols;
1310 }
1311 // -----------------------------------------------------------------------------
1312
impl_getColumnType_nothrow(sal_Int32 columnIndex)1313 SWORD ODatabaseMetaDataResultSet::impl_getColumnType_nothrow(sal_Int32 columnIndex)
1314 {
1315 ::std::map<sal_Int32,SWORD>::iterator aFind = m_aODBCColumnTypes.find(columnIndex);
1316 if ( aFind == m_aODBCColumnTypes.end() )
1317 aFind = m_aODBCColumnTypes.insert(::std::map<sal_Int32,SWORD>::value_type(columnIndex,OResultSetMetaData::getColumnODBCType(m_pConnection,m_aStatementHandle,*this,columnIndex))).first;
1318 return aFind->second;
1319 }
1320