connectivity/source/drivers/postgresql/pq_xtable.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 <rtl/ustrbuf.hxx>
  38
  39 #include <cppuhelper/typeprovider.hxx>
  40 #include <cppuhelper/queryinterface.hxx>
  41
  42 #include <com/sun/star/beans/PropertyAttribute.hpp>
  43 #include <com/sun/star/sdbc/SQLException.hpp>
  44
  45 #include "pq_xtable.hxx"
  46 #include "pq_xtables.hxx"
  47 #include "pq_xviews.hxx"
  48 #include "pq_xindexes.hxx"
  49 #include "pq_xkeys.hxx"
  50 #include "pq_xcolumns.hxx"
  51 #include "pq_tools.hxx"
  52 #include "pq_statics.hxx"
  53
  54 using osl::MutexGuard;
  55
  56 using com::sun::star::container::XNameAccess;
  57 using com::sun::star::container::XIndexAccess;
  58
  59 using com::sun::star::uno::Reference;
  60 using com::sun::star::uno::UNO_QUERY;
  61 using com::sun::star::uno::Sequence;
  62 using com::sun::star::uno::Any;
  63 using com::sun::star::uno::makeAny;
  64 using com::sun::star::uno::Type;
  65
  66 using com::sun::star::beans::XPropertySet;
  67
  68 using com::sun::star::sdbc::XStatement;
  69 using com::sun::star::sdbc::SQLException;
  70
  71 namespace pq_sdbc_driver
  72 {
  73 Table::Table( const ::rtl::Reference< comphelper::RefCountedMutex > & refMutex,
  74               const Reference< css::sdbc::XConnection > & connection,
  75               ConnectionSettings *pSettings)
  76     : ReflectionBase(
  77         getStatics().refl.table.implName,
  78         getStatics().refl.table.serviceNames,
  79         refMutex,
  80         connection,
  81         pSettings,
  82         * getStatics().refl.table.pProps ),
  83       m_pColumns( nullptr )
  84 {}
  85
  86 Reference< XPropertySet > Table::createDataDescriptor(  )
  87 {
  88     TableDescriptor * pTable = new TableDescriptor(
  89         m_xMutex, m_conn, m_pSettings );
  90     pTable->copyValuesFrom( this );
  91
  92     return Reference< XPropertySet > ( pTable );
  93 }
  94
  95 Reference< XNameAccess > Table::getColumns(  )
  96 {
  97     if( ! m_columns.is() )
  98     {
  99         m_columns = Columns::create(
 100             m_xMutex,
 101             m_conn,
 102             m_pSettings,
 103             extractStringProperty( this, getStatics().SCHEMA_NAME ),
 104             extractStringProperty( this, getStatics().NAME ),
 105             &m_pColumns);
 106     }
 107     return m_columns;
 108 }
 109
 110 Reference< XNameAccess > Table::getIndexes()
 111 {
 112     if( ! m_indexes.is() )
 113     {
 114         m_indexes = ::pq_sdbc_driver::Indexes::create(
 115             m_xMutex,
 116             m_conn,
 117             m_pSettings,
 118             extractStringProperty( this, getStatics().SCHEMA_NAME ),
 119             extractStringProperty( this, getStatics().NAME ) );
 120     }
 121     return m_indexes;
 122 }
 123
 124 Reference< XIndexAccess > Table::getKeys(  )
 125 {
 126     if( ! m_keys.is() )
 127     {
 128         m_keys = ::pq_sdbc_driver::Keys::create(
 129             m_xMutex,
 130             m_conn,
 131             m_pSettings,
 132             extractStringProperty( this, getStatics().SCHEMA_NAME ),
 133             extractStringProperty( this, getStatics().NAME ) );
 134     }
 135     return m_keys;
 136 }
 137
 138 void Table::rename( const OUString& newName )
 139 {
 140     MutexGuard guard( m_xMutex->GetMutex() );
 141     Statics & st = getStatics();
 142
 143     OUString oldName = extractStringProperty(this,st.NAME );
 144     OUString schema = extractStringProperty(this,st.SCHEMA_NAME );
 145     OUString fullOldName = concatQualified( schema, oldName );
 146
 147     OUString newTableName;
 148     OUString newSchemaName;
 149     // OOo2.0 passes schema + dot + new-table-name while
 150     // OO1.1.x passes new Name without schema
 151     // in case name contains a dot, it is interpreted as schema.tablename
 152     if( newName.indexOf( '.' ) >= 0 )
 153     {
 154         splitConcatenatedIdentifier( newName, &newSchemaName, &newTableName );
 155     }
 156     else
 157     {
 158         newTableName = newName;
 159         newSchemaName = schema;
 160     }
 161     OUString fullNewName = concatQualified( newSchemaName, newTableName );
 162
 163     if( extractStringProperty( this, st.TYPE ) == st.VIEW && m_pSettings->views.is() )
 164     {
 165         // maintain view list (really strange API !)
 166         Any a = m_pSettings->pViewsImpl->getByName( fullOldName );
 167         Reference< css::sdbcx::XRename > Xrename;
 168         a >>= Xrename;
 169         if( Xrename.is() )
 170         {
 171             Xrename->rename( newName );
 172             setPropertyValue_NoBroadcast_public( st.SCHEMA_NAME, makeAny(newSchemaName) );
 173         }
 174     }
 175     else
 176     {
 177         if( newSchemaName != schema )
 178         {
 179             // try new schema name first
 180             try
 181             {
 182                 OUStringBuffer buf(128);
 183                 buf.append( "ALTER TABLE" );
 184                 bufferQuoteQualifiedIdentifier(buf, schema, oldName, m_pSettings );
 185                 buf.append( "SET SCHEMA" );
 186                 bufferQuoteIdentifier( buf, newSchemaName, m_pSettings );
 187                 Reference< XStatement > statement = m_conn->createStatement();
 188                 statement->executeUpdate( buf.makeStringAndClear() );
 189                 setPropertyValue_NoBroadcast_public( st.SCHEMA_NAME, makeAny(newSchemaName) );
 190                 disposeNoThrow( statement );
 191                 schema = newSchemaName;
 192             }
 193             catch( css::sdbc::SQLException &e )
 194             {
 195                 OUString buf( e.Message + "(NOTE: Only postgresql server >= V8.1 support changing a table's schema)" );
 196                 e.Message = buf;
 197                 throw;
 198             }
 199
 200         }
 201         if( newTableName != oldName ) // might also be just the change of a schema name
 202         {
 203             OUStringBuffer buf(128);
 204             buf.append( "ALTER TABLE" );
 205             bufferQuoteQualifiedIdentifier(buf, schema, oldName, m_pSettings );
 206             buf.append( "RENAME TO" );
 207             bufferQuoteIdentifier( buf, newTableName, m_pSettings );
 208             Reference< XStatement > statement = m_conn->createStatement();
 209             statement->executeUpdate( buf.makeStringAndClear() );
 210             disposeNoThrow( statement );
 211         }
 212     }
 213     setPropertyValue_NoBroadcast_public( st.NAME, makeAny(newTableName) );
 214     // inform the container of the name change !
 215     if( m_pSettings->tables.is() )
 216     {
 217         m_pSettings->pTablesImpl->rename( fullOldName, fullNewName );
 218     }
 219 }
 220
 221 void Table::alterColumnByName(
 222     const OUString& colName,
 223     const Reference< XPropertySet >& descriptor )
 224 {
 225     Reference< css::container::XNameAccess > columns =
 226         Reference< css::container::XNameAccess > ( getColumns(), UNO_QUERY );
 227
 228     OUString newName = extractStringProperty(descriptor, getStatics().NAME );
 229     ::pq_sdbc_driver::alterColumnByDescriptor(
 230         extractStringProperty( this, getStatics().SCHEMA_NAME ),
 231         extractStringProperty( this, getStatics().NAME ),
 232         m_pSettings,
 233         m_conn->createStatement(),
 234         Reference< css::beans::XPropertySet>( columns->getByName( colName ), UNO_QUERY) ,
 235         descriptor );
 236
 237     if( colName !=  newName )
 238     {
 239 //         m_pColumns->rename( colName, newName );
 240         m_pColumns->refresh();
 241     }
 242 }
 243
 244 void Table::alterColumnByIndex(
 245     sal_Int32 index,
 246     const css::uno::Reference< css::beans::XPropertySet >& descriptor )
 247 {
 248     Reference< css::container::XIndexAccess > columns =
 249         Reference< css::container::XIndexAccess>( getColumns(), UNO_QUERY );
 250     Reference< css::beans::XPropertySet> column(columns->getByIndex( index ), UNO_QUERY );
 251     ::pq_sdbc_driver::alterColumnByDescriptor(
 252         extractStringProperty( this, getStatics().SCHEMA_NAME ),
 253         extractStringProperty( this, getStatics().NAME ),
 254         m_pSettings,
 255         m_conn->createStatement(),
 256         column,
 257         descriptor );
 258     m_pColumns->refresh();
 259 }
 260
 261 Sequence<Type > Table::getTypes()
 262 {
 263     static cppu::OTypeCollection collection(
 264         cppu::UnoType<css::sdbcx::XIndexesSupplier>::get(),
 265         cppu::UnoType<css::sdbcx::XKeysSupplier>::get(),
 266         cppu::UnoType<css::sdbcx::XColumnsSupplier>::get(),
 267         cppu::UnoType<css::sdbcx::XRename>::get(),
 268         cppu::UnoType<css::sdbcx::XAlterTable>::get(),
 269         ReflectionBase::getTypes());
 270
 271     return collection.getTypes();
 272 }
 273
 274 Sequence< sal_Int8> Table::getImplementationId()
 275 {
 276     return css::uno::Sequence<sal_Int8>();
 277 }
 278
 279 Any Table::queryInterface( const Type & reqType )
 280 {
 281     Any ret = ReflectionBase::queryInterface( reqType );
 282     if( ! ret.hasValue() )
 283         ret = ::cppu::queryInterface(
 284             reqType,
 285             static_cast< css::sdbcx::XIndexesSupplier * > ( this ),
 286             static_cast< css::sdbcx::XKeysSupplier * > ( this ),
 287             static_cast< css::sdbcx::XColumnsSupplier * > ( this ),
 288             static_cast< css::sdbcx::XRename * > ( this ),
 289             static_cast< css::sdbcx::XAlterTable * > ( this )
 290             );
 291     return ret;
 292 }
 293
 294 OUString Table::getName(  )
 295 {
 296     Statics & st = getStatics();
 297     return concatQualified(
 298         extractStringProperty( this, st.SCHEMA_NAME ),
 299         extractStringProperty( this, st.NAME ) );
 300 }
 301
 302 void Table::setName( const OUString& aName )
 303 {
 304     rename( aName );
 305 }
 306
 307
 308 TableDescriptor::TableDescriptor(
 309     const ::rtl::Reference< comphelper::RefCountedMutex > & refMutex,
 310     const Reference< css::sdbc::XConnection > & connection,
 311     ConnectionSettings *pSettings)
 312     : ReflectionBase(
 313         getStatics().refl.tableDescriptor.implName,
 314         getStatics().refl.tableDescriptor.serviceNames,
 315         refMutex,
 316         connection,
 317         pSettings,
 318         * getStatics().refl.tableDescriptor.pProps )
 319 {
 320 }
 321
 322 Reference< XNameAccess > TableDescriptor::getColumns(  )
 323 {
 324     if( ! m_columns.is() )
 325     {
 326         m_columns = new ColumnDescriptors(m_xMutex, m_conn, m_pSettings );
 327     }
 328     return m_columns;
 329 }
 330
 331 Reference< XNameAccess > TableDescriptor::getIndexes()
 332 {
 333     if( ! m_indexes.is() )
 334     {
 335         m_indexes = ::pq_sdbc_driver::IndexDescriptors::create(
 336             m_xMutex,
 337             m_conn,
 338             m_pSettings);
 339     }
 340     return m_indexes;
 341 }
 342
 343 Reference< XIndexAccess > TableDescriptor::getKeys(  )
 344 {
 345     if( ! m_keys.is() )
 346     {
 347         m_keys = ::pq_sdbc_driver::KeyDescriptors::create(
 348             m_xMutex,
 349             m_conn,
 350             m_pSettings );
 351     }
 352     return m_keys;
 353 }
 354
 355
 356 Sequence<Type > TableDescriptor::getTypes()
 357 {
 358     static cppu::OTypeCollection collection(
 359         cppu::UnoType<css::sdbcx::XIndexesSupplier>::get(),
 360         cppu::UnoType<css::sdbcx::XKeysSupplier>::get(),
 361         cppu::UnoType<css::sdbcx::XColumnsSupplier>::get(),
 362         ReflectionBase::getTypes());
 363
 364     return collection.getTypes();
 365 }
 366
 367 Sequence< sal_Int8> TableDescriptor::getImplementationId()
 368 {
 369     return css::uno::Sequence<sal_Int8>();
 370 }
 371
 372 Any TableDescriptor::queryInterface( const Type & reqType )
 373 {
 374     Any ret = ReflectionBase::queryInterface( reqType );
 375     if( ! ret.hasValue() )
 376         ret = ::cppu::queryInterface(
 377             reqType,
 378             static_cast< css::sdbcx::XIndexesSupplier * > ( this ),
 379             static_cast< css::sdbcx::XKeysSupplier * > ( this ),
 380             static_cast< css::sdbcx::XColumnsSupplier * > ( this ));
 381     return ret;
 382 }
 383
 384
 385 Reference< XPropertySet > TableDescriptor::createDataDescriptor(  )
 386 {
 387     TableDescriptor * pTable = new TableDescriptor(
 388         m_xMutex, m_conn, m_pSettings );
 389
 390     // TODO: deep copies
 391     pTable->m_values = m_values;
 392
 393     return Reference< XPropertySet > ( pTable );
 394 }
 395
 396 }
 397
 398 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */