connectivity/source/drivers/postgresql/pq_resultsetmetadata.cxx

   1 /*************************************************************************
   2  *
   3  *  $RCSfile: pq_resultsetmetadata.cxx,v $
   4  *
   5  *  $Revision: 1.1.2.7 $
   6  *
   7  *  last change: $Author: jbu $ $Date: 2006/05/27 11:32:13 $
   8  *
   9  *  The Contents of this file are made available subject to the terms of
  10  *  either of the following licenses
  11  *
  12  *         - GNU Lesser General Public License Version 2.1
  13  *         - Sun Industry Standards Source License Version 1.1
  14  *
  15  *  Sun Microsystems Inc., October, 2000
  16  *
  17  *  GNU Lesser General Public License Version 2.1
  18  *  =============================================
  19  *  Copyright 2000 by Sun Microsystems, Inc.
  20  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  21  *
  22  *  This library is free software; you can redistribute it and/or
  23  *  modify it under the terms of the GNU Lesser General Public
  24  *  License version 2.1, as published by the Free Software Foundation.
  25  *
  26  *  This library is distributed in the hope that it will be useful,
  27  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  29  *  Lesser General Public License for more details.
  30  *
  31  *  You should have received a copy of the GNU Lesser General Public
  32  *  License along with this library; if not, write to the Free Software
  33  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  34  *  MA  02111-1307  USA
  35  *
  36  *
  37  *  Sun Industry Standards Source License Version 1.1
  38  *  =================================================
  39  *  The contents of this file are subject to the Sun Industry Standards
  40  *  Source License Version 1.1 (the "License"); You may not use this file
  41  *  except in compliance with the License. You may obtain a copy of the
  42  *  License at http://www.openoffice.org/license.html.
  43  *
  44  *  Software provided under this License is provided on an "AS IS" basis,
  45  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  46  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  47  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  48  *  See the License for the specific provisions governing your rights and
  49  *  obligations concerning the Software.
  50  *
  51  *  The Initial Developer of the Original Code is: Joerg Budischewski
  52  *
  53  *   Copyright: 2000 by Sun Microsystems, Inc.
  54  *
  55  *   All Rights Reserved.
  56  *
  57  *   Contributor(s): Joerg Budischewski
  58  *
  59  *
  60  ************************************************************************/
  61 #include <rtl/ustrbuf.hxx>
  62
  63 #include "pq_resultsetmetadata.hxx"
  64 #include "pq_resultset.hxx"
  65 #include "pq_tools.hxx"
  66 #include "pq_statics.hxx"
  67
  68 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  69 #include <com/sun/star/sdbc/ColumnValue.hpp>
  70 #include <com/sun/star/sdbc/XRow.hpp>
  71
  72 #include <string.h>
  73
  74 using osl::Mutex;
  75 using osl::MutexGuard;
  76
  77 using rtl::OUString;
  78 using rtl::OUStringBuffer;
  79 using rtl::OString;
  80
  81 using com::sun::star::uno::Any;
  82 using com::sun::star::uno::RuntimeException;
  83 using com::sun::star::uno::Exception;
  84 using com::sun::star::uno::Reference;
  85 using com::sun::star::uno::XInterface;
  86 using com::sun::star::uno::UNO_QUERY;
  87
  88 using com::sun::star::lang::IllegalArgumentException;
  89
  90 using com::sun::star::sdbc::SQLException;
  91 using com::sun::star::sdbc::XStatement;
  92 using com::sun::star::sdbc::XRow;
  93 using com::sun::star::sdbc::XResultSet;
  94 // using com::sun::star::sdbc::XRow;
  95 using com::sun::star::sdbc::XResultSet;
  96 using com::sun::star::sdbcx::XColumnsSupplier;
  97 using com::sun::star::sdbcx::XTablesSupplier;
  98
  99 using com::sun::star::beans::XPropertySet;
 100 using com::sun::star::container::XNameAccess;
 101
 102
 103 #define ASCII_STR(x) OUString( RTL_CONSTASCII_USTRINGPARAM( x ) )
 104
 105 namespace pq_sdbc_driver
 106 {
 107
 108 // struct ColumnMetaData
 109 // {
 110 //     rtl::OUString tableName;
 111 //     rtl::OUString schemaTableName;
 112 //     rtl::OUString typeName;
 113 //     com::sun::star::sdbc::DataType type;
 114 //     sal_Int32 precision;
 115 //     sal_Int32 scale;
 116 //     sal_Bool isCurrency;
 117 //     sal_Bool isNullable;
 118 //     sal_Bool isAutoIncrement;
 119 //     sal_Bool isReadOnly;
 120 //     sal_Bool isSigned;
 121 // };
 122
 123 // is not exported by the postgres header
 124 const static int PQ_VARHDRSZ = sizeof( sal_Int32 );
 125
 126 static void extractPrecisionAndScale( sal_Int32 atttypmod, sal_Int32 *precision, sal_Int32 *scale )
 127 {
 128     if( atttypmod < PQ_VARHDRSZ )
 129     {
 130         *precision = 0;
 131         *scale = 0;
 132     }
 133     else
 134     {
 135         if( atttypmod & 0xffff0000 )
 136         {
 137             *precision = ( ( atttypmod - PQ_VARHDRSZ ) >> 16 ) & 0xffff;
 138             *scale = (atttypmod - PQ_VARHDRSZ ) & 0xffff;
 139         }
 140         else
 141         {
 142             *precision = atttypmod - PQ_VARHDRSZ;
 143             *scale = 0;
 144         }
 145     }
 146 }
 147
 148 ResultSetMetaData::ResultSetMetaData(
 149     const ::rtl::Reference< RefCountedMutex > & refMutex,
 150     const ::com::sun::star::uno::Reference< com::sun::star::sdbc::XResultSet >  & origin,
 151     ResultSet * pResultSet,
 152     ConnectionSettings **ppSettings,
 153     PGresult *pResult,
 154     const rtl::OUString &schemaName,
 155     const rtl::OUString &tableName ) :
 156     m_refMutex( refMutex ),
 157     m_origin( origin ),
 158     m_ppSettings( ppSettings ),
 159     m_colCount( PQnfields( pResult ) ),
 160     m_tableName( tableName ),
 161     m_schemaName( schemaName ),
 162     m_checkedForTable( false ),
 163     m_checkedForTypes( false ),
 164     m_colDesc( PQnfields( pResult ) ),
 165     m_pResultSet( pResultSet )
 166 {
 167
 168     // extract all needed information from the result object, so that we don't
 169     // need it anymore after this call !
 170     for( int col = 0; col < m_colCount ; col ++ )
 171     {
 172         sal_Int32 size = PQfsize( pResult, col );
 173         size = -1 == size ? 25 : size;
 174         m_colDesc[col].displaySize = size;
 175
 176         extractPrecisionAndScale(
 177             PQfmod( pResult, col ),
 178             & ( m_colDesc[col].precision ),
 179             & ( m_colDesc[col].scale ) );
 180         char *name = PQfname( pResult, col );
 181         m_colDesc[col].name = OUString( name, strlen(name) , (*m_ppSettings)->encoding );
 182         m_colDesc[col].typeOid = PQftype( pResult, col );
 183         m_colDesc[col].type = com::sun::star::sdbc::DataType::LONGVARCHAR;
 184     }
 185 }
 186
 187 // typedef std::hash_map<
 188 //     Oid,
 189 //     rtl::OUString,
 190 //     std::hash< Oid >,
 191 //     std::equal_to< Oid >,
 192 //     Allocator < std::pair< Oid, rtl::OUString > > >  PqTypeMap;
 193
 194
 195 void ResultSetMetaData::checkForTypes()
 196 {
 197     if( ! m_checkedForTypes )
 198     {
 199         Reference< XStatement > stmt =
 200             extractConnectionFromStatement( m_origin->getStatement() )->createStatement();
 201         DisposeGuard guard( stmt );
 202         OUStringBuffer buf(128);
 203         buf.appendAscii( "SELECT oid, typname, typtype FROM pg_type WHERE ");
 204         for( int i  = 0 ; i < m_colCount ; i ++ )
 205         {
 206             if( i > 0 )
 207                 buf.appendAscii( " OR " );
 208             int oid = m_colDesc[i].typeOid;
 209             buf.appendAscii( "oid=" );
 210             buf.append( (sal_Int32) oid, 10 );
 211         }
 212         Reference< XResultSet > rs = stmt->executeQuery( buf.makeStringAndClear() );
 213         Reference< XRow > xRow( rs, UNO_QUERY );
 214         while( rs->next() )
 215         {
 216             sal_Int32 oid = xRow->getInt( 1 );
 217             OUString typeName = xRow->getString( 2 );
 218             OUString typType = xRow->getString( 3 );
 219
 220             sal_Int32 type = typeNameToDataType( typeName, typType );
 221
 222             for( int j = 0; j < m_colCount ; j ++ )
 223             {
 224                 if( m_colDesc[j].typeOid == oid )
 225                 {
 226                     m_colDesc[j].typeName = typeName;
 227                     m_colDesc[j].type = type;
 228                 }
 229             }
 230         }
 231         m_checkedForTypes = true;
 232     }
 233 }
 234
 235 void ResultSetMetaData::checkTable()
 236 {
 237     if( ! m_checkedForTable )
 238     {
 239         m_checkedForTable = true;
 240         if( m_tableName.getLength() )
 241         {
 242
 243             Reference< com::sun::star::container::XNameAccess > tables = (*m_ppSettings)->tables;
 244             if( ! tables.is() )
 245             {
 246
 247                 Reference< XTablesSupplier > supplier =
 248                     Reference< XTablesSupplier > (
 249                         extractConnectionFromStatement( m_origin->getStatement() ), UNO_QUERY);
 250                 if( supplier.is() )
 251                     tables = supplier->getTables();
 252             }
 253             if( tables.is() )
 254             {
 255                 OUString name = getTableName( 1 );
 256 //                 if( tables->hasByName( name ) )
 257                 tables->getByName( name ) >>= m_table;
 258             }
 259         }
 260     }
 261 }
 262
 263 sal_Int32 ResultSetMetaData::getIntColumnProperty( const rtl::OUString & name, int index, int def )
 264 {
 265     sal_Int32 ret = def; // give defensive answers, when data is not available
 266     try
 267     {
 268         MutexGuard guard( m_refMutex->mutex );
 269         checkColumnIndex( index );
 270         Reference< XPropertySet > set = getColumnByIndex( index );
 271
 272         if( set.is() )
 273         {
 274             set->getPropertyValue( name ) >>= ret;
 275         }
 276     }
 277     catch( com::sun::star::uno::Exception & e )
 278     {
 279     }
 280     return ret;
 281 }
 282
 283 sal_Bool ResultSetMetaData::getBoolColumnProperty( const rtl::OUString & name, int index, sal_Bool def )
 284 {
 285     sal_Bool ret = def;
 286     try
 287     {
 288         MutexGuard guard( m_refMutex->mutex );
 289         checkColumnIndex( index );
 290         Reference< XPropertySet > set = getColumnByIndex( index );
 291         if( set.is() )
 292         {
 293             set->getPropertyValue( name ) >>= ret;
 294         }
 295     }
 296     catch( com::sun::star::uno::Exception & e )
 297     {
 298     }
 299
 300     return ret;
 301 }
 302
 303 Reference< com::sun::star::beans::XPropertySet > ResultSetMetaData::getColumnByIndex( int index )
 304 {
 305     Reference< XPropertySet > ret;
 306     checkTable();
 307     if( m_table.is() )
 308     {
 309         OUString columnName = getColumnName( index );
 310         Reference< XColumnsSupplier > supplier( m_table, UNO_QUERY );
 311         if( supplier.is() )
 312         {
 313             Reference< XNameAccess > columns = supplier->getColumns();
 314             if( columns.is() && columns->hasByName( columnName ) )
 315             {
 316                 columns->getByName( columnName ) >>= ret;
 317             }
 318         }
 319     }
 320     return ret;
 321 }
 322
 323 // Methods
 324 sal_Int32 ResultSetMetaData::getColumnCount(  )
 325     throw (SQLException, RuntimeException)
 326 {
 327     return m_colCount;
 328 }
 329
 330 sal_Bool ResultSetMetaData::isAutoIncrement( sal_Int32 column )
 331     throw (SQLException, RuntimeException)
 332 {
 333
 334     sal_Bool ret = getBoolColumnProperty( getStatics().IS_AUTO_INCREMENT, column, sal_False );
 335     return ret;
 336 }
 337
 338 sal_Bool ResultSetMetaData::isCaseSensitive( sal_Int32 column )
 339     throw (SQLException, RuntimeException)
 340 {
 341
 342     return sal_True; // ??? hmm, numeric types or
 343 }
 344
 345 sal_Bool ResultSetMetaData::isSearchable( sal_Int32 column ) throw (SQLException, RuntimeException)
 346 {
 347     return sal_True; // mmm, what types are not searchable ?
 348 }
 349
 350 sal_Bool ResultSetMetaData::isCurrency( sal_Int32 column ) throw (SQLException, RuntimeException)
 351 {
 352     return getBoolColumnProperty( getStatics().IS_CURRENCY, column, sal_False );
 353 }
 354
 355 sal_Int32 ResultSetMetaData::isNullable( sal_Int32 column )
 356     throw (SQLException, RuntimeException)
 357 {
 358     return getIntColumnProperty(
 359         getStatics().IS_NULLABLE, column, com::sun::star::sdbc::ColumnValue::NULLABLE_UNKNOWN );
 360 }
 361
 362 sal_Bool ResultSetMetaData::isSigned( sal_Int32 column )
 363     throw (SQLException, RuntimeException)
 364 {
 365     return sal_True; //
 366 }
 367
 368 sal_Int32 ResultSetMetaData::getColumnDisplaySize( sal_Int32 column )
 369     throw (SQLException, RuntimeException)
 370 {
 371     MutexGuard guard( m_refMutex->mutex );
 372     checkClosed();
 373     checkColumnIndex( column );
 374     return m_colDesc[column-1].displaySize;
 375 }
 376
 377 ::rtl::OUString ResultSetMetaData::getColumnLabel( sal_Int32 column )
 378     throw (SQLException, RuntimeException)
 379 {
 380     return getColumnName( column);
 381 }
 382
 383 ::rtl::OUString ResultSetMetaData::getColumnName( sal_Int32 column ) throw (SQLException, RuntimeException)
 384 {
 385     MutexGuard guard( m_refMutex->mutex );
 386     checkClosed();
 387     checkColumnIndex( column );
 388
 389     return m_colDesc[column-1].name;
 390 }
 391
 392 ::rtl::OUString ResultSetMetaData::getSchemaName( sal_Int32 column ) throw (SQLException, RuntimeException)
 393 {
 394     return m_schemaName;
 395 }
 396
 397
 398
 399 sal_Int32 ResultSetMetaData::getPrecision( sal_Int32 column )
 400     throw (SQLException, RuntimeException)
 401 {
 402     MutexGuard guard( m_refMutex->mutex );
 403     checkClosed();
 404     checkColumnIndex( column );
 405     return m_colDesc[column-1].precision;
 406 }
 407
 408 sal_Int32 ResultSetMetaData::getScale( sal_Int32 column )
 409     throw (SQLException, RuntimeException)
 410 {
 411     MutexGuard guard( m_refMutex->mutex );
 412     checkClosed();
 413     checkColumnIndex( column );
 414     return m_colDesc[column-1].scale;
 415 }
 416
 417 ::rtl::OUString ResultSetMetaData::getTableName( sal_Int32 column )
 418     throw (SQLException, RuntimeException)
 419 {
 420     rtl::OUString ret;
 421     if( m_tableName.getLength() )
 422     {
 423         OUStringBuffer buf( 128 );
 424         buf.append( m_schemaName );
 425         buf.appendAscii( "." );
 426         buf.append( m_tableName );
 427         ret = buf.makeStringAndClear();
 428     }
 429     return ret;
 430 }
 431
 432 ::rtl::OUString ResultSetMetaData::getCatalogName( sal_Int32 column )
 433     throw (SQLException, RuntimeException)
 434 {
 435     // can do this through XConnection.getCatalog() !
 436     return OUString();
 437 }
 438 sal_Int32 ResultSetMetaData::getColumnType( sal_Int32 column )
 439     throw (SQLException, RuntimeException)
 440 {
 441     int ret = getIntColumnProperty( getStatics().TYPE, column, -100 );
 442     if( -100 == ret )
 443     {
 444         checkForTypes();
 445         if( com::sun::star::sdbc::DataType::LONGVARCHAR == m_colDesc[column-1].type && m_pResultSet )
 446             m_colDesc[column-1].type = m_pResultSet->guessDataType( column );
 447         ret = m_colDesc[column-1].type;
 448     }
 449     return ret;
 450 }
 451
 452 ::rtl::OUString ResultSetMetaData::getColumnTypeName( sal_Int32 column )
 453     throw (SQLException, RuntimeException)
 454 {
 455     ::rtl::OUString ret; // give defensive answers, when data is not available
 456     try
 457     {
 458         MutexGuard guard( m_refMutex->mutex );
 459         checkColumnIndex( column );
 460         Reference< XPropertySet > set = getColumnByIndex( column );
 461
 462         if( set.is() )
 463         {
 464             set->getPropertyValue( getStatics().TYPE_NAME ) >>= ret;
 465         }
 466         else
 467         {
 468             checkForTypes();
 469             ret = m_colDesc[column-1].typeName;
 470         }
 471     }
 472     catch( com::sun::star::uno::Exception & e )
 473     {
 474     }
 475     return ret;
 476 }
 477
 478
 479 sal_Bool ResultSetMetaData::isReadOnly( sal_Int32 column )
 480     throw (SQLException, RuntimeException)
 481 {
 482     return sal_False;
 483 }
 484
 485 sal_Bool ResultSetMetaData::isWritable( sal_Int32 column )
 486     throw (SQLException, RuntimeException)
 487 {
 488     return ! isReadOnly( column ); // what's the sense if this method ?
 489 }
 490
 491 sal_Bool ResultSetMetaData::isDefinitelyWritable( sal_Int32 column )
 492     throw (SQLException, RuntimeException)
 493 {
 494     return isWritable(column); // uhh, now it becomes really esoteric ....
 495 }
 496 ::rtl::OUString ResultSetMetaData::getColumnServiceName( sal_Int32 column )
 497     throw (SQLException, RuntimeException)
 498 {
 499     return OUString();
 500 }
 501
 502 void ResultSetMetaData::checkClosed()
 503     throw (::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 504 {
 505     // we never close
 506 }
 507
 508 void ResultSetMetaData::checkColumnIndex(sal_Int32 columnIndex)
 509     throw (::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
 510 {
 511     if( columnIndex < 1 || columnIndex > m_colCount )
 512     {
 513         OUStringBuffer buf(128);
 514
 515         buf.appendAscii( "pq_resultsetmetadata: index out of range (expected 1 to " );
 516         buf.append( m_colCount );
 517         buf.appendAscii( ", got " );
 518         buf.append( columnIndex );
 519         throw SQLException(
 520             buf.makeStringAndClear(), *this, OUString(), 1, Any() );
 521     }
 522 }
 523
 524 }