connectivity/source/commontools/dbtools2.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 <connectivity/dbtools.hxx>
  21 #include <connectivity/dbconversion.hxx>
  22 #include <connectivity/dbcharset.hxx>
  23 #include <SQLStatementHelper.hxx>
  24 #include <unotools/confignode.hxx>
  25 #include <resource/sharedresources.hxx>
  26 #include <strings.hrc>
  27 #include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp>
  28 #include <com/sun/star/sdbc/SQLException.hpp>
  29 #include <com/sun/star/sdbc/XConnection.hpp>
  30 #include <com/sun/star/sdbc/XDataSource.hpp>
  31 #include <com/sun/star/sdbc/ColumnValue.hpp>
  32 #include <com/sun/star/sdbc/DataType.hpp>
  33 #include <com/sun/star/sdbc/DriverManager.hpp>
  34 #include <com/sun/star/sdbc/XRow.hpp>
  35 #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
  36 #include <com/sun/star/sdbcx/XKeysSupplier.hpp>
  37 #include <com/sun/star/sdbcx/XDataDefinitionSupplier.hpp>
  38 #include <com/sun/star/sdbcx/Privilege.hpp>
  39 #include <com/sun/star/container/XIndexAccess.hpp>
  40 #include <com/sun/star/sdbc/KeyRule.hpp>
  41 #include <com/sun/star/sdbcx/KeyType.hpp>
  42 #include <TConnection.hxx>
  43 #include <connectivity/sdbcx/VColumn.hxx>
  44 #include <com/sun/star/frame/XModel.hpp>
  45 #include <com/sun/star/container/XChild.hpp>
  46
  47 #include <comphelper/types.hxx>
  48 #include <tools/diagnose_ex.h>
  49 #include <unotools/sharedunocomponent.hxx>
  50 #include <algorithm>
  51 #include <string_view>
  52
  53 namespace dbtools
  54 {
  55
  56     using namespace ::com::sun::star::uno;
  57     using namespace ::com::sun::star::beans;
  58     using namespace ::com::sun::star::sdb;
  59     using namespace ::com::sun::star::sdbc;
  60     using namespace ::com::sun::star::sdbcx;
  61     using namespace ::com::sun::star::lang;
  62     using namespace ::com::sun::star::container;
  63     using namespace ::com::sun::star::frame;
  64     using namespace connectivity;
  65     using namespace comphelper;
  66
  67 OUString createStandardTypePart(const Reference< XPropertySet >& xColProp,const Reference< XConnection>& _xConnection,std::u16string_view _sCreatePattern)
  68 {
  69
  70     Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
  71
  72     ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
  73
  74     OUString sTypeName;
  75     sal_Int32       nDataType   = 0;
  76     sal_Int32       nPrecision  = 0;
  77     sal_Int32       nScale      = 0;
  78
  79     nDataType = nPrecision = nScale = 0;
  80
  81     xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_TYPENAME))           >>= sTypeName;
  82     xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_TYPE))               >>= nDataType;
  83     xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_PRECISION))          >>= nPrecision;
  84     xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCALE))              >>= nScale;
  85
  86     OUStringBuffer aSql;
  87
  88     // check if the user enter a specific string to create autoincrement values
  89     OUString sAutoIncrementValue;
  90     Reference<XPropertySetInfo> xPropInfo = xColProp->getPropertySetInfo();
  91     if ( xPropInfo.is() && xPropInfo->hasPropertyByName(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) )
  92         xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) >>= sAutoIncrementValue;
  93     // look if we have to use precisions
  94     bool bUseLiteral = false;
  95     OUString sPrefix,sPostfix,sCreateParams;
  96     {
  97         Reference<XResultSet> xRes = xMetaData->getTypeInfo();
  98         if(xRes.is())
  99         {
 100             Reference<XRow> xRow(xRes,UNO_QUERY);
 101             while(xRes->next())
 102             {
 103                 OUString sTypeName2Cmp = xRow->getString(1);
 104                 sal_Int32 nType = xRow->getShort(2);
 105                 sPrefix = xRow->getString (4);
 106                 sPostfix = xRow->getString (5);
 107                 sCreateParams = xRow->getString(6);
 108                 // first identical type will be used if typename is empty
 109                 if ( sTypeName.isEmpty() && nType == nDataType )
 110                     sTypeName = sTypeName2Cmp;
 111
 112                 if( sTypeName.equalsIgnoreAsciiCase(sTypeName2Cmp) && nType == nDataType && !sCreateParams.isEmpty() && !xRow->wasNull())
 113                 {
 114                     bUseLiteral = true;
 115                     break;
 116                 }
 117             }
 118         }
 119     }
 120
 121     if ( !sAutoIncrementValue.isEmpty() )
 122     {
 123         sal_Int32 nIndex = sTypeName.indexOf(sAutoIncrementValue);
 124         if (nIndex != -1)
 125             sTypeName = sTypeName.replaceAt(nIndex,sTypeName.getLength() - nIndex,OUString());
 126     }
 127
 128     if ( (nPrecision > 0 || nScale > 0) && bUseLiteral )
 129     {
 130         sal_Int32 nParenPos = sTypeName.indexOf('(');
 131         if ( nParenPos == -1 )
 132         {
 133             aSql.append(sTypeName);
 134             aSql.append("(");
 135         }
 136         else
 137         {
 138             aSql.append(std::u16string_view(sTypeName).substr(0, ++nParenPos));
 139         }
 140
 141         if ( nPrecision > 0 && nDataType != DataType::TIMESTAMP )
 142         {
 143             aSql.append(nPrecision);
 144             if ( (nScale > 0) || (!_sCreatePattern.empty() && sCreateParams.indexOf(_sCreatePattern) != -1) )
 145                 aSql.append(",");
 146         }
 147         if ( (nScale > 0) || ( !_sCreatePattern.empty() && sCreateParams.indexOf(_sCreatePattern) != -1 ) || nDataType == DataType::TIMESTAMP )
 148             aSql.append(nScale);
 149
 150         if ( nParenPos == -1 )
 151             aSql.append(")");
 152         else
 153         {
 154             nParenPos = sTypeName.indexOf(')',nParenPos);
 155             aSql.append(std::u16string_view(sTypeName).substr(nParenPos));
 156         }
 157     }
 158     else
 159         aSql.append(sTypeName); // simply add the type name
 160
 161     OUString aDefault = ::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_DEFAULTVALUE)));
 162     if ( !aDefault.isEmpty() )
 163     {
 164         aSql.append(" DEFAULT ");
 165         aSql.append(sPrefix);
 166         aSql.append(aDefault);
 167         aSql.append(sPostfix);
 168     } // if ( aDefault.getLength() )
 169
 170     return aSql.makeStringAndClear();
 171 }
 172
 173 OUString createStandardColumnPart(const Reference< XPropertySet >& xColProp,const Reference< XConnection>& _xConnection,ISQLStatementHelper* _pHelper,std::u16string_view _sCreatePattern)
 174 {
 175     Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
 176
 177     ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
 178
 179     bool bIsAutoIncrement = false;
 180     xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT))    >>= bIsAutoIncrement;
 181
 182     const OUString sQuoteString = xMetaData->getIdentifierQuoteString();
 183     OUStringBuffer aSql = ::dbtools::quoteName(sQuoteString,::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME))));
 184
 185     // check if the user enter a specific string to create autoincrement values
 186     OUString sAutoIncrementValue;
 187     Reference<XPropertySetInfo> xPropInfo = xColProp->getPropertySetInfo();
 188     if ( xPropInfo.is() && xPropInfo->hasPropertyByName(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) )
 189         xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) >>= sAutoIncrementValue;
 190
 191     aSql.append(" ");
 192
 193     aSql.append(createStandardTypePart(xColProp, _xConnection, _sCreatePattern));
 194
 195     if(::comphelper::getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_ISNULLABLE))) == ColumnValue::NO_NULLS)
 196         aSql.append(" NOT NULL");
 197
 198     if ( bIsAutoIncrement && !sAutoIncrementValue.isEmpty())
 199     {
 200         aSql.append(" ");
 201         aSql.append(sAutoIncrementValue);
 202     }
 203
 204     if ( _pHelper )
 205         _pHelper->addComment(xColProp,aSql);
 206
 207     return aSql.makeStringAndClear();
 208 }
 209
 210
 211 OUString createStandardCreateStatement(const Reference< XPropertySet >& descriptor,const Reference< XConnection>& _xConnection,ISQLStatementHelper* _pHelper,std::u16string_view _sCreatePattern)
 212 {
 213     OUStringBuffer aSql("CREATE TABLE ");
 214     OUString sCatalog,sSchema,sTable,sComposedName;
 215
 216     Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
 217     ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
 218
 219     descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME))  >>= sCatalog;
 220     descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME))   >>= sSchema;
 221     descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME))         >>= sTable;
 222
 223     sComposedName = ::dbtools::composeTableName( xMetaData, sCatalog, sSchema, sTable, true, ::dbtools::EComposeRule::InTableDefinitions );
 224     if ( sComposedName.isEmpty() )
 225         ::dbtools::throwFunctionSequenceException(_xConnection);
 226
 227     aSql.append(sComposedName);
 228     aSql.append(" (");
 229
 230     // columns
 231     Reference<XColumnsSupplier> xColumnSup(descriptor,UNO_QUERY);
 232     Reference<XIndexAccess> xColumns(xColumnSup->getColumns(),UNO_QUERY);
 233     // check if there are columns
 234     if(!xColumns.is() || !xColumns->getCount())
 235         ::dbtools::throwFunctionSequenceException(_xConnection);
 236
 237     Reference< XPropertySet > xColProp;
 238
 239     sal_Int32 nCount = xColumns->getCount();
 240     for(sal_Int32 i=0;i<nCount;++i)
 241     {
 242         if ( (xColumns->getByIndex(i) >>= xColProp) && xColProp.is() )
 243         {
 244             aSql.append(createStandardColumnPart(xColProp,_xConnection,_pHelper,_sCreatePattern));
 245             aSql.append(",");
 246         }
 247     }
 248     return aSql.makeStringAndClear();
 249 }
 250 namespace
 251 {
 252     OUString generateColumnNames(const Reference<XIndexAccess>& _xColumns,const Reference<XDatabaseMetaData>& _xMetaData)
 253     {
 254         ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
 255
 256         const OUString sQuote(_xMetaData->getIdentifierQuoteString());
 257         OUStringBuffer sSql( " (" );
 258         Reference< XPropertySet > xColProp;
 259
 260         sal_Int32 nColCount  = _xColumns->getCount();
 261         for(sal_Int32 i=0;i<nColCount;++i)
 262         {
 263             if ( (_xColumns->getByIndex(i) >>= xColProp) && xColProp.is() )
 264                 sSql.append( ::dbtools::quoteName(sQuote,::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME)))) )
 265                         .append(",");
 266         }
 267
 268         if ( nColCount )
 269             sSql[sSql.getLength()-1] = ')';
 270         return sSql.makeStringAndClear();
 271     }
 272 }
 273
 274 OUString createStandardKeyStatement(const Reference< XPropertySet >& descriptor,const Reference< XConnection>& _xConnection)
 275 {
 276     Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
 277     ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
 278
 279     OUStringBuffer aSql;
 280     // keys
 281     Reference<XKeysSupplier> xKeySup(descriptor,UNO_QUERY);
 282     Reference<XIndexAccess> xKeys = xKeySup->getKeys();
 283     if ( xKeys.is() )
 284     {
 285         Reference< XPropertySet > xColProp;
 286         Reference<XIndexAccess> xColumns;
 287         Reference<XColumnsSupplier> xColumnSup;
 288         OUString sCatalog,sSchema,sTable,sComposedName;
 289         bool bPKey = false;
 290         for(sal_Int32 i=0;i<xKeys->getCount();++i)
 291         {
 292             if ( (xKeys->getByIndex(i) >>= xColProp) && xColProp.is() )
 293             {
 294
 295                 sal_Int32 nKeyType      = ::comphelper::getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_TYPE)));
 296
 297                 if ( nKeyType == KeyType::PRIMARY )
 298                 {
 299                     if(bPKey)
 300                         ::dbtools::throwFunctionSequenceException(_xConnection);
 301
 302                     bPKey = true;
 303                     xColumnSup.set(xColProp,UNO_QUERY);
 304                     xColumns.set(xColumnSup->getColumns(),UNO_QUERY);
 305                     if(!xColumns.is() || !xColumns->getCount())
 306                         ::dbtools::throwFunctionSequenceException(_xConnection);
 307
 308                     aSql.append(" PRIMARY KEY ");
 309                     aSql.append(generateColumnNames(xColumns,xMetaData));
 310                 }
 311                 else if(nKeyType == KeyType::UNIQUE)
 312                 {
 313                     xColumnSup.set(xColProp,UNO_QUERY);
 314                     xColumns.set(xColumnSup->getColumns(),UNO_QUERY);
 315                     if(!xColumns.is() || !xColumns->getCount())
 316                         ::dbtools::throwFunctionSequenceException(_xConnection);
 317
 318                     aSql.append(" UNIQUE ");
 319                     aSql.append(generateColumnNames(xColumns,xMetaData));
 320                 }
 321                 else if(nKeyType == KeyType::FOREIGN)
 322                 {
 323                     sal_Int32 nDeleteRule   = getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_DELETERULE)));
 324
 325                     xColumnSup.set(xColProp,UNO_QUERY);
 326                     xColumns.set(xColumnSup->getColumns(),UNO_QUERY);
 327                     if(!xColumns.is() || !xColumns->getCount())
 328                         ::dbtools::throwFunctionSequenceException(_xConnection);
 329
 330                     aSql.append(" FOREIGN KEY ");
 331                     OUString sRefTable = getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_REFERENCEDTABLE)));
 332                     ::dbtools::qualifiedNameComponents(xMetaData,
 333                                                         sRefTable,
 334                                                         sCatalog,
 335                                                         sSchema,
 336                                                         sTable,
 337                                                         ::dbtools::EComposeRule::InDataManipulation);
 338                     sComposedName = ::dbtools::composeTableName( xMetaData, sCatalog, sSchema, sTable, true, ::dbtools::EComposeRule::InTableDefinitions );
 339
 340
 341                     if ( sComposedName.isEmpty() )
 342                         ::dbtools::throwFunctionSequenceException(_xConnection);
 343
 344                     aSql.append(generateColumnNames(xColumns,xMetaData));
 345
 346                     switch(nDeleteRule)
 347                     {
 348                         case KeyRule::CASCADE:
 349                             aSql.append(" ON DELETE CASCADE ");
 350                             break;
 351                         case KeyRule::RESTRICT:
 352                             aSql.append(" ON DELETE RESTRICT ");
 353                             break;
 354                         case KeyRule::SET_NULL:
 355                             aSql.append(" ON DELETE SET NULL ");
 356                             break;
 357                         case KeyRule::SET_DEFAULT:
 358                             aSql.append(" ON DELETE SET DEFAULT ");
 359                             break;
 360                         default:
 361                             ;
 362                     }
 363                 }
 364             }
 365         }
 366     }
 367
 368     if ( !aSql.isEmpty() )
 369     {
 370         if ( aSql[aSql.getLength() - 1] == ',' )
 371             aSql[aSql.getLength() - 1] = ')';
 372         else
 373             aSql.append(")");
 374     }
 375
 376     return aSql.makeStringAndClear();
 377
 378 }
 379
 380 OUString createSqlCreateTableStatement(  const Reference< XPropertySet >& descriptor,
 381                                          const Reference< XConnection>& _xConnection)
 382 {
 383     OUString aSql = ::dbtools::createStandardCreateStatement(descriptor,_xConnection,nullptr,{});
 384     const OUString sKeyStmt = ::dbtools::createStandardKeyStatement(descriptor,_xConnection);
 385     if ( !sKeyStmt.isEmpty() )
 386         aSql += sKeyStmt;
 387     else
 388     {
 389         if ( aSql.endsWith(",") )
 390             aSql = aSql.replaceAt(aSql.getLength()-1, 1, ")");
 391         else
 392             aSql += ")";
 393     }
 394     return aSql;
 395 }
 396 namespace
 397 {
 398     Reference<XPropertySet> lcl_createSDBCXColumn(const Reference<XNameAccess>& _xPrimaryKeyColumns,
 399                                           const Reference<XConnection>& _xConnection,
 400                                           const Any& _aCatalog,
 401                                           const OUString& _aSchema,
 402                                           const OUString& _aTable,
 403                                           const OUString& _rQueryName,
 404                                           const OUString& _rName,
 405                                           bool _bCase,
 406                                           bool _bQueryForInfo,
 407                                           bool _bIsAutoIncrement,
 408                                           bool _bIsCurrency,
 409                                           sal_Int32 _nDataType)
 410     {
 411         Reference<XPropertySet> xProp;
 412         Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
 413         Reference< XResultSet > xResult = xMetaData->getColumns(_aCatalog, _aSchema, _aTable, _rQueryName);
 414         OUString sCatalog;
 415         _aCatalog >>= sCatalog;
 416
 417         if ( xResult.is() )
 418         {
 419             UStringMixEqual aMixCompare(_bCase);
 420             Reference< XRow > xRow(xResult,UNO_QUERY);
 421             while( xResult->next() )
 422             {
 423                 if ( aMixCompare(xRow->getString(4),_rName) )
 424                 {
 425                     sal_Int32       nField5 = xRow->getInt(5);
 426                     OUString aField6 = xRow->getString(6);
 427                     sal_Int32       nField7 = xRow->getInt(7)
 428                                 ,   nField9 = xRow->getInt(9)
 429                                 ,   nField11= xRow->getInt(11);
 430                     OUString sField12 = xRow->getString(12),
 431                                     sField13 = xRow->getString(13);
 432                     ::comphelper::disposeComponent(xRow);
 433
 434                     bool bAutoIncrement = _bIsAutoIncrement
 435                             ,bIsCurrency    = _bIsCurrency;
 436                     if ( _bQueryForInfo )
 437                     {
 438                         const OUString sQuote = xMetaData->getIdentifierQuoteString();
 439                         OUString sQuotedName  = ::dbtools::quoteName(sQuote,_rName);
 440                         OUString sComposedName = composeTableNameForSelect(_xConnection, getString( _aCatalog ), _aSchema, _aTable );
 441
 442                         ColumnInformationMap aInfo(_bCase);
 443                         collectColumnInformation(_xConnection,sComposedName,sQuotedName,aInfo);
 444                         ColumnInformationMap::const_iterator aIter = aInfo.begin();
 445                         if ( aIter != aInfo.end() )
 446                         {
 447                             bAutoIncrement  = aIter->second.first.first;
 448                             bIsCurrency     = aIter->second.first.second;
 449                             if ( DataType::OTHER == nField5 )
 450                                 nField5     = aIter->second.second;
 451                         }
 452                     }
 453                     else if ( DataType::OTHER == nField5 )
 454                         nField5 = _nDataType;
 455
 456                     if ( nField11 != ColumnValue::NO_NULLS )
 457                     {
 458                         try
 459                         {
 460                             if ( _xPrimaryKeyColumns.is() )
 461                             {
 462                                 if ( _xPrimaryKeyColumns->hasByName(_rName) )
 463                                     nField11 = ColumnValue::NO_NULLS;
 464
 465                             }
 466                             else
 467                             {
 468                                 Reference< XResultSet > xPKeys = xMetaData->getPrimaryKeys( _aCatalog, _aSchema, _aTable );
 469                                 Reference< XRow > xPKeyRow( xPKeys, UNO_QUERY_THROW );
 470                                 while( xPKeys->next() ) // there can be only one primary key
 471                                 {
 472                                     OUString sKeyColumn = xPKeyRow->getString(4);
 473                                     if ( aMixCompare(_rName,sKeyColumn) )
 474                                     {
 475                                         nField11 = ColumnValue::NO_NULLS;
 476                                         break;
 477                                     }
 478                                 }
 479                             }
 480                         }
 481                         catch(SQLException&)
 482                         {
 483                             TOOLS_WARN_EXCEPTION( "connectivity.commontools", "lcl_createSDBCXColumn" );
 484                         }
 485                     }
 486
 487                     connectivity::sdbcx::OColumn* pRet = new connectivity::sdbcx::OColumn(_rName,
 488                                                 aField6,
 489                                                 sField13,
 490                                                 sField12,
 491                                                 nField11,
 492                                                 nField7,
 493                                                 nField9,
 494                                                 nField5,
 495                                                 bAutoIncrement,
 496                                                 false,
 497                                                 bIsCurrency,
 498                                                 _bCase,
 499                                                 sCatalog,
 500                                                 _aSchema,
 501                                                 _aTable);
 502
 503                     xProp = pRet;
 504                     break;
 505                 }
 506             }
 507         }
 508
 509         return xProp;
 510     }
 511
 512     Reference< XModel> lcl_getXModel(const Reference< XInterface>& _xIface)
 513     {
 514         Reference< XInterface > xParent = _xIface;
 515         Reference< XModel > xModel(xParent,UNO_QUERY);
 516         while( xParent.is() && !xModel.is() )
 517         {
 518             Reference<XChild> xChild(xParent,UNO_QUERY);
 519             xParent.set(xChild.is() ? xChild->getParent() : Reference< XInterface >(),UNO_QUERY);
 520             xModel.set(xParent,UNO_QUERY);
 521         }
 522         return xModel;
 523     }
 524 }
 525
 526 Reference<XPropertySet> createSDBCXColumn(const Reference<XPropertySet>& _xTable,
 527                                           const Reference<XConnection>& _xConnection,
 528                                           const OUString& _rName,
 529                                           bool _bCase,
 530                                           bool _bQueryForInfo,
 531                                           bool _bIsAutoIncrement,
 532                                           bool _bIsCurrency,
 533                                           sal_Int32 _nDataType)
 534 {
 535     Reference<XPropertySet> xProp;
 536     OSL_ENSURE(_xTable.is(),"Table is NULL!");
 537     if ( !_xTable.is() )
 538         return xProp;
 539
 540     ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
 541     Any aCatalog = _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME));
 542     OUString sCatalog;
 543     aCatalog >>= sCatalog;
 544
 545     OUString aSchema, aTable;
 546     _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME))  >>= aSchema;
 547     _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME))        >>= aTable;
 548
 549     Reference<XNameAccess> xPrimaryKeyColumns = getPrimaryKeyColumns_throw(_xTable);
 550
 551     xProp = lcl_createSDBCXColumn(xPrimaryKeyColumns,_xConnection,aCatalog, aSchema, aTable, _rName,_rName,_bCase,_bQueryForInfo,_bIsAutoIncrement,_bIsCurrency,_nDataType);
 552     if ( !xProp.is() )
 553     {
 554         xProp = lcl_createSDBCXColumn(xPrimaryKeyColumns,_xConnection,aCatalog, aSchema, aTable, "%",_rName,_bCase,_bQueryForInfo,_bIsAutoIncrement,_bIsCurrency,_nDataType);
 555         if ( !xProp.is() )
 556             xProp = new connectivity::sdbcx::OColumn(_rName,
 557                                                 OUString(),OUString(),OUString(),
 558                                                 ColumnValue::NULLABLE_UNKNOWN,
 559                                                 0,
 560                                                 0,
 561                                                 DataType::VARCHAR,
 562                                                 _bIsAutoIncrement,
 563                                                 false,
 564                                                 _bIsCurrency,
 565                                                 _bCase,
 566                                                 sCatalog,
 567                                                 aSchema,
 568                                                 aTable);
 569
 570     }
 571
 572     return xProp;
 573 }
 574
 575
 576 bool getBooleanDataSourceSetting( const Reference< XConnection >& _rxConnection, const char* _pAsciiSettingName )
 577 {
 578     bool bValue( false );
 579     try
 580     {
 581         Reference< XPropertySet> xDataSourceProperties( findDataSource( _rxConnection ), UNO_QUERY );
 582         OSL_ENSURE( xDataSourceProperties.is(), "::dbtools::getBooleanDataSourceSetting: somebody is using this with a non-SDB-level connection!" );
 583         if ( xDataSourceProperties.is() )
 584         {
 585             Reference< XPropertySet > xSettings(
 586                 xDataSourceProperties->getPropertyValue("Settings"),
 587                 UNO_QUERY_THROW
 588             );
 589             OSL_VERIFY( xSettings->getPropertyValue( OUString::createFromAscii( _pAsciiSettingName ) ) >>= bValue );
 590         }
 591     }
 592     catch( const Exception& )
 593     {
 594         DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
 595     }
 596     return bValue;
 597 }
 598
 599 bool getDataSourceSetting( const Reference< XInterface >& _xChild, const OUString& _sAsciiSettingsName,
 600     Any& /* [out] */ _rSettingsValue )
 601 {
 602     bool bIsPresent = false;
 603     try
 604     {
 605         const Reference< XPropertySet> xDataSourceProperties( findDataSource( _xChild ), UNO_QUERY );
 606         if ( !xDataSourceProperties.is() )
 607             return false;
 608
 609         const Reference< XPropertySet > xSettings(
 610                 xDataSourceProperties->getPropertyValue("Settings"),
 611                 UNO_QUERY_THROW
 612             );
 613
 614         _rSettingsValue = xSettings->getPropertyValue( _sAsciiSettingsName );
 615         bIsPresent = true;
 616     }
 617     catch( const Exception& )
 618     {
 619         bIsPresent = false;
 620     }
 621     return bIsPresent;
 622 }
 623
 624 bool getDataSourceSetting( const Reference< XInterface >& _rxDataSource, const char* _pAsciiSettingsName,
 625     Any& /* [out] */ _rSettingsValue )
 626 {
 627     OUString sAsciiSettingsName = OUString::createFromAscii(_pAsciiSettingsName);
 628     return getDataSourceSetting( _rxDataSource, sAsciiSettingsName,_rSettingsValue );
 629 }
 630
 631 bool isDataSourcePropertyEnabled(const Reference<XInterface>& _xProp, const OUString& _sProperty, bool _bDefault)
 632 {
 633     bool bEnabled = _bDefault;
 634     try
 635     {
 636         Reference< XPropertySet> xProp(findDataSource(_xProp),UNO_QUERY);
 637         if ( xProp.is() )
 638         {
 639             Sequence< PropertyValue > aInfo;
 640             xProp->getPropertyValue("Info") >>= aInfo;
 641             const PropertyValue* pValue =std::find_if(aInfo.begin(),
 642                                                 aInfo.end(),
 643                                                 [&_sProperty](const PropertyValue& lhs)
 644                                                 { return lhs.Name == _sProperty; });
 645             if ( pValue != aInfo.end() )
 646                 pValue->Value >>= bEnabled;
 647         }
 648     }
 649     catch(SQLException&)
 650     {
 651         DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
 652     }
 653     return bEnabled;
 654 }
 655
 656 Reference< XTablesSupplier> getDataDefinitionByURLAndConnection(
 657             const OUString& _rsUrl,
 658             const Reference< XConnection>& _xConnection,
 659             const Reference< XComponentContext >& _rxContext)
 660 {
 661     Reference< XTablesSupplier> xTablesSup;
 662     try
 663     {
 664         Reference< XDriverManager2 > xManager = DriverManager::create( _rxContext );
 665         Reference< XDataDefinitionSupplier > xSupp( xManager->getDriverByURL( _rsUrl ), UNO_QUERY );
 666
 667         if ( xSupp.is() )
 668         {
 669             xTablesSup = xSupp->getDataDefinitionByConnection( _xConnection );
 670             OSL_ENSURE(xTablesSup.is(),"No table supplier!");
 671         }
 672     }
 673     catch( const Exception& )
 674     {
 675         DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
 676     }
 677     return xTablesSup;
 678 }
 679
 680
 681 sal_Int32 getTablePrivileges(const Reference< XDatabaseMetaData>& _xMetaData,
 682                              const OUString& _sCatalog,
 683                              const OUString& _sSchema,
 684                              const OUString& _sTable)
 685 {
 686     OSL_ENSURE(_xMetaData.is(),"Invalid metadata!");
 687     sal_Int32 nPrivileges = 0;
 688     try
 689     {
 690         Any aVal;
 691         if(!_sCatalog.isEmpty())
 692             aVal <<= _sCatalog;
 693         Reference< XResultSet > xPrivileges = _xMetaData->getTablePrivileges(aVal, _sSchema, _sTable);
 694         Reference< XRow > xCurrentRow(xPrivileges, UNO_QUERY);
 695
 696         const OUString sUserWorkingFor = _xMetaData->getUserName();
 697         static const char sSELECT[] = "SELECT";
 698         static const char sINSERT[] = "INSERT";
 699         static const char sUPDATE[] = "UPDATE";
 700         static const char sDELETE[] = "DELETE";
 701         static const char sREAD[] = "READ";
 702         static const char sCREATE[] = "CREATE";
 703         static const char sALTER[] = "ALTER";
 704         static const char sREFERENCE[] = "REFERENCE";
 705         static const char sDROP[] = "DROP";
 706
 707         if ( xCurrentRow.is() )
 708         {
 709             // after creation the set is positioned before the first record, per definition
 710             OUString sPrivilege, sGrantee;
 711             while ( xPrivileges->next() )
 712             {
 713                 sGrantee    = xCurrentRow->getString(5);
 714                 sPrivilege  = xCurrentRow->getString(6);
 715
 716                 if (!sUserWorkingFor.equalsIgnoreAsciiCase(sGrantee))
 717                     continue;
 718
 719                 if (sPrivilege.equalsIgnoreAsciiCase(sSELECT))
 720                     nPrivileges |= Privilege::SELECT;
 721                 else if (sPrivilege.equalsIgnoreAsciiCase(sINSERT))
 722                     nPrivileges |= Privilege::INSERT;
 723                 else if (sPrivilege.equalsIgnoreAsciiCase(sUPDATE))
 724                     nPrivileges |= Privilege::UPDATE;
 725                 else if (sPrivilege.equalsIgnoreAsciiCase(sDELETE))
 726                     nPrivileges |= Privilege::DELETE;
 727                 else if (sPrivilege.equalsIgnoreAsciiCase(sREAD))
 728                     nPrivileges |= Privilege::READ;
 729                 else if (sPrivilege.equalsIgnoreAsciiCase(sCREATE))
 730                     nPrivileges |= Privilege::CREATE;
 731                 else if (sPrivilege.equalsIgnoreAsciiCase(sALTER))
 732                     nPrivileges |= Privilege::ALTER;
 733                 else if (sPrivilege.equalsIgnoreAsciiCase(sREFERENCE))
 734                     nPrivileges |= Privilege::REFERENCE;
 735                 else if (sPrivilege.equalsIgnoreAsciiCase(sDROP))
 736                     nPrivileges |= Privilege::DROP;
 737             }
 738         }
 739         disposeComponent(xPrivileges);
 740
 741         // Some drivers put a table privilege as soon as any column has the privilege,
 742         // some drivers only if all columns have the privilege.
 743         // To unify the situation, collect column privileges here, too.
 744         Reference< XResultSet > xColumnPrivileges = _xMetaData->getColumnPrivileges(aVal, _sSchema, _sTable, "%");
 745         Reference< XRow > xColumnCurrentRow(xColumnPrivileges, UNO_QUERY);
 746         if ( xColumnCurrentRow.is() )
 747         {
 748             // after creation the set is positioned before the first record, per definition
 749             OUString sPrivilege, sGrantee;
 750             while ( xColumnPrivileges->next() )
 751             {
 752                 sGrantee    = xColumnCurrentRow->getString(6);
 753                 sPrivilege  = xColumnCurrentRow->getString(7);
 754
 755                 if (!sUserWorkingFor.equalsIgnoreAsciiCase(sGrantee))
 756                     continue;
 757
 758                 if (sPrivilege.equalsIgnoreAsciiCase(sSELECT))
 759                     nPrivileges |= Privilege::SELECT;
 760                 else if (sPrivilege.equalsIgnoreAsciiCase(sINSERT))
 761                     nPrivileges |= Privilege::INSERT;
 762                 else if (sPrivilege.equalsIgnoreAsciiCase(sUPDATE))
 763                     nPrivileges |= Privilege::UPDATE;
 764                 else if (sPrivilege.equalsIgnoreAsciiCase(sDELETE))
 765                     nPrivileges |= Privilege::DELETE;
 766                 else if (sPrivilege.equalsIgnoreAsciiCase(sREAD))
 767                     nPrivileges |= Privilege::READ;
 768                 else if (sPrivilege.equalsIgnoreAsciiCase(sCREATE))
 769                     nPrivileges |= Privilege::CREATE;
 770                 else if (sPrivilege.equalsIgnoreAsciiCase(sALTER))
 771                     nPrivileges |= Privilege::ALTER;
 772                 else if (sPrivilege.equalsIgnoreAsciiCase(sREFERENCE))
 773                     nPrivileges |= Privilege::REFERENCE;
 774                 else if (sPrivilege.equalsIgnoreAsciiCase(sDROP))
 775                     nPrivileges |= Privilege::DROP;
 776             }
 777         }
 778         disposeComponent(xColumnPrivileges);
 779     }
 780     catch(const SQLException& e)
 781     {
 782         // some drivers don't support any privileges so we assume that we are allowed to do all we want :-)
 783         if(e.SQLState == "IM001")
 784             nPrivileges |=  Privilege::DROP         |
 785                             Privilege::REFERENCE    |
 786                             Privilege::ALTER        |
 787                             Privilege::CREATE       |
 788                             Privilege::READ         |
 789                             Privilege::DELETE       |
 790                             Privilege::UPDATE       |
 791                             Privilege::INSERT       |
 792                             Privilege::SELECT;
 793         else
 794             OSL_FAIL("Could not collect the privileges !");
 795     }
 796     return nPrivileges;
 797 }
 798
 799 // we need some more information about the column
 800 void collectColumnInformation(const Reference< XConnection>& _xConnection,
 801                               const OUString& _sComposedName,
 802                               const OUString& _rName,
 803                               ColumnInformationMap& _rInfo)
 804 {
 805     OUString sSelect = "SELECT " + _rName +
 806         " FROM " + _sComposedName +
 807         " WHERE 0 = 1";
 808
 809     try
 810     {
 811         ::utl::SharedUNOComponent< XStatement > xStmt( _xConnection->createStatement() );
 812         Reference< XPropertySet > xStatementProps( xStmt, UNO_QUERY_THROW );
 813         xStatementProps->setPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_ESCAPEPROCESSING ), makeAny( false ) );
 814         Reference< XResultSet > xResult( xStmt->executeQuery( sSelect ), UNO_SET_THROW );
 815         Reference< XResultSetMetaDataSupplier > xSuppMeta( xResult, UNO_QUERY_THROW );
 816         Reference< XResultSetMetaData > xMeta( xSuppMeta->getMetaData(), UNO_SET_THROW );
 817
 818         sal_Int32 nCount = xMeta->getColumnCount();
 819         OSL_ENSURE( nCount != 0, "::dbtools::collectColumnInformation: result set has empty (column-less) meta data!" );
 820         for (sal_Int32 i=1; i <= nCount ; ++i)
 821         {
 822             _rInfo.emplace( xMeta->getColumnName(i),
 823                 ColumnInformation(TBoolPair(xMeta->isAutoIncrement(i),xMeta->isCurrency(i)),xMeta->getColumnType(i)));
 824         }
 825     }
 826     catch( const Exception& )
 827     {
 828         DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
 829     }
 830 }
 831
 832
 833 bool isEmbeddedInDatabase( const Reference< XInterface >& _rxComponent, Reference< XConnection >& _rxActualConnection )
 834 {
 835     bool bIsEmbedded = false;
 836     try
 837     {
 838         Reference< XModel > xModel = lcl_getXModel( _rxComponent );
 839
 840         if ( xModel.is() )
 841         {
 842             Sequence< PropertyValue > aArgs = xModel->getArgs();
 843             const PropertyValue* pIter = aArgs.getConstArray();
 844             const PropertyValue* pEnd  = pIter + aArgs.getLength();
 845             for(;pIter != pEnd;++pIter)
 846             {
 847                 if ( pIter->Name == "ComponentData" )
 848                 {
 849                     Sequence<PropertyValue> aDocumentContext;
 850                     pIter->Value >>= aDocumentContext;
 851                     const PropertyValue* pContextIter = aDocumentContext.getConstArray();
 852                     const PropertyValue* pContextEnd  = pContextIter + aDocumentContext.getLength();
 853                     for(;pContextIter != pContextEnd;++pContextIter)
 854                     {
 855                         if (   pContextIter->Name == "ActiveConnection"
 856                             && ( pContextIter->Value >>= _rxActualConnection )
 857                            )
 858                         {
 859                             bIsEmbedded = true;
 860                             break;
 861                         }
 862                     }
 863                     break;
 864                 }
 865             }
 866         }
 867     }
 868     catch(Exception&)
 869     {
 870         // not interested in
 871     }
 872     return bIsEmbedded;
 873 }
 874
 875 namespace
 876 {
 877     OUString lcl_getEncodingName( rtl_TextEncoding _eEncoding )
 878     {
 879         OUString sEncodingName;
 880
 881         OCharsetMap aCharsets;
 882         OCharsetMap::CharsetIterator aEncodingPos = aCharsets.find( _eEncoding );
 883         OSL_ENSURE( aEncodingPos != aCharsets.end(), "lcl_getEncodingName: *which* encoding?" );
 884         if ( aEncodingPos != aCharsets.end() )
 885             sEncodingName = (*aEncodingPos).getIanaName();
 886
 887         return sEncodingName;
 888     }
 889 }
 890
 891
 892 sal_Int32 DBTypeConversion::convertUnicodeString( const OUString& _rSource, OString& _rDest, rtl_TextEncoding _eEncoding )
 893 {
 894     if ( !rtl_convertUStringToString( &_rDest.pData, _rSource.getStr(), _rSource.getLength(),
 895             _eEncoding,
 896             RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
 897             RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE |
 898             RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 )
 899         )
 900     {
 901         SharedResources aResources;
 902         OUString sMessage = aResources.getResourceStringWithSubstitution( STR_CANNOT_CONVERT_STRING,
 903             "$string$", _rSource,
 904             "$charset$",  lcl_getEncodingName( _eEncoding )
 905         );
 906
 907         throw SQLException(
 908             sMessage,
 909             nullptr,
 910             "22018",
 911             22018,
 912             Any()
 913         );
 914     }
 915
 916     return _rDest.getLength();
 917 }
 918
 919
 920 sal_Int32 DBTypeConversion::convertUnicodeStringToLength( const OUString& _rSource, OString&  _rDest,
 921    sal_Int32 _nMaxLen, rtl_TextEncoding _eEncoding )
 922 {
 923     sal_Int32 nLen = convertUnicodeString( _rSource, _rDest, _eEncoding );
 924     if ( nLen > _nMaxLen )
 925     {
 926         SharedResources aResources;
 927         OUString sMessage = aResources.getResourceStringWithSubstitution( STR_STRING_LENGTH_EXCEEDED,
 928             "$string$", _rSource,
 929             "$maxlen$", OUString::number( _nMaxLen ),
 930             "$charset$", lcl_getEncodingName( _eEncoding )
 931         );
 932
 933         throw SQLException(
 934             sMessage,
 935             nullptr,
 936             "22001",
 937             22001,
 938             Any()
 939         );
 940     }
 941
 942     return nLen;
 943 }
 944 static OUString lcl_getReportEngines()
 945 {
 946     return "org.openoffice.Office.DataAccess/ReportEngines";
 947 }
 948
 949 static OUString lcl_getDefaultReportEngine()
 950 {
 951     return "DefaultReportEngine";
 952 }
 953
 954 static OUString lcl_getReportEngineNames()
 955 {
 956     return "ReportEngineNames";
 957 }
 958
 959 OUString getDefaultReportEngineServiceName(const Reference< XComponentContext >& _rxORB)
 960 {
 961     ::utl::OConfigurationTreeRoot aReportEngines = ::utl::OConfigurationTreeRoot::createWithComponentContext(
 962         _rxORB, lcl_getReportEngines(), -1, ::utl::OConfigurationTreeRoot::CM_READONLY);
 963
 964     if ( aReportEngines.isValid() )
 965     {
 966         OUString sDefaultReportEngineName;
 967         aReportEngines.getNodeValue(lcl_getDefaultReportEngine()) >>= sDefaultReportEngineName;
 968         if ( !sDefaultReportEngineName.isEmpty() )
 969         {
 970             ::utl::OConfigurationNode aReportEngineNames = aReportEngines.openNode(lcl_getReportEngineNames());
 971             if ( aReportEngineNames.isValid() )
 972             {
 973                 ::utl::OConfigurationNode aReportEngine = aReportEngineNames.openNode(sDefaultReportEngineName);
 974                 if ( aReportEngine.isValid() )
 975                 {
 976                     OUString sRet;
 977                     aReportEngine.getNodeValue("ServiceName") >>= sRet;
 978                     return sRet;
 979                 }
 980             }
 981         }
 982         else
 983             return "org.libreoffice.report.pentaho.SOReportJobFactory";
 984     }
 985     else
 986         return "org.libreoffice.report.pentaho.SOReportJobFactory";
 987     return OUString();
 988 }
 989
 990 bool isAggregateColumn(const Reference< XSingleSelectQueryComposer > &_xParser, const Reference< XPropertySet > &_xField)
 991 {
 992     OUString sName;
 993     _xField->getPropertyValue("Name") >>= sName;
 994     Reference< XColumnsSupplier > xColumnsSupplier(_xParser, UNO_QUERY);
 995     Reference< css::container::XNameAccess >  xCols;
 996     if (xColumnsSupplier.is())
 997         xCols = xColumnsSupplier->getColumns();
 998
 999     return isAggregateColumn(xCols, sName);
1000 }
1001
1002 bool isAggregateColumn(const Reference< XNameAccess > &_xColumns, const OUString &_sName)
1003 {
1004     if ( _xColumns.is() && _xColumns->hasByName(_sName) )
1005     {
1006         Reference<XPropertySet> xProp(_xColumns->getByName(_sName),UNO_QUERY);
1007         assert(xProp.is());
1008         return isAggregateColumn( xProp );
1009     }
1010     return false;
1011 }
1012
1013 bool isAggregateColumn( const Reference< XPropertySet > &_xColumn )
1014 {
1015     bool bAgg(false);
1016
1017     static const char sAgg[] = "AggregateFunction";
1018     if ( _xColumn->getPropertySetInfo()->hasPropertyByName(sAgg) )
1019         _xColumn->getPropertyValue(sAgg) >>= bAgg;
1020
1021     return bAgg;
1022 }
1023
1024
1025 }   // namespace dbtools
1026
1027
1028 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */