dbaccess/source/ui/relationdesign/RTableConnectionData.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: RTableConnectionData.cxx,v $
  10  * $Revision: 1.16 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_dbaccess.hxx"
  33 #include "RTableConnectionData.hxx"
  34 #include <tools/debug.hxx>
  35 #include <com/sun/star/sdbc/KeyRule.hpp>
  36 #include <com/sun/star/sdbcx/KeyType.hpp>
  37 #include <com/sun/star/sdbcx/XKeysSupplier.hpp>
  38 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  39 #include <com/sun/star/sdbcx/XDataDescriptorFactory.hpp>
  40 #include <com/sun/star/sdbcx/XAppend.hpp>
  41 #include <com/sun/star/sdbcx/XDrop.hpp>
  42 #include <com/sun/star/container/XIndexAccess.hpp>
  43 #include "dbustrings.hrc"
  44 #include "dbu_rel.hrc"
  45 #include "UITools.hxx"
  46 #include "moduledbu.hxx"
  47 #include <connectivity/dbexception.hxx>
  48
  49 using namespace dbaui;
  50 using namespace ::com::sun::star::sdbc;
  51 using namespace ::com::sun::star::sdbcx;
  52 using namespace ::com::sun::star::uno;
  53 using namespace ::com::sun::star::beans;
  54 using namespace ::com::sun::star::container;
  55 using namespace ::com::sun::star::lang;
  56
  57 DBG_NAME(ORelationTableConnectionData)
  58 //========================================================================
  59 // class ORelationTableConnectionData
  60 //========================================================================
  61 //------------------------------------------------------------------------
  62 ORelationTableConnectionData::ORelationTableConnectionData()
  63     :OTableConnectionData()
  64     ,m_nUpdateRules(KeyRule::NO_ACTION)
  65     ,m_nDeleteRules(KeyRule::NO_ACTION)
  66     ,m_nCardinality(CARDINAL_UNDEFINED)
  67 {
  68     DBG_CTOR(ORelationTableConnectionData,NULL);
  69 }
  70 //------------------------------------------------------------------------
  71 ORelationTableConnectionData::ORelationTableConnectionData( const TTableWindowData::value_type& _pReferencingTable,
  72                                                             const TTableWindowData::value_type& _pReferencedTable,
  73                                                             const ::rtl::OUString& rConnName )
  74     :OTableConnectionData( _pReferencingTable, _pReferencedTable )
  75     ,m_nUpdateRules(KeyRule::NO_ACTION)
  76     ,m_nDeleteRules(KeyRule::NO_ACTION)
  77     ,m_nCardinality(CARDINAL_UNDEFINED)
  78 {
  79     DBG_CTOR(ORelationTableConnectionData,NULL);
  80     m_aConnName = rConnName;
  81
  82     if ( m_aConnName.Len() )
  83         SetCardinality();
  84 }
  85
  86 //------------------------------------------------------------------------
  87 ORelationTableConnectionData::ORelationTableConnectionData( const ORelationTableConnectionData& rConnData )
  88     :OTableConnectionData( rConnData )
  89 {
  90     DBG_CTOR(ORelationTableConnectionData,NULL);
  91     *this = rConnData;
  92 }
  93
  94 //------------------------------------------------------------------------
  95 ORelationTableConnectionData::~ORelationTableConnectionData()
  96 {
  97     DBG_DTOR(ORelationTableConnectionData,NULL);
  98 }
  99
 100 //------------------------------------------------------------------------
 101 BOOL ORelationTableConnectionData::DropRelation()
 102 {
 103     DBG_CHKTHIS(ORelationTableConnectionData,NULL);
 104     ::osl::MutexGuard aGuard( m_aMutex );
 105     ////////////////////////////////////////////////////////////
 106     // Relation loeschen
 107     Reference< XIndexAccess> xKeys = getReferencingTable()->getKeys();
 108     if( m_aConnName.Len() && xKeys.is() )
 109     {
 110         const sal_Int32 nCount = xKeys->getCount();
 111         for(sal_Int32 i = 0;i < nCount;++i)
 112         {
 113             Reference< XPropertySet> xKey(xKeys->getByIndex(i),UNO_QUERY);
 114             OSL_ENSURE(xKey.is(),"Key is not valid!");
 115             if(xKey.is())
 116             {
 117                 ::rtl::OUString sName;
 118                 xKey->getPropertyValue(PROPERTY_NAME) >>= sName;
 119                 if(String(sName) == m_aConnName)
 120                 {
 121                     Reference< XDrop> xDrop(xKeys,UNO_QUERY);
 122                     OSL_ENSURE(xDrop.is(),"can't drop key because we haven't a drop interface!");
 123                     if(xDrop.is())
 124                         xDrop->dropByIndex(i);
 125                     break;
 126                 }
 127             }
 128         }
 129     }
 130     return TRUE;
 131 }
 132
 133 //------------------------------------------------------------------------
 134 void ORelationTableConnectionData::ChangeOrientation()
 135 {
 136     DBG_CHKTHIS(ORelationTableConnectionData,NULL);
 137     //////////////////////////////////////////////////////////////////////
 138     // Source- und DestFieldName der Linien austauschen
 139     ::rtl::OUString sTempString;
 140     OConnectionLineDataVec::iterator aIter = m_vConnLineData.begin();
 141     OConnectionLineDataVec::iterator aEnd = m_vConnLineData.end();
 142     for(;aIter != aEnd;++aIter)
 143     {
 144         sTempString = (*aIter)->GetSourceFieldName();
 145         (*aIter)->SetSourceFieldName( (*aIter)->GetDestFieldName() );
 146         (*aIter)->SetDestFieldName( sTempString );
 147     }
 148
 149     //////////////////////////////////////////////////////////////////////
 150     // Member anpassen
 151     TTableWindowData::value_type pTemp = m_pReferencingTable;
 152     m_pReferencingTable = m_pReferencedTable;
 153     m_pReferencedTable = pTemp;
 154 }
 155
 156 //------------------------------------------------------------------------
 157 void ORelationTableConnectionData::SetCardinality()
 158 {
 159     DBG_CHKTHIS(ORelationTableConnectionData,NULL);
 160     ::osl::MutexGuard aGuard( m_aMutex );
 161     m_nCardinality = CARDINAL_UNDEFINED;
 162
 163     if( IsSourcePrimKey() )
 164     {
 165         if( IsDestPrimKey() )
 166             m_nCardinality = CARDINAL_ONE_ONE;
 167         else
 168             m_nCardinality = CARDINAL_ONE_MANY;
 169     }
 170
 171     if( IsDestPrimKey() )
 172     {
 173         if( !IsSourcePrimKey() )
 174             m_nCardinality = CARDINAL_MANY_ONE;
 175     }
 176
 177 }
 178 // -----------------------------------------------------------------------------
 179 BOOL ORelationTableConnectionData::checkPrimaryKey(const Reference< XIndexAccess>& _xKeys,EConnectionSide _eEConnectionSide) const
 180 {
 181     // check if Table has the primary key column dependig on _eEConnectionSide
 182     USHORT      nPrimKeysCount          = 0,
 183             nValidLinesCount    = 0;
 184     ::std::vector<Reference<XNameAccess> > vKeyColumns  = ::dbaui::getKeyColumns(_xKeys,KeyType::PRIMARY);
 185     if ( vKeyColumns.size() == 1 )
 186     {
 187 //              OSL_ENSURE(vKeyColumns.size()==1,"There can be only one primary key in a table!");
 188         Sequence< ::rtl::OUString> aKeyColumns;
 189         Reference<XNameAccess> xKeyColumns = *vKeyColumns.begin();
 190         if ( xKeyColumns.is() )
 191         {
 192             aKeyColumns = xKeyColumns->getElementNames();
 193             const ::rtl::OUString* pKeyIter     = aKeyColumns.getConstArray();
 194             const ::rtl::OUString* pKeyEnd  = pKeyIter + aKeyColumns.getLength();
 195
 196             for(;pKeyIter != pKeyEnd;++pKeyIter)
 197             {
 198                 OConnectionLineDataVec::const_iterator aIter = m_vConnLineData.begin();
 199                 OConnectionLineDataVec::const_iterator aEnd = m_vConnLineData.end();
 200                 for(;aIter != aEnd;++aIter)
 201                 {
 202                     ++nValidLinesCount;
 203                     if ( (*aIter)->GetFieldName(_eEConnectionSide) == *pKeyIter )
 204                     {
 205                         ++nPrimKeysCount;
 206                         break;
 207                     }
 208                 }
 209             }
 210         }
 211         if ( nPrimKeysCount != aKeyColumns.getLength() )
 212             return FALSE;
 213     }
 214     if ( !nPrimKeysCount || nPrimKeysCount != nValidLinesCount )
 215         return FALSE;
 216
 217     return TRUE;
 218 }
 219 //------------------------------------------------------------------------
 220 BOOL ORelationTableConnectionData::IsConnectionPossible()
 221 {
 222     DBG_CHKTHIS(ORelationTableConnectionData,NULL);
 223     ::osl::MutexGuard aGuard( m_aMutex );
 224
 225     //////////////////////////////////////////////////////////////////////
 226     // Wenn die SourceFelder ein PrimKey sind, ist nur die Orientierung falsch
 227     if ( IsSourcePrimKey() && !IsDestPrimKey() )
 228         ChangeOrientation();
 229
 230     return TRUE;
 231 }
 232
 233 //------------------------------------------------------------------------
 234 OConnectionLineDataRef ORelationTableConnectionData::CreateLineDataObj()
 235 {
 236     return new OConnectionLineData();
 237 }
 238
 239 //------------------------------------------------------------------------
 240 OConnectionLineDataRef ORelationTableConnectionData::CreateLineDataObj( const OConnectionLineData& rConnLineData )
 241 {
 242     return new OConnectionLineData( rConnLineData );
 243 }
 244
 245 //------------------------------------------------------------------------
 246 void ORelationTableConnectionData::CopyFrom(const OTableConnectionData& rSource)
 247 {
 248     // wie in der Basisklasse zurueckziehen auf das (nicht-virtuelle) operator=
 249     *this = *static_cast<const ORelationTableConnectionData*>(&rSource);
 250 }
 251
 252 //------------------------------------------------------------------------
 253 ORelationTableConnectionData& ORelationTableConnectionData::operator=( const ORelationTableConnectionData& rConnData )
 254 {
 255     if (&rConnData == this)
 256         return *this;
 257
 258     OTableConnectionData::operator=( rConnData );
 259     m_nUpdateRules = rConnData.GetUpdateRules();
 260     m_nDeleteRules = rConnData.GetDeleteRules();
 261     m_nCardinality = rConnData.GetCardinality();
 262
 263     return *this;
 264 }
 265 namespace dbaui
 266 {
 267 //-------------------------------------------------------------------------
 268 bool operator==(const ORelationTableConnectionData& lhs, const ORelationTableConnectionData& rhs)
 269 {
 270     bool bEqual = (lhs.m_nUpdateRules == rhs.m_nUpdateRules)
 271         && (lhs.m_nDeleteRules == rhs.m_nDeleteRules)
 272         && (lhs.m_nCardinality == rhs.m_nCardinality)
 273         && (lhs.getReferencingTable() == rhs.getReferencingTable())
 274         && (lhs.getReferencedTable() == rhs.getReferencedTable())
 275         && (lhs.m_aConnName == rhs.m_aConnName)
 276         && (lhs.m_vConnLineData.size() == rhs.m_vConnLineData.size());
 277
 278     if ( bEqual )
 279     {
 280         std::vector< OConnectionLineDataRef >::const_iterator aIter = lhs.m_vConnLineData.begin();
 281         std::vector< OConnectionLineDataRef >::const_iterator aEnd = lhs.m_vConnLineData.end();
 282         for (sal_Int32 i = 0; aIter != aEnd; ++aIter,++i)
 283         {
 284             if ( *(rhs.m_vConnLineData[i]) != **aIter )
 285                 break;
 286         }
 287         bEqual = aIter == aEnd;
 288     }
 289     return bEqual;
 290 }
 291 }
 292 //------------------------------------------------------------------------
 293 BOOL ORelationTableConnectionData::Update()
 294 {
 295     ::osl::MutexGuard aGuard( m_aMutex );
 296     ////////////////////////////////////////////////////////////
 297     // Alte Relation loeschen
 298     {
 299         DropRelation();
 300         if( !IsConnectionPossible() )
 301             return FALSE;
 302     }
 303
 304     // reassign the keys because the orientaion could be changed
 305     Reference<XPropertySet> xTableProp(getReferencingTable()->getTable());
 306     Reference< XIndexAccess> xKeys ( getReferencingTable()->getKeys());
 307
 308     if ( !xKeys.is() )
 309         return FALSE;
 310     ////////////////////////////////////////////////////////////
 311     // Neue Relation erzeugen
 312     Reference<XDataDescriptorFactory> xKeyFactory(xKeys,UNO_QUERY);
 313     OSL_ENSURE(xKeyFactory.is(),"No XDataDescriptorFactory Interface!");
 314     Reference<XAppend> xAppend(xKeyFactory,UNO_QUERY);
 315     OSL_ENSURE(xAppend.is(),"No XAppend Interface!");
 316
 317     Reference<XPropertySet> xKey = xKeyFactory->createDataDescriptor();
 318     OSL_ENSURE(xKey.is(),"Key is null!");
 319     if ( xKey.is() && xTableProp.is() )
 320     {
 321         // build a foreign key name
 322         ::rtl::OUString sSourceName;
 323         xTableProp->getPropertyValue(PROPERTY_NAME) >>= sSourceName;
 324         ::rtl::OUString sKeyName = sSourceName;
 325         sKeyName += getReferencedTable()->GetTableName();
 326
 327         xKey->setPropertyValue(PROPERTY_NAME,makeAny(sKeyName));
 328         xKey->setPropertyValue(PROPERTY_TYPE,makeAny(KeyType::FOREIGN));
 329         xKey->setPropertyValue(PROPERTY_REFERENCEDTABLE,makeAny(::rtl::OUString(getReferencedTable()->GetTableName())));
 330         xKey->setPropertyValue(PROPERTY_UPDATERULE, makeAny(GetUpdateRules()));
 331         xKey->setPropertyValue(PROPERTY_DELETERULE, makeAny(GetDeleteRules()));
 332     }
 333
 334     Reference<XColumnsSupplier> xColSup(xKey,UNO_QUERY);
 335     if ( xColSup.is() )
 336     {
 337         Reference<XNameAccess> xColumns = xColSup->getColumns();
 338         Reference<XDataDescriptorFactory> xColumnFactory(xColumns,UNO_QUERY);
 339         Reference<XAppend> xColumnAppend(xColumns,UNO_QUERY);
 340         if ( xColumnFactory.is() )
 341         {
 342             OConnectionLineDataVec::iterator aIter = m_vConnLineData.begin();
 343             OConnectionLineDataVec::iterator aEnd = m_vConnLineData.end();
 344             for(;aIter != aEnd;++aIter)
 345             {
 346                 if((*aIter)->GetSourceFieldName().getLength() && (*aIter)->GetDestFieldName().getLength())
 347                 {
 348                     Reference<XPropertySet> xColumn;
 349                     xColumn = xColumnFactory->createDataDescriptor();
 350                     if ( xColumn.is() )
 351                     {
 352                         xColumn->setPropertyValue(PROPERTY_NAME,makeAny((*aIter)->GetSourceFieldName()));
 353                         xColumn->setPropertyValue(PROPERTY_RELATEDCOLUMN,makeAny((*aIter)->GetDestFieldName()));
 354                         xColumnAppend->appendByDescriptor(xColumn);
 355                     }
 356                 }
 357             }
 358
 359             if ( xColumns->hasElements() )
 360                 xAppend->appendByDescriptor(xKey);
 361         }
 362         // to get the key we have to reget it because after append it is no longer valid
 363     }
 364
 365     // get the name of foreign key // search for columns
 366     m_aConnName = ::rtl::OUString();
 367     xKey = NULL;
 368     bool bDropRelation = false;
 369     for(sal_Int32 i=0;i<xKeys->getCount();++i)
 370     {
 371         xKeys->getByIndex(i) >>= xKey;
 372         OSL_ENSURE(xKey.is(),"Key is not valid!");
 373         if ( xKey.is() )
 374         {
 375             sal_Int32 nType = 0;
 376             xKey->getPropertyValue(PROPERTY_TYPE) >>= nType;
 377             ::rtl::OUString sReferencedTable;
 378             xKey->getPropertyValue(PROPERTY_REFERENCEDTABLE) >>= sReferencedTable;
 379             if ( sReferencedTable == ::rtl::OUString(getReferencedTable()->GetTableName()) )
 380             {
 381                 xColSup.set(xKey,UNO_QUERY_THROW);
 382                 try
 383                 {
 384                     Reference<XNameAccess> xColumns = xColSup->getColumns();
 385                     Sequence< ::rtl::OUString> aNames = xColumns->getElementNames();
 386                     const ::rtl::OUString* pIter = aNames.getConstArray();
 387                     const ::rtl::OUString* pEnd = pIter + aNames.getLength();
 388
 389                     Reference<XPropertySet> xColumn;
 390                     ::rtl::OUString sName,sRelatedColumn;
 391                     for ( ; pIter != pEnd ; ++pIter )
 392                     {
 393                         xColumn.set(xColumns->getByName(*pIter),UNO_QUERY_THROW);
 394                         xColumn->getPropertyValue(PROPERTY_NAME)                        >>= sName;
 395                         xColumn->getPropertyValue(PROPERTY_RELATEDCOLUMN)       >>= sRelatedColumn;
 396
 397                         OConnectionLineDataVec::iterator aIter = m_vConnLineData.begin();
 398                         OConnectionLineDataVec::iterator aEnd = m_vConnLineData.end();
 399                         for(;aIter != aEnd;++aIter)
 400                         {
 401                             if(    (*aIter)->GetSourceFieldName() == sName
 402                                 && (*aIter)->GetDestFieldName() == sRelatedColumn )
 403                             {
 404                                 break;
 405                             }
 406                         }
 407                         if ( aIter == m_vConnLineData.end() )
 408                             break;
 409                     }
 410                     if ( pIter == pEnd )
 411                     {
 412                         xKey->getPropertyValue(PROPERTY_NAME) >>= sName;
 413                         m_aConnName = sName;
 414                         bDropRelation = aNames.getLength() == 0; // the key contains no column, so it isn't valid and we have to drop it
 415                         //here we already know our column structure so we don't have to recreate the table connection data
 416                         xColSup.clear();
 417                         break;
 418                     }
 419                 }
 420                 catch(Exception&)
 421                 {
 422                 }
 423             }
 424         }
 425         xKey = NULL;
 426     } // for(sal_Int32 i=0;i<xKeys->getCount();++i)
 427     if ( bDropRelation )
 428     {
 429         DropRelation();
 430         String sError(ModuleRes(STR_QUERY_REL_COULD_NOT_CREATE));
 431         ::dbtools::throwGenericSQLException(sError,NULL);
 432     }
 433
 434 //      OSL_ENSURE(xKey.is(),"No key found have insertion!");
 435
 436     // The fields the relation marks may not be the same as our LineDatas mark after the relation has been updated
 437     if ( xColSup.is() )
 438     {
 439         OConnectionLineDataVec().swap(m_vConnLineData);
 440         Reference<XNameAccess> xColumns = xColSup->getColumns();
 441         Sequence< ::rtl::OUString> aNames = xColumns->getElementNames();
 442         const ::rtl::OUString* pIter = aNames.getConstArray();
 443         const ::rtl::OUString* pEnd = pIter + aNames.getLength();
 444
 445         m_vConnLineData.reserve( aNames.getLength() );
 446         Reference<XPropertySet> xColumn;
 447         ::rtl::OUString sName,sRelatedColumn;
 448
 449         for(;pIter != pEnd;++pIter)
 450         {
 451             xColumns->getByName(*pIter) >>= xColumn;
 452             if ( xColumn.is() )
 453             {
 454                 OConnectionLineDataRef pNewData = CreateLineDataObj();
 455
 456                 xColumn->getPropertyValue(PROPERTY_NAME)                        >>= sName;
 457                 xColumn->getPropertyValue(PROPERTY_RELATEDCOLUMN)       >>= sRelatedColumn;
 458
 459                 pNewData->SetSourceFieldName(sName);
 460                 pNewData->SetDestFieldName(sRelatedColumn);
 461                 m_vConnLineData.push_back(pNewData);
 462             }
 463         }
 464     } // if ( xColSup.is() )
 465     // NOTE : the caller is resposible for updating any other objects referencing the old LineDatas (for instance a ConnLine)
 466
 467     ////////////////////////////////////////////////////////////
 468     // Kardinalitaet bestimmen
 469     SetCardinality();
 470
 471     return TRUE;
 472 }
 473 // -----------------------------------------------------------------------------
 474