001    /**
002     * Copyright (c) 2000-2012 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
166                            // anywhere
167    
168                            return null;
169                    }
170                    catch (Exception e) {
171                            throw ExceptionTranslator.translate(e);
172                    }
173            }
174    
175            public void saveOrUpdate(Object object) throws ORMException {
176                    try {
177                            entityManager.merge(object);
178                    }
179                    catch (Exception e) {
180                            throw ExceptionTranslator.translate(e);
181                    }
182            }
183    
184            protected int executeUpdate(
185                    String queryString, Map<Integer, Object> positionalParameterMap,
186                    Map<String, Object> namedParameterMap, boolean strictName,
187                    int firstResult, int maxResults, FlushModeType flushMode,
188                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
189    
190                    javax.persistence.Query query = _getExecutableQuery(
191                            queryString, positionalParameterMap, namedParameterMap, strictName,
192                            firstResult, maxResults, flushMode, lockModeType, sqlQuery,
193                            entityClass);
194    
195                    return query.executeUpdate();
196            }
197    
198            protected List<?> list(
199                    String queryString, Map<Integer, Object> positionalParameterMap,
200                    Map<String, Object> namedParameterMap, boolean strictName,
201                    int firstResult, int maxResults, FlushModeType flushMode,
202                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
203    
204                    javax.persistence.Query query = _getExecutableQuery(
205                            queryString, positionalParameterMap, namedParameterMap, strictName,
206                            firstResult, maxResults, flushMode, lockModeType, sqlQuery,
207                            entityClass);
208    
209                    return query.getResultList();
210            }
211    
212            protected Object uniqueResult(
213                    String queryString, Map<Integer, Object> positionalParameterMap,
214                    Map<String, Object> namedParameterMap, boolean strictName,
215                    int firstResult, int maxResults, FlushModeType flushMode,
216                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
217    
218                    javax.persistence.Query query = _getExecutableQuery(
219                            queryString, positionalParameterMap, namedParameterMap, strictName,
220                            firstResult, maxResults, flushMode, lockModeType, sqlQuery,
221                            entityClass);
222    
223                    return query.getSingleResult();
224    
225            }
226    
227            @PersistenceContext
228            protected EntityManager entityManager;
229    
230            private javax.persistence.Query _getExecutableQuery(
231                    String queryString, Map<Integer, Object> positionalParameterMap,
232                    Map<String, Object> namedParameterMap, boolean strictName,
233                    int firstResult, int maxResults, FlushModeType flushMode,
234                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
235    
236                    javax.persistence.Query query = null;
237    
238                    if (sqlQuery) {
239                            if (entityClass != null) {
240                                    query = entityManager.createNativeQuery(
241                                            queryString, entityClass);
242                            }
243                            else {
244                                    query = entityManager.createNativeQuery(queryString);
245                            }
246                    }
247                    else {
248                            query = entityManager.createQuery(queryString);
249                    }
250    
251                    _setParameters(
252                            query, positionalParameterMap, namedParameterMap, strictName);
253    
254                    if (firstResult != -1) {
255                            query.setFirstResult(firstResult);
256                    }
257    
258                    if (maxResults != -1) {
259                            query.setMaxResults(maxResults);
260                    }
261    
262                    if (flushMode != null) {
263                            query.setFlushMode(flushMode);
264                    }
265    
266                    if (lockModeType != null) {
267                            query.setLockMode(lockModeType);
268                    }
269    
270                    return query;
271            }
272    
273            private void _setParameters(
274                    javax.persistence.Query query,
275                    Map<Integer, Object> positionalParameterMap,
276                    Map<String, Object> namedParameterMap, boolean strictName) {
277    
278                    for (Map.Entry<Integer, Object> entry :
279                                    positionalParameterMap.entrySet()) {
280    
281                            int position = entry.getKey() + 1;
282                            Object value = entry.getValue();
283    
284                            if (value instanceof Date) {
285                                    query.setParameter(
286                                            position, (Date)value, TemporalType.TIMESTAMP);
287                            }
288                            else {
289                                    query.setParameter(position, value);
290                            }
291                    }
292    
293                    if (!strictName) {
294                            Set<Parameter<?>> parameters = query.getParameters();
295    
296                            Set<String> parameterNames = new HashSet<String>();
297    
298                            if (parameters != null) {
299                                    for (Parameter<?> parameter : parameters) {
300                                            String parameterName = parameter.getName();
301    
302                                            if (parameterName != null) {
303                                                    parameterNames.add(parameterName);
304                                            }
305                                    }
306                            }
307    
308                            namedParameterMap.keySet().retainAll(parameterNames);
309                    }
310    
311                    for (Map.Entry<String, Object> entry : namedParameterMap.entrySet()) {
312                            String name = entry.getKey();
313                            Object value = entry.getValue();
314    
315                            if (value instanceof Date) {
316                                    query.setParameter(name, (Date)value, TemporalType.TIMESTAMP);
317                            }
318                            else {
319                                    query.setParameter(name, value);
320                            }
321                    }
322            }
323    
324    }