001    /**
002     * Copyright (c) 2000-2013 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.jpa;
016    
017    import com.liferay.portal.kernel.dao.orm.LockMode;
018    import com.liferay.portal.kernel.dao.orm.ORMException;
019    import com.liferay.portal.kernel.dao.orm.Query;
020    import com.liferay.portal.kernel.dao.orm.SQLQuery;
021    import com.liferay.portal.kernel.dao.orm.Session;
022    
023    import java.io.Serializable;
024    
025    import java.sql.Connection;
026    
027    import java.util.Date;
028    import java.util.HashSet;
029    import java.util.List;
030    import java.util.Map;
031    import java.util.Set;
032    
033    import javax.persistence.EntityManager;
034    import javax.persistence.FlushModeType;
035    import javax.persistence.LockModeType;
036    import javax.persistence.Parameter;
037    import javax.persistence.PersistenceContext;
038    import javax.persistence.TemporalType;
039    
040    /**
041     * @author Prashant Dighe
042     * @author Brian Wing Shun Chan
043     * @author Shuyang Zhou
044     */
045    public class SessionImpl implements Session {
046    
047            public void clear() throws ORMException {
048                    try {
049                            entityManager.clear();
050                    }
051                    catch (Exception e) {
052                            throw ExceptionTranslator.translate(e);
053                    }
054            }
055    
056            public Connection close() throws ORMException {
057                    return null;
058            }
059    
060            public boolean contains(Object object) throws ORMException {
061                    try {
062                            return entityManager.contains(object);
063                    }
064                    catch (Exception e) {
065                            throw ExceptionTranslator.translate(e);
066                    }
067            }
068    
069            public Query createQuery(String queryString) throws ORMException {
070                    return createQuery(queryString, true);
071            }
072    
073            public Query createQuery(String queryString, boolean strictName)
074                    throws ORMException {
075    
076                    return new QueryImpl(this, queryString, strictName);
077            }
078    
079            public SQLQuery createSQLQuery(String queryString) throws ORMException {
080                    return createSQLQuery(queryString, true);
081            }
082    
083            public SQLQuery createSQLQuery(String queryString, boolean strictName)
084                    throws ORMException {
085    
086                    return new SQLQueryImpl(this, queryString, strictName);
087            }
088    
089            public void delete(Object object) throws ORMException {
090                    try {
091                            entityManager.remove(entityManager.merge(object));
092                    }
093                    catch (Exception e) {
094                            throw ExceptionTranslator.translate(e);
095                    }
096            }
097    
098            public void evict(Object object) throws ORMException {
099            }
100    
101            public void flush() throws ORMException {
102                    try {
103                            entityManager.flush();
104                    }
105                    catch (Exception e) {
106                            throw ExceptionTranslator.translate(e);
107                    }
108            }
109    
110            public Object get(Class<?> clazz, Serializable id) throws ORMException {
111                    try {
112                            return entityManager.find(clazz, id);
113                    }
114                    catch (Exception e) {
115                            throw ExceptionTranslator.translate(e);
116                    }
117            }
118    
119            public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
120                    throws ORMException {
121    
122                    try {
123                            Object entity = entityManager.find(clazz, id);
124    
125                            javax.persistence.LockModeType lockModeType =
126                                    LockModeTranslator.translate(lockMode);
127    
128                            if (lockModeType != null) {
129                                    entityManager.lock(entity, lockModeType);
130                            }
131    
132                            return entity;
133                    }
134                    catch (Exception e) {
135                            throw ExceptionTranslator.translate(e);
136                    }
137            }
138    
139            public Object getWrappedSession() throws ORMException {
140                    return entityManager;
141            }
142    
143            public Object load(Class<?> clazz, Serializable id) throws ORMException {
144                    try {
145                            return entityManager.getReference(clazz, id);
146                    }
147                    catch (Exception e) {
148                            throw ExceptionTranslator.translate(e);
149                    }
150            }
151    
152            public Object merge(Object object) throws ORMException {
153                    try {
154                            return entityManager.merge(object);
155                    }
156                    catch (Exception e) {
157                            throw ExceptionTranslator.translate(e);
158                    }
159            }
160    
161            public Serializable save(Object object) throws ORMException {
162                    try {
163                            entityManager.persist(object);
164    
165                            // Hibernate returns generated idenitfier which is not used anywhere
166    
167                            return null;
168                    }
169                    catch (Exception e) {
170                            throw ExceptionTranslator.translate(e);
171                    }
172            }
173    
174            public void saveOrUpdate(Object object) throws ORMException {
175                    try {
176                            entityManager.merge(object);
177                    }
178                    catch (Exception e) {
179                            throw ExceptionTranslator.translate(e);
180                    }
181            }
182    
183            protected int executeUpdate(
184                    String queryString, Map<Integer, Object> positionalParameterMap,
185                    Map<String, Object> namedParameterMap, boolean strictName,
186                    int firstResult, int maxResults, FlushModeType flushMode,
187                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
188    
189                    javax.persistence.Query query = _getExecutableQuery(
190                            queryString, positionalParameterMap, namedParameterMap, strictName,
191                            firstResult, maxResults, flushMode, lockModeType, sqlQuery,
192                            entityClass);
193    
194                    return query.executeUpdate();
195            }
196    
197            protected List<?> list(
198                    String queryString, Map<Integer, Object> positionalParameterMap,
199                    Map<String, Object> namedParameterMap, boolean strictName,
200                    int firstResult, int maxResults, FlushModeType flushMode,
201                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
202    
203                    javax.persistence.Query query = _getExecutableQuery(
204                            queryString, positionalParameterMap, namedParameterMap, strictName,
205                            firstResult, maxResults, flushMode, lockModeType, sqlQuery,
206                            entityClass);
207    
208                    return query.getResultList();
209            }
210    
211            protected Object uniqueResult(
212                    String queryString, Map<Integer, Object> positionalParameterMap,
213                    Map<String, Object> namedParameterMap, boolean strictName,
214                    int firstResult, int maxResults, FlushModeType flushMode,
215                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
216    
217                    javax.persistence.Query query = _getExecutableQuery(
218                            queryString, positionalParameterMap, namedParameterMap, strictName,
219                            firstResult, maxResults, flushMode, lockModeType, sqlQuery,
220                            entityClass);
221    
222                    return query.getSingleResult();
223    
224            }
225    
226            @PersistenceContext
227            protected EntityManager entityManager;
228    
229            private javax.persistence.Query _getExecutableQuery(
230                    String queryString, Map<Integer, Object> positionalParameterMap,
231                    Map<String, Object> namedParameterMap, boolean strictName,
232                    int firstResult, int maxResults, FlushModeType flushMode,
233                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
234    
235                    javax.persistence.Query query = null;
236    
237                    if (sqlQuery) {
238                            if (entityClass != null) {
239                                    query = entityManager.createNativeQuery(
240                                            queryString, entityClass);
241                            }
242                            else {
243                                    query = entityManager.createNativeQuery(queryString);
244                            }
245                    }
246                    else {
247                            query = entityManager.createQuery(queryString);
248                    }
249    
250                    _setParameters(
251                            query, positionalParameterMap, namedParameterMap, strictName);
252    
253                    if (firstResult != -1) {
254                            query.setFirstResult(firstResult);
255                    }
256    
257                    if (maxResults != -1) {
258                            query.setMaxResults(maxResults);
259                    }
260    
261                    if (flushMode != null) {
262                            query.setFlushMode(flushMode);
263                    }
264    
265                    if (lockModeType != null) {
266                            query.setLockMode(lockModeType);
267                    }
268    
269                    return query;
270            }
271    
272            private void _setParameters(
273                    javax.persistence.Query query,
274                    Map<Integer, Object> positionalParameterMap,
275                    Map<String, Object> namedParameterMap, boolean strictName) {
276    
277                    for (Map.Entry<Integer, Object> entry :
278                                    positionalParameterMap.entrySet()) {
279    
280                            int position = entry.getKey() + 1;
281                            Object value = entry.getValue();
282    
283                            if (value instanceof Date) {
284                                    query.setParameter(
285                                            position, (Date)value, TemporalType.TIMESTAMP);
286                            }
287                            else {
288                                    query.setParameter(position, value);
289                            }
290                    }
291    
292                    if (!strictName) {
293                            Set<Parameter<?>> parameters = query.getParameters();
294    
295                            Set<String> parameterNames = new HashSet<String>();
296    
297                            if (parameters != null) {
298                                    for (Parameter<?> parameter : parameters) {
299                                            String parameterName = parameter.getName();
300    
301                                            if (parameterName != null) {
302                                                    parameterNames.add(parameterName);
303                                            }
304                                    }
305                            }
306    
307                            namedParameterMap.keySet().retainAll(parameterNames);
308                    }
309    
310                    for (Map.Entry<String, Object> entry : namedParameterMap.entrySet()) {
311                            String name = entry.getKey();
312                            Object value = entry.getValue();
313    
314                            if (value instanceof Date) {
315                                    query.setParameter(name, (Date)value, TemporalType.TIMESTAMP);
316                            }
317                            else {
318                                    query.setParameter(name, value);
319                            }
320                    }
321            }
322    
323    }