001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.dao.orm.hibernate;
016    
017    import com.liferay.portal.kernel.dao.orm.CacheMode;
018    import com.liferay.portal.kernel.dao.orm.LockMode;
019    import com.liferay.portal.kernel.dao.orm.ORMException;
020    import com.liferay.portal.kernel.dao.orm.Query;
021    import com.liferay.portal.kernel.dao.orm.SQLQuery;
022    import com.liferay.portal.kernel.dao.orm.ScrollableResults;
023    import com.liferay.portal.kernel.dao.orm.Type;
024    import com.liferay.portal.kernel.security.pacl.DoPrivileged;
025    import com.liferay.portal.kernel.security.pacl.NotPrivileged;
026    import com.liferay.portal.kernel.util.ListUtil;
027    
028    import java.io.Serializable;
029    
030    import java.sql.Timestamp;
031    
032    import java.util.Arrays;
033    import java.util.Collections;
034    import java.util.Iterator;
035    import java.util.List;
036    
037    /**
038     * @author Brian Wing Shun Chan
039     * @author Shuyang Zhou
040     */
041    @DoPrivileged
042    public class SQLQueryImpl implements SQLQuery {
043    
044            public SQLQueryImpl(org.hibernate.SQLQuery sqlQuery, boolean strictName) {
045                    _sqlQuery = sqlQuery;
046                    _strictName = strictName;
047    
048                    String[] names = null;
049    
050                    if (!_strictName) {
051                            names = sqlQuery.getNamedParameters();
052    
053                            Arrays.sort(names);
054                    }
055    
056                    _names = names;
057            }
058    
059            @Override
060            public SQLQuery addEntity(String alias, Class<?> entityClass) {
061                    _sqlQuery.addEntity(alias, entityClass);
062    
063                    return this;
064            }
065    
066            @Override
067            public SQLQuery addScalar(String columnAlias, Type type) {
068                    _sqlQuery.addScalar(columnAlias, TypeTranslator.translate(type));
069    
070                    return this;
071            }
072    
073            @Override
074            public SQLQuery addSynchronizedEntityClass(Class<?> entityClass) {
075                    _sqlQuery.addSynchronizedEntityClass(entityClass);
076    
077                    return this;
078            }
079    
080            @Override
081            public SQLQuery addSynchronizedEntityClasses(Class<?>... entityClasses) {
082                    for (Class<?> entityClass : entityClasses) {
083                            _sqlQuery.addSynchronizedEntityClass(entityClass);
084                    }
085    
086                    return this;
087            }
088    
089            @Override
090            public SQLQuery addSynchronizedEntityName(String entityName) {
091                    _sqlQuery.addSynchronizedEntityName(entityName);
092    
093                    return this;
094            }
095    
096            @Override
097            public SQLQuery addSynchronizedEntityNames(String... entityNames) {
098                    for (String entityName : entityNames) {
099                            _sqlQuery.addSynchronizedEntityName(entityName);
100                    }
101    
102                    return this;
103            }
104    
105            @Override
106            public SQLQuery addSynchronizedQuerySpace(String querySpace) {
107                    _sqlQuery.addSynchronizedQuerySpace(querySpace);
108    
109                    return this;
110            }
111    
112            @Override
113            public SQLQuery addSynchronizedQuerySpaces(String... querySpaces) {
114                    for (String querySpace : querySpaces) {
115                            _sqlQuery.addSynchronizedQuerySpace(querySpace);
116                    }
117    
118                    return this;
119            }
120    
121            @NotPrivileged
122            @Override
123            public int executeUpdate() throws ORMException {
124                    try {
125                            return _sqlQuery.executeUpdate();
126                    }
127                    catch (Exception e) {
128                            throw ExceptionTranslator.translate(e);
129                    }
130            }
131    
132            @NotPrivileged
133            @Override
134            @SuppressWarnings("rawtypes")
135            public Iterator iterate() throws ORMException {
136                    return iterate(true);
137            }
138    
139            @NotPrivileged
140            @Override
141            @SuppressWarnings("rawtypes")
142            public Iterator iterate(boolean unmodifiable) throws ORMException {
143                    try {
144                            return list(unmodifiable).iterator();
145                    }
146                    catch (Exception e) {
147                            throw ExceptionTranslator.translate(e);
148                    }
149            }
150    
151            @NotPrivileged
152            @Override
153            public Object iterateNext() throws ORMException {
154                    Iterator<?> iterator = iterate(false);
155    
156                    if (iterator.hasNext()) {
157                            return iterator.next();
158                    }
159    
160                    return null;
161            }
162    
163            @NotPrivileged
164            @Override
165            public List<?> list() throws ORMException {
166                    return list(false, false);
167            }
168    
169            @NotPrivileged
170            @Override
171            public List<?> list(boolean unmodifiable) throws ORMException {
172                    return list(true, unmodifiable);
173            }
174    
175            @NotPrivileged
176            @Override
177            public List<?> list(boolean copy, boolean unmodifiable)
178                    throws ORMException {
179    
180                    try {
181                            List<?> list = _sqlQuery.list();
182    
183                            if (unmodifiable) {
184                                    list = Collections.unmodifiableList(list);
185                            }
186                            else if (copy) {
187                                    list = ListUtil.copy(list);
188                            }
189    
190                            return list;
191                    }
192                    catch (Exception e) {
193                            throw ExceptionTranslator.translate(e);
194                    }
195            }
196    
197            @NotPrivileged
198            @Override
199            public ScrollableResults scroll() throws ORMException {
200                    try {
201                            return new ScrollableResultsImpl(_sqlQuery.scroll());
202                    }
203                    catch (Exception e) {
204                            throw ExceptionTranslator.translate(e);
205                    }
206            }
207    
208            @Override
209            public Query setBoolean(int pos, boolean value) {
210                    _sqlQuery.setBoolean(pos, value);
211    
212                    return this;
213            }
214    
215            @Override
216            public Query setBoolean(String name, boolean value) {
217                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
218                            return this;
219                    }
220    
221                    _sqlQuery.setBoolean(name, value);
222    
223                    return this;
224            }
225    
226            @Override
227            public Query setCacheable(boolean cacheable) {
228                    _sqlQuery.setCacheable(cacheable);
229    
230                    return this;
231            }
232    
233            @Override
234            public Query setCacheMode(CacheMode cacheMode) {
235                    _sqlQuery.setCacheMode(CacheModeTranslator.translate(cacheMode));
236    
237                    return this;
238            }
239    
240            @Override
241            public Query setCacheRegion(String cacheRegion) {
242                    _sqlQuery.setCacheRegion(cacheRegion);
243    
244                    return this;
245            }
246    
247            @Override
248            public Query setDouble(int pos, double value) {
249                    _sqlQuery.setDouble(pos, value);
250    
251                    return this;
252            }
253    
254            @Override
255            public Query setDouble(String name, double value) {
256                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
257                            return this;
258                    }
259    
260                    _sqlQuery.setDouble(name, value);
261    
262                    return this;
263            }
264    
265            @Override
266            public Query setFirstResult(int firstResult) {
267                    _sqlQuery.setFirstResult(firstResult);
268    
269                    return this;
270            }
271    
272            @Override
273            public Query setFloat(int pos, float value) {
274                    _sqlQuery.setFloat(pos, value);
275    
276                    return this;
277            }
278    
279            @Override
280            public Query setFloat(String name, float value) {
281                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
282                            return this;
283                    }
284    
285                    _sqlQuery.setFloat(name, value);
286    
287                    return this;
288            }
289    
290            @Override
291            public Query setInteger(int pos, int value) {
292                    _sqlQuery.setInteger(pos, value);
293    
294                    return this;
295            }
296    
297            @Override
298            public Query setInteger(String name, int value) {
299                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
300                            return this;
301                    }
302    
303                    _sqlQuery.setInteger(name, value);
304    
305                    return this;
306            }
307    
308            @Override
309            public Query setLockMode(String alias, LockMode lockMode) {
310                    _sqlQuery.setLockMode(alias, LockModeTranslator.translate(lockMode));
311    
312                    return this;
313            }
314    
315            @Override
316            public Query setLong(int pos, long value) {
317                    _sqlQuery.setLong(pos, value);
318    
319                    return this;
320            }
321    
322            @Override
323            public Query setLong(String name, long value) {
324                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
325                            return this;
326                    }
327    
328                    _sqlQuery.setLong(name, value);
329    
330                    return this;
331            }
332    
333            @Override
334            public Query setMaxResults(int maxResults) {
335                    _sqlQuery.setMaxResults(maxResults);
336    
337                    return this;
338            }
339    
340            @Override
341            public Query setSerializable(int pos, Serializable value) {
342                    _sqlQuery.setSerializable(pos, value);
343    
344                    return this;
345            }
346    
347            @Override
348            public Query setSerializable(String name, Serializable value) {
349                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
350                            return this;
351                    }
352    
353                    _sqlQuery.setSerializable(name, value);
354    
355                    return this;
356            }
357    
358            @Override
359            public Query setShort(int pos, short value) {
360                    _sqlQuery.setShort(pos, value);
361    
362                    return this;
363            }
364    
365            @Override
366            public Query setShort(String name, short value) {
367                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
368                            return this;
369                    }
370    
371                    _sqlQuery.setShort(name, value);
372    
373                    return this;
374            }
375    
376            @Override
377            public Query setString(int pos, String value) {
378                    _sqlQuery.setString(pos, value);
379    
380                    return this;
381            }
382    
383            @Override
384            public Query setString(String name, String value) {
385                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
386                            return this;
387                    }
388    
389                    _sqlQuery.setString(name, value);
390    
391                    return this;
392            }
393    
394            @Override
395            public Query setTimestamp(int pos, Timestamp value) {
396                    _sqlQuery.setTimestamp(pos, value);
397    
398                    return this;
399            }
400    
401            @Override
402            public Query setTimestamp(String name, Timestamp value) {
403                    if (!_strictName && (Arrays.binarySearch(_names, name) < 0)) {
404                            return this;
405                    }
406    
407                    _sqlQuery.setTimestamp(name, value);
408    
409                    return this;
410            }
411    
412            @NotPrivileged
413            @Override
414            public Object uniqueResult() throws ORMException {
415                    try {
416                            return _sqlQuery.uniqueResult();
417                    }
418                    catch (Exception e) {
419                            throw ExceptionTranslator.translate(e);
420                    }
421            }
422    
423            private final String[] _names;
424            private final org.hibernate.SQLQuery _sqlQuery;
425            private final boolean _strictName;
426    
427    }