001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
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            private javax.persistence.Query _getExecutableQuery(
228                    String queryString, Map<Integer, Object> positionalParameterMap,
229                    Map<String, Object> namedParameterMap, boolean strictName,
230                    int firstResult, int maxResults, FlushModeType flushMode,
231                    LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
232    
233                    javax.persistence.Query query = null;
234    
235                    if (sqlQuery) {
236                            if (entityClass != null) {
237                                    query = _entityManager.createNativeQuery(
238                                            queryString, entityClass);
239                            }
240                            else {
241                                    query = _entityManager.createNativeQuery(queryString);
242                            }
243                    }
244                    else {
245                            query = _entityManager.createQuery(queryString);
246                    }
247    
248                    _setParameters(
249                            query, positionalParameterMap, namedParameterMap, strictName);
250    
251                    if (firstResult != -1) {
252                            query.setFirstResult(firstResult);
253                    }
254    
255                    if (maxResults != -1) {
256                            query.setMaxResults(maxResults);
257                    }
258    
259                    if (flushMode != null) {
260                            query.setFlushMode(flushMode);
261                    }
262    
263                    if (lockModeType != null) {
264                            query.setLockMode(lockModeType);
265                    }
266    
267                    return query;
268            }
269    
270            private void _setParameters(
271                    javax.persistence.Query query,
272                    Map<Integer, Object> positionalParameterMap,
273                    Map<String, Object> namedParameterMap, boolean strictName) {
274    
275                    for (Map.Entry<Integer, Object> entry :
276                                    positionalParameterMap.entrySet()) {
277    
278                            int position = entry.getKey() + 1;
279                            Object value = entry.getValue();
280    
281                            if (value instanceof Date) {
282                                    query.setParameter(
283                                            position, (Date)value, TemporalType.TIMESTAMP);
284                            }
285                            else {
286                                    query.setParameter(position, value);
287                            }
288                    }
289    
290                    if (!strictName) {
291                            Set<Parameter<?>> parameters = query.getParameters();
292    
293                            Set<String> parameterNames = new HashSet<String>();
294    
295                            if (parameters != null) {
296                                    for (Parameter<?> parameter : parameters) {
297                                            String parameterName = parameter.getName();
298    
299                                            if (parameterName != null) {
300                                                    parameterNames.add(parameterName);
301                                            }
302                                    }
303                            }
304    
305                            namedParameterMap.keySet().retainAll(parameterNames);
306                    }
307    
308                    for (Map.Entry<String, Object> entry : namedParameterMap.entrySet()) {
309                            String name = entry.getKey();
310                            Object value = entry.getValue();
311    
312                            if (value instanceof Date) {
313                                    query.setParameter(name, (Date)value, TemporalType.TIMESTAMP);
314                            }
315                            else {
316                                    query.setParameter(name, value);
317                            }
318                    }
319            }
320    
321            @PersistenceContext
322            protected EntityManager _entityManager;
323    
324    }