1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.dao.orm.jpa;
16  
17  import com.liferay.portal.kernel.dao.orm.LockMode;
18  import com.liferay.portal.kernel.dao.orm.ORMException;
19  import com.liferay.portal.kernel.dao.orm.Query;
20  import com.liferay.portal.kernel.dao.orm.SQLQuery;
21  import com.liferay.portal.kernel.dao.orm.Session;
22  
23  import java.io.Serializable;
24  
25  import java.sql.Connection;
26  
27  import java.util.Date;
28  import java.util.List;
29  import java.util.Map;
30  
31  import javax.persistence.EntityManager;
32  import javax.persistence.FlushModeType;
33  import javax.persistence.PersistenceContext;
34  import javax.persistence.TemporalType;
35  
36  /**
37   * <a href="SessionImpl.java.html"><b><i>View Source</i></b></a>
38   *
39   * @author Prashant Dighe
40   * @author Brian Wing Shun Chan
41   */
42  public class SessionImpl implements Session {
43  
44      public void clear() throws ORMException {
45          try {
46              _entityManager.clear();
47          }
48          catch (Exception e) {
49              throw ExceptionTranslator.translate(e);
50          }
51      }
52  
53      public Connection close() throws ORMException {
54          return null;
55      }
56  
57      public boolean contains(Object object) throws ORMException {
58          try {
59              return _entityManager.contains(object);
60          }
61          catch (Exception e) {
62              throw ExceptionTranslator.translate(e);
63          }
64      }
65  
66      public Query createQuery(String queryString) throws ORMException {
67          return new QueryImpl(this, queryString);
68      }
69  
70      public SQLQuery createSQLQuery(String queryString) throws ORMException {
71          return new SQLQueryImpl(this, queryString);
72      }
73  
74      public void delete(Object object) throws ORMException {
75          try {
76              _entityManager.remove(_entityManager.merge(object));
77          }
78          catch (Exception e) {
79              throw ExceptionTranslator.translate(e);
80          }
81      }
82  
83      public void evict(Object object) throws ORMException {
84      }
85  
86      public void flush() throws ORMException {
87          try {
88              _entityManager.flush();
89          }
90          catch (Exception e) {
91              throw ExceptionTranslator.translate(e);
92          }
93      }
94  
95      public Object get(Class<?> clazz, Serializable id) throws ORMException {
96          try {
97              return _entityManager.find(clazz, id);
98          }
99          catch (Exception e) {
100             throw ExceptionTranslator.translate(e);
101         }
102     }
103 
104     public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
105         throws ORMException {
106 
107         try {
108             Object entity = _entityManager.find(clazz, id);
109 
110             javax.persistence.LockModeType lockModeType =
111                 LockModeTranslator.translate(lockMode);
112 
113             if (lockModeType != null) {
114                 _entityManager.lock(entity, lockModeType);
115             }
116 
117             return entity;
118         }
119         catch (Exception e) {
120             throw ExceptionTranslator.translate(e);
121         }
122     }
123 
124     public Object getWrappedSession() throws ORMException {
125         return _entityManager;
126     }
127 
128     public Object load(Class<?> clazz, Serializable id) throws ORMException {
129         try {
130             return _entityManager.getReference(clazz, id);
131         }
132         catch (Exception e) {
133             throw ExceptionTranslator.translate(e);
134         }
135     }
136 
137     public Object merge(Object object) throws ORMException {
138         try {
139             return _entityManager.merge(object);
140         }
141         catch (Exception e) {
142             throw ExceptionTranslator.translate(e);
143         }
144     }
145 
146     public Serializable save(Object object) throws ORMException {
147         try {
148             _entityManager.persist(object);
149 
150             // Hibernate returns generated idenitfier which is not used
151             // anywhere
152 
153             return null;
154         }
155         catch (Exception e) {
156             throw ExceptionTranslator.translate(e);
157         }
158     }
159 
160     public void saveOrUpdate(Object object) throws ORMException {
161         try {
162             _entityManager.merge(object);
163         }
164         catch (Exception e) {
165             throw ExceptionTranslator.translate(e);
166         }
167     }
168 
169     protected int executeUpdate(
170         String queryString, Map<Integer, Object> parameterMap,
171         int firstResult, int maxResults, FlushModeType flushMode,
172         boolean sqlQuery, Class<?> entityClass) {
173 
174         javax.persistence.Query query = _getExecutableQuery(
175             queryString, parameterMap, firstResult, maxResults,
176             flushMode, sqlQuery, entityClass);
177 
178         return query.executeUpdate();
179     }
180 
181     protected List<?> list(
182         String queryString, Map<Integer, Object> parameterMap, int firstResult,
183         int maxResults, FlushModeType flushMode, boolean sqlQuery,
184         Class<?> entityClass) {
185 
186         javax.persistence.Query query = _getExecutableQuery(
187             queryString, parameterMap, firstResult, maxResults,
188             flushMode, sqlQuery, entityClass);
189 
190         return query.getResultList();
191     }
192 
193     protected Object uniqueResult(
194         String queryString, Map<Integer, Object> parameterMap, int firstResult,
195         int maxResults, FlushModeType flushMode, boolean sqlQuery,
196         Class<?> entityClass) {
197 
198         javax.persistence.Query query = _getExecutableQuery(
199             queryString, parameterMap, firstResult, maxResults,
200             flushMode, sqlQuery, entityClass);
201 
202         return query.getSingleResult();
203 
204     }
205 
206     private javax.persistence.Query _getExecutableQuery(
207         String queryString, Map<Integer, Object> parameterMap,
208         int firstResult, int maxResults, FlushModeType flushMode,
209         boolean sqlQuery, Class<?> entityClass) {
210 
211         javax.persistence.Query query = null;
212 
213         if (sqlQuery) {
214             if (entityClass != null) {
215                 query = _entityManager.createNativeQuery(
216                     queryString, entityClass);
217             }
218             else {
219                 query = _entityManager.createNativeQuery(queryString);
220             }
221         }
222         else {
223             query = _entityManager.createQuery(queryString);
224         }
225 
226         _setParameters(query, parameterMap);
227 
228         if (firstResult != -1) {
229             query.setFirstResult(firstResult);
230         }
231 
232         if (maxResults != -1) {
233             query.setMaxResults(maxResults);
234         }
235 
236         if (flushMode != null) {
237             query.setFlushMode(flushMode);
238         }
239 
240         return query;
241     }
242 
243     private void _setParameters(
244         javax.persistence.Query query, Map<Integer, Object> parameterMap) {
245 
246         for(Map.Entry<Integer, Object> entry : parameterMap.entrySet()) {
247             int position = entry.getKey() + 1;
248 
249             Object value = entry.getValue();
250 
251             if (value instanceof Date) {
252                 query.setParameter(
253                     position, (Date)value, TemporalType.TIMESTAMP);
254             }
255             else {
256                 query.setParameter(position, value);
257             }
258         }
259     }
260 
261     @PersistenceContext
262     protected EntityManager _entityManager;
263 
264 }