connectivity/source/drivers/odbc/ODatabaseMetaDataResultSet.cxx

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