Branch data Line data Source code
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 : :
21 : : #include "composertools.hxx"
22 : : #include "core_resource.hrc"
23 : : #include "core_resource.hxx"
24 : : #include "dbastrings.hrc"
25 : : #include "HelperCollections.hxx"
26 : : #include "SingleSelectQueryComposer.hxx"
27 : : #include "sdbcoretools.hxx"
28 : :
29 : : #include <com/sun/star/beans/PropertyAttribute.hpp>
30 : : #include <com/sun/star/container/XChild.hpp>
31 : : #include <com/sun/star/i18n/XLocaleData.hpp>
32 : : #include <com/sun/star/lang/DisposedException.hpp>
33 : : #include <com/sun/star/sdb/BooleanComparisonMode.hpp>
34 : : #include <com/sun/star/sdb/SQLFilterOperator.hpp>
35 : : #include <com/sun/star/sdb/XQueriesSupplier.hpp>
36 : : #include <com/sun/star/sdb/CommandType.hpp>
37 : : #include <com/sun/star/sdbc/ColumnSearch.hpp>
38 : : #include <com/sun/star/sdbc/DataType.hpp>
39 : : #include <com/sun/star/sdbc/XResultSetMetaData.hpp>
40 : : #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
41 : : #include <com/sun/star/sdbc/XParameters.hpp>
42 : : #include <com/sun/star/uno/XAggregation.hpp>
43 : : #include <com/sun/star/util/XNumberFormatter.hpp>
44 : :
45 : : #include <comphelper/processfactory.hxx>
46 : : #include <comphelper/sequence.hxx>
47 : : #include <comphelper/types.hxx>
48 : : #include <cppuhelper/typeprovider.hxx>
49 : : #include <connectivity/predicateinput.hxx>
50 : : #include <rtl/logfile.hxx>
51 : : #include <unotools/syslocale.hxx>
52 : : #include <tools/debug.hxx>
53 : : #include <tools/diagnose_ex.h>
54 : : #include <osl/diagnose.h>
55 : : #include <unotools/configmgr.hxx>
56 : : #include <unotools/sharedunocomponent.hxx>
57 : :
58 : : #include <memory>
59 : :
60 : : using namespace ::dbaccess;
61 : : using namespace ::dbtools;
62 : : using namespace ::comphelper;
63 : : using namespace ::connectivity;
64 : : using namespace ::com::sun::star::uno;
65 : : using namespace ::com::sun::star::beans;
66 : : using namespace ::com::sun::star::sdbc;
67 : : using namespace ::com::sun::star::sdb;
68 : : using namespace ::com::sun::star::sdbcx;
69 : : using namespace ::com::sun::star::container;
70 : : using namespace ::com::sun::star::i18n;
71 : : using namespace ::com::sun::star::lang;
72 : : using namespace ::com::sun::star::script;
73 : : using namespace ::com::sun::star::util;
74 : : using namespace ::cppu;
75 : : using namespace ::osl;
76 : : using namespace ::utl;
77 : :
78 : : namespace dbaccess {
79 : : namespace BooleanComparisonMode = ::com::sun::star::sdb::BooleanComparisonMode;
80 : : }
81 : :
82 : : #define STR_SELECT ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SELECT "))
83 : : #define STR_FROM ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" FROM "))
84 : : #define STR_WHERE ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" WHERE "))
85 : : #define STR_GROUP_BY ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" GROUP BY "))
86 : : #define STR_HAVING ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" HAVING "))
87 : : #define STR_ORDER_BY ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" ORDER BY "))
88 : : #define STR_AND ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" AND "))
89 : : #define STR_OR ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" OR "))
90 : : #define STR_LIKE ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" LIKE "))
91 : : #define L_BRACKET ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("("))
92 : : #define R_BRACKET ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")"))
93 : : #define COMMA ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(","))
94 : :
95 : : namespace
96 : : {
97 : : /** parses the given statement, using the given parser, returns a parse node representing
98 : : the statement
99 : :
100 : : If the statement cannot be parsed, an error is thrown.
101 : : */
102 : 278 : const OSQLParseNode* parseStatement_throwError( OSQLParser& _rParser, const ::rtl::OUString& _rStatement, const Reference< XInterface >& _rxContext )
103 : : {
104 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "SingleSelectQueryComposer.cxx::parseStatement_throwError" );
105 : 278 : ::rtl::OUString aErrorMsg;
106 [ + - ]: 278 : const OSQLParseNode* pNewSqlParseNode = _rParser.parseTree( aErrorMsg, _rStatement );
107 [ + + ]: 278 : if ( !pNewSqlParseNode )
108 : : {
109 [ + - ]: 2 : ::rtl::OUString sSQLStateGeneralError( getStandardSQLState( SQL_GENERAL_ERROR ) );
110 [ + - ]: 2 : SQLException aError2( aErrorMsg, _rxContext, sSQLStateGeneralError, 1000, Any() );
111 [ + - ][ + - ]: 2 : SQLException aError1( _rStatement, _rxContext, sSQLStateGeneralError, 1000, makeAny( aError2 ) );
112 [ + - ][ + - ]: 2 : throw SQLException(_rParser.getContext().getErrorMessage(OParseContext::ERROR_GENERAL),_rxContext,sSQLStateGeneralError,1000,makeAny(aError1));
[ + - ]
113 : : }
114 : 278 : return pNewSqlParseNode;
115 : : }
116 : :
117 : : // .....................................................................
118 : : /** checks whether the given parse node describes a valid single select statement, throws
119 : : an error if not
120 : : */
121 : 276 : void checkForSingleSelect_throwError( const OSQLParseNode* pStatementNode, OSQLParseTreeIterator& _rIterator,
122 : : const Reference< XInterface >& _rxContext, const ::rtl::OUString& _rOriginatingCommand )
123 : : {
124 : 276 : const OSQLParseNode* pOldNode = _rIterator.getParseTree();
125 : :
126 : : // determine the statement type
127 : 276 : _rIterator.setParseTree( pStatementNode );
128 : 276 : _rIterator.traverseAll();
129 : 276 : bool bIsSingleSelect = ( _rIterator.getStatementType() == SQL_STATEMENT_SELECT );
130 : :
131 : : // throw the error, if necessary
132 [ + - ][ - + ]: 276 : if ( !bIsSingleSelect || SQL_ISRULE( pStatementNode, union_statement ) ) // #i4229# OJ
[ - + ][ + - ]
133 : : {
134 : : // restore the old node before throwing the exception
135 [ # # ]: 0 : _rIterator.setParseTree( pOldNode );
136 : : // and now really ...
137 [ # # ][ # # ]: 0 : SQLException aError1( _rOriginatingCommand, _rxContext, getStandardSQLState( SQL_GENERAL_ERROR ), 1000, Any() );
138 : : throw SQLException( DBACORE_RESSTRING( RID_STR_ONLY_QUERY ), _rxContext,
139 [ # # ][ # # ]: 0 : getStandardSQLState( SQL_GENERAL_ERROR ), 1000, makeAny( aError1 ) );
[ # # ][ # # ]
140 : : }
141 : :
142 [ + + ]: 276 : delete pOldNode;
143 : 276 : }
144 : :
145 : : // .....................................................................
146 : : /** combines parseStatement_throwError and checkForSingleSelect_throwError
147 : : */
148 : 278 : void parseAndCheck_throwError( OSQLParser& _rParser, const ::rtl::OUString& _rStatement,
149 : : OSQLParseTreeIterator& _rIterator, const Reference< XInterface >& _rxContext )
150 : : {
151 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "SingleSelectQueryComposer.cxx::parseAndCheck_throwError" );
152 : 278 : const OSQLParseNode* pNode = parseStatement_throwError( _rParser, _rStatement, _rxContext );
153 : 276 : checkForSingleSelect_throwError( pNode, _rIterator, _rxContext, _rStatement );
154 : 276 : }
155 : :
156 : : // .....................................................................
157 : : /** transforms a parse node describing a complete statement into a pure select
158 : : statement, without any filter/order/groupby/having clauses
159 : : */
160 : 138 : ::rtl::OUString getPureSelectStatement( const OSQLParseNode* _pRootNode, Reference< XConnection > _rxConnection )
161 : : {
162 : 138 : ::rtl::OUString sSQL = STR_SELECT;
163 [ + - ][ + - ]: 138 : _pRootNode->getChild(1)->parseNodeToStr( sSQL, _rxConnection );
164 [ + - ][ + - ]: 138 : _pRootNode->getChild(2)->parseNodeToStr( sSQL, _rxConnection );
165 [ + - ]: 138 : sSQL += STR_FROM;
166 [ + - ][ + - ]: 138 : _pRootNode->getChild(3)->getChild(0)->getChild(1)->parseNodeToStr( sSQL, _rxConnection );
[ + - ][ + - ]
167 : 138 : return sSQL;
168 : : }
169 : :
170 : : /** resets an SQL iterator, including deletion of the parse tree, and disposal if desired
171 : : */
172 : 152 : void resetIterator( OSQLParseTreeIterator& _rIterator, bool _bDispose )
173 : : {
174 : 152 : const OSQLParseNode* pSqlParseNode = _rIterator.getParseTree();
175 : 152 : _rIterator.setParseTree(NULL);
176 [ + - ]: 152 : delete pSqlParseNode;
177 [ + - ]: 152 : if ( _bDispose )
178 : 152 : _rIterator.dispose();
179 : 152 : }
180 : 78 : void lcl_addFilterCriteria_throw(sal_Int32 i_nFilterOperator,const ::rtl::OUString& i_sValue,::rtl::OUStringBuffer& o_sRet)
181 : : {
182 [ + - - - : 78 : switch( i_nFilterOperator )
- - - - +
- - ]
183 : : {
184 : : case SQLFilterOperator::EQUAL:
185 [ + - ]: 72 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" = ")));
186 : 72 : o_sRet.append(i_sValue);
187 : 72 : break;
188 : : case SQLFilterOperator::NOT_EQUAL:
189 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" <> ")));
190 : 0 : o_sRet.append(i_sValue);
191 : 0 : break;
192 : : case SQLFilterOperator::LESS:
193 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" < ")));
194 : 0 : o_sRet.append(i_sValue);
195 : 0 : break;
196 : : case SQLFilterOperator::GREATER:
197 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" > ")));
198 : 0 : o_sRet.append(i_sValue);
199 : 0 : break;
200 : : case SQLFilterOperator::LESS_EQUAL:
201 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" <= ")));
202 : 0 : o_sRet.append(i_sValue);
203 : 0 : break;
204 : : case SQLFilterOperator::GREATER_EQUAL:
205 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" >= ")));
206 : 0 : o_sRet.append(i_sValue);
207 : 0 : break;
208 : : case SQLFilterOperator::LIKE:
209 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" LIKE ")));
210 : 0 : o_sRet.append(i_sValue);
211 : 0 : break;
212 : : case SQLFilterOperator::NOT_LIKE:
213 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" NOT LIKE ")));
214 : 0 : o_sRet.append(i_sValue);
215 : 0 : break;
216 : : case SQLFilterOperator::SQLNULL:
217 [ + - ]: 6 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" IS NULL")) );
218 : 6 : break;
219 : : case SQLFilterOperator::NOT_SQLNULL:
220 [ # # ]: 0 : o_sRet.append(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" IS NOT NULL")) );
221 : 0 : break;
222 : : default:
223 [ # # ]: 0 : throw SQLException();
224 : : }
225 : 78 : }
226 : :
227 : : }
228 : :
229 : : DBG_NAME(OSingleSelectQueryComposer)
230 : :
231 : 76 : OSingleSelectQueryComposer::OSingleSelectQueryComposer(const Reference< XNameAccess>& _rxTables,
232 : : const Reference< XConnection>& _xConnection,
233 : : const ::comphelper::ComponentContext& _rContext )
234 : : :OSubComponent(m_aMutex,_xConnection)
235 : : ,OPropertyContainer(m_aBHelper)
236 : : ,m_aSqlParser( _rContext.getLegacyServiceFactory() )
237 : : ,m_aSqlIterator( _xConnection, _rxTables, m_aSqlParser, NULL )
238 : : ,m_aAdditiveIterator( _xConnection, _rxTables, m_aSqlParser, NULL )
239 : : ,m_aElementaryParts( (size_t)SQLPartCount )
240 : : ,m_xConnection(_xConnection)
241 [ + - ]: 76 : ,m_xMetaData(_xConnection->getMetaData())
242 : : ,m_xConnectionTables( _rxTables )
243 : : ,m_aContext( _rContext )
244 : : ,m_pTables(NULL)
245 : : ,m_nBoolCompareMode( BooleanComparisonMode::EQUAL_INTEGER )
246 [ + - ][ + - ]: 152 : ,m_nCommandType(CommandType::COMMAND)
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
247 : : {
248 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::OSingleSelectQueryComposer" );
249 : : DBG_CTOR(OSingleSelectQueryComposer,NULL);
250 : :
251 [ + - ][ - + ]: 76 : if ( !m_aContext.is() || !m_xConnection.is() || !m_xConnectionTables.is() )
[ - + ][ + - ]
252 [ # # ]: 0 : throw IllegalArgumentException();
253 : :
254 [ + - ][ + - ]: 76 : registerProperty(PROPERTY_ORIGINAL,PROPERTY_ID_ORIGINAL,PropertyAttribute::BOUND|PropertyAttribute::READONLY,&m_sOrignal,::getCppuType(&m_sOrignal));
[ + - ]
255 : :
256 [ + - ]: 76 : m_aCurrentColumns.resize(4);
257 : :
258 [ + - ][ + - ]: 76 : m_aLocale = SvtSysLocale().GetLocaleData().getLocale();
[ + - ][ + - ]
259 [ + - ][ + - ]: 76 : m_xNumberFormatsSupplier = dbtools::getNumberFormats( m_xConnection, sal_True, m_aContext.getLegacyServiceFactory() );
[ + - ]
260 : 76 : Reference< XLocaleData > xLocaleData;
261 [ + - ]: 76 : m_aContext.createComponent( "com.sun.star.i18n.LocaleData", xLocaleData );
262 [ + - ][ + - ]: 76 : LocaleDataItem aData = xLocaleData->getLocaleItem(m_aLocale);
263 : 76 : m_sDecimalSep = aData.decimalSeparator;
264 : : OSL_ENSURE(m_sDecimalSep.getLength() == 1,"OSingleSelectQueryComposer::OSingleSelectQueryComposer decimal separator is not 1 length");
265 : : try
266 : : {
267 : 76 : Any aValue;
268 [ + - ]: 76 : Reference<XInterface> xDs = dbaccess::getDataSource(_xConnection);
269 [ + - ][ + - ]: 76 : if ( dbtools::getDataSourceSetting(xDs,static_cast <rtl::OUString> (PROPERTY_BOOLEANCOMPARISONMODE),aValue) )
[ + - ]
270 : : {
271 : 76 : OSL_VERIFY( aValue >>= m_nBoolCompareMode );
272 : : }
273 [ + - ]: 76 : Reference< XQueriesSupplier > xQueriesAccess(m_xConnection, UNO_QUERY);
274 [ + - ]: 76 : if (xQueriesAccess.is())
275 [ + - ][ + - ]: 76 : m_xConnectionQueries = xQueriesAccess->getQueries();
[ + - ][ # # ]
276 : : }
277 [ # # ]: 0 : catch(Exception&)
278 : : {
279 : 76 : }
280 : 76 : }
281 : :
282 [ + - ][ + - ]: 76 : OSingleSelectQueryComposer::~OSingleSelectQueryComposer()
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
283 : : {
284 : : DBG_DTOR(OSingleSelectQueryComposer,NULL);
285 : 76 : ::std::vector<OPrivateColumns*>::iterator aColIter = m_aColumnsCollection.begin();
286 : 76 : ::std::vector<OPrivateColumns*>::iterator aEnd = m_aColumnsCollection.end();
287 [ + - ][ + + ]: 226 : for(;aColIter != aEnd;++aColIter)
288 [ + - ][ + - ]: 150 : delete *aColIter;
289 : :
290 : 76 : ::std::vector<OPrivateTables*>::iterator aTabIter = m_aTablesCollection.begin();
291 : 76 : ::std::vector<OPrivateTables*>::iterator aTabEnd = m_aTablesCollection.end();
292 [ + - ][ + + ]: 158 : for(;aTabIter != aTabEnd;++aTabIter)
293 [ + - ][ + - ]: 82 : delete *aTabIter;
294 [ - + ]: 152 : }
295 : :
296 : : // OComponentHelper
297 : 76 : void SAL_CALL OSingleSelectQueryComposer::disposing(void)
298 : : {
299 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::disposing" );
300 [ + - ]: 76 : OSubComponent::disposing();
301 : :
302 [ + - ]: 76 : MutexGuard aGuard(m_aMutex);
303 : :
304 [ + - ]: 76 : resetIterator( m_aSqlIterator, true );
305 [ + - ]: 76 : resetIterator( m_aAdditiveIterator, true );
306 : :
307 [ + - ]: 76 : m_xConnectionTables = NULL;
308 [ + - ]: 76 : m_xConnection = NULL;
309 : :
310 [ + - ][ + - ]: 76 : clearCurrentCollections();
311 : 76 : }
312 [ + + ][ + - ]: 9266 : IMPLEMENT_FORWARD_XINTERFACE3(OSingleSelectQueryComposer,OSubComponent,OSingleSelectQueryComposer_BASE,OPropertyContainer)
[ + + ][ + - ]
313 [ + - ][ + - ]: 6 : IMPLEMENT_SERVICE_INFO1(OSingleSelectQueryComposer,"org.openoffice.comp.dba.OSingleSelectQueryComposer",SERVICE_NAME_SINGLESELECTQUERYCOMPOSER.ascii)
[ + - ][ + - ]
[ + - ]
314 [ # # ][ # # ]: 0 : IMPLEMENT_TYPEPROVIDER3(OSingleSelectQueryComposer,OSubComponent,OSingleSelectQueryComposer_BASE,OPropertyContainer)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
315 [ + - ][ + - ]: 22 : IMPLEMENT_PROPERTYCONTAINER_DEFAULTS(OSingleSelectQueryComposer)
[ + - ][ + - ]
316 : :
317 : : // com::sun::star::lang::XUnoTunnel
318 : 0 : sal_Int64 SAL_CALL OSingleSelectQueryComposer::getSomething( const Sequence< sal_Int8 >& rId ) throw(RuntimeException)
319 : : {
320 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getSomething" );
321 [ # # ][ # # ]: 0 : if (rId.getLength() == 16 && 0 == rtl_compareMemory(getImplementationId().getConstArray(), rId.getConstArray(), 16 ) )
[ # # ][ # # ]
[ # # ]
[ # # # # ]
322 : 0 : return reinterpret_cast<sal_Int64>(this);
323 : :
324 : 0 : return sal_Int64(0);
325 : : }
326 : :
327 : : // XSingleSelectQueryAnalyzer
328 : 146 : ::rtl::OUString SAL_CALL OSingleSelectQueryComposer::getQuery( ) throw(RuntimeException)
329 : : {
330 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getQuery" );
331 [ + - ]: 146 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
332 [ + - ]: 146 : ::osl::MutexGuard aGuard( m_aMutex );
333 : :
334 [ + - ]: 146 : TGetParseNode F_tmp(&OSQLParseTreeIterator::getParseTree);
335 [ + - ][ + - ]: 146 : return getStatementPart(F_tmp,m_aSqlIterator);
336 : : }
337 : :
338 : 10 : void SAL_CALL OSingleSelectQueryComposer::setQuery( const ::rtl::OUString& command ) throw(SQLException, RuntimeException)
339 : : {
340 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "OSingleSelectQueryComposer::setQuery" );
341 [ + - ]: 10 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
342 : :
343 [ + - ]: 10 : ::osl::MutexGuard aGuard( m_aMutex );
344 : 10 : m_nCommandType = CommandType::COMMAND;
345 : : // first clear the tables and columns
346 [ + - ]: 10 : clearCurrentCollections();
347 : : // now set the new one
348 [ + + ]: 10 : setQuery_Impl(command);
349 : 8 : m_sOrignal = command;
350 : :
351 : : // reset the additive iterator to the same statement
352 [ + - ][ + - ]: 8 : parseAndCheck_throwError( m_aSqlParser, m_sOrignal, m_aAdditiveIterator, *this );
353 : :
354 : : // we have no "elementary" parts anymore (means filter/groupby/having/order clauses)
355 [ + + ]: 40 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
356 [ + - ]: 42 : m_aElementaryParts[ eLoopParts ] = ::rtl::OUString();
357 : 8 : }
358 : :
359 : 42 : void SAL_CALL OSingleSelectQueryComposer::setCommand( const ::rtl::OUString& Command,sal_Int32 _nCommandType ) throw(SQLException, RuntimeException)
360 : : {
361 : 42 : ::rtl::OUStringBuffer sSQL;
362 [ + + - - ]: 42 : switch(_nCommandType)
363 : : {
364 : : case CommandType::COMMAND:
365 [ + - ]: 18 : setElementaryQuery(Command);
366 : 42 : return;
367 : : case CommandType::TABLE:
368 [ + - ][ + - ]: 24 : if ( m_xConnectionTables->hasByName(Command) )
[ + - ]
369 : : {
370 [ + - ]: 24 : sSQL.appendAscii("SELECT * FROM ");
371 : 24 : Reference< XPropertySet > xTable;
372 : : try
373 : : {
374 [ + - ][ + - ]: 24 : m_xConnectionTables->getByName( Command ) >>= xTable;
[ + - ]
375 : : }
376 [ # # # # : 0 : catch(const WrappedTargetException& e)
# ]
377 : : {
378 [ # # ]: 0 : SQLException e2;
379 [ # # # # ]: 0 : if ( e.TargetException >>= e2 )
380 [ # # # # ]: 0 : throw e2;
381 : : }
382 [ # # ]: 0 : catch(Exception&)
383 : : {
384 : : DBG_UNHANDLED_EXCEPTION();
385 : : }
386 : :
387 [ + - ][ + - ]: 24 : sSQL.append(dbtools::composeTableNameForSelect(m_xConnection,xTable));
388 : : }
389 : : else
390 : : {
391 [ # # ][ # # ]: 0 : String sMessage( DBACORE_RESSTRING( RID_STR_TABLE_DOES_NOT_EXIST ) );
392 [ # # ][ # # ]: 0 : sMessage.SearchAndReplaceAscii( "$table$", Command );
[ # # ]
393 [ # # ][ # # ]: 0 : throwGenericSQLException(sMessage,*this);
[ # # ][ # # ]
394 : : }
395 : 24 : break;
396 : : case CommandType::QUERY:
397 [ # # ][ # # ]: 0 : if ( m_xConnectionQueries->hasByName(Command) )
[ # # ]
398 : : {
399 : :
400 [ # # ][ # # ]: 0 : Reference<XPropertySet> xQuery(m_xConnectionQueries->getByName(Command),UNO_QUERY);
[ # # ]
401 : 0 : ::rtl::OUString sCommand;
402 [ # # ][ # # ]: 0 : xQuery->getPropertyValue(PROPERTY_COMMAND) >>= sCommand;
[ # # ]
403 [ # # ]: 0 : sSQL.append(sCommand);
404 : : }
405 : : else
406 : : {
407 [ # # ][ # # ]: 0 : String sMessage( DBACORE_RESSTRING( RID_STR_QUERY_DOES_NOT_EXIST ) );
408 [ # # ][ # # ]: 0 : sMessage.SearchAndReplaceAscii( "$table$", Command );
[ # # ]
409 [ # # ][ # # ]: 0 : throwGenericSQLException(sMessage,*this);
[ # # ][ # # ]
410 : : }
411 : :
412 : 0 : break;
413 : : default:
414 : 0 : break;
415 : : }
416 [ + - ]: 24 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
417 : :
418 [ + - ]: 24 : ::osl::MutexGuard aGuard( m_aMutex );
419 : 24 : m_nCommandType = _nCommandType;
420 : 24 : m_sCommand = Command;
421 : : // first clear the tables and columns
422 [ + - ]: 24 : clearCurrentCollections();
423 : : // now set the new one
424 [ + - ]: 24 : ::rtl::OUString sCommand = sSQL.makeStringAndClear();
425 [ + - ]: 24 : setElementaryQuery(sCommand);
426 [ + - ][ + + ]: 42 : m_sOrignal = sCommand;
427 : : }
428 : :
429 : 140 : void OSingleSelectQueryComposer::setQuery_Impl( const ::rtl::OUString& command )
430 : : {
431 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "OSingleSelectQueryComposer::setQuery_Impl" );
432 : : // parse this
433 [ + + ]: 140 : parseAndCheck_throwError( m_aSqlParser, command, m_aSqlIterator, *this );
434 : :
435 : : // strip it from all clauses, to have the pure SELECT statement
436 [ + - ]: 138 : m_aPureSelectSQL = getPureSelectStatement( m_aSqlIterator.getParseTree(), m_xConnection );
437 : :
438 : : // update tables
439 : 138 : getTables();
440 : 138 : }
441 : :
442 : 4 : Sequence< Sequence< PropertyValue > > SAL_CALL OSingleSelectQueryComposer::getStructuredHavingClause( ) throw (RuntimeException)
443 : : {
444 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getStructuredHavingClause" );
445 [ + - ]: 4 : TGetParseNode F_tmp(&OSQLParseTreeIterator::getSimpleHavingTree);
446 [ + - ]: 4 : return getStructuredCondition(F_tmp);
447 : : }
448 : :
449 : 4 : Sequence< Sequence< PropertyValue > > SAL_CALL OSingleSelectQueryComposer::getStructuredFilter( ) throw(RuntimeException)
450 : : {
451 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getStructuredFilter" );
452 [ + - ]: 4 : TGetParseNode F_tmp(&OSQLParseTreeIterator::getSimpleWhereTree);
453 [ + - ]: 4 : return getStructuredCondition(F_tmp);
454 : : }
455 : :
456 : 4 : void SAL_CALL OSingleSelectQueryComposer::appendHavingClauseByColumn( const Reference< XPropertySet >& column, sal_Bool andCriteria,sal_Int32 filterOperator ) throw (SQLException, RuntimeException)
457 : : {
458 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::appendHavingClauseByColumn" );
459 : 4 : ::std::mem_fun1_t<bool,OSingleSelectQueryComposer,::rtl::OUString> F_tmp(&OSingleSelectQueryComposer::implSetHavingClause);
460 [ + + ]: 4 : setConditionByColumn(column,andCriteria,F_tmp,filterOperator);
461 : 4 : }
462 : :
463 : 6 : void SAL_CALL OSingleSelectQueryComposer::appendFilterByColumn( const Reference< XPropertySet >& column, sal_Bool andCriteria,sal_Int32 filterOperator ) throw(SQLException, RuntimeException)
464 : : {
465 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::appendFilterByColumn" );
466 : 6 : ::std::mem_fun1_t<bool,OSingleSelectQueryComposer,::rtl::OUString> F_tmp(&OSingleSelectQueryComposer::implSetFilter);
467 [ + + ]: 6 : setConditionByColumn(column,andCriteria,F_tmp,filterOperator);
468 : 6 : }
469 : :
470 : 8 : ::rtl::OUString OSingleSelectQueryComposer::impl_getColumnName_throw(const Reference< XPropertySet >& column)
471 : : {
472 [ + - ]: 8 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
473 : :
474 [ + - ]: 8 : getColumns();
475 [ - + ][ + + ]: 24 : if ( !column.is()
[ + + + - ]
476 : 4 : || !m_aCurrentColumns[SelectColumns]
477 [ + - ][ + - ]: 12 : || !column->getPropertySetInfo()->hasPropertyByName(PROPERTY_NAME)
[ + - ][ + - ]
[ + - ][ + + ]
[ + + ]
[ # # # # ]
478 : : )
479 : : {
480 [ + - ][ + - ]: 4 : String sError(DBACORE_RESSTRING(RID_STR_COLUMN_UNKNOWN_PROP));
481 [ + - ][ + - ]: 4 : sError.SearchAndReplaceAscii("%value", ::rtl::OUString(PROPERTY_NAME));
[ + - ][ + - ]
482 [ + - ][ + - ]: 4 : SQLException aErr(sError,*this,SQLSTATE_GENERAL,1000,Any() );
[ + - ][ + - ]
483 [ + - ][ + - ]: 4 : throw SQLException(DBACORE_RESSTRING(RID_STR_COLUMN_NOT_VALID),*this,SQLSTATE_GENERAL,1000,makeAny(aErr) );
[ + - ][ + - ]
[ + - ]
484 : : }
485 : :
486 : 4 : ::rtl::OUString aName,aNewName;
487 [ + - ][ + - ]: 4 : column->getPropertyValue(PROPERTY_NAME) >>= aName;
[ + - ]
488 : :
489 [ + - ][ - + ]: 4 : if ( !m_xMetaData->supportsOrderByUnrelated() && m_aCurrentColumns[SelectColumns] && !m_aCurrentColumns[SelectColumns]->hasByName(aName))
[ # # ][ # # ]
[ # # ][ - + ]
[ + - ]
490 : : {
491 [ # # ][ # # ]: 0 : String sError(DBACORE_RESSTRING(RID_STR_COLUMN_MUST_VISIBLE));
492 [ # # ][ # # ]: 0 : sError.SearchAndReplaceAscii("%name", aName);
[ # # ]
493 [ # # ][ # # ]: 0 : throw SQLException(sError,*this,SQLSTATE_GENERAL,1000,Any() );
[ # # ][ # # ]
494 : : }
495 : :
496 : : // Attach filter
497 : : // Construct SELECT without WHERE and ORDER BY
498 [ + - ][ + - ]: 4 : ::rtl::OUString aQuote = m_xMetaData->getIdentifierQuoteString();
499 [ + - ][ + - ]: 4 : if ( m_aCurrentColumns[SelectColumns]->hasByName(aName) )
500 : : {
501 : 4 : Reference<XPropertySet> xColumn;
502 [ + - ][ + - ]: 4 : m_aCurrentColumns[SelectColumns]->getByName(aName) >>= xColumn;
503 : : OSL_ENSURE(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_REALNAME),"Property REALNAME not available!");
504 : : OSL_ENSURE(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_TABLENAME),"Property TABLENAME not available!");
505 : : OSL_ENSURE(xColumn->getPropertySetInfo()->hasPropertyByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Function"))),"Property FUNCTION not available!");
506 : :
507 : 4 : ::rtl::OUString sRealName,sTableName;
508 [ + - ][ + - ]: 4 : xColumn->getPropertyValue(PROPERTY_REALNAME) >>= sRealName;
[ + - ]
509 [ + - ][ + - ]: 4 : xColumn->getPropertyValue(PROPERTY_TABLENAME) >>= sTableName;
[ + - ]
510 : 4 : sal_Bool bFunction = sal_False;
511 [ + - ][ + - ]: 4 : xColumn->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Function"))) >>= bFunction;
[ + - ]
512 [ + - ]: 4 : if ( sRealName == aName )
513 : : {
514 [ - + ]: 4 : if ( bFunction )
515 : 0 : aNewName = aName;
516 : : else
517 : : {
518 [ - + ]: 4 : if(sTableName.indexOf('.',0) != -1)
519 : : {
520 : 0 : ::rtl::OUString aCatlog,aSchema,aTable;
521 [ # # ]: 0 : ::dbtools::qualifiedNameComponents(m_xMetaData,sTableName,aCatlog,aSchema,aTable,::dbtools::eInDataManipulation);
522 [ # # ]: 0 : sTableName = ::dbtools::composeTableName( m_xMetaData, aCatlog, aSchema, aTable, sal_True, ::dbtools::eInDataManipulation );
523 : : }
524 : : else
525 [ + - ]: 4 : sTableName = ::dbtools::quoteName(aQuote,sTableName);
526 : :
527 : 4 : aNewName = sTableName;
528 [ + - ]: 4 : aNewName += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("."));
529 [ + - ]: 4 : aNewName += ::dbtools::quoteName(aQuote,sRealName);
530 : : }
531 : : }
532 : : else
533 [ # # ]: 4 : aNewName = ::dbtools::quoteName(aQuote,aName);
534 : : }
535 : : else
536 [ # # ][ # # ]: 0 : aNewName = getTableAlias(column) + ::dbtools::quoteName(aQuote,aName);
537 : 8 : return aNewName;
538 : : }
539 : :
540 : 4 : void SAL_CALL OSingleSelectQueryComposer::appendOrderByColumn( const Reference< XPropertySet >& column, sal_Bool ascending ) throw(SQLException, RuntimeException)
541 : : {
542 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::appendOrderByColumn" );
543 [ + - ]: 4 : ::osl::MutexGuard aGuard( m_aMutex );
544 [ + + ]: 4 : ::rtl::OUString sColumnName( impl_getColumnName_throw(column) );
545 [ + - ]: 2 : ::rtl::OUString sOrder = getOrder();
546 [ - + ][ # # ]: 2 : if ( !(sOrder.isEmpty() || sColumnName.isEmpty()) )
[ - + ]
547 [ # # ]: 0 : sOrder += COMMA;
548 : 2 : sOrder += sColumnName;
549 [ # # ][ - + ]: 2 : if ( !(ascending || sColumnName.isEmpty()) )
[ - + ]
550 [ # # ]: 0 : sOrder += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" DESC "));
551 : :
552 [ + - ][ + - ]: 4 : setOrder(sOrder);
553 : 2 : }
554 : :
555 : 4 : void SAL_CALL OSingleSelectQueryComposer::appendGroupByColumn( const Reference< XPropertySet >& column) throw(SQLException, RuntimeException)
556 : : {
557 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::appendGroupByColumn" );
558 [ + - ]: 4 : ::osl::MutexGuard aGuard( m_aMutex );
559 [ + + ]: 4 : ::rtl::OUString sColumnName( impl_getColumnName_throw(column) );
560 : 2 : OrderCreator aComposer;
561 [ + - ][ + - ]: 2 : aComposer.append( getGroup() );
562 [ + - ]: 2 : aComposer.append( sColumnName );
563 [ + - ][ + - ]: 4 : setGroup( aComposer.getComposedAndClear() );
[ + - ]
564 : 2 : }
565 : :
566 : 74 : ::rtl::OUString OSingleSelectQueryComposer::composeStatementFromParts( const ::std::vector< ::rtl::OUString >& _rParts )
567 : : {
568 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::composeStatementFromParts" );
569 : : OSL_ENSURE( _rParts.size() == (size_t)SQLPartCount, "OSingleSelectQueryComposer::composeStatementFromParts: invalid parts array!" );
570 : :
571 [ + - ]: 74 : ::rtl::OUStringBuffer aSql( m_aPureSelectSQL );
572 [ + + ]: 370 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
573 [ - + ]: 296 : if ( !_rParts[ eLoopParts ].isEmpty() )
574 : : {
575 [ # # ][ # # ]: 0 : aSql.append( getKeyword( eLoopParts ) );
576 [ # # ]: 0 : aSql.append( _rParts[ eLoopParts ] );
577 : : }
578 : :
579 [ + - ]: 74 : return aSql.makeStringAndClear();
580 : : }
581 : :
582 : 0 : ::rtl::OUString SAL_CALL OSingleSelectQueryComposer::getElementaryQuery() throw (::com::sun::star::uno::RuntimeException)
583 : : {
584 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getElementaryQuery" );
585 : 0 : return composeStatementFromParts( m_aElementaryParts );
586 : : }
587 : :
588 : 74 : void SAL_CALL OSingleSelectQueryComposer::setElementaryQuery( const ::rtl::OUString& _rElementary ) throw (::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
589 : : {
590 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "OSingleSelectQueryComposer::setElementaryQuery" );
591 [ + - ]: 74 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
592 [ + - ]: 74 : ::osl::MutexGuard aGuard( m_aMutex );
593 : :
594 : : // remember the 4 current "additive" clauses
595 [ + - ]: 74 : ::std::vector< ::rtl::OUString > aAdditiveClauses( SQLPartCount );
596 [ + + ]: 370 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
597 [ + - ]: 296 : aAdditiveClauses[ eLoopParts ] = getSQLPart( eLoopParts, m_aAdditiveIterator, sal_False );
598 : :
599 : : // clear the tables and columns
600 [ + - ]: 74 : clearCurrentCollections();
601 : : // set and parse the new query
602 [ + - ]: 74 : setQuery_Impl( _rElementary );
603 : :
604 : : // get the 4 elementary parts of the statement
605 [ + + ]: 370 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
606 [ + - ]: 296 : m_aElementaryParts[ eLoopParts ] = getSQLPart( eLoopParts, m_aSqlIterator, sal_False );
607 : :
608 : : // reset the the AdditiveIterator: m_aPureSelectSQL may have changed
609 : : try
610 : : {
611 [ + - ][ + - ]: 74 : parseAndCheck_throwError( m_aSqlParser, composeStatementFromParts( aAdditiveClauses ), m_aAdditiveIterator, *this );
[ + - ][ # # ]
612 : : }
613 [ # # ]: 0 : catch( const Exception& e )
614 : : {
615 : : (void)e;
616 : : OSL_FAIL( "OSingleSelectQueryComposer::setElementaryQuery: there should be no error anymore for the additive statement!" );
617 : : DBG_UNHANDLED_EXCEPTION();
618 : : // every part of the additive statement should have passed other tests already, and should not
619 : : // be able to cause any errors ... me thinks
620 [ + - ]: 74 : }
621 : 74 : }
622 : :
623 : : namespace
624 : : {
625 : 112 : ::rtl::OUString getComposedClause( const ::rtl::OUString _rElementaryClause, const ::rtl::OUString _rAdditionalClause,
626 : : TokenComposer& _rComposer, const ::rtl::OUString _rKeyword )
627 : : {
628 : 112 : _rComposer.clear();
629 : 112 : _rComposer.append( _rElementaryClause );
630 : 112 : _rComposer.append( _rAdditionalClause );
631 : 112 : ::rtl::OUString sComposed = _rComposer.getComposedAndClear();
632 [ + + ]: 112 : if ( !sComposed.isEmpty() )
633 : 96 : sComposed = _rKeyword + sComposed;
634 : 112 : return sComposed;
635 : : }
636 : : }
637 : :
638 : 280 : void OSingleSelectQueryComposer::setSingleAdditiveClause( SQLPart _ePart, const ::rtl::OUString& _rClause )
639 : : {
640 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setSingleAdditiveClause" );
641 [ + - ]: 280 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
642 [ + - ]: 280 : ::osl::MutexGuard aGuard( m_aMutex );
643 : :
644 : : // if nothing is changed, do nothing
645 [ + - ][ + + ]: 280 : if ( getSQLPart( _ePart, m_aAdditiveIterator, sal_False ) == _rClause )
646 : 280 : return;
647 : :
648 : : // collect the 4 single parts as they're currently set
649 [ + - ]: 56 : ::std::vector< ::rtl::OUString > aClauses;
650 [ + - ]: 56 : aClauses.reserve( (size_t)SQLPartCount );
651 [ + + ]: 280 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
652 [ + - ][ + - ]: 224 : aClauses.push_back( getSQLPart( eLoopParts, m_aSqlIterator, sal_True ) );
653 : :
654 : : // overwrite the one part in question here
655 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
656 : 56 : ::std::auto_ptr< TokenComposer > pComposer;
657 : : SAL_WNODEPRECATED_DECLARATIONS_POP
658 [ + + ][ + + ]: 56 : if ( ( _ePart == Where ) || ( _ePart == Having ) )
659 [ + - ]: 38 : pComposer.reset( new FilterCreator );
660 : : else
661 [ + - ]: 18 : pComposer.reset( new OrderCreator );
662 : 112 : aClauses[ _ePart ] = getComposedClause( m_aElementaryParts[ _ePart ], _rClause,
663 [ + - ][ + - ]: 168 : *pComposer, getKeyword( _ePart ) );
664 : :
665 : : // construct the complete statement
666 [ + - ]: 56 : ::rtl::OUStringBuffer aSql(m_aPureSelectSQL);
667 [ + + ]: 280 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
668 [ + - ]: 224 : aSql.append(aClauses[ eLoopParts ]);
669 : :
670 : : // set the query
671 [ + - ][ + - ]: 56 : setQuery_Impl(aSql.makeStringAndClear());
672 : :
673 : : // clear column collections which (might) have changed
674 [ + - ]: 56 : clearColumns( ParameterColumns );
675 [ + + ]: 56 : if ( _ePart == Order )
676 [ + - ]: 12 : clearColumns( OrderColumns );
677 [ + + ]: 56 : if ( _ePart == Group )
678 [ + - ]: 6 : clearColumns( GroupByColumns );
679 : :
680 : : // also, since the "additive filter" change, we need to rebuild our "additive" statement
681 [ + - ][ + - ]: 56 : aSql = m_aPureSelectSQL;
682 : : // again, first get all the old additive parts
683 [ + + ]: 280 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
684 [ + - ]: 224 : aClauses[ eLoopParts ] = getSQLPart( eLoopParts, m_aAdditiveIterator, sal_True );
685 : : // then overwrite the one in question
686 [ + - ][ + - ]: 56 : aClauses[ _ePart ] = getComposedClause( ::rtl::OUString(), _rClause, *pComposer, getKeyword( _ePart ) );
687 : : // and parse it, so that m_aAdditiveIterator is up to date
688 [ + + ]: 280 : for ( SQLPart eLoopParts = Where; eLoopParts != SQLPartCount; incSQLPart( eLoopParts ) )
689 [ + - ]: 224 : aSql.append(aClauses[ eLoopParts ]);
690 : : try
691 : : {
692 [ + - ][ + - ]: 56 : parseAndCheck_throwError( m_aSqlParser, aSql.makeStringAndClear(), m_aAdditiveIterator, *this );
[ + - ][ # # ]
693 : : }
694 [ # # ]: 0 : catch( const Exception& e )
695 : : {
696 : : (void)e;
697 : : OSL_FAIL( "OSingleSelectQueryComposer::setSingleAdditiveClause: there should be no error anymore for the additive statement!" );
698 : : // every part of the additive statement should have passed other tests already, and should not
699 : : // be able to cause any errors ... me thinks
700 [ + - ][ + - ]: 280 : }
[ + + ]
701 : : }
702 : :
703 : 94 : void SAL_CALL OSingleSelectQueryComposer::setFilter( const ::rtl::OUString& filter ) throw(SQLException, RuntimeException)
704 : : {
705 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setFilter" );
706 : 94 : setSingleAdditiveClause( Where, filter );
707 : 94 : }
708 : :
709 : 80 : void SAL_CALL OSingleSelectQueryComposer::setOrder( const ::rtl::OUString& order ) throw(SQLException, RuntimeException)
710 : : {
711 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setOrder" );
712 : 80 : setSingleAdditiveClause( Order, order );
713 : 80 : }
714 : :
715 : 46 : void SAL_CALL OSingleSelectQueryComposer::setGroup( const ::rtl::OUString& group ) throw (SQLException, RuntimeException)
716 : : {
717 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setGroup" );
718 : 46 : setSingleAdditiveClause( Group, group );
719 : 46 : }
720 : :
721 : 60 : void SAL_CALL OSingleSelectQueryComposer::setHavingClause( const ::rtl::OUString& filter ) throw(SQLException, RuntimeException)
722 : : {
723 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setHavingClause" );
724 : 60 : setSingleAdditiveClause( Having, filter );
725 : 60 : }
726 : :
727 : : // XTablesSupplier
728 : 142 : Reference< XNameAccess > SAL_CALL OSingleSelectQueryComposer::getTables( ) throw(RuntimeException)
729 : : {
730 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getTables" );
731 [ + - ]: 142 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
732 : :
733 [ + - ]: 142 : ::osl::MutexGuard aGuard( m_aMutex );
734 [ + + ]: 142 : if ( !m_pTables )
735 : : {
736 [ + - ]: 82 : const OSQLTables& aTables = m_aSqlIterator.getTables();
737 [ + - ]: 82 : ::std::vector< ::rtl::OUString> aNames;
738 : 82 : OSQLTables::const_iterator aEnd = aTables.end();
739 [ + + ]: 142 : for(OSQLTables::const_iterator aIter = aTables.begin(); aIter != aEnd;++aIter)
740 [ + - ]: 60 : aNames.push_back(aIter->first);
741 : :
742 [ + - ][ + - ]: 82 : m_pTables = new OPrivateTables(aTables,m_xMetaData->supportsMixedCaseQuotedIdentifiers(),*this,m_aMutex,aNames);
[ + - ][ + - ]
743 : : }
744 : :
745 [ + - ][ + - ]: 142 : return m_pTables;
[ + - ]
746 : : }
747 : :
748 : : // XColumnsSupplier
749 : 90 : Reference< XNameAccess > SAL_CALL OSingleSelectQueryComposer::getColumns( ) throw(RuntimeException)
750 : : {
751 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getColumns" );
752 [ + - ]: 90 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
753 [ + - ]: 90 : ::osl::MutexGuard aGuard( m_aMutex );
754 [ + + ]: 90 : if ( !!m_aCurrentColumns[SelectColumns] )
755 [ + - ][ + - ]: 20 : return m_aCurrentColumns[SelectColumns];
756 : :
757 [ + - ]: 70 : ::std::vector< ::rtl::OUString> aNames;
758 : 70 : ::rtl::Reference< OSQLColumns> aSelectColumns;
759 : 70 : sal_Bool bCase = sal_True;
760 : 70 : Reference< XNameAccess> xQueryColumns;
761 [ - + ]: 70 : if ( m_nCommandType == CommandType::QUERY )
762 : : {
763 [ # # ][ # # ]: 0 : Reference<XColumnsSupplier> xSup(m_xConnectionQueries->getByName(m_sCommand),UNO_QUERY);
[ # # ]
764 [ # # ]: 0 : if(xSup.is())
765 [ # # ][ # # ]: 0 : xQueryColumns = xSup->getColumns();
[ # # ]
766 : : }
767 : :
768 : : do {
769 : :
770 : : try
771 : : {
772 [ + - ]: 70 : SharedUNOComponent< XStatement, DisposableComponent > xStatement;
773 [ + - ]: 70 : SharedUNOComponent< XPreparedStatement, DisposableComponent > xPreparedStatement;
774 : :
775 [ + - ][ + - ]: 70 : bCase = m_xMetaData->supportsMixedCaseQuotedIdentifiers();
776 [ + - ][ + - ]: 70 : aSelectColumns = m_aSqlIterator.getSelectColumns();
[ + - ]
777 : :
778 : 70 : ::rtl::OUStringBuffer aSQL;
779 [ + - ]: 70 : aSQL.append( m_aPureSelectSQL );
780 [ + - ][ + - ]: 70 : aSQL.append( STR_WHERE );
781 : :
782 : : // preserve the original WHERE clause
783 : : // #i102234#
784 [ + - ]: 70 : ::rtl::OUString sOriginalWhereClause = getSQLPart( Where, m_aSqlIterator, sal_False );
785 [ + + ]: 70 : if ( !sOriginalWhereClause.isEmpty() )
786 : : {
787 [ + - ]: 12 : aSQL.appendAscii( " ( 0 = 1 ) AND ( " );
788 [ + - ]: 12 : aSQL.append( sOriginalWhereClause );
789 [ + - ]: 12 : aSQL.appendAscii( " ) " );
790 : : }
791 : : else
792 : : {
793 [ + - ]: 58 : aSQL.appendAscii( " ( 0 = 1 ) " );
794 : : }
795 : :
796 [ + - ]: 70 : ::rtl::OUString sGroupBy = getSQLPart( Group, m_aSqlIterator, sal_True );
797 [ - + ]: 70 : if ( !sGroupBy.isEmpty() )
798 [ # # ]: 0 : aSQL.append( sGroupBy );
799 : :
800 [ + - ]: 70 : ::rtl::OUString sSQL( aSQL.makeStringAndClear() );
801 : : // normalize the statement so that it doesn't contain any application-level features anymore
802 : 70 : ::rtl::OUString sError;
803 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
804 [ + - ]: 70 : const ::std::auto_ptr< OSQLParseNode > pStatementTree( m_aSqlParser.parseTree( sError, sSQL, false ) );
805 : : SAL_WNODEPRECATED_DECLARATIONS_POP
806 : : OSL_ENSURE( pStatementTree.get(), "OSingleSelectQueryComposer::getColumns: could not parse the column retrieval statement!" );
807 [ + - ]: 70 : if ( pStatementTree.get() )
808 [ + - ][ - + ]: 70 : if ( !pStatementTree->parseNodeToExecutableStatement( sSQL, m_xConnection, m_aSqlParser, NULL ) )
809 : : break;
810 : :
811 : 70 : Reference< XResultSetMetaData > xResultSetMeta;
812 : 70 : Reference< XResultSetMetaDataSupplier > xResMetaDataSup;
813 : : try
814 : : {
815 [ + + ][ + - ]: 70 : xPreparedStatement.set( m_xConnection->prepareStatement( sSQL ), UNO_QUERY_THROW );
[ + - ]
816 [ + - ]: 48 : xResMetaDataSup.set( xPreparedStatement, UNO_QUERY_THROW );
817 [ + - ][ + - ]: 70 : xResultSetMeta.set( xResMetaDataSup->getMetaData(), UNO_QUERY_THROW );
[ + - ][ - + ]
818 : : }
819 [ + - ]: 22 : catch( const Exception& ) { }
820 : :
821 : : try
822 : : {
823 [ + + ]: 70 : if ( !xResultSetMeta.is() )
824 : : {
825 [ + - ][ + - ]: 22 : xStatement.reset( Reference< XStatement >( m_xConnection->createStatement(), UNO_QUERY_THROW ) );
[ + - ][ + - ]
826 [ + - ]: 22 : Reference< XPropertySet > xStatementProps( xStatement, UNO_QUERY_THROW );
827 [ + - ][ + - ]: 22 : try { xStatementProps->setPropertyValue( PROPERTY_ESCAPE_PROCESSING, makeAny( sal_False ) ); }
[ + - ][ + - ]
[ # # ]
828 [ # # ]: 0 : catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); }
829 [ + - ][ - + ]: 22 : xResMetaDataSup.set( xStatement->executeQuery( sSQL ), UNO_QUERY_THROW );
[ # # ]
830 [ # # ][ # # ]: 22 : xResultSetMeta.set( xResMetaDataSup->getMetaData(), UNO_QUERY_THROW );
[ # # ]
831 : : }
832 : : }
833 [ - + ][ # # ]: 44 : catch( const Exception& )
834 : : {
835 : : //@see issue http://qa.openoffice.org/issues/show_bug.cgi?id=110111
836 : : // access returns a different order of column names when executing select * from
837 : : // and asking the columns from the metadata.
838 [ + - ]: 22 : Reference< XParameters > xParameters( xPreparedStatement, UNO_QUERY_THROW );
839 [ # # ]: 0 : Reference< XIndexAccess > xPara = getParameters();
840 [ # # # # : 0 : for(sal_Int32 i = 1;i <= xPara->getCount();++i)
# # ]
841 [ # # # # ]: 0 : xParameters->setNull(i,DataType::VARCHAR);
842 [ # # # # : 0 : xResMetaDataSup.set(xPreparedStatement->executeQuery(), UNO_QUERY_THROW );
# # ]
843 [ # # # # : 22 : xResultSetMeta.set( xResMetaDataSup->getMetaData(), UNO_QUERY_THROW );
# # ]
844 : : }
845 : :
846 [ - + ]: 48 : if ( aSelectColumns->get().empty() )
847 : : {
848 : : // This is a valid case. If we can syntactically parse the query, but not semantically
849 : : // (e.g. because it is based on a table we do not know), then there will be no SelectColumns
850 [ # # ][ # # ]: 0 : aSelectColumns = ::connectivity::parse::OParseColumn::createColumnsForResultSet( xResultSetMeta, m_xMetaData ,xQueryColumns);
[ # # ]
851 : : break;
852 : : }
853 : :
854 : 48 : const ::comphelper::UStringMixEqual aCaseCompare( bCase );
855 : 48 : const ::comphelper::TStringMixEqualFunctor aCaseCompareFunctor( bCase );
856 : : typedef ::std::set< size_t > SizeTSet;
857 [ + - ]: 48 : SizeTSet aUsedSelectColumns;
858 [ + - ]: 48 : ::connectivity::parse::OParseColumn::StringMap aColumnNames;
859 : :
860 [ + - ][ + - ]: 48 : sal_Int32 nCount = xResultSetMeta->getColumnCount();
861 : : OSL_ENSURE( (size_t) nCount == aSelectColumns->get().size(), "OSingleSelectQueryComposer::getColumns: inconsistent column counts, this might result in wrong columns!" );
862 [ + + ]: 624 : for(sal_Int32 i=1;i<=nCount;++i)
863 : : {
864 [ + - ][ + - ]: 576 : ::rtl::OUString sColumnName = xResultSetMeta->getColumnName(i);
865 : 576 : ::rtl::OUString sColumnLabel;
866 [ # # ][ # # ]: 576 : if ( xQueryColumns.is() && xQueryColumns->hasByName(sColumnName) )
[ # # ][ - + ]
[ - + ]
867 : : {
868 [ # # ][ # # ]: 0 : Reference<XPropertySet> xQueryColumn(xQueryColumns->getByName(sColumnName),UNO_QUERY_THROW);
[ # # ]
869 [ # # ][ # # ]: 0 : xQueryColumn->getPropertyValue(PROPERTY_LABEL) >>= sColumnLabel;
[ # # ]
870 : : }
871 : : else
872 [ + - ][ + - ]: 576 : sColumnLabel = xResultSetMeta->getColumnLabel(i);
873 : 576 : sal_Bool bFound = sal_False;
874 [ + - ][ + - ]: 576 : OSQLColumns::Vector::const_iterator aFind = ::connectivity::find(aSelectColumns->get().begin(),aSelectColumns->get().end(),sColumnLabel,aCaseCompare);
[ + - ]
875 [ + - ]: 576 : size_t nFoundSelectColumnPos = aFind - aSelectColumns->get().begin();
876 [ + - ][ + - ]: 576 : if ( aFind != aSelectColumns->get().end() )
877 : : {
878 [ + - ][ + - ]: 576 : if ( aUsedSelectColumns.find( nFoundSelectColumnPos ) != aUsedSelectColumns.end() )
[ - + ]
879 : : { // we found a column name which exists twice
880 : : // so we start after the first found
881 [ # # ][ # # ]: 0 : do
[ # # ]
882 : : {
883 [ # # ][ # # ]: 0 : aFind = ::connectivity::findRealName(++aFind,aSelectColumns->get().end(),sColumnName,aCaseCompare);
884 [ # # ]: 0 : nFoundSelectColumnPos = aFind - aSelectColumns->get().begin();
885 : : }
886 [ # # ][ # # ]: 0 : while ( ( aUsedSelectColumns.find( nFoundSelectColumnPos ) != aUsedSelectColumns.end() )
[ # # ][ # # ]
[ # # # # ]
887 [ # # ][ # # ]: 0 : && ( aFind != aSelectColumns->get().end() )
[ # # ]
888 : : );
889 : : }
890 [ + - ][ + - ]: 576 : if ( aFind != aSelectColumns->get().end() )
891 : : {
892 [ + - ][ + - ]: 576 : (*aFind)->getPropertyValue(PROPERTY_NAME) >>= sColumnName;
[ + - ]
893 [ + - ]: 576 : aUsedSelectColumns.insert( nFoundSelectColumnPos );
894 [ + - ]: 576 : aNames.push_back(sColumnName);
895 : 576 : bFound = sal_True;
896 : : }
897 : : }
898 : :
899 [ + - ]: 576 : if ( bFound )
900 : 576 : continue;
901 : :
902 : : OSQLColumns::Vector::const_iterator aRealFind = ::connectivity::findRealName(
903 [ # # ][ # # ]: 0 : aSelectColumns->get().begin(), aSelectColumns->get().end(), sColumnName, aCaseCompare );
[ # # ]
904 : :
905 [ # # ]: 0 : if ( i > static_cast< sal_Int32>( aSelectColumns->get().size() ) )
906 : : {
907 : 0 : aSelectColumns->get().push_back(
908 [ # # ]: 0 : ::connectivity::parse::OParseColumn::createColumnForResultSet( xResultSetMeta, m_xMetaData, i ,aColumnNames)
909 [ # # ]: 0 : );
[ # # # # ]
910 : : OSL_ENSURE( aSelectColumns->get().size() == (size_t)i, "OSingleSelectQueryComposer::getColumns: inconsistency!" );
911 : : }
912 [ # # ][ # # ]: 0 : else if ( aRealFind == aSelectColumns->get().end() )
913 : : {
914 : : // we can now only look if we found it under the realname propertery
915 : : // here we have to make the assumption that the position is correct
916 [ # # ][ # # ]: 0 : OSQLColumns::Vector::iterator aFind2 = aSelectColumns->get().begin() + i-1;
917 [ # # ]: 0 : Reference<XPropertySet> xProp(*aFind2,UNO_QUERY);
918 [ # # ][ # # ]: 0 : if ( !xProp.is() || !xProp->getPropertySetInfo()->hasPropertyByName( PROPERTY_REALNAME ) )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # #
# # # # ]
919 : 0 : continue;
920 : :
921 [ # # ]: 0 : ::connectivity::parse::OParseColumn* pColumn = new ::connectivity::parse::OParseColumn(xProp,bCase);
922 [ # # ][ # # ]: 0 : pColumn->setFunction(::comphelper::getBOOL(xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Function")))));
[ # # ][ # # ]
923 [ # # ][ # # ]: 0 : pColumn->setAggregateFunction(::comphelper::getBOOL(xProp->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AggregateFunction")))));
[ # # ][ # # ]
924 : :
925 : 0 : ::rtl::OUString sRealName;
926 [ # # ][ # # ]: 0 : xProp->getPropertyValue(PROPERTY_REALNAME) >>= sRealName;
[ # # ]
927 : 0 : ::std::vector< ::rtl::OUString>::iterator aFindName;
928 [ # # ]: 0 : if ( sColumnName.isEmpty() )
929 [ # # ][ # # ]: 0 : xProp->getPropertyValue(PROPERTY_NAME) >>= sColumnName;
[ # # ]
930 : :
931 [ # # ][ # # ]: 0 : aFindName = ::std::find_if(aNames.begin(),aNames.end(),::std::bind2nd(aCaseCompareFunctor,sColumnName));
932 : 0 : sal_Int32 j = 0;
933 [ # # ][ # # ]: 0 : while ( aFindName != aNames.end() )
934 : : {
935 : 0 : sColumnName += ::rtl::OUString::valueOf(++j);
936 [ # # ][ # # ]: 0 : aFindName = ::std::find_if(aNames.begin(),aNames.end(),::std::bind2nd(aCaseCompareFunctor,sColumnName));
937 : : }
938 : :
939 [ # # ]: 0 : pColumn->setName(sColumnName);
940 : 0 : pColumn->setRealName(sRealName);
941 [ # # ][ # # ]: 0 : pColumn->setTableName(::comphelper::getString(xProp->getPropertyValue(PROPERTY_TABLENAME)));
[ # # ][ # # ]
942 : :
943 [ # # ][ # # ]: 0 : (aSelectColumns->get())[i-1] = pColumn;
[ # # ]
944 : : }
945 : : else
946 : 0 : continue;
947 : :
948 [ # # ]: 0 : aUsedSelectColumns.insert( (size_t)(i - 1) );
949 [ # # ][ + - ]: 576 : aNames.push_back( sColumnName );
950 [ - + ][ - + ]: 1222 : }
[ - + ][ + - ]
[ - + ][ - + ]
[ - + ][ - + ]
[ - + ][ - + ]
[ + - ][ - + ]
[ + - ][ + - ]
[ - + ]
951 : : }
952 [ + - ]: 22 : catch(const Exception&)
953 : : {
954 : : }
955 : :
956 : : } while ( false );
957 : :
958 [ + + ]: 70 : if ( aNames.empty() )
959 [ + - ]: 22 : m_aCurrentColumns[ SelectColumns ] = OPrivateColumns::createWithIntrinsicNames( aSelectColumns, bCase, *this, m_aMutex );
960 : : else
961 [ + - ][ + - ]: 48 : m_aCurrentColumns[ SelectColumns ] = new OPrivateColumns( aSelectColumns, bCase, *this, m_aMutex, aNames );
962 : :
963 [ + - ][ + - ]: 90 : return m_aCurrentColumns[SelectColumns];
[ + - ][ + - ]
964 : : }
965 : :
966 : 32 : sal_Bool OSingleSelectQueryComposer::setORCriteria(OSQLParseNode* pCondition, OSQLParseTreeIterator& _rIterator,
967 : : ::std::vector< ::std::vector < PropertyValue > >& rFilters, const Reference< ::com::sun::star::util::XNumberFormatter > & xFormatter) const
968 : : {
969 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setORCriteria" );
970 : : // Round brackets around the expression
971 [ + - - + : 64 : if (pCondition->count() == 3 &&
# # # # #
# ][ - + ]
972 : 32 : SQL_ISPUNCTUATION(pCondition->getChild(0),"(") &&
973 : 0 : SQL_ISPUNCTUATION(pCondition->getChild(2),")"))
974 : : {
975 : 0 : return setORCriteria(pCondition->getChild(1), _rIterator, rFilters, xFormatter);
976 : : }
977 : : // OR logic expression
978 : : // a searchcondition can only look like this: search_condition SQL_TOKEN_OR boolean_term
979 [ + - ][ + - ]: 32 : else if (SQL_ISRULE(pCondition,search_condition))
[ + - ]
980 : : {
981 : 32 : sal_Bool bResult = sal_True;
982 [ + - ][ + + ]: 96 : for (int i = 0; bResult && i < 3; i+=2)
[ + + ]
983 : : {
984 : : // Is the first element a OR logic expression again?
985 : : // Then descend recursively ...
986 [ + - ][ + + ]: 64 : if (SQL_ISRULE(pCondition->getChild(i),search_condition))
[ + + ]
987 : 24 : bResult = setORCriteria(pCondition->getChild(i), _rIterator, rFilters, xFormatter);
988 : : else
989 : : {
990 [ + - ]: 40 : rFilters.push_back( ::std::vector < PropertyValue >());
991 : 40 : bResult = setANDCriteria(pCondition->getChild(i), _rIterator, rFilters[rFilters.size() - 1], xFormatter);
992 : : }
993 : : }
994 : 32 : return bResult;
995 : : }
996 : : else
997 : : {
998 [ # # ]: 0 : rFilters.push_back(::std::vector < PropertyValue >());
999 : 32 : return setANDCriteria(pCondition, _rIterator, rFilters[rFilters.size() - 1], xFormatter);
1000 : : }
1001 : : }
1002 : :
1003 : 104 : sal_Bool OSingleSelectQueryComposer::setANDCriteria( OSQLParseNode * pCondition,
1004 : : OSQLParseTreeIterator& _rIterator, ::std::vector < PropertyValue >& rFilter, const Reference< XNumberFormatter > & xFormatter) const
1005 : : {
1006 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setANDCriteria" );
1007 : : // Round brackets
1008 [ + - ][ - + ]: 104 : if (SQL_ISRULE(pCondition,boolean_primary))
[ - + ]
1009 : : {
1010 : : // this should not occur
1011 : : OSL_FAIL("boolean_primary in And-Criteria");
1012 : 0 : return sal_False;
1013 : : }
1014 : : // The first element is an AND logical expression again
1015 [ + - ][ + + ]: 104 : else if ( SQL_ISRULE(pCondition,boolean_term) && pCondition->count() == 3 )
[ + - ][ + + ]
1016 : : {
1017 : 32 : return setANDCriteria(pCondition->getChild(0), _rIterator, rFilter, xFormatter) &&
1018 [ + - ][ + - ]: 32 : setANDCriteria(pCondition->getChild(2), _rIterator, rFilter, xFormatter);
1019 : : }
1020 [ + - ][ + - ]: 72 : else if (SQL_ISRULE(pCondition, comparison_predicate))
[ + - ]
1021 : : {
1022 : 72 : return setComparsionPredicate(pCondition,_rIterator,rFilter,xFormatter);
1023 : : }
1024 [ # # ][ # # : 0 : else if (SQL_ISRULE(pCondition,like_predicate) ||
# # # # #
# # # # #
# # # # #
# ][ # # ]
1025 : 0 : SQL_ISRULE(pCondition,test_for_null) ||
1026 : 0 : SQL_ISRULE(pCondition,in_predicate) ||
1027 : 0 : SQL_ISRULE(pCondition,all_or_any_predicate) ||
1028 : 0 : SQL_ISRULE(pCondition,between_predicate))
1029 : : {
1030 [ # # ][ # # ]: 0 : if (SQL_ISRULE(pCondition->getChild(0), column_ref))
[ # # ]
1031 : : {
1032 : 0 : PropertyValue aItem;
1033 : 0 : ::rtl::OUString aValue;
1034 : 0 : ::rtl::OUString aColumnName;
1035 : :
1036 : :
1037 [ # # ]: 0 : pCondition->parseNodeToStr( aValue, m_xConnection, NULL );
1038 [ # # ][ # # ]: 0 : pCondition->getChild(0)->parseNodeToStr( aColumnName, m_xConnection, NULL );
1039 : :
1040 : : // don't display the column name
1041 : 0 : aValue = aValue.copy(aColumnName.getLength());
1042 : 0 : aValue = aValue.trim();
1043 : :
1044 [ # # ][ # # ]: 0 : aItem.Name = getColumnName(pCondition->getChild(0),_rIterator);
1045 [ # # ]: 0 : aItem.Value <<= aValue;
1046 : 0 : aItem.Handle = 0; // just to know that this is not one the known ones
1047 [ # # ][ # # ]: 0 : if ( SQL_ISRULE(pCondition,like_predicate) )
[ # # ][ # # ]
1048 : : {
1049 [ # # ][ # # ]: 0 : if ( SQL_ISTOKEN(pCondition->getChild(1)->getChild(0),NOT) )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1050 : 0 : aItem.Handle = SQLFilterOperator::NOT_LIKE;
1051 : : else
1052 : 0 : aItem.Handle = SQLFilterOperator::LIKE;
1053 : : }
1054 [ # # ][ # # ]: 0 : else if (SQL_ISRULE(pCondition,test_for_null))
[ # # ][ # # ]
1055 : : {
1056 [ # # ][ # # ]: 0 : if (SQL_ISTOKEN(pCondition->getChild(1)->getChild(1),NOT) )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1057 : 0 : aItem.Handle = SQLFilterOperator::NOT_SQLNULL;
1058 : : else
1059 : 0 : aItem.Handle = SQLFilterOperator::SQLNULL;
1060 : : }
1061 [ # # ][ # # ]: 0 : else if (SQL_ISRULE(pCondition,in_predicate))
[ # # ][ # # ]
1062 : : {
1063 : : OSL_FAIL( "OSingleSelectQueryComposer::setANDCriteria: in_predicate not implemented!" );
1064 : : }
1065 [ # # ][ # # ]: 0 : else if (SQL_ISRULE(pCondition,all_or_any_predicate))
[ # # ][ # # ]
1066 : : {
1067 : : OSL_FAIL( "OSingleSelectQueryComposer::setANDCriteria: all_or_any_predicate not implemented!" );
1068 : : }
1069 [ # # ][ # # ]: 0 : else if (SQL_ISRULE(pCondition,between_predicate))
[ # # ]
1070 : : {
1071 : : OSL_FAIL( "OSingleSelectQueryComposer::setANDCriteria: between_predicate not implemented!" );
1072 : : }
1073 : :
1074 [ # # ]: 0 : rFilter.push_back(aItem);
1075 : : }
1076 : : else
1077 : 0 : return sal_False;
1078 : : }
1079 [ # # ][ # # : 0 : else if (SQL_ISRULE(pCondition,existence_test) ||
# # # # ]
[ # # ]
1080 : 0 : SQL_ISRULE(pCondition,unique_test))
1081 : : {
1082 : : // this couldn't be handled here, too complex
1083 : : // as we need a field name
1084 : 0 : return sal_False;
1085 : : }
1086 : : else
1087 : 104 : return sal_False;
1088 : :
1089 : 0 : return sal_True;
1090 : : }
1091 : :
1092 : 72 : sal_Int32 OSingleSelectQueryComposer::getPredicateType(OSQLParseNode * _pPredicate) const
1093 : : {
1094 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getPredicateType" );
1095 : 72 : sal_Int32 nPredicate = SQLFilterOperator::EQUAL;
1096 [ + - - - : 72 : switch (_pPredicate->getNodeType())
- - - ]
1097 : : {
1098 : : case SQL_NODE_EQUAL:
1099 : 72 : nPredicate = SQLFilterOperator::EQUAL;
1100 : 72 : break;
1101 : : case SQL_NODE_NOTEQUAL:
1102 : 0 : nPredicate = SQLFilterOperator::NOT_EQUAL;
1103 : 0 : break;
1104 : : case SQL_NODE_LESS:
1105 : 0 : nPredicate = SQLFilterOperator::LESS;
1106 : 0 : break;
1107 : : case SQL_NODE_LESSEQ:
1108 : 0 : nPredicate = SQLFilterOperator::LESS_EQUAL;
1109 : 0 : break;
1110 : : case SQL_NODE_GREAT:
1111 : 0 : nPredicate = SQLFilterOperator::GREATER;
1112 : 0 : break;
1113 : : case SQL_NODE_GREATEQ:
1114 : 0 : nPredicate = SQLFilterOperator::GREATER_EQUAL;
1115 : 0 : break;
1116 : : default:
1117 : : OSL_FAIL("Wrong NodeType!");
1118 : : }
1119 : 72 : return nPredicate;
1120 : : }
1121 : :
1122 : 72 : sal_Bool OSingleSelectQueryComposer::setComparsionPredicate(OSQLParseNode * pCondition, OSQLParseTreeIterator& _rIterator,
1123 : : ::std::vector < PropertyValue >& rFilter, const Reference< ::com::sun::star::util::XNumberFormatter > & xFormatter) const
1124 : : {
1125 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setComparsionPredicate" );
1126 : : OSL_ENSURE(SQL_ISRULE(pCondition, comparison_predicate),"setComparsionPredicate: pCondition ist kein ComparsionPredicate");
1127 [ + - ][ - + : 72 : if (SQL_ISRULE(pCondition->getChild(0), column_ref) ||
# # # # ]
[ + - ]
1128 : 0 : SQL_ISRULE(pCondition->getChild(pCondition->count()-1), column_ref))
1129 : : {
1130 : 72 : PropertyValue aItem;
1131 : 72 : ::rtl::OUString aValue;
1132 : : sal_uInt32 nPos;
1133 [ + - ][ + - ]: 72 : if (SQL_ISRULE(pCondition->getChild(0), column_ref))
[ + - ][ + - ]
[ + - ][ + - ]
1134 : : {
1135 : 72 : nPos = 0;
1136 : 72 : sal_uInt32 i=1;
1137 : :
1138 [ + - ]: 72 : aItem.Handle = getPredicateType(pCondition->getChild(i));
1139 : : // don't display the equal
1140 [ + - ][ + - ]: 72 : if (pCondition->getChild(i)->getNodeType() == SQL_NODE_EQUAL)
1141 : 72 : i++;
1142 : :
1143 : : // go forward
1144 [ + + ]: 144 : for (;i < pCondition->count();i++)
1145 : : pCondition->getChild(i)->parseNodeToPredicateStr(
1146 [ + - ][ + - ]: 72 : aValue, m_xConnection, xFormatter, m_aLocale, static_cast<sal_Char>(m_sDecimalSep.toChar() ) );
1147 : : }
1148 [ # # ][ # # ]: 0 : else if (SQL_ISRULE(pCondition->getChild(pCondition->count()-1), column_ref))
[ # # ][ # # ]
[ # # ][ # # ]
1149 : : {
1150 : 0 : nPos = pCondition->count()-1;
1151 : :
1152 : 0 : sal_Int32 i = pCondition->count() - 2;
1153 [ # # # # : 0 : switch (pCondition->getChild(i)->getNodeType())
# # # ]
[ # # ]
1154 : : {
1155 : : case SQL_NODE_EQUAL:
1156 : : // don't display the equal
1157 : 0 : i--;
1158 : 0 : aItem.Handle = SQLFilterOperator::EQUAL;
1159 : 0 : break;
1160 : : case SQL_NODE_NOTEQUAL:
1161 : 0 : i--;
1162 : 0 : aItem.Handle = SQLFilterOperator::NOT_EQUAL;
1163 : 0 : break;
1164 : : case SQL_NODE_LESS:
1165 : : // take the opposite as we change the order
1166 : 0 : i--;
1167 [ # # ]: 0 : aValue = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">="));
1168 : 0 : aItem.Handle = SQLFilterOperator::GREATER_EQUAL;
1169 : 0 : break;
1170 : : case SQL_NODE_LESSEQ:
1171 : : // take the opposite as we change the order
1172 : 0 : i--;
1173 [ # # ]: 0 : aValue = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">"));
1174 : 0 : aItem.Handle = SQLFilterOperator::GREATER;
1175 : 0 : break;
1176 : : case SQL_NODE_GREAT:
1177 : : // take the opposite as we change the order
1178 : 0 : i--;
1179 [ # # ]: 0 : aValue = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<="));
1180 : 0 : aItem.Handle = SQLFilterOperator::LESS_EQUAL;
1181 : 0 : break;
1182 : : case SQL_NODE_GREATEQ:
1183 : : // take the opposite as we change the order
1184 : 0 : i--;
1185 [ # # ]: 0 : aValue = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<"));
1186 : 0 : aItem.Handle = SQLFilterOperator::LESS;
1187 : 0 : break;
1188 : : default:
1189 : 0 : break;
1190 : : }
1191 : :
1192 : : // go backward
1193 [ # # ]: 0 : for (; i >= 0; i--)
1194 : : pCondition->getChild(i)->parseNodeToPredicateStr(
1195 [ # # ][ # # ]: 0 : aValue, m_xConnection, xFormatter, m_aLocale, static_cast<sal_Char>( m_sDecimalSep.toChar() ) );
1196 : : }
1197 : : else
1198 : 0 : return sal_False;
1199 : :
1200 [ + - ][ + - ]: 72 : aItem.Name = getColumnName(pCondition->getChild(nPos),_rIterator);
1201 [ + - ]: 72 : aItem.Value <<= aValue;
1202 [ + - ][ - + ]: 72 : rFilter.push_back(aItem);
[ + - ]
1203 : : }
1204 [ # # ][ # # : 0 : else if (SQL_ISRULE(pCondition->getChild(0), set_fct_spec ) ||
# # # # ]
[ # # ]
1205 : 0 : SQL_ISRULE(pCondition->getChild(0), general_set_fct))
1206 : : {
1207 : 0 : PropertyValue aItem;
1208 : 0 : ::rtl::OUString aValue;
1209 : 0 : ::rtl::OUString aColumnName;
1210 : :
1211 [ # # ][ # # ]: 0 : pCondition->getChild(2)->parseNodeToPredicateStr(aValue, m_xConnection, xFormatter, m_aLocale, static_cast<sal_Char>( m_sDecimalSep.toChar() ) );
1212 [ # # ][ # # ]: 0 : pCondition->getChild(0)->parseNodeToPredicateStr( aColumnName, m_xConnection, xFormatter, m_aLocale, static_cast<sal_Char>( m_sDecimalSep .toChar() ) );
1213 : :
1214 [ # # ][ # # ]: 0 : aItem.Name = getColumnName(pCondition->getChild(0),_rIterator);
1215 [ # # ]: 0 : aItem.Value <<= aValue;
1216 [ # # ]: 0 : aItem.Handle = getPredicateType(pCondition->getChild(1));
1217 [ # # ]: 0 : rFilter.push_back(aItem);
1218 : : }
1219 : : else // Can only be an expression
1220 : : {
1221 : 0 : PropertyValue aItem;
1222 : 0 : ::rtl::OUString aName, aValue;
1223 : :
1224 [ # # ]: 0 : OSQLParseNode *pLhs = pCondition->getChild(0);
1225 [ # # ]: 0 : OSQLParseNode *pRhs = pCondition->getChild(2);
1226 : :
1227 : : // Field names
1228 : : sal_uInt16 i;
1229 [ # # ]: 0 : for (i=0;i< pLhs->count();i++)
1230 [ # # ][ # # ]: 0 : pLhs->getChild(i)->parseNodeToPredicateStr( aName, m_xConnection, xFormatter, m_aLocale, static_cast<sal_Char>( m_sDecimalSep.toChar() ) );
1231 : :
1232 : : // Criterion
1233 [ # # ]: 0 : aItem.Handle = getPredicateType(pCondition->getChild(1));
1234 [ # # ]: 0 : aValue = pCondition->getChild(1)->getTokenValue();
1235 [ # # ]: 0 : for(i=0;i< pRhs->count();i++)
1236 [ # # ][ # # ]: 0 : pRhs->getChild(i)->parseNodeToPredicateStr(aValue, m_xConnection, xFormatter, m_aLocale, static_cast<sal_Char>( m_sDecimalSep.toChar() ) );
1237 : :
1238 : 0 : aItem.Name = aName;
1239 [ # # ]: 0 : aItem.Value <<= aValue;
1240 [ # # ]: 0 : rFilter.push_back(aItem);
1241 : : }
1242 : 72 : return sal_True;
1243 : : }
1244 : :
1245 : : // Functions for analysing SQL
1246 : 72 : ::rtl::OUString OSingleSelectQueryComposer::getColumnName( ::connectivity::OSQLParseNode* pColumnRef, OSQLParseTreeIterator& _rIterator ) const
1247 : : {
1248 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getColumnName" );
1249 : 72 : ::rtl::OUString aTableRange, aColumnName;
1250 [ + - ]: 72 : _rIterator.getColumnRange(pColumnRef,aColumnName,aTableRange);
1251 : 72 : return aColumnName;
1252 : : }
1253 : :
1254 : 40 : ::rtl::OUString SAL_CALL OSingleSelectQueryComposer::getFilter( ) throw(RuntimeException)
1255 : : {
1256 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getFilter" );
1257 [ + - ]: 40 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1258 [ + - ]: 40 : ::osl::MutexGuard aGuard( m_aMutex );
1259 [ + - ][ + - ]: 40 : return getSQLPart(Where,m_aAdditiveIterator,sal_False);
1260 : : }
1261 : :
1262 : 12 : ::rtl::OUString SAL_CALL OSingleSelectQueryComposer::getOrder( ) throw(RuntimeException)
1263 : : {
1264 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getOrder" );
1265 [ + - ]: 12 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1266 [ + - ]: 12 : ::osl::MutexGuard aGuard( m_aMutex );
1267 [ + - ][ + - ]: 12 : return getSQLPart(Order,m_aAdditiveIterator,sal_False);
1268 : : }
1269 : :
1270 : 6 : ::rtl::OUString SAL_CALL OSingleSelectQueryComposer::getGroup( ) throw (RuntimeException)
1271 : : {
1272 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getGroup" );
1273 [ + - ]: 6 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1274 [ + - ]: 6 : ::osl::MutexGuard aGuard( m_aMutex );
1275 [ + - ][ + - ]: 6 : return getSQLPart(Group,m_aAdditiveIterator,sal_False);
1276 : : }
1277 : :
1278 : 14 : ::rtl::OUString OSingleSelectQueryComposer::getHavingClause() throw (RuntimeException)
1279 : : {
1280 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getHavingClause" );
1281 [ + - ]: 14 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1282 [ + - ]: 14 : ::osl::MutexGuard aGuard( m_aMutex );
1283 [ + - ][ + - ]: 14 : return getSQLPart(Having,m_aAdditiveIterator,sal_False);
1284 : : }
1285 : :
1286 : 0 : ::rtl::OUString OSingleSelectQueryComposer::getTableAlias(const Reference< XPropertySet >& column) const
1287 : : {
1288 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getTableAlias" );
1289 : 0 : ::rtl::OUString sReturn;
1290 [ # # ][ # # ]: 0 : if(m_pTables && m_pTables->getCount() > 1)
[ # # ][ # # ]
1291 : : {
1292 : 0 : ::rtl::OUString aCatalog,aSchema,aTable,aComposedName,aColumnName;
1293 [ # # ][ # # ]: 0 : column->getPropertyValue(PROPERTY_CATALOGNAME) >>= aCatalog;
[ # # ]
1294 [ # # ][ # # ]: 0 : column->getPropertyValue(PROPERTY_SCHEMANAME) >>= aSchema;
[ # # ]
1295 [ # # ][ # # ]: 0 : column->getPropertyValue(PROPERTY_TABLENAME) >>= aTable;
[ # # ]
1296 [ # # ][ # # ]: 0 : column->getPropertyValue(PROPERTY_NAME) >>= aColumnName;
[ # # ]
1297 : :
1298 [ # # ]: 0 : Sequence< ::rtl::OUString> aNames(m_pTables->getElementNames());
1299 : 0 : const ::rtl::OUString* pBegin = aNames.getConstArray();
1300 : 0 : const ::rtl::OUString* pEnd = pBegin + aNames.getLength();
1301 : :
1302 [ # # ]: 0 : if(aTable.isEmpty())
1303 : : { // we haven't found a table name, now we must search every table for this column
1304 [ # # ]: 0 : for(;pBegin != pEnd;++pBegin)
1305 : : {
1306 : 0 : Reference<XColumnsSupplier> xColumnsSupp;
1307 [ # # ][ # # ]: 0 : m_pTables->getByName(*pBegin) >>= xColumnsSupp;
1308 : :
1309 [ # # ][ # # ]: 0 : if(xColumnsSupp.is() && xColumnsSupp->getColumns()->hasByName(aColumnName))
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
[ # # ]
1310 : : {
1311 : 0 : aTable = *pBegin;
1312 : : break;
1313 : : }
1314 [ # # ]: 0 : }
1315 : : }
1316 : : else
1317 : : {
1318 [ # # ]: 0 : aComposedName = ::dbtools::composeTableName( m_xMetaData, aCatalog, aSchema, aTable, sal_False, ::dbtools::eInDataManipulation );
1319 : :
1320 : : // first check if this is the table we want to or has it a tablealias
1321 : :
1322 [ # # ][ # # ]: 0 : if(!m_pTables->hasByName(aComposedName))
1323 : : {
1324 [ # # ][ # # ]: 0 : ::comphelper::UStringMixLess aTmp(m_aAdditiveIterator.getTables().key_comp());
1325 : 0 : ::comphelper::UStringMixEqual aComp(static_cast< ::comphelper::UStringMixLess*>(&aTmp)->isCaseSensitive());
1326 [ # # ]: 0 : for(;pBegin != pEnd;++pBegin)
1327 : : {
1328 : 0 : Reference<XPropertySet> xTableProp;
1329 [ # # ][ # # ]: 0 : m_pTables->getByName(*pBegin) >>= xTableProp;
1330 : : OSL_ENSURE(xTableProp.is(),"Table isn't a propertyset!");
1331 [ # # ]: 0 : if(xTableProp.is())
1332 : : {
1333 : 0 : ::rtl::OUString aCatalog2,aSchema2,aTable2;
1334 [ # # ][ # # ]: 0 : xTableProp->getPropertyValue(PROPERTY_CATALOGNAME) >>= aCatalog2;
[ # # ]
1335 [ # # ][ # # ]: 0 : xTableProp->getPropertyValue(PROPERTY_SCHEMANAME) >>= aSchema2;
[ # # ]
1336 [ # # ][ # # ]: 0 : xTableProp->getPropertyValue(PROPERTY_NAME) >>= aTable2;
[ # # ]
1337 [ # # ][ # # ]: 0 : if(aComp(aCatalog,aCatalog2) && aComp(aSchema,aSchema2) && aComp(aTable,aTable2))
[ # # ][ # # ]
1338 : : {
1339 : 0 : aCatalog = aCatalog2;
1340 : 0 : aSchema = aSchema2;
1341 : 0 : aTable = aTable2;
1342 : : break;
1343 [ # # ][ # # ]: 0 : }
[ # # ]
1344 : : }
1345 [ # # ]: 0 : }
1346 : : }
1347 : : }
1348 [ # # ]: 0 : if(pBegin != pEnd)
1349 : : {
1350 [ # # ]: 0 : sReturn = ::dbtools::composeTableName( m_xMetaData, aCatalog, aSchema, aTable, sal_True, ::dbtools::eInDataManipulation );
1351 [ # # ]: 0 : sReturn += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("."));
1352 [ # # ]: 0 : }
1353 : : }
1354 : 0 : return sReturn;
1355 : : }
1356 : :
1357 : 82 : Reference< XIndexAccess > SAL_CALL OSingleSelectQueryComposer::getParameters( ) throw(RuntimeException)
1358 : : {
1359 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getParameters" );
1360 : : // now set the Parameters
1361 [ + + ]: 82 : if ( !m_aCurrentColumns[ParameterColumns] )
1362 : : {
1363 [ + - ]: 74 : ::rtl::Reference< OSQLColumns> aCols = m_aSqlIterator.getParameters();
1364 [ + - ]: 74 : ::std::vector< ::rtl::OUString> aNames;
1365 [ + - ]: 74 : OSQLColumns::Vector::const_iterator aEnd = aCols->get().end();
1366 [ + - ][ + - ]: 88 : for(OSQLColumns::Vector::const_iterator aIter = aCols->get().begin(); aIter != aEnd;++aIter)
[ + + ]
1367 [ + - ][ + - ]: 14 : aNames.push_back(getString((*aIter)->getPropertyValue(PROPERTY_NAME)));
[ + - ][ + - ]
[ + - ]
1368 [ + - ][ + - ]: 74 : m_aCurrentColumns[ParameterColumns] = new OPrivateColumns(aCols,m_xMetaData->supportsMixedCaseQuotedIdentifiers(),*this,m_aMutex,aNames,sal_True);
[ + - ][ + - ]
[ + - ]
1369 : : }
1370 : :
1371 [ + - ]: 82 : return m_aCurrentColumns[ParameterColumns];
1372 : : }
1373 : :
1374 : 74 : void OSingleSelectQueryComposer::clearColumns( const EColumnType _eType )
1375 : : {
1376 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::clearColumns" );
1377 : 74 : OPrivateColumns* pColumns = m_aCurrentColumns[ _eType ];
1378 [ - + ]: 74 : if ( pColumns != NULL )
1379 : : {
1380 [ # # ]: 0 : pColumns->disposing();
1381 [ # # ]: 0 : m_aColumnsCollection.push_back( pColumns );
1382 : 0 : m_aCurrentColumns[ _eType ] = NULL;
1383 : : }
1384 : 74 : }
1385 : :
1386 : 184 : void OSingleSelectQueryComposer::clearCurrentCollections()
1387 : : {
1388 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::clearCurrentCollections" );
1389 : 184 : ::std::vector<OPrivateColumns*>::iterator aIter = m_aCurrentColumns.begin();
1390 : 184 : ::std::vector<OPrivateColumns*>::iterator aEnd = m_aCurrentColumns.end();
1391 [ + - ][ + + ]: 920 : for (;aIter != aEnd;++aIter)
1392 : : {
1393 [ + + ]: 736 : if ( *aIter )
1394 : : {
1395 [ + - ]: 150 : (*aIter)->disposing();
1396 [ + - ]: 150 : m_aColumnsCollection.push_back(*aIter);
1397 : 150 : *aIter = NULL;
1398 : : }
1399 : : }
1400 : :
1401 [ + + ]: 184 : if(m_pTables)
1402 : : {
1403 [ + - ]: 82 : m_pTables->disposing();
1404 [ + - ]: 82 : m_aTablesCollection.push_back(m_pTables);
1405 : 82 : m_pTables = NULL;
1406 : : }
1407 : 184 : }
1408 : :
1409 : 6 : Reference< XIndexAccess > OSingleSelectQueryComposer::setCurrentColumns( EColumnType _eType,
1410 : : const ::rtl::Reference< OSQLColumns >& _rCols )
1411 : : {
1412 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setCurrentColumns" );
1413 [ + - ]: 6 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1414 : :
1415 [ + - ]: 6 : ::osl::MutexGuard aGuard( m_aMutex );
1416 : : // now set the group columns
1417 [ + - ]: 6 : if ( !m_aCurrentColumns[_eType] )
1418 : : {
1419 [ + - ]: 6 : ::std::vector< ::rtl::OUString> aNames;
1420 [ + - ]: 6 : OSQLColumns::Vector::const_iterator aEnd = _rCols->get().end();
1421 [ + - ][ + - ]: 12 : for(OSQLColumns::Vector::const_iterator aIter = _rCols->get().begin(); aIter != aEnd;++aIter)
[ + + ]
1422 [ + - ][ + - ]: 6 : aNames.push_back(getString((*aIter)->getPropertyValue(PROPERTY_NAME)));
[ + - ][ + - ]
[ + - ]
1423 [ + - ][ + - ]: 6 : m_aCurrentColumns[_eType] = new OPrivateColumns(_rCols,m_xMetaData->supportsMixedCaseQuotedIdentifiers(),*this,m_aMutex,aNames,sal_True);
[ + - ][ + - ]
1424 : : }
1425 : :
1426 [ + - ][ + - ]: 6 : return m_aCurrentColumns[_eType];
[ + - ]
1427 : : }
1428 : :
1429 : 2 : Reference< XIndexAccess > SAL_CALL OSingleSelectQueryComposer::getGroupColumns( ) throw(RuntimeException)
1430 : : {
1431 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getGroupColumns" );
1432 [ + - ]: 2 : return setCurrentColumns( GroupByColumns, m_aAdditiveIterator.getGroupColumns() );
1433 : : }
1434 : :
1435 : 4 : Reference< XIndexAccess > SAL_CALL OSingleSelectQueryComposer::getOrderColumns( ) throw(RuntimeException)
1436 : : {
1437 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getOrderColumns" );
1438 [ + - ]: 4 : return setCurrentColumns( OrderColumns, m_aAdditiveIterator.getOrderColumns() );
1439 : : }
1440 : :
1441 : 40 : ::rtl::OUString SAL_CALL OSingleSelectQueryComposer::getQueryWithSubstitution( ) throw (SQLException, RuntimeException)
1442 : : {
1443 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getQueryWithSubstitution" );
1444 [ + - ]: 40 : ::osl::MutexGuard aGuard( m_aMutex );
1445 [ + - ]: 40 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1446 : :
1447 [ + - ]: 40 : ::rtl::OUString sSqlStatement( getQuery() );
1448 : :
1449 : 40 : const OSQLParseNode* pStatementNode = m_aSqlIterator.getParseTree();
1450 [ + - ]: 40 : if ( pStatementNode )
1451 : : {
1452 [ + - ]: 40 : SQLException aError;
1453 [ + - ][ - + ]: 40 : if ( !pStatementNode->parseNodeToExecutableStatement( sSqlStatement, m_xConnection, m_aSqlParser, &aError ) )
1454 [ # # ][ + - ]: 40 : throw SQLException( aError );
1455 : : }
1456 : :
1457 [ + - ]: 40 : return sSqlStatement;
1458 : : }
1459 : :
1460 : 1686 : ::rtl::OUString OSingleSelectQueryComposer::getStatementPart( TGetParseNode& _aGetFunctor, OSQLParseTreeIterator& _rIterator )
1461 : : {
1462 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getStatementPart" );
1463 : 1686 : ::rtl::OUString sResult;
1464 : :
1465 [ + - ]: 1686 : const OSQLParseNode* pNode = _aGetFunctor( &_rIterator );
1466 [ + + ]: 1686 : if ( pNode )
1467 [ + - ]: 422 : pNode->parseNodeToStr( sResult, m_xConnection );
1468 : :
1469 : 1686 : return sResult;
1470 : : }
1471 : :
1472 : : namespace
1473 : : {
1474 : 8 : ::rtl::OUString lcl_getCondition(const Sequence< Sequence< PropertyValue > >& filter,const OPredicateInputController& i_aPredicateInputController,const Reference< XNameAccess >& i_xSelectColumns)
1475 : : {
1476 : 8 : ::rtl::OUStringBuffer sRet;
1477 : 8 : const Sequence< PropertyValue >* pOrIter = filter.getConstArray();
1478 : 8 : const Sequence< PropertyValue >* pOrEnd = pOrIter + filter.getLength();
1479 [ + + ]: 48 : while ( pOrIter != pOrEnd )
1480 : : {
1481 [ + - ]: 40 : if ( pOrIter->getLength() )
1482 : : {
1483 [ + - ][ + - ]: 40 : sRet.append(L_BRACKET);
1484 : 40 : const PropertyValue* pAndIter = pOrIter->getConstArray();
1485 : 40 : const PropertyValue* pAndEnd = pAndIter + pOrIter->getLength();
1486 [ + + ]: 112 : while ( pAndIter != pAndEnd )
1487 : : {
1488 [ + - ]: 72 : sRet.append(pAndIter->Name);
1489 : 72 : ::rtl::OUString sValue;
1490 : 72 : pAndIter->Value >>= sValue;
1491 [ + - ][ + - ]: 72 : if ( i_xSelectColumns.is() && i_xSelectColumns->hasByName(pAndIter->Name) )
[ + - ][ + - ]
[ + - ]
1492 : : {
1493 [ + - ][ + - ]: 72 : Reference<XPropertySet> xColumn(i_xSelectColumns->getByName(pAndIter->Name),UNO_QUERY);
[ + - ]
1494 [ + - ]: 72 : sValue = i_aPredicateInputController.getPredicateValue(sValue,xColumn,sal_True);
1495 : : }
1496 : : else
1497 : : {
1498 [ # # ]: 0 : sValue = i_aPredicateInputController.getPredicateValue(pAndIter->Name,sValue,sal_True);
1499 : : }
1500 [ + - ]: 72 : lcl_addFilterCriteria_throw(pAndIter->Handle,sValue,sRet);
1501 : 72 : ++pAndIter;
1502 [ + + ]: 72 : if ( pAndIter != pAndEnd )
1503 [ + - ][ + - ]: 32 : sRet.append(STR_AND);
1504 : 72 : }
1505 [ + - ][ + - ]: 40 : sRet.append(R_BRACKET);
1506 : : }
1507 : 40 : ++pOrIter;
1508 [ + + ][ + - ]: 40 : if ( pOrIter != pOrEnd && sRet.getLength() )
[ + + ]
1509 [ + - ][ + - ]: 32 : sRet.append(STR_OR);
1510 : : }
1511 [ + - ]: 8 : return sRet.makeStringAndClear();
1512 : : }
1513 : : }
1514 : :
1515 : 4 : void SAL_CALL OSingleSelectQueryComposer::setStructuredFilter( const Sequence< Sequence< PropertyValue > >& filter ) throw (SQLException, ::com::sun::star::lang::IllegalArgumentException, RuntimeException)
1516 : : {
1517 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setStructuredFilter" );
1518 [ + - ][ + - ]: 4 : OPredicateInputController aPredicateInput(m_aContext.getLegacyServiceFactory(),m_xConnection);
1519 [ + - ][ + - ]: 4 : setFilter(lcl_getCondition(filter,aPredicateInput,getColumns()));
[ + - ][ + - ]
1520 : 4 : }
1521 : :
1522 : 4 : void SAL_CALL OSingleSelectQueryComposer::setStructuredHavingClause( const Sequence< Sequence< PropertyValue > >& filter ) throw (SQLException, RuntimeException)
1523 : : {
1524 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setStructuredHavingClause" );
1525 [ + - ][ + - ]: 4 : OPredicateInputController aPredicateInput(m_aContext.getLegacyServiceFactory(),m_xConnection);
1526 [ + - ][ + - ]: 4 : setHavingClause(lcl_getCondition(filter,aPredicateInput,getColumns()));
[ + - ][ + - ]
1527 : 4 : }
1528 : :
1529 : 10 : void OSingleSelectQueryComposer::setConditionByColumn( const Reference< XPropertySet >& column, sal_Bool andCriteria ,::std::mem_fun1_t<bool,OSingleSelectQueryComposer,::rtl::OUString>& _aSetFunctor,sal_Int32 filterOperator)
1530 : : {
1531 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::setConditionByColumn" );
1532 [ + - ]: 10 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1533 : :
1534 [ + + ][ + - ]: 38 : if ( !column.is()
[ + - ][ - + ]
[ + + ]
1535 [ + - ][ + - ]: 16 : || !column->getPropertySetInfo()->hasPropertyByName(PROPERTY_VALUE)
[ + - ][ + - ]
[ + - ][ + + ]
[ + + ]
[ # # # # ]
1536 [ + - ][ + - ]: 16 : || !column->getPropertySetInfo()->hasPropertyByName(PROPERTY_NAME)
[ + - ][ + - ]
[ + - ][ + + ]
[ + + ]
[ # # # # ]
1537 [ + - ][ + - ]: 16 : || !column->getPropertySetInfo()->hasPropertyByName(PROPERTY_TYPE))
[ + - ][ + - ]
[ + - ][ + + ]
[ + + ]
[ # # # # ]
1538 [ + - ][ + - ]: 4 : throw SQLException(DBACORE_RESSTRING(RID_STR_COLUMN_NOT_VALID),*this,SQLSTATE_GENERAL,1000,Any() );
[ + - ][ + - ]
1539 : :
1540 : 6 : sal_Int32 nType = 0;
1541 [ + - ][ + - ]: 6 : column->getPropertyValue(PROPERTY_TYPE) >>= nType;
[ + - ]
1542 [ + - ]: 6 : sal_Int32 nSearchable = dbtools::getSearchColumnFlag(m_xConnection,nType);
1543 [ - + ]: 6 : if(nSearchable == ColumnSearch::NONE)
1544 [ # # ][ # # ]: 0 : throw SQLException(DBACORE_RESSTRING(RID_STR_COLUMN_NOT_SEARCHABLE),*this,SQLSTATE_GENERAL,1000,Any() );
[ # # ][ # # ]
1545 : :
1546 [ + - ]: 6 : ::osl::MutexGuard aGuard( m_aMutex );
1547 : :
1548 : 6 : ::rtl::OUString aName;
1549 [ + - ][ + - ]: 6 : column->getPropertyValue(PROPERTY_NAME) >>= aName;
[ + - ]
1550 : :
1551 : 6 : Any aValue;
1552 [ + - ][ + - ]: 6 : column->getPropertyValue(PROPERTY_VALUE) >>= aValue;
[ + - ]
1553 : :
1554 : 6 : ::rtl::OUStringBuffer aSQL;
1555 [ + - ][ + - ]: 6 : const ::rtl::OUString aQuote = m_xMetaData->getIdentifierQuoteString();
1556 [ + - ]: 6 : getColumns();
1557 : :
1558 [ + - ][ + - ]: 6 : if ( m_aCurrentColumns[SelectColumns] && m_aCurrentColumns[SelectColumns]->hasByName(aName) )
[ + - ][ + - ]
1559 : : {
1560 : 6 : Reference<XPropertySet> xColumn;
1561 [ + - ][ + - ]: 6 : m_aCurrentColumns[SelectColumns]->getByName(aName) >>= xColumn;
1562 : : OSL_ENSURE(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_REALNAME),"Property REALNAME not available!");
1563 : : OSL_ENSURE(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_TABLENAME),"Property TABLENAME not available!");
1564 : : OSL_ENSURE(xColumn->getPropertySetInfo()->hasPropertyByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AggregateFunction"))),"Property AggregateFunction not available!");
1565 : :
1566 : 6 : ::rtl::OUString sRealName,sTableName;
1567 [ + - ][ + - ]: 6 : xColumn->getPropertyValue(PROPERTY_REALNAME) >>= sRealName;
[ + - ]
1568 [ + - ][ + - ]: 6 : xColumn->getPropertyValue(PROPERTY_TABLENAME) >>= sTableName;
[ + - ]
1569 [ - + ]: 6 : if(sTableName.indexOf('.',0) != -1)
1570 : : {
1571 : 0 : ::rtl::OUString aCatlog,aSchema,aTable;
1572 [ # # ]: 0 : ::dbtools::qualifiedNameComponents(m_xMetaData,sTableName,aCatlog,aSchema,aTable,::dbtools::eInDataManipulation);
1573 [ # # ]: 0 : sTableName = ::dbtools::composeTableName( m_xMetaData, aCatlog, aSchema, aTable, sal_True, ::dbtools::eInDataManipulation );
1574 : : }
1575 : : else
1576 [ + - ]: 6 : sTableName = ::dbtools::quoteName(aQuote,sTableName);
1577 : :
1578 [ + - ][ + - ]: 6 : if ( !::comphelper::getBOOL(xColumn->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Function")))) )
[ + - ][ + - ]
[ + - ]
1579 : : {
1580 [ + - ][ + - ]: 6 : aSQL = sTableName;
1581 [ + - ]: 6 : aSQL.appendAscii( "." );
1582 [ + - ][ + - ]: 6 : aSQL.append( ::dbtools::quoteName( aQuote, sRealName ) );
1583 : : }
1584 : : else
1585 [ # # ][ # # ]: 6 : aSQL = sRealName;
1586 : :
1587 : : }
1588 : : else
1589 : : {
1590 [ # # ][ # # ]: 0 : aSQL = getTableAlias( column );
[ # # ]
1591 [ # # ][ # # ]: 0 : aSQL.append( ::dbtools::quoteName( aQuote, aName ) );
1592 : : }
1593 : :
1594 [ - + ]: 6 : if ( aValue.hasValue() )
1595 : : {
1596 [ # # ]: 0 : if( !m_xTypeConverter.is() )
1597 [ # # ]: 0 : m_aContext.createComponent( "com.sun.star.script.Converter", m_xTypeConverter );
1598 : : OSL_ENSURE(m_xTypeConverter.is(),"NO typeconverter!");
1599 : :
1600 [ # # ][ # # ]: 0 : if ( nType != DataType::BOOLEAN && DataType::BIT != nType )
1601 : : {
1602 : 0 : ::rtl::OUString sEmpty;
1603 [ # # ]: 0 : lcl_addFilterCriteria_throw(filterOperator,sEmpty,aSQL);
1604 : : }
1605 : :
1606 [ # # # # : 0 : switch(nType)
# ]
1607 : : {
1608 : : case DataType::VARCHAR:
1609 : : case DataType::CHAR:
1610 : : case DataType::LONGVARCHAR:
1611 [ # # ][ # # ]: 0 : aSQL.append( DBTypeConversion::toSQLString( nType, aValue, sal_True, m_xTypeConverter ) );
1612 : 0 : break;
1613 : : case DataType::CLOB:
1614 : : {
1615 [ # # ]: 0 : Reference< XClob > xClob(aValue,UNO_QUERY);
1616 [ # # ]: 0 : if ( xClob.is() )
1617 : : {
1618 [ # # ][ # # ]: 0 : const ::sal_Int64 nLength = xClob->length();
1619 [ # # ][ # # ]: 0 : if ( sal_Int64(nLength + aSQL.getLength() + STR_LIKE.getLength() ) < sal_Int64(SAL_MAX_INT32) )
1620 : : {
1621 [ # # ]: 0 : aSQL.appendAscii("'");
1622 [ # # ][ # # ]: 0 : aSQL.append( xClob->getSubString(1,(sal_Int32)nLength) );
[ # # ]
1623 [ # # ]: 0 : aSQL.appendAscii("'");
1624 : : }
1625 : : }
1626 : : else
1627 : : {
1628 [ # # ][ # # ]: 0 : aSQL.append( DBTypeConversion::toSQLString( nType, aValue, sal_True, m_xTypeConverter ) );
1629 : 0 : }
1630 : : }
1631 : 0 : break;
1632 : : case DataType::VARBINARY:
1633 : : case DataType::BINARY:
1634 : : case DataType::LONGVARBINARY:
1635 : : {
1636 [ # # ]: 0 : Sequence<sal_Int8> aSeq;
1637 [ # # ][ # # ]: 0 : if(aValue >>= aSeq)
1638 : : {
1639 [ # # ]: 0 : if(nSearchable == ColumnSearch::CHAR)
1640 : : {
1641 [ # # ]: 0 : aSQL.appendAscii( "\'" );
1642 : : }
1643 [ # # ]: 0 : aSQL.appendAscii( "0x" );
1644 : 0 : const sal_Int8* pBegin = aSeq.getConstArray();
1645 : 0 : const sal_Int8* pEnd = pBegin + aSeq.getLength();
1646 [ # # ]: 0 : for(;pBegin != pEnd;++pBegin)
1647 : : {
1648 [ # # ]: 0 : aSQL.append( (sal_Int32)*pBegin, 16 ).getStr();
1649 : : }
1650 [ # # ]: 0 : if(nSearchable == ColumnSearch::CHAR)
1651 [ # # ]: 0 : aSQL.appendAscii( "\'" );
1652 : : }
1653 : : else
1654 [ # # ][ # # ]: 0 : throw SQLException(DBACORE_RESSTRING(RID_STR_NOT_SEQUENCE_INT8),*this,SQLSTATE_GENERAL,1000,Any() );
[ # # ][ # # ]
[ # # ]
1655 : : }
1656 : 0 : break;
1657 : : case DataType::BIT:
1658 : : case DataType::BOOLEAN:
1659 : : {
1660 : 0 : sal_Bool bValue = sal_False;
1661 [ # # ][ # # ]: 0 : m_xTypeConverter->convertToSimpleType(aValue, TypeClass_BOOLEAN) >>= bValue;
1662 : :
1663 [ # # ]: 0 : ::rtl::OUString sColumnExp = aSQL.makeStringAndClear();
1664 [ # # ]: 0 : getBoleanComparisonPredicate( sColumnExp, bValue, m_nBoolCompareMode, aSQL );
1665 : : }
1666 : 0 : break;
1667 : : default:
1668 [ # # ][ # # ]: 0 : aSQL.append( DBTypeConversion::toSQLString( nType, aValue, sal_True, m_xTypeConverter ) );
1669 : 0 : break;
1670 : : }
1671 : : }
1672 : : else
1673 : : {
1674 : 6 : sal_Int32 nFilterOp = filterOperator;
1675 [ + - ][ + - ]: 6 : if ( filterOperator != SQLFilterOperator::SQLNULL && filterOperator != SQLFilterOperator::NOT_SQLNULL )
1676 : 6 : nFilterOp = SQLFilterOperator::SQLNULL;
1677 : 6 : ::rtl::OUString sEmpty;
1678 [ + - ]: 6 : lcl_addFilterCriteria_throw(nFilterOp,sEmpty,aSQL);
1679 : : }
1680 : :
1681 : : // Attach filter
1682 : : // Construct SELECT without WHERE and ORDER BY
1683 [ + - ]: 6 : ::rtl::OUString sFilter = getFilter();
1684 : :
1685 [ + - ][ + - ]: 6 : if ( !sFilter.isEmpty() && aSQL.getLength() )
[ + - ]
1686 : : {
1687 [ + - ]: 6 : ::rtl::OUString sTemp(L_BRACKET);
1688 : 6 : sTemp += sFilter;
1689 [ + - ]: 6 : sTemp += R_BRACKET;
1690 [ + - ][ + - ]: 6 : sTemp += andCriteria ? STR_AND : STR_OR;
[ + + ]
1691 : 6 : sFilter = sTemp;
1692 : : }
1693 [ + - ]: 6 : sFilter += aSQL.makeStringAndClear();
1694 : :
1695 : : // add the filter and the sort order
1696 [ + - ][ + - ]: 10 : _aSetFunctor(this,sFilter);
1697 : 6 : }
1698 : :
1699 : 8 : Sequence< Sequence< PropertyValue > > OSingleSelectQueryComposer::getStructuredCondition( TGetParseNode& _aGetFunctor )
1700 : : {
1701 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getStructuredCondition" );
1702 [ + - ]: 8 : ::connectivity::checkDisposed(OSubComponent::rBHelper.bDisposed);
1703 : :
1704 [ + - ]: 8 : MutexGuard aGuard(m_aMutex);
1705 : :
1706 [ + - ]: 8 : Sequence< Sequence< PropertyValue > > aFilterSeq;
1707 [ + - ]: 8 : ::rtl::OUString sFilter = getStatementPart( _aGetFunctor, m_aAdditiveIterator );
1708 : :
1709 [ + - ]: 8 : if ( !sFilter.isEmpty() )
1710 : : {
1711 : 8 : ::rtl::OUString aSql(m_aPureSelectSQL);
1712 : : // build a temporary parse node
1713 : 8 : const OSQLParseNode* pTempNode = m_aAdditiveIterator.getParseTree();
1714 : :
1715 [ + - ]: 8 : aSql += STR_WHERE;
1716 : 8 : aSql += sFilter;
1717 : :
1718 : 8 : ::rtl::OUString aErrorMsg;
1719 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1720 [ + - ]: 8 : ::std::auto_ptr<OSQLParseNode> pSqlParseNode( m_aSqlParser.parseTree(aErrorMsg,aSql));
1721 : : SAL_WNODEPRECATED_DECLARATIONS_POP
1722 [ + - ]: 8 : if ( pSqlParseNode.get() )
1723 : : {
1724 [ + - ]: 8 : m_aAdditiveIterator.setParseTree(pSqlParseNode.get());
1725 : : // normalize the filter
1726 [ + - ]: 8 : OSQLParseNode* pWhereNode = const_cast<OSQLParseNode*>(m_aAdditiveIterator.getWhereTree());
1727 : :
1728 [ + - ]: 8 : OSQLParseNode* pCondition = pWhereNode->getChild(1);
1729 : : #if OSL_DEBUG_LEVEL > 0
1730 : : ::rtl::OUString sCondition;
1731 : : pCondition->parseNodeToStr( sCondition, m_xConnection );
1732 : : #endif
1733 [ + - ]: 8 : OSQLParseNode::negateSearchCondition(pCondition);
1734 : :
1735 [ + - ]: 8 : pCondition = pWhereNode->getChild(1);
1736 : : #if OSL_DEBUG_LEVEL > 0
1737 : : sCondition = ::rtl::OUString();
1738 : : pCondition->parseNodeToStr( sCondition, m_xConnection );
1739 : : #endif
1740 [ + - ]: 8 : OSQLParseNode::disjunctiveNormalForm(pCondition);
1741 : :
1742 [ + - ]: 8 : pCondition = pWhereNode->getChild(1);
1743 : : #if OSL_DEBUG_LEVEL > 0
1744 : : sCondition = ::rtl::OUString();
1745 : : pCondition->parseNodeToStr( sCondition, m_xConnection );
1746 : : #endif
1747 [ + - ]: 8 : OSQLParseNode::absorptions(pCondition);
1748 : :
1749 [ + - ]: 8 : pCondition = pWhereNode->getChild(1);
1750 : : #if OSL_DEBUG_LEVEL > 0
1751 : : sCondition = ::rtl::OUString();
1752 : : pCondition->parseNodeToStr( sCondition, m_xConnection );
1753 : : #endif
1754 [ + - ]: 8 : if ( pCondition )
1755 : : {
1756 [ + - ]: 8 : ::std::vector< ::std::vector < PropertyValue > > aFilters;
1757 : 8 : Reference< XNumberFormatter > xFormatter;
1758 [ + - ]: 8 : m_aContext.createComponent( "com.sun.star.util.NumberFormatter", xFormatter );
1759 [ + - ][ + - ]: 8 : xFormatter->attachNumberFormatsSupplier( m_xNumberFormatsSupplier );
1760 : :
1761 [ + - ][ + - ]: 8 : if (setORCriteria(pCondition, m_aAdditiveIterator, aFilters, xFormatter))
1762 : : {
1763 [ + - ]: 8 : aFilterSeq.realloc(aFilters.size());
1764 [ + - ]: 8 : Sequence<PropertyValue>* pFilters = aFilterSeq.getArray();
1765 [ + - ]: 8 : ::std::vector< ::std::vector < PropertyValue > >::const_iterator aEnd = aFilters.end();
1766 [ + - ]: 8 : ::std::vector< ::std::vector < PropertyValue > >::const_iterator i = aFilters.begin();
1767 [ + - ][ + + ]: 48 : for ( ; i != aEnd ; ++i)
1768 : : {
1769 : 40 : const ::std::vector < PropertyValue >& rProperties = *i;
1770 [ + - ]: 40 : pFilters->realloc(rProperties.size());
1771 [ + - ]: 40 : PropertyValue* pFilter = pFilters->getArray();
1772 : 40 : ::std::vector < PropertyValue >::const_iterator j = rProperties.begin();
1773 : 40 : ::std::vector < PropertyValue >::const_iterator aEnd2 = rProperties.end();
1774 [ + - ][ + + ]: 112 : for ( ; j != aEnd2 ; ++j)
1775 : : {
1776 : 72 : *pFilter = *j;
1777 : 72 : ++pFilter;
1778 : : }
1779 : 40 : ++pFilters;
1780 : : }
1781 : 8 : }
1782 : : }
1783 : : // restore
1784 [ + - ]: 8 : m_aAdditiveIterator.setParseTree(pTempNode);
1785 [ + - ]: 8 : }
1786 : : }
1787 [ + - ]: 8 : return aFilterSeq;
1788 : : }
1789 : :
1790 : 1644 : ::rtl::OUString OSingleSelectQueryComposer::getKeyword( SQLPart _ePart ) const
1791 : : {
1792 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getKeyword" );
1793 : 1644 : ::rtl::OUString sKeyword;
1794 [ + + + + ]: 1644 : switch(_ePart)
1795 : : {
1796 : : default:
1797 : : OSL_FAIL( "OSingleSelectQueryComposer::getKeyWord: Invalid enum value!" );
1798 : : // no break, fallback to WHERE
1799 : : case Where:
1800 [ + - ]: 504 : sKeyword = STR_WHERE;
1801 : 504 : break;
1802 : : case Group:
1803 [ + - ]: 394 : sKeyword = STR_GROUP_BY;
1804 : 394 : break;
1805 : : case Having:
1806 [ + - ]: 370 : sKeyword = STR_HAVING;
1807 : 370 : break;
1808 : : case Order:
1809 [ + - ]: 376 : sKeyword = STR_ORDER_BY;
1810 : 376 : break;
1811 : : }
1812 : 1644 : return sKeyword;
1813 : : }
1814 : :
1815 : 1532 : ::rtl::OUString OSingleSelectQueryComposer::getSQLPart( SQLPart _ePart, OSQLParseTreeIterator& _rIterator, sal_Bool _bWithKeyword )
1816 : : {
1817 : : RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OSingleSelectQueryComposer::getSQLPart" );
1818 [ + - ]: 1532 : TGetParseNode F_tmp(&OSQLParseTreeIterator::getSimpleWhereTree);
1819 [ + - ]: 1532 : ::rtl::OUString sKeyword( getKeyword( _ePart ) );
1820 [ + + + + : 1532 : switch(_ePart)
- ]
1821 : : {
1822 : : case Where:
1823 [ + - ]: 464 : F_tmp = TGetParseNode(&OSQLParseTreeIterator::getSimpleWhereTree);
1824 : 464 : break;
1825 : : case Group:
1826 [ + - ]: 382 : F_tmp = TGetParseNode (&OSQLParseTreeIterator::getSimpleGroupByTree);
1827 : 382 : break;
1828 : : case Having:
1829 [ + - ]: 334 : F_tmp = TGetParseNode(&OSQLParseTreeIterator::getSimpleHavingTree);
1830 : 334 : break;
1831 : : case Order:
1832 [ + - ]: 352 : F_tmp = TGetParseNode(&OSQLParseTreeIterator::getSimpleOrderTree);
1833 : 352 : break;
1834 : : default:
1835 : : OSL_FAIL("Invalid enum value!");
1836 : : }
1837 : :
1838 [ + - ]: 1532 : ::rtl::OUString sRet = getStatementPart( F_tmp, _rIterator );
1839 [ + + ][ + + ]: 1532 : if ( _bWithKeyword && !sRet.isEmpty() )
[ + + ]
1840 : 164 : sRet = sKeyword + sRet;
1841 : 1532 : return sRet;
1842 : : }
1843 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
