1
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
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
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 }