1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.cms.util;
35
36 import info.magnolia.cms.core.Content;
37 import info.magnolia.cms.core.ItemType;
38 import info.magnolia.context.MgnlContext;
39 import info.magnolia.jcr.util.NodeUtil;
40
41 import org.apache.commons.lang.StringUtils;
42 import org.apache.commons.lang.time.DateUtils;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
45
46 import javax.jcr.LoginException;
47 import javax.jcr.NodeIterator;
48 import javax.jcr.RepositoryException;
49 import javax.jcr.Session;
50 import javax.jcr.query.InvalidQueryException;
51 import javax.jcr.query.Query;
52 import javax.jcr.query.QueryManager;
53 import javax.jcr.query.QueryResult;
54 import javax.jcr.query.qom.QueryObjectModel;
55
56 import java.util.ArrayList;
57 import java.util.Arrays;
58 import java.util.Calendar;
59 import java.util.Collection;
60 import java.util.Collections;
61 import java.util.HashSet;
62 import java.util.Iterator;
63 import java.util.Set;
64
65
66
67
68
69
70 public class QueryUtil {
71
72 private static Logger log = LoggerFactory.getLogger(QueryUtil.class);
73
74
75
76
77
78 public static Collection<Content> query(String repository, String statement) {
79 return query(repository, statement, "sql");
80 }
81
82
83
84
85
86 public static Collection<Content> query(String repository, String statement, String language) {
87 return query(repository, statement, language, ItemType.NT_BASE);
88 }
89
90
91
92
93 public static Collection<Content> exceptionThrowingQuery(String repository, String statement, String language, String returnItemType) throws RepositoryException {
94 return exceptionThrowingQuery(repository, statement, language, returnItemType, Long.MAX_VALUE);
95 }
96
97
98
99
100
101 public static Collection<Content> exceptionThrowingQuery(String repository, String statement, String language, String returnItemType,
102 long maxResultSize) throws RepositoryException {
103 Collection<Content> results = new ArrayList<Content>();
104 if(maxResultSize <= 0){
105 maxResultSize = Long.MAX_VALUE;
106 }
107 NodeIterator iterator = search(repository, statement, language, returnItemType);
108
109 long count = 1;
110 while(iterator.hasNext() && count <= maxResultSize){
111 results.add(ContentUtil.getContent(repository, iterator.nextNode().getPath()));
112 count++;
113 }
114 return results;
115 }
116
117
118
119
120 public static Collection<Content> query(String repository, String statement, String language, String returnItemType) {
121 return query(repository, statement, language, returnItemType, Long.MAX_VALUE);
122 }
123
124
125
126
127
128
129 @SuppressWarnings("unchecked")
130
131 public static Collection<Content> query(String repository, String statement, String language, String returnItemType, long maxResultSize) {
132 try {
133 return exceptionThrowingQuery(repository, statement, language, returnItemType, maxResultSize);
134 }
135 catch (Exception e) {
136 log.error("can't execute query [" + statement + "], will return empty collection", e);
137 }
138 return Collections.EMPTY_LIST;
139 }
140
141
142
143
144
145 public static String createDateExpression(int year, int month, int day) {
146 Calendar cal = Calendar.getInstance();
147 cal.set(year, month - 1, day);
148 return createDateExpression(cal);
149 }
150
151
152
153
154
155 public static String createDateExpression(Calendar calendar) {
156 return DateUtil.createDateExpression(calendar);
157 }
158
159
160
161
162
163 public static String createDateTimeExpression(int year, int month, int day, int hour, int minutes, int seconds) {
164 Calendar cal = Calendar.getInstance();
165 cal.set(year, month - 1, day, hour, minutes, seconds);
166 return createDateTimeExpression(cal);
167 }
168
169
170
171
172
173 public static String createDateTimeExpression(Calendar calendar) {
174 return DateUtil.createDateTimeExpression(calendar);
175 }
176
177
178
179
180
181 public static String createDateTimeExpressionIgnoreTimeZone(int year, int month, int day, int hour, int minutes, int seconds) {
182 Calendar cal = Calendar.getInstance(DateUtils.UTC_TIME_ZONE);
183 cal.set(year, month - 1, day, hour, minutes, seconds);
184 return createDateTimeExpression(cal);
185 }
186
187
188
189
190
191 public static String createDateTimeExpressionIgnoreTimeZone(Calendar calendar) {
192 return DateUtil.createDateTimeExpressionIgnoreTimeZone(calendar);
193 }
194
195
196
197
198
199
200
201
202
203
204
205
206 public static NodeIterator search(QueryObjectModel model, String returnItemType) throws InvalidQueryException, RepositoryException{
207 return NodeUtil.filterDuplicates(NodeUtil.filterParentNodeType(model.execute().getNodes(), returnItemType));
208 }
209
210
211
212
213
214
215
216
217
218
219
220
221
222 public static NodeIterator search(String workspace, String statement, String language) throws InvalidQueryException, RepositoryException{
223 Session session = MgnlContext.getJCRSession(workspace);
224 QueryManager manager = session.getWorkspace().getQueryManager();
225 Query query = manager.createQuery(statement, language);
226
227 return NodeUtil.filterDuplicates(query.execute().getNodes());
228 }
229
230
231
232
233
234
235
236
237
238
239
240
241
242 public static NodeIterator search(String workspace, String statement) throws InvalidQueryException, RepositoryException{
243 return search(workspace, statement, javax.jcr.query.Query.JCR_SQL2);
244 }
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259 public static NodeIterator search(String workspace, String statement, String language, String returnItemType) throws LoginException, RepositoryException{
260 return search(workspace, statement, language, returnItemType, false);
261 }
262
263
264
265
266
267
268
269
270
271
272 public static NodeIterator search(String workspace, String statement, String language, String returnItemType, boolean isSelector) throws RepositoryException {
273 Session session = MgnlContext.getJCRSession(workspace);
274 QueryManager manager = session.getWorkspace().getQueryManager();
275 Query query = manager.createQuery(statement, language);
276 QueryResult result = query.execute();
277
278 if (isSelector) {
279 return NodeUtil.filterDuplicates(NodeUtil.filterParentNodeType(result.getRows(), returnItemType));
280 }
281 return NodeUtil.filterDuplicates(NodeUtil.filterParentNodeType(result.getNodes(), returnItemType));
282 }
283
284
285
286
287
288
289
290 public static String buildQuery (String statement, String startPath){
291 Set<String> arguments = new HashSet<String>(Arrays.asList(StringUtils.splitByWholeSeparator(statement, ",")));
292
293 Iterator<String> argIt = arguments.iterator();
294 String queryString = "select * from [nt:base] as t where ISDESCENDANTNODE(["+startPath+"])";
295 while(argIt.hasNext()){
296 queryString = queryString + " AND contains(t.*, '"+argIt.next()+"')";
297 }
298 log.debug("query string: " + queryString);
299 return queryString;
300 }
301 }