?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cid#1636690 Dereference after null check
[LibreOffice.git] / connectivity / source / commontools / dbtools2.cxx
blobc85a5440238fceba0ca32215ea75387e1481321a
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 <comphelper/diagnose_ex.hxx>
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, u"");
126 }
127
128 if ( (nPrecision > 0 || nScale > 0) && bUseLiteral )
129 {
130 bool bTimed = (nDataType == DataType::TIME ||
131 nDataType == DataType::TIME_WITH_TIMEZONE ||
132 nDataType == DataType::TIMESTAMP ||
133 nDataType == DataType::TIMESTAMP_WITH_TIMEZONE);
134
135 sal_Int32 nParenPos = (nDataType == DataType::TIME_WITH_TIMEZONE ||
136 nDataType == DataType::TIMESTAMP_WITH_TIMEZONE) ?
137 sTypeName.indexOf(' ') :
138 sTypeName.indexOf('(');
139
140 if ( nParenPos == -1 )
141 aSql.append(sTypeName);
142 else
143 aSql.append(sTypeName.subView(0, nParenPos));
144 aSql.append("(");
145
146 if ( nPrecision > 0 && !bTimed )
147 {
148 aSql.append(nPrecision);
149 if ( (nScale > 0) || (!_sCreatePattern.empty() && sCreateParams.indexOf(_sCreatePattern) != -1) )
150 aSql.append(",");
151 }
152 if ( (nScale > 0) || ( !_sCreatePattern.empty() && sCreateParams.indexOf(_sCreatePattern) != -1 ) || bTimed )
153 aSql.append(nScale);
154
155 if ( nParenPos == -1 )
156 aSql.append(")");
157 else
158 {
159 if ( bTimed )
160 aSql.append(")");
161 else
162 nParenPos = sTypeName.indexOf(')',nParenPos);
163 aSql.append(sTypeName.subView(nParenPos));
164 }
165 }
166 else
167 aSql.append(sTypeName); // simply add the type name
168
169 OUString aDefault = ::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_DEFAULTVALUE)));
170 if ( !aDefault.isEmpty() )
171 {
172 aSql.append(" DEFAULT " + sPrefix + aDefault + sPostfix);
173 } // if ( aDefault.getLength() )
174
175 return aSql.makeStringAndClear();
176 }
177
178 OUString createStandardColumnPart(const Reference< XPropertySet >& xColProp,const Reference< XConnection>& _xConnection,ISQLStatementHelper* _pHelper,std::u16string_view _sCreatePattern)
179 {
180 Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
181
182 ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
183
184 bool bIsAutoIncrement = false;
185 xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_ISAUTOINCREMENT)) >>= bIsAutoIncrement;
186
187 const OUString sQuoteString = xMetaData->getIdentifierQuoteString();
188 OUStringBuffer aSql(::dbtools::quoteName(sQuoteString,::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME)))));
189
190 // check if the user enter a specific string to create autoincrement values
191 OUString sAutoIncrementValue;
192 Reference<XPropertySetInfo> xPropInfo = xColProp->getPropertySetInfo();
193 if ( xPropInfo.is() && xPropInfo->hasPropertyByName(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) )
194 xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_AUTOINCREMENTCREATION)) >>= sAutoIncrementValue;
195
196 aSql.append(" " + createStandardTypePart(xColProp, _xConnection, _sCreatePattern));
197
198 if(::comphelper::getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_ISNULLABLE))) == ColumnValue::NO_NULLS)
199 aSql.append(" NOT NULL");
200
201 if ( bIsAutoIncrement && !sAutoIncrementValue.isEmpty())
202 {
203 aSql.append(" " + sAutoIncrementValue);
204 }
205
206 if ( _pHelper )
207 _pHelper->addComment(xColProp,aSql);
208
209 return aSql.makeStringAndClear();
210 }
211
212
213 OUString createStandardCreateStatement(const Reference< XPropertySet >& descriptor,const Reference< XConnection>& _xConnection,ISQLStatementHelper* _pHelper,std::u16string_view _sCreatePattern)
214 {
215 OUStringBuffer aSql("CREATE TABLE ");
216 OUString sCatalog,sSchema,sTable,sComposedName;
217
218 Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
219 ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
220
221 descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME)) >>= sCatalog;
222 descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME)) >>= sSchema;
223 descriptor->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME)) >>= sTable;
224
225 sComposedName = ::dbtools::composeTableName( xMetaData, sCatalog, sSchema, sTable, true, ::dbtools::EComposeRule::InTableDefinitions );
226 if ( sComposedName.isEmpty() )
227 ::dbtools::throwFunctionSequenceException(_xConnection);
228
229 aSql.append(sComposedName + " (");
230
231 // columns
232 Reference<XColumnsSupplier> xColumnSup(descriptor,UNO_QUERY);
233 Reference<XIndexAccess> xColumns(xColumnSup->getColumns(),UNO_QUERY);
234 // check if there are columns
235 if(!xColumns.is() || !xColumns->getCount())
236 ::dbtools::throwFunctionSequenceException(_xConnection);
237
238 Reference< XPropertySet > xColProp;
239
240 sal_Int32 nCount = xColumns->getCount();
241 for(sal_Int32 i=0;i<nCount;++i)
242 {
243 if ( (xColumns->getByIndex(i) >>= xColProp) && xColProp.is() )
244 {
245 aSql.append(
246 createStandardColumnPart(xColProp,_xConnection,_pHelper,_sCreatePattern)
247 + ",");
248 }
249 }
250 return aSql.makeStringAndClear();
251 }
252 namespace
253 {
254 OUString generateColumnNames(const Reference<XIndexAccess>& _xColumns,const Reference<XDatabaseMetaData>& _xMetaData)
255 {
256 ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
257
258 const OUString sQuote(_xMetaData->getIdentifierQuoteString());
259 OUStringBuffer sSql( " (" );
260 Reference< XPropertySet > xColProp;
261
262 sal_Int32 nColCount = _xColumns->getCount();
263 for(sal_Int32 i=0;i<nColCount;++i)
264 {
265 if ( (_xColumns->getByIndex(i) >>= xColProp) && xColProp.is() )
266 sSql.append( ::dbtools::quoteName(sQuote,::comphelper::getString(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME)))) +
267 ",");
268 }
269
270 if ( nColCount )
271 sSql[sSql.getLength()-1] = ')';
272 return sSql.makeStringAndClear();
273 }
274 }
275
276 OUString createStandardKeyStatement(const Reference< XPropertySet >& descriptor,const Reference< XConnection>& _xConnection)
277 {
278 Reference<XDatabaseMetaData> xMetaData = _xConnection->getMetaData();
279 ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
280
281 OUStringBuffer aSql;
282 // keys
283 Reference<XKeysSupplier> xKeySup(descriptor,UNO_QUERY);
284 Reference<XIndexAccess> xKeys = xKeySup->getKeys();
285 if ( xKeys.is() )
286 {
287 Reference< XPropertySet > xColProp;
288 Reference<XIndexAccess> xColumns;
289 Reference<XColumnsSupplier> xColumnSup;
290 OUString sCatalog,sSchema,sTable,sComposedName;
291 bool bPKey = false;
292 for(sal_Int32 i=0;i<xKeys->getCount();++i)
293 {
294 if ( (xKeys->getByIndex(i) >>= xColProp) && xColProp.is() )
295 {
296
297 sal_Int32 nKeyType = ::comphelper::getINT32(xColProp->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_TYPE)));
298
299 if ( nKeyType == KeyType::PRIMARY )
300 {
301 if(bPKey)
302 ::dbtools::throwFunctionSequenceException(_xConnection);
303
304 bPKey = true;
305 xColumnSup.set(xColProp,UNO_QUERY);
306 xColumns.set(xColumnSup->getColumns(),UNO_QUERY);
307 if(!xColumns.is() || !xColumns->getCount())
308 ::dbtools::throwFunctionSequenceException(_xConnection);
309
310 aSql.append(" PRIMARY KEY " + generateColumnNames(xColumns,xMetaData));
311 }
312 else if(nKeyType == KeyType::UNIQUE)
313 {
314 xColumnSup.set(xColProp,UNO_QUERY);
315 xColumns.set(xColumnSup->getColumns(),UNO_QUERY);
316 if(!xColumns.is() || !xColumns->getCount())
317 ::dbtools::throwFunctionSequenceException(_xConnection);
318
319 aSql.append(" UNIQUE " + 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, u")");
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((UStringMixLess(_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 xProp = 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 break;
504 }
505 }
506 }
507
508 return xProp;
509 }
510
511 Reference< XModel> lcl_getXModel(const Reference< XInterface>& _xIface)
512 {
513 Reference< XInterface > xParent = _xIface;
514 Reference< XModel > xModel(xParent,UNO_QUERY);
515 while( xParent.is() && !xModel.is() )
516 {
517 Reference<XChild> xChild(xParent,UNO_QUERY);
518 xParent.set(xChild.is() ? xChild->getParent() : Reference< XInterface >(),UNO_QUERY);
519 xModel.set(xParent,UNO_QUERY);
520 }
521 return xModel;
522 }
523 }
524
525 Reference<XPropertySet> createSDBCXColumn(const Reference<XPropertySet>& _xTable,
526 const Reference<XConnection>& _xConnection,
527 const OUString& _rName,
528 bool _bCase,
529 bool _bQueryForInfo,
530 bool _bIsAutoIncrement,
531 bool _bIsCurrency,
532 sal_Int32 _nDataType)
533 {
534 Reference<XPropertySet> xProp;
535 OSL_ENSURE(_xTable.is(),"Table is NULL!");
536 if ( !_xTable.is() )
537 return xProp;
538
539 ::dbtools::OPropertyMap& rPropMap = OMetaConnection::getPropMap();
540 Any aCatalog = _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_CATALOGNAME));
541 OUString sCatalog;
542 aCatalog >>= sCatalog;
543
544 OUString aSchema, aTable;
545 _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_SCHEMANAME)) >>= aSchema;
546 _xTable->getPropertyValue(rPropMap.getNameByIndex(PROPERTY_ID_NAME)) >>= aTable;
547
548 Reference<XNameAccess> xPrimaryKeyColumns = getPrimaryKeyColumns_throw(_xTable);
549
550 xProp = lcl_createSDBCXColumn(xPrimaryKeyColumns,_xConnection,aCatalog, aSchema, aTable, _rName,_rName,_bCase,_bQueryForInfo,_bIsAutoIncrement,_bIsCurrency,_nDataType);
551 if ( !xProp.is() )
552 {
553 xProp = lcl_createSDBCXColumn(xPrimaryKeyColumns,_xConnection,aCatalog, aSchema, aTable, u"%"_ustr,_rName,_bCase,_bQueryForInfo,_bIsAutoIncrement,_bIsCurrency,_nDataType);
554 if ( !xProp.is() )
555 xProp = new connectivity::sdbcx::OColumn(_rName,
556 OUString(),OUString(),OUString(),
557 ColumnValue::NULLABLE_UNKNOWN,
558 0,
559 0,
560 DataType::VARCHAR,
561 _bIsAutoIncrement,
562 false,
563 _bIsCurrency,
564 _bCase,
565 sCatalog,
566 aSchema,
567 aTable);
568
569 }
570
571 return xProp;
572 }
573
574
575 bool getBooleanDataSourceSetting( const Reference< XConnection >& _rxConnection, const char* _pAsciiSettingName )
576 {
577 return getBooleanDataSourceSetting(_rxConnection, OUString::createFromAscii( _pAsciiSettingName ));
578 }
579
580 bool getBooleanDataSourceSetting( const Reference< XConnection >& _rxConnection, const OUString & rSettingName )
581 {
582 bool bValue( false );
583 try
584 {
585 Reference< XPropertySet> xDataSourceProperties( findDataSource( _rxConnection ), UNO_QUERY );
586 OSL_ENSURE( xDataSourceProperties.is(), "::dbtools::getBooleanDataSourceSetting: somebody is using this with a non-SDB-level connection!" );
587 if ( xDataSourceProperties.is() )
588 {
589 Reference< XPropertySet > xSettings(
590 xDataSourceProperties->getPropertyValue(u"Settings"_ustr),
591 UNO_QUERY_THROW
592 );
593 OSL_VERIFY( xSettings->getPropertyValue( rSettingName ) >>= bValue );
594 }
595 }
596 catch( const Exception& )
597 {
598 DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
599 }
600 return bValue;
601 }
602
603 bool getDataSourceSetting( const Reference< XInterface >& _xChild, const OUString& _sAsciiSettingsName,
604 Any& /* [out] */ _rSettingsValue )
605 {
606 bool bIsPresent = false;
607 try
608 {
609 const Reference< XPropertySet> xDataSourceProperties( findDataSource( _xChild ), UNO_QUERY );
610 if ( !xDataSourceProperties.is() )
611 return false;
612
613 const Reference< XPropertySet > xSettings(
614 xDataSourceProperties->getPropertyValue(u"Settings"_ustr),
615 UNO_QUERY_THROW
616 );
617
618 _rSettingsValue = xSettings->getPropertyValue( _sAsciiSettingsName );
619 bIsPresent = true;
620 }
621 catch( const Exception& )
622 {
623 bIsPresent = false;
624 }
625 return bIsPresent;
626 }
627
628 bool getDataSourceSetting( const Reference< XInterface >& _rxDataSource, const char* _pAsciiSettingsName,
629 Any& /* [out] */ _rSettingsValue )
630 {
631 OUString sAsciiSettingsName = OUString::createFromAscii(_pAsciiSettingsName);
632 return getDataSourceSetting( _rxDataSource, sAsciiSettingsName,_rSettingsValue );
633 }
634
635 bool isDataSourcePropertyEnabled(const Reference<XInterface>& _xProp, const OUString& _sProperty, bool _bDefault)
636 {
637 bool bEnabled = _bDefault;
638 try
639 {
640 Reference< XPropertySet> xProp(findDataSource(_xProp),UNO_QUERY);
641 if ( xProp.is() )
642 {
643 Sequence< PropertyValue > aInfo;
644 xProp->getPropertyValue(u"Info"_ustr) >>= aInfo;
645 const PropertyValue* pValue =std::find_if(std::cbegin(aInfo),
646 std::cend(aInfo),
647 [&_sProperty](const PropertyValue& lhs)
648 { return lhs.Name == _sProperty; });
649 if ( pValue != std::cend(aInfo) )
650 pValue->Value >>= bEnabled;
651 }
652 }
653 catch(SQLException&)
654 {
655 DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
656 }
657 return bEnabled;
658 }
659
660 Reference< XTablesSupplier> getDataDefinitionByURLAndConnection(
661 const OUString& _rsUrl,
662 const Reference< XConnection>& _xConnection,
663 const Reference< XComponentContext >& _rxContext)
664 {
665 Reference< XTablesSupplier> xTablesSup;
666 try
667 {
668 Reference< XDriverManager2 > xManager = DriverManager::create( _rxContext );
669 Reference< XDataDefinitionSupplier > xSupp( xManager->getDriverByURL( _rsUrl ), UNO_QUERY );
670
671 if ( xSupp.is() )
672 {
673 xTablesSup = xSupp->getDataDefinitionByConnection( _xConnection );
674 OSL_ENSURE(xTablesSup.is(),"No table supplier!");
675 }
676 }
677 catch( const Exception& )
678 {
679 DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
680 }
681 return xTablesSup;
682 }
683
684
685 sal_Int32 getTablePrivileges(const Reference< XDatabaseMetaData>& _xMetaData,
686 const OUString& _sCatalog,
687 const OUString& _sSchema,
688 const OUString& _sTable)
689 {
690 OSL_ENSURE(_xMetaData.is(),"Invalid metadata!");
691 sal_Int32 nPrivileges = 0;
692 try
693 {
694 Any aVal;
695 if(!_sCatalog.isEmpty())
696 aVal <<= _sCatalog;
697 Reference< XResultSet > xPrivileges = _xMetaData->getTablePrivileges(aVal, _sSchema, _sTable);
698 Reference< XRow > xCurrentRow(xPrivileges, UNO_QUERY);
699
700 const OUString sUserWorkingFor = _xMetaData->getUserName();
701 static const char sSELECT[] = "SELECT";
702 static const char sINSERT[] = "INSERT";
703 static const char sUPDATE[] = "UPDATE";
704 static const char sDELETE[] = "DELETE";
705 static const char sREAD[] = "READ";
706 static const char sCREATE[] = "CREATE";
707 static const char sALTER[] = "ALTER";
708 static const char sREFERENCE[] = "REFERENCE";
709 static const char sDROP[] = "DROP";
710
711 if ( xCurrentRow.is() )
712 {
713 // after creation the set is positioned before the first record, per definition
714 OUString sPrivilege, sGrantee;
715 while ( xPrivileges->next() )
716 {
717 sGrantee = xCurrentRow->getString(5);
718 sPrivilege = xCurrentRow->getString(6);
719
720 if (!sUserWorkingFor.equalsIgnoreAsciiCase(sGrantee))
721 continue;
722
723 if (sPrivilege.equalsIgnoreAsciiCase(sSELECT))
724 nPrivileges |= Privilege::SELECT;
725 else if (sPrivilege.equalsIgnoreAsciiCase(sINSERT))
726 nPrivileges |= Privilege::INSERT;
727 else if (sPrivilege.equalsIgnoreAsciiCase(sUPDATE))
728 nPrivileges |= Privilege::UPDATE;
729 else if (sPrivilege.equalsIgnoreAsciiCase(sDELETE))
730 nPrivileges |= Privilege::DELETE;
731 else if (sPrivilege.equalsIgnoreAsciiCase(sREAD))
732 nPrivileges |= Privilege::READ;
733 else if (sPrivilege.equalsIgnoreAsciiCase(sCREATE))
734 nPrivileges |= Privilege::CREATE;
735 else if (sPrivilege.equalsIgnoreAsciiCase(sALTER))
736 nPrivileges |= Privilege::ALTER;
737 else if (sPrivilege.equalsIgnoreAsciiCase(sREFERENCE))
738 nPrivileges |= Privilege::REFERENCE;
739 else if (sPrivilege.equalsIgnoreAsciiCase(sDROP))
740 nPrivileges |= Privilege::DROP;
741 }
742 }
743 disposeComponent(xPrivileges);
744
745 // Some drivers put a table privilege as soon as any column has the privilege,
746 // some drivers only if all columns have the privilege.
747 // To unify the situation, collect column privileges here, too.
748 Reference< XResultSet > xColumnPrivileges = _xMetaData->getColumnPrivileges(aVal, _sSchema, _sTable, u"%"_ustr);
749 Reference< XRow > xColumnCurrentRow(xColumnPrivileges, UNO_QUERY);
750 if ( xColumnCurrentRow.is() )
751 {
752 // after creation the set is positioned before the first record, per definition
753 OUString sPrivilege, sGrantee;
754 while ( xColumnPrivileges->next() )
755 {
756 sGrantee = xColumnCurrentRow->getString(6);
757 sPrivilege = xColumnCurrentRow->getString(7);
758
759 if (!sUserWorkingFor.equalsIgnoreAsciiCase(sGrantee))
760 continue;
761
762 if (sPrivilege.equalsIgnoreAsciiCase(sSELECT))
763 nPrivileges |= Privilege::SELECT;
764 else if (sPrivilege.equalsIgnoreAsciiCase(sINSERT))
765 nPrivileges |= Privilege::INSERT;
766 else if (sPrivilege.equalsIgnoreAsciiCase(sUPDATE))
767 nPrivileges |= Privilege::UPDATE;
768 else if (sPrivilege.equalsIgnoreAsciiCase(sDELETE))
769 nPrivileges |= Privilege::DELETE;
770 else if (sPrivilege.equalsIgnoreAsciiCase(sREAD))
771 nPrivileges |= Privilege::READ;
772 else if (sPrivilege.equalsIgnoreAsciiCase(sCREATE))
773 nPrivileges |= Privilege::CREATE;
774 else if (sPrivilege.equalsIgnoreAsciiCase(sALTER))
775 nPrivileges |= Privilege::ALTER;
776 else if (sPrivilege.equalsIgnoreAsciiCase(sREFERENCE))
777 nPrivileges |= Privilege::REFERENCE;
778 else if (sPrivilege.equalsIgnoreAsciiCase(sDROP))
779 nPrivileges |= Privilege::DROP;
780 }
781 }
782 disposeComponent(xColumnPrivileges);
783 }
784 catch(const SQLException& e)
785 {
786 // some drivers don't support any privileges so we assume that we are allowed to do all we want :-)
787 if(e.SQLState == "IM001")
788 nPrivileges |= Privilege::DROP |
789 Privilege::REFERENCE |
790 Privilege::ALTER |
791 Privilege::CREATE |
792 Privilege::READ |
793 Privilege::DELETE |
794 Privilege::UPDATE |
795 Privilege::INSERT |
796 Privilege::SELECT;
797 else
798 OSL_FAIL("Could not collect the privileges !");
799 }
800 return nPrivileges;
801 }
802
803 // we need some more information about the column
804 void collectColumnInformation(const Reference< XConnection>& _xConnection,
805 std::u16string_view _sComposedName,
806 std::u16string_view _rName,
807 ColumnInformationMap& _rInfo)
808 {
809 OUString sSelect = OUString::Concat("SELECT ") + _rName +
810 " FROM " + _sComposedName +
811 " WHERE 0 = 1";
812
813 try
814 {
815 ::utl::SharedUNOComponent< XStatement > xStmt( _xConnection->createStatement() );
816 Reference< XPropertySet > xStatementProps( xStmt, UNO_QUERY_THROW );
817 xStatementProps->setPropertyValue( OMetaConnection::getPropMap().getNameByIndex( PROPERTY_ID_ESCAPEPROCESSING ), Any( false ) );
818 Reference< XResultSet > xResult( xStmt->executeQuery( sSelect ), UNO_SET_THROW );
819 Reference< XResultSetMetaDataSupplier > xSuppMeta( xResult, UNO_QUERY_THROW );
820 Reference< XResultSetMetaData > xMeta( xSuppMeta->getMetaData(), UNO_SET_THROW );
821
822 sal_Int32 nCount = xMeta->getColumnCount();
823 OSL_ENSURE( nCount != 0, "::dbtools::collectColumnInformation: result set has empty (column-less) meta data!" );
824 for (sal_Int32 i=1; i <= nCount ; ++i)
825 {
826 _rInfo.emplace( xMeta->getColumnName(i),
827 ColumnInformation(TBoolPair(xMeta->isAutoIncrement(i),xMeta->isCurrency(i)),xMeta->getColumnType(i)));
828 }
829 }
830 catch( const Exception& )
831 {
832 DBG_UNHANDLED_EXCEPTION("connectivity.commontools");
833 }
834 }
835
836
837 bool isEmbeddedInDatabase( const Reference< XInterface >& _rxComponent, Reference< XConnection >& _rxActualConnection )
838 {
839 bool bIsEmbedded = false;
840 try
841 {
842 Reference< XModel > xModel = lcl_getXModel( _rxComponent );
843
844 if ( xModel.is() )
845 {
846 for (auto& arg : xModel->getArgs())
847 {
848 if (arg.Name == "ComponentData")
849 {
850 Sequence<PropertyValue> aDocumentContext;
851 arg.Value >>= aDocumentContext;
852 for (auto& item : aDocumentContext)
853 {
854 if (item.Name == "ActiveConnection" && (item.Value >>= _rxActualConnection))
855 {
856 bIsEmbedded = true;
857 break;
858 }
859 }
860 break;
861 }
862 }
863 }
864 }
865 catch(Exception&)
866 {
867 // not interested in
868 }
869 return bIsEmbedded;
870 }
871
872 namespace
873 {
874 OUString lcl_getEncodingName( rtl_TextEncoding _eEncoding )
875 {
876 OUString sEncodingName;
877
878 OCharsetMap aCharsets;
879 OCharsetMap::CharsetIterator aEncodingPos = aCharsets.find( _eEncoding );
880 OSL_ENSURE( aEncodingPos != aCharsets.end(), "lcl_getEncodingName: *which* encoding?" );
881 if ( aEncodingPos != aCharsets.end() )
882 sEncodingName = (*aEncodingPos).getIanaName();
883
884 return sEncodingName;
885 }
886 }
887
888
889 sal_Int32 DBTypeConversion::convertUnicodeString( const OUString& _rSource, OString& _rDest, rtl_TextEncoding _eEncoding )
890 {
891 if ( !rtl_convertUStringToString( &_rDest.pData, _rSource.getStr(), _rSource.getLength(),
892 _eEncoding,
893 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
894 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE |
895 RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 )
896 )
897 {
898 SharedResources aResources;
899 OUString sMessage = aResources.getResourceStringWithSubstitution( STR_CANNOT_CONVERT_STRING,
900 "$string$", _rSource,
901 "$charset$", lcl_getEncodingName( _eEncoding )
902 );
903
904 throw SQLException(
905 sMessage,
906 nullptr,
907 u"22018"_ustr,
908 22018,
909 Any()
910 );
911 }
912
913 return _rDest.getLength();
914 }
915
916
917 sal_Int32 DBTypeConversion::convertUnicodeStringToLength( const OUString& _rSource, OString& _rDest,
918 sal_Int32 _nMaxLen, rtl_TextEncoding _eEncoding )
919 {
920 sal_Int32 nLen = convertUnicodeString( _rSource, _rDest, _eEncoding );
921 if ( nLen > _nMaxLen )
922 {
923 SharedResources aResources;
924 OUString sMessage = aResources.getResourceStringWithSubstitution( STR_STRING_LENGTH_EXCEEDED,
925 "$string$", _rSource,
926 "$maxlen$", OUString::number( _nMaxLen ),
927 "$charset$", lcl_getEncodingName( _eEncoding )
928 );
929
930 throw SQLException(
931 sMessage,
932 nullptr,
933 u"22001"_ustr,
934 22001,
935 Any()
936 );
937 }
938
939 return nLen;
940 }
941
942 OUString getDefaultReportEngineServiceName(const Reference< XComponentContext >& _rxORB)
943 {
944 ::utl::OConfigurationTreeRoot aReportEngines = ::utl::OConfigurationTreeRoot::createWithComponentContext(
945 _rxORB, u"org.openoffice.Office.DataAccess/ReportEngines"_ustr, -1, ::utl::OConfigurationTreeRoot::CM_READONLY);
946
947 if ( aReportEngines.isValid() )
948 {
949 OUString sDefaultReportEngineName;
950 aReportEngines.getNodeValue(u"DefaultReportEngine"_ustr) >>= sDefaultReportEngineName;
951 if ( !sDefaultReportEngineName.isEmpty() )
952 {
953 ::utl::OConfigurationNode aReportEngineNames = aReportEngines.openNode(u"ReportEngineNames"_ustr);
954 if ( aReportEngineNames.isValid() )
955 {
956 ::utl::OConfigurationNode aReportEngine = aReportEngineNames.openNode(sDefaultReportEngineName);
957 if ( aReportEngine.isValid() )
958 {
959 OUString sRet;
960 aReportEngine.getNodeValue(u"ServiceName"_ustr) >>= sRet;
961 return sRet;
962 }
963 }
964 }
965 else
966 return u"org.libreoffice.report.pentaho.SOReportJobFactory"_ustr;
967 }
968 else
969 return u"org.libreoffice.report.pentaho.SOReportJobFactory"_ustr;
970 return OUString();
971 }
972
973 bool isAggregateColumn(const Reference< XSingleSelectQueryComposer > &_xParser, const Reference< XPropertySet > &_xField)
974 {
975 OUString sName;
976 _xField->getPropertyValue(u"Name"_ustr) >>= sName;
977 Reference< XColumnsSupplier > xColumnsSupplier(_xParser, UNO_QUERY);
978 Reference< css::container::XNameAccess > xCols;
979 if (xColumnsSupplier.is())
980 xCols = xColumnsSupplier->getColumns();
981
982 return isAggregateColumn(xCols, sName);
983 }
984
985 bool isAggregateColumn(const Reference< XNameAccess > &_xColumns, const OUString &_sName)
986 {
987 if ( _xColumns.is() && _xColumns->hasByName(_sName) )
988 {
989 Reference<XPropertySet> xProp(_xColumns->getByName(_sName),UNO_QUERY);
990 assert(xProp.is());
991 return isAggregateColumn( xProp );
992 }
993 return false;
994 }
995
996 bool isAggregateColumn( const Reference< XPropertySet > &_xColumn )
997 {
998 bool bAgg(false);
999
1000 static constexpr OUString sAgg = u"AggregateFunction"_ustr;
1001 if ( _xColumn->getPropertySetInfo()->hasPropertyByName(sAgg) )
1002 _xColumn->getPropertyValue(sAgg) >>= bAgg;
1003
1004 return bAgg;
1005 }
1006
1007
1008 } // namespace dbtools
1009
1010
1011 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE