connectivity/source/drivers/postgresql/pq_connection.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  Effective License of whole file:
   5  *
   6  *    This library is free software; you can redistribute it and/or
   7  *    modify it under the terms of the GNU Lesser General Public
   8  *    License version 2.1, as published by the Free Software Foundation.
   9  *
  10  *    This library is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *    Lesser General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU Lesser General Public
  16  *    License along with this library; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  18  *    MA  02111-1307  USA
  19  *
  20  *  Parts "Copyright by Sun Microsystems, Inc" prior to August 2011:
  21  *
  22  *    The Contents of this file are made available subject to the terms of
  23  *    the GNU Lesser General Public License Version 2.1
  24  *
  25  *    Copyright: 2000 by Sun Microsystems, Inc.
  26  *
  27  *    Contributor(s): Joerg Budischewski
  28  *
  29  *  All parts contributed on or after August 2011:
  30  *
  31  *    This Source Code Form is subject to the terms of the Mozilla Public
  32  *    License, v. 2.0. If a copy of the MPL was not distributed with this
  33  *    file, You can obtain one at http://mozilla.org/MPL/2.0/.
  34  *
  35  ************************************************************************/
  36
  37 #include <list>
  38 #include <stdio.h>
  39 #include <time.h>
  40 #include <string.h>
  41
  42 #include <boost/shared_ptr.hpp>
  43
  44 #include "pq_connection.hxx"
  45 #include "pq_statement.hxx"
  46 #include "pq_preparedstatement.hxx"
  47 #include "pq_databasemetadata.hxx"
  48 #include "pq_xcontainer.hxx"
  49 #include "pq_statics.hxx"
  50 #include "pq_xtables.hxx"
  51 #include "pq_xviews.hxx"
  52 #include "pq_xusers.hxx"
  53
  54 #include <rtl/ustrbuf.hxx>
  55 #include <rtl/strbuf.hxx>
  56 #include <rtl/uuid.h>
  57 #include <rtl/bootstrap.hxx>
  58 #include <osl/module.h>
  59
  60 #include <cppuhelper/implementationentry.hxx>
  61 #include <cppuhelper/implbase1.hxx>
  62
  63 #include <com/sun/star/beans/PropertyValue.hpp>
  64 #include <com/sun/star/script/Converter.hpp>
  65 #include <com/sun/star/sdbc/XRow.hpp>
  66
  67 using osl::MutexGuard;
  68
  69 using com::sun::star::container::XNameAccess;
  70
  71 using com::sun::star::lang::XComponent;
  72 using com::sun::star::lang::XInitialization;
  73 using com::sun::star::lang::IllegalArgumentException;
  74
  75 using com::sun::star::script::Converter;
  76 using com::sun::star::script::XTypeConverter;
  77
  78 using com::sun::star::uno::RuntimeException;
  79 using com::sun::star::uno::Exception;
  80 using com::sun::star::uno::Sequence;
  81 using com::sun::star::uno::Reference;
  82 using com::sun::star::uno::XInterface;
  83 using com::sun::star::uno::UNO_QUERY;
  84 using com::sun::star::uno::XComponentContext;
  85 using com::sun::star::uno::Any;
  86 using com::sun::star::uno::makeAny;
  87
  88 using com::sun::star::beans::PropertyValue;
  89 using com::sun::star::beans::XPropertySet;
  90
  91 using com::sun::star::sdbc::XConnection;
  92 using com::sun::star::sdbc::XResultSet;
  93 using com::sun::star::sdbc::XRow;
  94 using com::sun::star::sdbc::XCloseable;
  95 using com::sun::star::sdbc::SQLException;
  96 using com::sun::star::sdbc::XWarningsSupplier;
  97 using com::sun::star::sdbc::XPreparedStatement;
  98 using com::sun::star::sdbc::XStatement;
  99 using com::sun::star::sdbc::XDatabaseMetaData;
 100
 101 namespace pq_sdbc_driver
 102 {
 103
 104
 105
 106 // Helper class for statement lifetime management
 107 class ClosableReference : public cppu::WeakImplHelper1< com::sun::star::uno::XReference >
 108 {
 109     Connection *m_conn;
 110     ::rtl::ByteSequence m_id;
 111 public:
 112     ClosableReference( const ::rtl::ByteSequence & id , Connection *that )
 113       :  m_conn( that ), m_id( id )
 114     {
 115         that->acquire();
 116     }
 117
 118     virtual ~ClosableReference()
 119     {
 120         if( m_conn )
 121             m_conn->release();
 122     }
 123
 124     virtual void SAL_CALL dispose() throw (std::exception) SAL_OVERRIDE
 125     {
 126         if( m_conn )
 127         {
 128             m_conn->removeFromWeakMap(m_id);
 129             m_conn->release();
 130             m_conn = 0;
 131         }
 132     }
 133 };
 134
 135 OUString    ConnectionGetImplementationName()
 136 {
 137     return OUString( "org.openoffice.comp.connectivity.pq.Connection.noext" );
 138 }
 139 com::sun::star::uno::Sequence<OUString> ConnectionGetSupportedServiceNames(void)
 140 {
 141     OUString serv( "com.sun.star.sdbc.Connection" );
 142     return Sequence< OUString> (&serv,1);
 143 }
 144
 145 static sal_Int32 readLogLevelFromConfiguration()
 146 {
 147     sal_Int32 loglevel = LogLevel::NONE;
 148     OUString fileName;
 149     osl_getModuleURLFromAddress(
 150         (void*) readLogLevelFromConfiguration, (rtl_uString **) &fileName );
 151     fileName = fileName.copy( fileName.lastIndexOf( '/' )+1 );
 152     fileName += "postgresql-sdbc.ini";
 153     rtl::Bootstrap bootstrapHandle( fileName );
 154
 155     OUString str;
 156     if( bootstrapHandle.getFrom( "PQ_LOGLEVEL", str ) )
 157     {
 158         if ( str == "NONE" )
 159             loglevel = LogLevel::NONE;
 160         else if ( str == "ERROR" )
 161             loglevel = LogLevel::ERROR;
 162         else if ( str == "SQL" )
 163             loglevel = LogLevel::SQL;
 164         else if ( str == "INFO" )
 165             loglevel = LogLevel::INFO;
 166         else
 167         {
 168             fprintf( stderr, "unknown loglevel %s\n",
 169                      OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() );
 170         }
 171     }
 172     return loglevel;
 173 }
 174
 175 Connection::Connection(
 176     const rtl::Reference< RefCountedMutex > &refMutex,
 177     const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext > & ctx )
 178     : ConnectionBase( refMutex->mutex ),
 179       m_ctx( ctx ) ,
 180       m_refMutex( refMutex )
 181 {
 182     m_settings.loglevel = readLogLevelFromConfiguration();
 183
 184     if( m_settings.loglevel > LogLevel::NONE )
 185     {
 186         m_settings.logFile = fopen( "sdbc-pqsql.log", "a" );
 187         if( m_settings.logFile )
 188         {
 189             setvbuf( m_settings.logFile, 0, _IONBF, 0 );
 190             log( &m_settings, m_settings.loglevel , "set this loglevel" );
 191         }
 192         else
 193         {
 194             fprintf( stderr, "Couldn't open sdbc-pqsql.log file\n" );
 195         }
 196     }
 197 }
 198
 199 Connection::~Connection()
 200 {
 201     POSTGRE_TRACE( "dtor connection" );
 202     if( m_settings.pConnection )
 203     {
 204         PQfinish( m_settings.pConnection );
 205         m_settings.pConnection = 0;
 206     }
 207     if( m_settings.logFile )
 208     {
 209         fclose( m_settings.logFile );
 210         m_settings.logFile = 0;
 211     }
 212 }
 213 typedef ::std::list< ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XCloseable > > CloseableList;
 214
 215 typedef ::std::list< ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > > DisposeableList;
 216
 217 void Connection::close() throw ( SQLException, RuntimeException, std::exception )
 218 {
 219     CloseableList lst;
 220     DisposeableList lstDispose;
 221     {
 222         MutexGuard guard( m_refMutex->mutex );
 223         // silently ignore, if the connection has been closed already
 224         if( m_settings.pConnection )
 225         {
 226             log( &m_settings, LogLevel::INFO, "closing connection" );
 227             PQfinish( m_settings.pConnection );
 228             m_settings.pConnection = 0;
 229         }
 230
 231         lstDispose.push_back( Reference< XComponent > ( m_settings.users, UNO_QUERY ) );
 232         lstDispose.push_back( Reference< XComponent > ( m_settings.tables , UNO_QUERY ) );
 233         lstDispose.push_back( Reference< XComponent > ( m_meta, UNO_QUERY ) );
 234         m_meta.clear();
 235         m_settings.tables.clear();
 236         m_settings.users.clear();
 237
 238         for( WeakHashMap::iterator ii = m_myStatements.begin() ;
 239              ii != m_myStatements.end() ;
 240              ++ii )
 241         {
 242             Reference< XCloseable > r = ii->second;
 243             if( r.is() )
 244                 lst.push_back( r );
 245         }
 246     }
 247
 248     // close all created statements
 249     for( CloseableList::iterator ii = lst.begin(); ii != lst.end() ; ++ii )
 250         ii->get()->close();
 251
 252     // close all created statements
 253     for( DisposeableList::iterator iiDispose = lstDispose.begin();
 254          iiDispose != lstDispose.end() ; ++iiDispose )
 255     {
 256         if( iiDispose->is() )
 257             iiDispose->get()->dispose();
 258     }
 259 }
 260
 261
 262 void Connection::removeFromWeakMap( const ::rtl::ByteSequence & id )
 263 {
 264     // shrink the list !
 265     MutexGuard guard( m_refMutex->mutex );
 266     WeakHashMap::iterator ii = m_myStatements.find( id );
 267     if( ii != m_myStatements.end() )
 268         m_myStatements.erase( ii );
 269 }
 270
 271 Reference< XStatement > Connection::createStatement() throw (SQLException, RuntimeException, std::exception)
 272 {
 273     MutexGuard guard( m_refMutex->mutex );
 274     checkClosed();
 275
 276     Statement *stmt = new Statement( m_refMutex, this , &m_settings );
 277     Reference< XStatement > ret( stmt );
 278     ::rtl::ByteSequence id( 16 );
 279     rtl_createUuid( (sal_uInt8*) id.getConstArray(), 0 , sal_False );
 280     m_myStatements[ id ] = Reference< XCloseable > ( stmt );
 281     stmt->queryAdapter()->addReference( new ClosableReference( id, this ) );
 282     return ret;
 283 }
 284
 285 Reference< XPreparedStatement > Connection::prepareStatement( const OUString& sql )
 286         throw (SQLException, RuntimeException, std::exception)
 287 {
 288     MutexGuard guard( m_refMutex->mutex );
 289     checkClosed();
 290
 291     OString byteSql = OUStringToOString( sql, m_settings.encoding );
 292     PreparedStatement *stmt = new PreparedStatement( m_refMutex, this, &m_settings, byteSql );
 293     Reference< XPreparedStatement > ret = stmt;
 294
 295     ::rtl::ByteSequence id( 16 );
 296     rtl_createUuid( (sal_uInt8*) id.getConstArray(), 0 , sal_False );
 297     m_myStatements[ id ] = Reference< XCloseable > ( stmt );
 298     stmt->queryAdapter()->addReference( new ClosableReference( id, this ) );
 299     return ret;
 300 }
 301
 302 Reference< XPreparedStatement > Connection::prepareCall( const OUString& )
 303         throw (SQLException, RuntimeException, std::exception)
 304 {
 305     throw SQLException(
 306         OUString( "pq_driver: Callable statements not supported" ),
 307         Reference< XInterface > (), OUString() , 1, Any() );
 308 }
 309
 310
 311 OUString Connection::nativeSQL( const OUString& sql )
 312         throw (SQLException, RuntimeException, std::exception)
 313 {
 314     return sql;
 315 }
 316
 317 void Connection::setAutoCommit( sal_Bool ) throw (SQLException, RuntimeException, std::exception)
 318 {
 319     // UNSUPPORTED
 320 }
 321
 322 sal_Bool Connection::getAutoCommit() throw (SQLException, RuntimeException, std::exception)
 323 {
 324     // UNSUPPORTED
 325     return sal_True;
 326 }
 327
 328 void Connection::commit() throw (SQLException, RuntimeException, std::exception)
 329 {
 330     // UNSUPPORTED
 331 }
 332
 333 void Connection::rollback() throw (SQLException, RuntimeException, std::exception)
 334 {
 335     // UNSUPPORTED
 336 }
 337
 338 sal_Bool Connection::isClosed() throw (SQLException, RuntimeException, std::exception)
 339 {
 340     return m_settings.pConnection == 0;
 341 }
 342
 343 Reference< XDatabaseMetaData > Connection::getMetaData()
 344         throw (SQLException, RuntimeException, std::exception)
 345 {
 346     MutexGuard guard( m_refMutex->mutex );
 347     checkClosed();
 348     if( ! m_meta.is() )
 349         m_meta = new DatabaseMetaData( m_refMutex, this, &m_settings );
 350     return m_meta;
 351 }
 352
 353 void  Connection::setReadOnly( sal_Bool ) throw (SQLException, RuntimeException, std::exception)
 354 {
 355     // UNSUPPORTED
 356
 357 }
 358
 359 sal_Bool Connection::isReadOnly() throw (SQLException, RuntimeException, std::exception)
 360 {
 361     // UNSUPPORTED
 362     return sal_False;
 363 }
 364
 365 void Connection::setCatalog( const OUString& )
 366         throw (SQLException, RuntimeException, std::exception)
 367 {
 368     // UNSUPPORTED
 369 }
 370
 371 OUString Connection::getCatalog() throw (SQLException, RuntimeException, std::exception)
 372 {
 373     MutexGuard guard( m_refMutex->mutex );
 374     if( m_settings.pConnection == 0 )
 375     {
 376         throw SQLException( "pq_connection: connection is closed", *this,
 377                             OUString(), 1, Any() );
 378     }
 379     char * p = PQdb(m_settings.pConnection );
 380     return OUString( p, strlen(p) ,  m_settings.encoding );
 381 }
 382
 383 void Connection::setTransactionIsolation( sal_Int32 )
 384         throw (SQLException, RuntimeException, std::exception)
 385 {
 386     // UNSUPPORTED
 387 }
 388
 389 sal_Int32 Connection::getTransactionIsolation() throw (SQLException, RuntimeException, std::exception)
 390 {
 391     // UNSUPPORTED
 392     return 0;
 393 }
 394
 395 Reference< XNameAccess > Connection::getTypeMap() throw (SQLException, RuntimeException, std::exception)
 396 {
 397     Reference< XNameAccess > t;
 398     {
 399         MutexGuard guard( m_refMutex->mutex );
 400         t = m_typeMap;
 401     }
 402     return t;
 403 }
 404
 405 void Connection::setTypeMap( const Reference< XNameAccess >& typeMap )
 406         throw (SQLException, RuntimeException, std::exception)
 407 {
 408     MutexGuard guard( m_refMutex->mutex );
 409     m_typeMap = typeMap;
 410 }
 411 Any Connection::getWarnings() throw (SQLException, RuntimeException, std::exception)
 412 {
 413     return Any();
 414 }
 415
 416 void Connection::clearWarnings() throw (SQLException, RuntimeException, std::exception)
 417 {
 418 }
 419
 420 class cstr_vector
 421 {
 422     std::vector<char*> values;
 423     std::vector<bool>  acquired;
 424 public:
 425     cstr_vector () : values(), acquired() { values.reserve(8); acquired.reserve(8); }
 426     ~cstr_vector ()
 427     {
 428         OSL_ENSURE(values.size() == acquired.size(), "pq_connection: cstr_vector values and acquired size mismatch");
 429         std::vector<char*>::iterator pv = values.begin();
 430         std::vector<bool>::iterator pa = acquired.begin();
 431         const std::vector<char*>::iterator pve = values.end();
 432         for( ; pv < pve ; ++pv, ++pa )
 433             if (*pa)
 434                 free(*pv);
 435     }
 436     void push_back(const char* s, __sal_NoAcquire)
 437     {
 438         values.push_back(const_cast<char*>(s));
 439         acquired.push_back(false);
 440     }
 441     void push_back(char* s)
 442     {
 443         values.push_back(s);
 444         acquired.push_back(true);
 445     }
 446     // This const_cast is there for compatibility with PostgreSQL <= 9.1;
 447     // PostgreSQL >= 9.2 has the right const qualifiers in the headers
 448     // for a return type of "char const*const*".
 449     char const** c_array() const { return const_cast <const char**>(&values[0]); }
 450 };
 451
 452 static void properties2arrays( const Sequence< PropertyValue > & args,
 453                                const Reference< XTypeConverter> &tc,
 454                                rtl_TextEncoding enc,
 455                                cstr_vector &keywords,
 456                                cstr_vector &values)
 457 {
 458     // LEM TODO: can we just blindly take all properties?
 459     // I.e. they are prefiltered to have only relevant ones?
 460     // Else, at least support all keywords from
 461     // http://www.postgresql.org/docs/9.0/interactive/libpq-connect.html
 462
 463     static const char* keyword_list[] = {
 464         "password",
 465         "user",
 466         "port",
 467         "dbname",
 468         "connect_timeout",
 469         "options",
 470         "requiressl"
 471     };
 472
 473     for( int i = 0; i < args.getLength() ; ++i )
 474     {
 475         bool append = false;
 476         for( size_t j = 0; j < SAL_N_ELEMENTS( keyword_list ); j++)
 477         {
 478             if( args[i].Name.equalsIgnoreAsciiCaseAscii( keyword_list[j] ))
 479             {
 480                 keywords.push_back( keyword_list[j], SAL_NO_ACQUIRE );
 481                 append = true;
 482                 break;
 483             }
 484         }
 485
 486         if( append )
 487         {
 488             OUString value;
 489             tc->convertTo( args[i].Value, getCppuType( &value) ) >>= value;
 490             char *v = strdup(OUStringToOString(value, enc).getStr());
 491             values.push_back ( v );
 492         }
 493         else
 494         {
 495             // ignore for now
 496             OSL_TRACE("sdbc-postgresql: unknown argument '%s'", OUStringToOString( args[i].Name, RTL_TEXTENCODING_UTF8 ).getStr() );
 497         }
 498     }
 499 }
 500
 501 void Connection::initialize( const Sequence< Any >& aArguments )
 502         throw (Exception, RuntimeException, std::exception)
 503 {
 504     OUString url;
 505     Sequence< PropertyValue > args;
 506
 507     Reference< XTypeConverter > tc( Converter::create(m_ctx) );
 508     if( ! tc.is() )
 509     {
 510         throw RuntimeException(
 511             OUString("pq_driver: Couldn't instantiate converter service" ),
 512             Reference< XInterface > () );
 513     }
 514     if( aArguments.getLength() != 2 )
 515     {
 516         OUStringBuffer buf(128);
 517         buf.appendAscii( "pq_driver: expected 2 arguments, got " );
 518         buf.append( aArguments.getLength( ) );
 519         throw IllegalArgumentException(buf.makeStringAndClear(), Reference< XInterface > () , 0 );
 520     }
 521
 522     if( ! (aArguments[0] >>= url) )
 523     {
 524         OUStringBuffer buf(128);
 525         buf.appendAscii( "pq_driver: expected string as first argument, got " );
 526         buf.append( aArguments[0].getValueType().getTypeName() );
 527         throw IllegalArgumentException( buf.makeStringAndClear() , *this, 0 );
 528     }
 529
 530     tc->convertTo( aArguments[1], getCppuType( &args ) ) >>= args;
 531
 532     OString o;
 533     int nColon = url.indexOf( ':' );
 534     if( nColon != -1 )
 535     {
 536         nColon = url.indexOf( ':' , 1+ nColon );
 537         if( nColon != -1 )
 538         {
 539              o = OUStringToOString( url.getStr()+nColon+1, m_settings.encoding );
 540         }
 541     }
 542     {
 543         cstr_vector keywords;
 544         cstr_vector values;
 545
 546         if ( o.getLength() > 0 )
 547         {
 548             char *err;
 549             boost::shared_ptr<PQconninfoOption> oOpts(PQconninfoParse(o.getStr(), &err), PQconninfoFree);
 550             if ( oOpts.get() == NULL )
 551             {
 552                 OUString errorMessage;
 553                 if ( err != NULL)
 554                 {
 555                     errorMessage = OUString( err, strlen(err), m_settings.encoding );
 556                     free(err);
 557                 }
 558                 else
 559                     errorMessage = "#no error message#";
 560                 OUStringBuffer buf( 128 );
 561                 buf.appendAscii( "Error in database URL '" );
 562                 buf.append( url );
 563                 buf.appendAscii( "':\n" );
 564                 buf.append( errorMessage );
 565                 // HY092 is "Invalid attribute/option identifier."
 566                 // Just the most likely error; the error might be  HY024 "Invalid attribute value".
 567                 throw SQLException( buf.makeStringAndClear(), *this, OUString("HY092"), 5, Any() );
 568             }
 569
 570             for (  PQconninfoOption * opt = oOpts.get(); opt->keyword != NULL; ++opt)
 571             {
 572                 if ( opt->val != NULL )
 573                 {
 574                     keywords.push_back(strdup(opt->keyword));
 575                     values.push_back(strdup(opt->val));
 576                 }
 577             }
 578         }
 579         properties2arrays( args , tc, m_settings.encoding, keywords, values );
 580         keywords.push_back(NULL, SAL_NO_ACQUIRE);
 581         values.push_back(NULL, SAL_NO_ACQUIRE);
 582
 583         m_settings.pConnection = PQconnectdbParams( keywords.c_array(), values.c_array(), 0 );
 584     }
 585     if( ! m_settings.pConnection )
 586         throw RuntimeException("pq_driver: out of memory",
 587                                 Reference< XInterface > () );
 588     if( PQstatus( m_settings.pConnection ) == CONNECTION_BAD )
 589     {
 590         OUStringBuffer buf( 128 );
 591
 592         const char * error = PQerrorMessage( m_settings.pConnection );
 593         OUString errorMessage( error, strlen( error) , RTL_TEXTENCODING_ASCII_US );
 594         buf.appendAscii( "Couldn't establish database connection to '" );
 595         buf.append( url );
 596         buf.appendAscii( "'\n" );
 597         buf.append( errorMessage );
 598         PQfinish( m_settings.pConnection );
 599         m_settings.pConnection = 0;
 600         throw SQLException( buf.makeStringAndClear(), *this, errorMessage, CONNECTION_BAD, Any() );
 601     }
 602     PQsetClientEncoding( m_settings.pConnection, "UNICODE" );
 603     char *p = PQuser( m_settings.pConnection );
 604     m_settings.user = OUString( p, strlen(p), RTL_TEXTENCODING_UTF8);
 605     p = PQdb( m_settings.pConnection );
 606     m_settings.catalog = OUString( p, strlen(p), RTL_TEXTENCODING_UTF8);
 607     m_settings.tc = tc;
 608
 609     if( isLog( &m_settings, LogLevel::INFO ) )
 610     {
 611         OUStringBuffer buf( 128 );
 612         buf.appendAscii( "connection to '" );
 613         buf.append( url );
 614         buf.appendAscii( "' successfully opened" );
 615         log( &m_settings, LogLevel::INFO, buf.makeStringAndClear() );
 616     }
 617 }
 618
 619 void Connection::disposing()
 620 {
 621     close();
 622 }
 623
 624 void Connection::checkClosed() throw ( SQLException, RuntimeException )
 625 {
 626     if( !m_settings.pConnection )
 627         throw SQLException( "pq_connection: Connection already closed",
 628                             *this, OUString(), 1, Any() );
 629 }
 630
 631 Reference< XNameAccess > Connection::getTables()
 632     throw (::com::sun::star::uno::RuntimeException, std::exception)
 633 {
 634     if( isLog( &m_settings, LogLevel::INFO ) )
 635     {
 636         log( &m_settings, LogLevel::INFO, "Connection::getTables() got called" );
 637     }
 638     MutexGuard guard( m_refMutex->mutex );
 639     if( !m_settings.tables.is() )
 640         m_settings.tables = Tables::create( m_refMutex, this, &m_settings , &m_settings.pTablesImpl);
 641     else
 642         // TODO: how to overcome the performance problem ?
 643         Reference< com::sun::star::util::XRefreshable > ( m_settings.tables, UNO_QUERY )->refresh();
 644     return m_settings.tables;
 645 }
 646
 647 Reference< XNameAccess > Connection::getViews()
 648     throw (::com::sun::star::uno::RuntimeException, std::exception)
 649 {
 650     if( isLog( &m_settings, LogLevel::INFO ) )
 651     {
 652         log( &m_settings, LogLevel::INFO, "Connection::getViews() got called" );
 653     }
 654     MutexGuard guard( m_refMutex->mutex );
 655     if( !m_settings.views.is() )
 656         m_settings.views = Views::create( m_refMutex, this, &m_settings, &(m_settings.pViewsImpl) );
 657     else
 658         // TODO: how to overcome the performance problem ?
 659         Reference< com::sun::star::util::XRefreshable > ( m_settings.views, UNO_QUERY )->refresh();
 660     return m_settings.views;
 661 }
 662
 663
 664
 665 Reference< XNameAccess > Connection::getUsers()
 666     throw (::com::sun::star::uno::RuntimeException, std::exception)
 667 {
 668     if( isLog( &m_settings, LogLevel::INFO ) )
 669     {
 670         log( &m_settings, LogLevel::INFO, "Connection::getUsers() got called" );
 671     }
 672
 673     MutexGuard guard( m_refMutex->mutex );
 674     if( !m_settings.users.is() )
 675         m_settings.users = Users::create( m_refMutex, this, &m_settings );
 676     return m_settings.users;
 677 }
 678
 679
 680 Reference< XInterface >  ConnectionCreateInstance(
 681     const Reference< XComponentContext > & ctx ) throw (Exception)
 682 {
 683     ::rtl::Reference< RefCountedMutex > ref = new RefCountedMutex();
 684     return * new Connection( ref, ctx );
 685 }
 686
 687
 688
 689 bool isLog( ConnectionSettings *settings, int loglevel )
 690 {
 691     return settings->loglevel >= loglevel && settings->logFile;
 692 }
 693
 694 void log( ConnectionSettings *settings, sal_Int32 level, const OUString &logString )
 695 {
 696     log( settings, level, OUStringToOString( logString, settings->encoding ).getStr() );
 697 }
 698 void log( ConnectionSettings *settings, sal_Int32 level, const char *str )
 699 {
 700     if( isLog( settings, level ) )
 701     {
 702         static const char *strLevel[] = { "NONE", "ERROR", "SQL", "INFO", "DATA" };
 703
 704         time_t t = ::time( 0 );
 705         char *pString;
 706 #ifdef SAL_W32
 707         pString = asctime( localtime( &t ) );
 708 #else
 709         struct tm timestruc;
 710         char timestr[50];
 711         memset( timestr, 0 , 50);
 712         pString = timestr;
 713         ::localtime_r( &t , &timestruc );
 714         asctime_r( &timestruc, timestr );
 715 #endif
 716         for( int i = 0 ; pString[i] ; i ++ )
 717         {
 718             if( pString[i] <= 13 )
 719             {
 720                 pString[i] = 0;
 721                 break;
 722             }
 723         }
 724         fprintf( settings->logFile, "%s [%s]: %s\n", pString, strLevel[level], str );
 725     }
 726 }
 727
 728
 729 }
 730
 731
 732
 733 static const struct cppu::ImplementationEntry g_entries[] =
 734 {
 735     {
 736         pq_sdbc_driver::ConnectionCreateInstance, pq_sdbc_driver::ConnectionGetImplementationName,
 737         pq_sdbc_driver::ConnectionGetSupportedServiceNames, cppu::createSingleComponentFactory,
 738         0 , 0
 739     },
 740     { 0, 0, 0, 0, 0, 0 }
 741 };
 742
 743
 744 extern "C"
 745 {
 746
 747 SAL_DLLPUBLIC_EXPORT void * SAL_CALL postgresql_sdbc_impl_component_getFactory(
 748     const sal_Char * pImplName, void * pServiceManager, void * pRegistryKey )
 749 {
 750     return cppu::component_getFactoryHelper( pImplName, pServiceManager, pRegistryKey , g_entries );
 751 }
 752
 753 }
 754
 755 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */