001    /**
002     * Copyright (c) 2000-2010 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.List;
029    import java.util.Map;
030    
031    import javax.persistence.EntityManager;
032    import javax.persistence.FlushModeType;
033    import javax.persistence.PersistenceContext;
034    import javax.persistence.TemporalType;
035    
036    /**
037     * @author Prashant Dighe
038     * @author Brian Wing Shun Chan
039     */
040    public class SessionImpl implements Session {
041    
042            public void clear() throws ORMException {
043                    try {
044                            _entityManager.clear();
045                    }
046                    catch (Exception e) {
047                            throw ExceptionTranslator.translate(e);
048                    }
049            }
050    
051            public Connection close() throws ORMException {
052                    return null;
053            }
054    
055            public boolean contains(Object object) throws ORMException {
056                    try {
057                            return _entityManager.contains(object);
058                    }
059                    catch (Exception e) {
060                            throw ExceptionTranslator.translate(e);
061                    }
062            }
063    
064            public Query createQuery(String queryString) throws ORMException {
065                    return new QueryImpl(this, queryString);
066            }
067    
068            public SQLQuery createSQLQuery(String queryString) throws ORMException {
069                    return new SQLQueryImpl(this, queryString);
070            }
071    
072            public void delete(Object object) throws ORMException {
073                    try {
074                            _entityManager.remove(_entityManager.merge(object));
075                    }
076                    catch (Exception e) {
077                            throw ExceptionTranslator.translate(e);
078                    }
079            }
080    
081            public void evict(Object object) throws ORMException {
082            }
083    
084            public void flush() throws ORMException {
085                    try {
086                            _entityManager.flush();
087                    }
088                    catch (Exception e) {
089                            throw ExceptionTranslator.translate(e);
090                    }
091            }
092    
093            public Object get(Class<?> clazz, Serializable id) throws ORMException {
094                    try {
095                            return _entityManager.find(clazz, id);
096                    }
097                    catch (Exception e) {
098                            throw ExceptionTranslator.translate(e);
099                    }
100            }
101    
102            public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
103                    throws ORMException {
104    
105                    try {
106                            Object entity = _entityManager.find(clazz, id);
107    
108                            javax.persistence.LockModeType lockModeType =
109                                    LockModeTranslator.translate(lockMode);
110    
111                            if (lockModeType != null) {
112                                    _entityManager.lock(entity, lockModeType);
113                            }
114    
115                            return entity;
116                    }
117                    catch (Exception e) {
118                            throw ExceptionTranslator.translate(e);
119                    }
120            }
121    
122            public Object getWrappedSession() throws ORMException {
123                    return _entityManager;
124            }
125    
126            public Object load(Class<?> clazz, Serializable id) throws ORMException {
127                    try {
128                            return _entityManager.getReference(clazz, id);
129                    }
130                    catch (Exception e) {
131                            throw ExceptionTranslator.translate(e);
132                    }
133            }
134    
135            public Object merge(Object object) throws ORMException {
136                    try {
137                            return _entityManager.merge(object);
138                    }
139                    catch (Exception e) {
140                            throw ExceptionTranslator.translate(e);
141                    }
142            }
143    
144            public Serializable save(Object object) throws ORMException {
145                    try {
146                            _entityManager.persist(object);
147    
148                            // Hibernate returns generated idenitfier which is not used
149                            // anywhere
150    
151                            return null;
152                    }
153                    catch (Exception e) {
154                            throw ExceptionTranslator.translate(e);
155                    }
156            }
157    
158            public void saveOrUpdate(Object object) throws ORMException {
159                    try {
160                            _entityManager.merge(object);
161                    }
162                    catch (Exception e) {
163                            throw ExceptionTranslator.translate(e);
164                    }
165            }
166    
167            protected int executeUpdate(
168                    String queryString, Map<Integer, Object> parameterMap,
169                    int firstResult, int maxResults, FlushModeType flushMode,
170                    boolean sqlQuery, Class<?> entityClass) {
171    
172                    javax.persistence.Query query = _getExecutableQuery(
173                            queryString, parameterMap, firstResult, maxResults,
174                            flushMode, sqlQuery, entityClass);
175    
176                    return query.executeUpdate();
177            }
178    
179            protected List<?> list(
180                    String queryString, Map<Integer, Object> parameterMap, int firstResult,
181                    int maxResults, FlushModeType flushMode, boolean sqlQuery,
182                    Class<?> entityClass) {
183    
184                    javax.persistence.Query query = _getExecutableQuery(
185                            queryString, parameterMap, firstResult, maxResults,
186                            flushMode, sqlQuery, entityClass);
187    
188                    return query.getResultList();
189            }
190    
191            protected Object uniqueResult(
192                    String queryString, Map<Integer, Object> parameterMap, int firstResult,
193                    int maxResults, FlushModeType flushMode, boolean sqlQuery,
194                    Class<?> entityClass) {
195    
196                    javax.persistence.Query query = _getExecutableQuery(
197                            queryString, parameterMap, firstResult, maxResults,
198                            flushMode, sqlQuery, entityClass);
199    
200                    return query.getSingleResult();
201    
202            }
203    
204            private javax.persistence.Query _getExecutableQuery(
205                    String queryString, Map<Integer, Object> parameterMap,
206                    int firstResult, int maxResults, FlushModeType flushMode,
207                    boolean sqlQuery, Class<?> entityClass) {
208    
209                    javax.persistence.Query query = null;
210    
211                    if (sqlQuery) {
212                            if (entityClass != null) {
213                                    query = _entityManager.createNativeQuery(
214                                            queryString, entityClass);
215                            }
216                            else {
217                                    query = _entityManager.createNativeQuery(queryString);
218                            }
219                    }
220                    else {
221                            query = _entityManager.createQuery(queryString);
222                    }
223    
224                    _setParameters(query, parameterMap);
225    
226                    if (firstResult != -1) {
227                            query.setFirstResult(firstResult);
228                    }
229    
230                    if (maxResults != -1) {
231                            query.setMaxResults(maxResults);
232                    }
233    
234                    if (flushMode != null) {
235                            query.setFlushMode(flushMode);
236                    }
237    
238                    return query;
239            }
240    
241            private void _setParameters(
242                    javax.persistence.Query query, Map<Integer, Object> parameterMap) {
243    
244                    for (Map.Entry<Integer, Object> entry : parameterMap.entrySet()) {
245                            int position = entry.getKey() + 1;
246    
247                            Object value = entry.getValue();
248    
249                            if (value instanceof Date) {
250                                    query.setParameter(
251                                            position, (Date)value, TemporalType.TIMESTAMP);
252                            }
253                            else {
254                                    query.setParameter(position, value);
255                            }
256                    }
257            }
258    
259            @PersistenceContext
260            protected EntityManager _entityManager;
261    
262    }