Clover Coverage Report - XWiki Platform - Parent POM 4.2-SNAPSHOT
Coverage timestamp: Mon Jul 2 2012 08:46:36 CEST
../../../../img/srcFileCovDistChart10.png 0% of files have more coverage
37   258   23   1.85
6   144   0.62   20
20     1.15  
1    
 
  DefaultQuery       Line # 40 37 0% 23 2 96.8% 0.96825397
 
No Tests
 
1    /*
2    * See the NOTICE file distributed with this work for additional
3    * information regarding copyright ownership.
4    *
5    * This is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU Lesser General Public License as
7    * published by the Free Software Foundation; either version 2.1 of
8    * the License, or (at your option) any later version.
9    *
10    * This software is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13    * Lesser General Public License for more details.
14    *
15    * You should have received a copy of the GNU Lesser General Public
16    * License along with this software; if not, write to the Free
17    * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18    * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19    */
20    package org.xwiki.query.internal;
21   
22    import java.util.ArrayList;
23    import java.util.HashMap;
24    import java.util.List;
25    import java.util.Map;
26   
27    import org.slf4j.Logger;
28    import org.slf4j.LoggerFactory;
29    import org.xwiki.query.Query;
30    import org.xwiki.query.QueryException;
31    import org.xwiki.query.QueryExecutor;
32    import org.xwiki.query.QueryFilter;
33   
34    /**
35    * Stores all information needed for execute a query.
36    *
37    * @version $Id: 11a6200dcfa7bb2da8e9e7c1c21e0ace0b4abd48 $
38    * @since 1.6M1
39    */
 
40    public class DefaultQuery implements Query
41    {
42    /**
43    * Used to log possible warnings.
44    */
45    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultQuery.class);
46   
47    /**
48    * field for {@link #isNamed()}.
49    */
50    protected boolean isNamed;
51   
52    /**
53    * field for {@link Query#getStatement()}.
54    */
55    private String statement;
56   
57    /**
58    * field for {@link Query#getLanguage()}.
59    */
60    private String language;
61   
62    /**
63    * virtual wiki to run the query.
64    */
65    private String wiki;
66   
67    /**
68    * map from query parameters to values.
69    */
70    private Map<String, Object> namedParameters = new HashMap<String, Object>();
71   
72    /**
73    * map from index to positional parameter value.
74    */
75    private Map<Integer, Object> positionalParameters = new HashMap<Integer, Object>();
76   
77    /**
78    * field for {@link Query#setLimit(int)}.
79    */
80    private int limit;
81   
82    /**
83    * field for {@link Query#setOffset(int)}.
84    */
85    private int offset;
86   
87    /**
88    * field for {@link #getFilters()}.
89    */
90    private List<QueryFilter> filters = new ArrayList<QueryFilter>();
91   
92    /**
93    * field for {@link #getExecuter()}.
94    */
95    private QueryExecutor executer;
96   
97    /**
98    * Create a Query.
99    *
100    * @param statement query statement
101    * @param language query language
102    * @param executor QueryExecutor component for execute the query.
103    */
 
104  119 toggle public DefaultQuery(String statement, String language, QueryExecutor executor)
105    {
106  119 this.statement = statement;
107  119 this.language = language;
108  119 this.executer = executor;
109  119 this.isNamed = false;
110    }
111   
112    /**
113    * Create a named Query.
114    *
115    * @param queryName the name of the query.
116    * @param executor QueryExecutor component for execute the query.
117    */
 
118  50 toggle public DefaultQuery(String queryName, QueryExecutor executor)
119    {
120  50 this.statement = queryName;
121  50 this.executer = executor;
122  50 this.isNamed = true;
123    }
124   
 
125  210 toggle @Override
126    public String getStatement()
127    {
128  210 return statement;
129    }
130   
 
131  148 toggle @Override
132    public String getLanguage()
133    {
134  148 return language;
135    }
136   
 
137  238 toggle @Override
138    public boolean isNamed()
139    {
140  238 return isNamed;
141    }
142   
 
143  30 toggle @Override
144    public Query setWiki(String wiki)
145    {
146  30 this.wiki = wiki;
147  30 return this;
148    }
149   
 
150  132 toggle @Override
151    public String getWiki()
152    {
153  132 return wiki;
154    }
155   
 
156  125 toggle @Override
157    public Query bindValue(String var, Object val)
158    {
159  125 namedParameters.put(var, val);
160  125 return this;
161    }
162   
 
163  12 toggle @Override
164    public Query bindValue(int index, Object val)
165    {
166  12 positionalParameters.put(index, val);
167  12 return this;
168    }
169   
 
170  20 toggle @Override
171    public Query bindValues(List<Object> values)
172    {
173  26 for (int i = 0; i < values.size(); i++) {
174    // There's a difference in the way positional parameters are handled:
175    // - HQL (jdbc-like), the index of positional parameters must start at 0
176    // - XWQL (jpql-like), the index of positional parameters must start at 1
177    //
178    // This difference is also hardcoded in HqlQueryExecutor#populateParameters(), a better solution could
179    // be to replace the current DefaultQuery with distinct implementations: XwqlQuery, HqlQuery, NamedQuery.
180  6 if (Query.HQL.equals(getLanguage())) {
181  6 bindValue(i, values.get(i));
182    } else {
183  0 bindValue(i + 1, values.get(i));
184    }
185    }
186  20 return this;
187    }
188   
 
189  124 toggle @Override
190    public int getLimit()
191    {
192  124 return limit;
193    }
194   
 
195  104 toggle @Override
196    public int getOffset()
197    {
198  104 return offset;
199    }
200   
 
201  39 toggle @Override
202    public Query setLimit(int limit)
203    {
204  39 this.limit = limit;
205  39 return this;
206    }
207   
 
208  39 toggle @Override
209    public Query setOffset(int offset)
210    {
211  39 this.offset = offset;
212  39 return this;
213    }
214   
 
215  124 toggle @Override
216    public Map<String, Object> getNamedParameters()
217    {
218  124 return namedParameters;
219    }
220   
 
221  140 toggle @Override
222    public Map<Integer, Object> getPositionalParameters()
223    {
224  140 return positionalParameters;
225    }
226   
 
227  461 toggle @Override
228    public List<QueryFilter> getFilters()
229    {
230  461 return filters;
231    }
232   
 
233  102 toggle @Override
234    public Query addFilter(QueryFilter filter)
235    {
236  102 if (!filters.contains(filter)) {
237  101 this.filters.add(filter);
238    } else {
239  1 LOGGER.warn("QueryFilter [{}] already added to the query [{}]", filter.toString(), this.getStatement());
240    }
241   
242  102 return this;
243    }
244   
 
245  122 toggle @Override
246    public <T> List<T> execute() throws QueryException
247    {
248  122 return getExecuter().execute(this);
249    }
250   
251    /**
252    * @return QueryExecutor interface for execute the query.
253    */
 
254  122 toggle protected QueryExecutor getExecuter()
255    {
256  122 return executer;
257    }
258    }