dbaccess/source/sdbtools/connection/tablename.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 "tablename.hxx"
  21 #include <core_resource.hxx>
  22 #include <strings.hrc>
  23 #include <strings.hxx>
  24
  25 #include <com/sun/star/sdb/tools/CompositionType.hpp>
  26 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
  27
  28 #include <connectivity/dbtools.hxx>
  29 #include <comphelper/diagnose_ex.hxx>
  30
  31 namespace sdbtools
  32 {
  33
  34     using ::com::sun::star::uno::Reference;
  35     using ::com::sun::star::sdbc::XConnection;
  36     using ::com::sun::star::uno::RuntimeException;
  37     using ::com::sun::star::lang::IllegalArgumentException;
  38     using ::com::sun::star::beans::XPropertySet;
  39     using ::com::sun::star::container::NoSuchElementException;
  40     using ::com::sun::star::sdbcx::XTablesSupplier;
  41     using ::com::sun::star::container::XNameAccess;
  42     using ::com::sun::star::uno::UNO_QUERY_THROW;
  43     using ::com::sun::star::lang::WrappedTargetException;
  44     using ::com::sun::star::uno::Exception;
  45     using ::com::sun::star::uno::UNO_QUERY;
  46     using ::com::sun::star::beans::XPropertySetInfo;
  47     using ::com::sun::star::uno::XComponentContext;
  48
  49     namespace CompositionType = ::com::sun::star::sdb::tools::CompositionType;
  50
  51     using namespace ::dbtools;
  52
  53     // TableName
  54     struct TableName_Impl
  55     {
  56         OUString sCatalog;
  57         OUString sSchema;
  58         OUString sName;
  59     };
  60
  61     // TableName
  62     TableName::TableName( const Reference<XComponentContext>& _rContext, const Reference< XConnection >& _rxConnection )
  63         :ConnectionDependentComponent( _rContext )
  64         ,m_pImpl( new TableName_Impl )
  65     {
  66         setWeakConnection( _rxConnection );
  67     }
  68
  69     TableName::~TableName()
  70     {
  71     }
  72
  73     OUString SAL_CALL TableName::getCatalogName()
  74     {
  75         EntryGuard aGuard( *this );
  76         return m_pImpl->sCatalog;
  77     }
  78
  79     void SAL_CALL TableName::setCatalogName( const OUString& _catalogName )
  80     {
  81         EntryGuard aGuard( *this );
  82         m_pImpl->sCatalog = _catalogName;
  83     }
  84
  85     OUString SAL_CALL TableName::getSchemaName()
  86     {
  87         EntryGuard aGuard( *this );
  88         return m_pImpl->sSchema;
  89     }
  90
  91     void SAL_CALL TableName::setSchemaName( const OUString& _schemaName )
  92     {
  93         EntryGuard aGuard( *this );
  94         m_pImpl->sSchema = _schemaName;
  95     }
  96
  97     OUString SAL_CALL TableName::getTableName()
  98     {
  99         EntryGuard aGuard( *this );
 100         return m_pImpl->sName;
 101     }
 102
 103     void SAL_CALL TableName::setTableName( const OUString& _tableName )
 104     {
 105         EntryGuard aGuard( *this );
 106         m_pImpl->sName = _tableName;
 107     }
 108
 109     OUString SAL_CALL TableName::getNameForSelect()
 110     {
 111         EntryGuard aGuard( *this );
 112         return composeTableNameForSelect( getConnection(), m_pImpl->sCatalog, m_pImpl->sSchema, m_pImpl->sName );
 113     }
 114
 115     Reference< XPropertySet > SAL_CALL TableName::getTable()
 116     {
 117         EntryGuard aGuard( *this );
 118
 119         Reference< XTablesSupplier > xSuppTables( getConnection(), UNO_QUERY_THROW );
 120         Reference< XNameAccess > xTables( xSuppTables->getTables(), css::uno::UNO_SET_THROW );
 121
 122         Reference< XPropertySet > xTable;
 123         try
 124         {
 125             xTable.set( xTables->getByName( getComposedName( CompositionType::Complete, false ) ), UNO_QUERY_THROW );
 126         }
 127         catch( const WrappedTargetException& )
 128         {
 129             throw NoSuchElementException();
 130         }
 131         catch( const RuntimeException& ) { throw; }
 132         catch( const NoSuchElementException& ) { throw; }
 133         catch( const Exception& )
 134         {
 135             DBG_UNHANDLED_EXCEPTION("dbaccess");
 136             throw NoSuchElementException();
 137         }
 138
 139         return xTable;
 140     }
 141
 142     void SAL_CALL TableName::setTable( const Reference< XPropertySet >& _table )
 143     {
 144         EntryGuard aGuard( *this );
 145
 146         Reference< XPropertySetInfo > xPSI( _table, UNO_QUERY );
 147         if  (   !xPSI.is()
 148             ||  !xPSI->hasPropertyByName( PROPERTY_CATALOGNAME )
 149             ||  !xPSI->hasPropertyByName( PROPERTY_SCHEMANAME )
 150             ||  !xPSI->hasPropertyByName( PROPERTY_NAME )
 151             )
 152             throw IllegalArgumentException(
 153                 DBA_RES( STR_NO_TABLE_OBJECT ),
 154                 *this,
 155                 0
 156             );
 157
 158         try
 159         {
 160             OSL_VERIFY( _table->getPropertyValue( PROPERTY_CATALOGNAME ) >>= m_pImpl->sCatalog );
 161             OSL_VERIFY( _table->getPropertyValue( PROPERTY_SCHEMANAME ) >>= m_pImpl->sSchema );
 162             OSL_VERIFY( _table->getPropertyValue( PROPERTY_NAME ) >>= m_pImpl->sName );
 163         }
 164         catch( const RuntimeException& ) { throw; }
 165         catch( const Exception& e )
 166         {
 167             throw IllegalArgumentException( e.Message, e.Context, 0 );
 168         }
 169     }
 170
 171     namespace
 172     {
 173         /** translates a CompositionType into an EComposeRule
 174             @throws IllegalArgumentException
 175                 if the given value does not denote a valid CompositionType
 176         */
 177         EComposeRule lcl_translateCompositionType_throw( sal_Int32 _nType )
 178         {
 179             static const struct
 180             {
 181                 sal_Int32       nCompositionType;
 182                 EComposeRule    eComposeRule;
 183             }   TypeTable[] =
 184             {
 185                 { CompositionType::ForTableDefinitions,      EComposeRule::InTableDefinitions },
 186                 { CompositionType::ForIndexDefinitions,      EComposeRule::InIndexDefinitions },
 187                 { CompositionType::ForDataManipulation,      EComposeRule::InDataManipulation },
 188                 { CompositionType::ForProcedureCalls,        EComposeRule::InProcedureCalls },
 189                 { CompositionType::ForPrivilegeDefinitions,  EComposeRule::InPrivilegeDefinitions },
 190                 { CompositionType::Complete,                 EComposeRule::Complete }
 191             };
 192
 193             auto const found = std::find_if(std::begin(TypeTable), std::end(TypeTable)
 194                                             , [_nType](auto const & type){ return type.nCompositionType == _nType; });
 195             if (found == std::end(TypeTable))
 196                 throw IllegalArgumentException(
 197                     DBA_RES( STR_INVALID_COMPOSITION_TYPE ),
 198                     nullptr,
 199                     0
 200                 );
 201
 202             return found->eComposeRule;
 203         }
 204     }
 205
 206     OUString SAL_CALL TableName::getComposedName( ::sal_Int32 Type, sal_Bool Quote )
 207     {
 208         EntryGuard aGuard( *this );
 209
 210         return composeTableName(
 211             getConnection()->getMetaData(),
 212             m_pImpl->sCatalog, m_pImpl->sSchema, m_pImpl->sName, Quote,
 213             lcl_translateCompositionType_throw( Type ) );
 214     }
 215
 216     void SAL_CALL TableName::setComposedName( const OUString& ComposedName, ::sal_Int32 Type )
 217     {
 218         EntryGuard aGuard( *this );
 219
 220         qualifiedNameComponents(
 221             getConnection()->getMetaData(),
 222             ComposedName,
 223             m_pImpl->sCatalog, m_pImpl->sSchema, m_pImpl->sName,
 224             lcl_translateCompositionType_throw( Type ) );
 225     }
 226
 227 } // namespace sdbtools
 228
 229 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */