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 @PersistenceContext
243 protected EntityManager entityManager;
244
245 private javax.persistence.Query _getExecutableQuery(
246 String queryString, Map<Integer, Object> positionalParameterMap,
247 Map<String, Object> namedParameterMap, boolean strictName,
248 int firstResult, int maxResults, FlushModeType flushMode,
249 LockModeType lockModeType, boolean sqlQuery, Class<?> entityClass) {
250
251 javax.persistence.Query query = null;
252
253 if (sqlQuery) {
254 if (entityClass != null) {
255 query = entityManager.createNativeQuery(
256 queryString, entityClass);
257 }
258 else {
259 query = entityManager.createNativeQuery(queryString);
260 }
261 }
262 else {
263 query = entityManager.createQuery(queryString);
264 }
265
266 _setParameters(
267 query, positionalParameterMap, namedParameterMap, strictName);
268
269 if (firstResult != -1) {
270 query.setFirstResult(firstResult);
271 }
272
273 if (maxResults != -1) {
274 query.setMaxResults(maxResults);
275 }
276
277 if (flushMode != null) {
278 query.setFlushMode(flushMode);
279 }
280
281 if (lockModeType != null) {
282 query.setLockMode(lockModeType);
283 }
284
285 return query;
286 }
287
288 private void _setParameters(
289 javax.persistence.Query query,
290 Map<Integer, Object> positionalParameterMap,
291 Map<String, Object> namedParameterMap, boolean strictName) {
292
293 for (Map.Entry<Integer, Object> entry :
294 positionalParameterMap.entrySet()) {
295
296 int position = entry.getKey() + 1;
297 Object value = entry.getValue();
298
299 if (value instanceof Date) {
300 query.setParameter(
301 position, (Date)value, TemporalType.TIMESTAMP);
302 }
303 else {
304 query.setParameter(position, value);
305 }
306 }
307
308 if (!strictName) {
309 Set<Parameter<?>> parameters = query.getParameters();
310
311 Set<String> parameterNames = new HashSet<String>();
312
313 if (parameters != null) {
314 for (Parameter<?> parameter : parameters) {
315 String parameterName = parameter.getName();
316
317 if (parameterName != null) {
318 parameterNames.add(parameterName);
319 }
320 }
321 }
322
323 namedParameterMap.keySet().retainAll(parameterNames);
324 }
325
326 for (Map.Entry<String, Object> entry : namedParameterMap.entrySet()) {
327 String name = entry.getKey();
328 Object value = entry.getValue();
329
330 if (value instanceof Date) {
331 query.setParameter(name, (Date)value, TemporalType.TIMESTAMP);
332 }
333 else {
334 query.setParameter(name, value);
335 }
336 }
337 }
338
339 }