001
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
045 public class SessionImpl implements Session {
046
047 @Override
048 public void clear() throws ORMException {
049 try {
050 entityManager.clear();
051 }
052 catch (Exception e) {
053 throw ExceptionTranslator.translate(e);
054 }
055 }
056
057 @Override
058 public Connection close() throws ORMException {
059 return null;
060 }
061
062 @Override
063 public boolean contains(Object object) throws ORMException {
064 try {
065 return entityManager.contains(object);
066 }
067 catch (Exception e) {
068 throw ExceptionTranslator.translate(e);
069 }
070 }
071
072 @Override
073 public Query createQuery(String queryString) throws ORMException {
074 return createQuery(queryString, true);
075 }
076
077 @Override
078 public Query createQuery(String queryString, boolean strictName)
079 throws ORMException {
080
081 return new QueryImpl(this, queryString, strictName);
082 }
083
084 @Override
085 public SQLQuery createSQLQuery(String queryString) throws ORMException {
086 return createSQLQuery(queryString, true);
087 }
088
089 @Override
090 public SQLQuery createSQLQuery(String queryString, boolean strictName)
091 throws ORMException {
092
093 return new SQLQueryImpl(this, queryString, strictName);
094 }
095
096 @Override
097 public void delete(Object object) throws ORMException {
098 try {
099 entityManager.remove(entityManager.merge(object));
100 }
101 catch (Exception e) {
102 throw ExceptionTranslator.translate(e);
103 }
104 }
105
106 @Override
107 public void evict(Object object) throws ORMException {
108 }
109
110 @Override
111 public void flush() throws ORMException {
112 try {
113 entityManager.flush();
114 }
115 catch (Exception e) {
116 throw ExceptionTranslator.translate(e);
117 }
118 }
119
120 @Override
121 public Object get(Class<?> clazz, Serializable id) throws ORMException {
122 try {
123 return entityManager.find(clazz, id);
124 }
125 catch (Exception e) {
126 throw ExceptionTranslator.translate(e);
127 }
128 }
129
130 @Override
131 public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
132 throws ORMException {
133
134 try {
135 Object entity = entityManager.find(clazz, id);
136
137 javax.persistence.LockModeType lockModeType =
138 LockModeTranslator.translate(lockMode);
139
140 if (lockModeType != null) {
141 entityManager.lock(entity, lockModeType);
142 }
143
144 return entity;
145 }
146 catch (Exception e) {
147 throw ExceptionTranslator.translate(e);
148 }
149 }
150
151 @Override
152 public Object getWrappedSession() throws ORMException {
153 return entityManager;
154 }
155
156 @Override
157 public Object load(Class<?> clazz, Serializable id) throws ORMException {
158 try {
159 return entityManager.getReference(clazz, id);
160 }
161 catch (Exception e) {
162 throw ExceptionTranslator.translate(e);
163 }
164 }
165
166 @Override
167 public Object merge(Object object) throws ORMException {
168 try {
169 return entityManager.merge(object);
170 }
171 catch (Exception e) {
172 throw ExceptionTranslator.translate(e);
173 }
174 }
175
176 @Override
177 public Serializable save(Object object) throws ORMException {
178 try {
179 entityManager.persist(object);
180
181
182
183 return null;
184 }
185 catch (Exception e) {
186 throw ExceptionTranslator.translate(e);
187 }
188 }
189
190 @Override
191 public void saveOrUpdate(Object object) throws ORMException {
192 try {
193 entityManager.merge(object);
194 }
195 catch (Exception e) {
196 throw ExceptionTranslator.translate(e);
197 }
198 }
199
200 protected int executeUpdate(
201 String queryString, Map<Integer, Object> positionalParameterMap,
202 Map<String, Object> namedParameterMap, boolean strictName,
203 int firstResult, int maxResults, FlushModeType flushMode,
204 LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
205
206 javax.persistence.Query query = _getExecutableQuery(
207 queryString, positionalParameterMap, namedParameterMap, strictName,
208 firstResult, maxResults, flushMode, lockModeType, sqlQuery,
209 entityClass);
210
211 return query.executeUpdate();
212 }
213
214 protected List<?> list(
215 String queryString, Map<Integer, Object> positionalParameterMap,
216 Map<String, Object> namedParameterMap, boolean strictName,
217 int firstResult, int maxResults, FlushModeType flushMode,
218 LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
219
220 javax.persistence.Query query = _getExecutableQuery(
221 queryString, positionalParameterMap, namedParameterMap, strictName,
222 firstResult, maxResults, flushMode, lockModeType, sqlQuery,
223 entityClass);
224
225 return query.getResultList();
226 }
227
228 protected Object uniqueResult(
229 String queryString, Map<Integer, Object> positionalParameterMap,
230 Map<String, Object> namedParameterMap, boolean strictName,
231 int firstResult, int maxResults, FlushModeType flushMode,
232 LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
233
234 javax.persistence.Query query = _getExecutableQuery(
235 queryString, positionalParameterMap, namedParameterMap, strictName,
236 firstResult, maxResults, flushMode, lockModeType, sqlQuery,
237 entityClass);
238
239 return query.getSingleResult();
240
241 }
242
243 @PersistenceContext
244 protected EntityManager entityManager;
245
246 private javax.persistence.Query _getExecutableQuery(
247 String queryString, Map<Integer, Object> positionalParameterMap,
248 Map<String, Object> namedParameterMap, boolean strictName,
249 int firstResult, int maxResults, FlushModeType flushMode,
250 LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
251
252 javax.persistence.Query query = null;
253
254 if (sqlQuery) {
255 if (entityClass != null) {
256 query = entityManager.createNativeQuery(
257 queryString, entityClass);
258 }
259 else {
260 query = entityManager.createNativeQuery(queryString);
261 }
262 }
263 else {
264 query = entityManager.createQuery(queryString);
265 }
266
267 _setParameters(
268 query, positionalParameterMap, namedParameterMap, strictName);
269
270 if (firstResult != -1) {
271 query.setFirstResult(firstResult);
272 }
273
274 if (maxResults != -1) {
275 query.setMaxResults(maxResults);
276 }
277
278 if (flushMode != null) {
279 query.setFlushMode(flushMode);
280 }
281
282 if (lockModeType != null) {
283 query.setLockMode(lockModeType);
284 }
285
286 return query;
287 }
288
289 private void _setParameters(
290 javax.persistence.Query query,
291 Map<Integer, Object> positionalParameterMap,
292 Map<String, Object> namedParameterMap, boolean strictName) {
293
294 for (Map.Entry<Integer, Object> entry :
295 positionalParameterMap.entrySet()) {
296
297 int position = entry.getKey() + 1;
298 Object value = entry.getValue();
299
300 if (value instanceof Date) {
301 query.setParameter(
302 position, (Date)value, TemporalType.TIMESTAMP);
303 }
304 else {
305 query.setParameter(position, value);
306 }
307 }
308
309 if (!strictName) {
310 Set<Parameter<?>> parameters = query.getParameters();
311
312 Set<String> parameterNames = new HashSet<String>();
313
314 if (parameters != null) {
315 for (Parameter<?> parameter : parameters) {
316 String parameterName = parameter.getName();
317
318 if (parameterName != null) {
319 parameterNames.add(parameterName);
320 }
321 }
322 }
323
324 namedParameterMap.keySet().retainAll(parameterNames);
325 }
326
327 for (Map.Entry<String, Object> entry : namedParameterMap.entrySet()) {
328 String name = entry.getKey();
329 Object value = entry.getValue();
330
331 if (value instanceof Date) {
332 query.setParameter(name, (Date)value, TemporalType.TIMESTAMP);
333 }
334 else {
335 query.setParameter(name, value);
336 }
337 }
338 }
339
340 }