001
014
015 package com.liferay.portal.service.persistence.impl;
016
017 import com.liferay.portal.NoSuchModelException;
018 import com.liferay.portal.kernel.dao.db.DB;
019 import com.liferay.portal.kernel.dao.db.DBFactoryUtil;
020 import com.liferay.portal.kernel.dao.orm.Dialect;
021 import com.liferay.portal.kernel.dao.orm.DynamicQuery;
022 import com.liferay.portal.kernel.dao.orm.ORMException;
023 import com.liferay.portal.kernel.dao.orm.OrderFactoryUtil;
024 import com.liferay.portal.kernel.dao.orm.ProjectionFactoryUtil;
025 import com.liferay.portal.kernel.dao.orm.Session;
026 import com.liferay.portal.kernel.dao.orm.SessionFactory;
027 import com.liferay.portal.kernel.exception.SystemException;
028 import com.liferay.portal.kernel.log.Log;
029 import com.liferay.portal.kernel.log.LogFactoryUtil;
030 import com.liferay.portal.kernel.util.ListUtil;
031 import com.liferay.portal.kernel.util.OrderByComparator;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.model.BaseModel;
034 import com.liferay.portal.model.ModelListener;
035 import com.liferay.portal.service.ServiceContext;
036 import com.liferay.portal.service.ServiceContextThreadLocal;
037 import com.liferay.portal.service.persistence.BasePersistence;
038
039 import java.io.Serializable;
040
041 import java.sql.Connection;
042
043 import java.util.List;
044
045 import javax.sql.DataSource;
046
047
059 public class BasePersistenceImpl<T extends BaseModel<T>>
060 implements BasePersistence<T>, SessionFactory {
061
062 public static final String COUNT_COLUMN_NAME = "COUNT_VALUE";
063
064 public void clearCache() {
065 }
066
067 public void clearCache(List<T> model) {
068 }
069
070 public void clearCache(T model) {
071 }
072
073 public void closeSession(Session session) {
074 _sessionFactory.closeSession(session);
075 }
076
077 public long countWithDynamicQuery(DynamicQuery dynamicQuery)
078 throws SystemException {
079
080 dynamicQuery.setProjection(ProjectionFactoryUtil.rowCount());
081
082 List<Long> results = findWithDynamicQuery(dynamicQuery);
083
084 if (results.isEmpty()) {
085 return 0;
086 }
087 else {
088 return (results.get(0)).longValue();
089 }
090 }
091
092 @SuppressWarnings("unused")
093 public T fetchByPrimaryKey(Serializable primaryKey) throws SystemException {
094 throw new UnsupportedOperationException();
095 }
096
097 @SuppressWarnings("unused")
098 public T findByPrimaryKey(Serializable primaryKey)
099 throws NoSuchModelException, SystemException {
100
101 throw new UnsupportedOperationException();
102 }
103
104 @SuppressWarnings("rawtypes")
105 public List findWithDynamicQuery(DynamicQuery dynamicQuery)
106 throws SystemException {
107
108 Session session = null;
109
110 try {
111 session = openSession();
112
113 dynamicQuery.compile(session);
114
115 return dynamicQuery.list();
116 }
117 catch (Exception e) {
118 throw processException(e);
119 }
120 finally {
121 closeSession(session);
122 }
123 }
124
125 @SuppressWarnings("rawtypes")
126 public List findWithDynamicQuery(
127 DynamicQuery dynamicQuery, int start, int end)
128 throws SystemException {
129
130 Session session = null;
131
132 try {
133 session = openSession();
134
135 dynamicQuery.setLimit(start, end);
136
137 dynamicQuery.compile(session);
138
139 return dynamicQuery.list();
140 }
141 catch (Exception e) {
142 throw processException(e);
143 }
144 finally {
145 closeSession(session);
146 }
147 }
148
149 @SuppressWarnings("rawtypes")
150 public List findWithDynamicQuery(
151 DynamicQuery dynamicQuery, int start, int end,
152 OrderByComparator orderByComparator)
153 throws SystemException {
154
155 OrderFactoryUtil.addOrderByComparator(dynamicQuery, orderByComparator);
156
157 return findWithDynamicQuery(dynamicQuery, start, end);
158 }
159
160 public DataSource getDataSource() {
161 return _dataSource;
162 }
163
164 public DB getDB() {
165 return _db;
166 }
167
168 public Dialect getDialect() {
169 return _dialect;
170 }
171
172 public ModelListener<T>[] getListeners() {
173 return listeners;
174 }
175
176 public Session openNewSession(Connection connection) throws ORMException {
177 return _sessionFactory.openNewSession(connection);
178 }
179
180 public Session openSession() throws ORMException {
181 return _sessionFactory.openSession();
182 }
183
184 public SystemException processException(Exception e) {
185 if (!(e instanceof ORMException)) {
186 _log.error("Caught unexpected exception " + e.getClass().getName());
187 }
188
189 if (_log.isDebugEnabled()) {
190 _log.debug(e, e);
191 }
192
193 return new SystemException(e);
194 }
195
196 public void registerListener(ModelListener<T> listener) {
197 List<ModelListener<T>> listenersList = ListUtil.fromArray(listeners);
198
199 listenersList.add(listener);
200
201 listeners = listenersList.toArray(
202 new ModelListener[listenersList.size()]);
203 }
204
205 @SuppressWarnings("unused")
206 public T remove(Serializable primaryKey)
207 throws NoSuchModelException, SystemException {
208
209 throw new UnsupportedOperationException();
210 }
211
212 public T remove(T model) throws SystemException {
213 for (ModelListener<T> listener : listeners) {
214 listener.onBeforeRemove(model);
215 }
216
217 model = removeImpl(model);
218
219 for (ModelListener<T> listener : listeners) {
220 listener.onAfterRemove(model);
221 }
222
223 return model;
224 }
225
226 public void setDataSource(DataSource dataSource) {
227 _dataSource = dataSource;
228 }
229
230 public void setSessionFactory(SessionFactory sessionFactory) {
231 _sessionFactory = sessionFactory;
232 _dialect = _sessionFactory.getDialect();
233 _db = DBFactoryUtil.getDB(_dialect);
234 }
235
236 public void unregisterListener(ModelListener<T> listener) {
237 List<ModelListener<T>> listenersList = ListUtil.fromArray(listeners);
238
239 ListUtil.remove(listenersList, listener);
240
241 listeners = listenersList.toArray(
242 new ModelListener[listenersList.size()]);
243 }
244
245 public T update(T model, boolean merge) throws SystemException {
246 boolean isNew = model.isNew();
247
248 for (ModelListener<T> listener : listeners) {
249 if (isNew) {
250 listener.onBeforeCreate(model);
251 }
252 else {
253 listener.onBeforeUpdate(model);
254 }
255 }
256
257 model = updateImpl(model, merge);
258
259 for (ModelListener<T> listener : listeners) {
260 if (isNew) {
261 listener.onAfterCreate(model);
262 }
263 else {
264 listener.onAfterUpdate(model);
265 }
266 }
267
268 return model;
269 }
270
271 public T update(T model, boolean merge, ServiceContext serviceContext)
272 throws SystemException {
273
274 try {
275 ServiceContextThreadLocal.pushServiceContext(serviceContext);
276
277 update(model, merge);
278
279 return model;
280 }
281 finally {
282 ServiceContextThreadLocal.popServiceContext();
283 }
284 }
285
286 protected void appendOrderByComparator(
287 StringBundler query, String entityAlias,
288 OrderByComparator orderByComparator) {
289
290 query.append(ORDER_BY_CLAUSE);
291
292 String[] orderByFields = orderByComparator.getOrderByFields();
293
294 for (int i = 0; i < orderByFields.length; i++) {
295 query.append(entityAlias);
296 query.append(orderByFields[i]);
297
298 if ((i + 1) < orderByFields.length) {
299 if (orderByComparator.isAscending(orderByFields[i])) {
300 query.append(ORDER_BY_ASC_HAS_NEXT);
301 }
302 else {
303 query.append(ORDER_BY_DESC_HAS_NEXT);
304 }
305 }
306 else {
307 if (orderByComparator.isAscending(orderByFields[i])) {
308 query.append(ORDER_BY_ASC);
309 }
310 else {
311 query.append(ORDER_BY_DESC);
312 }
313 }
314 }
315 }
316
317
326 protected T removeImpl(T model) throws SystemException {
327 throw new UnsupportedOperationException();
328 }
329
330
344 protected T updateImpl(T model, boolean merge) throws SystemException {
345 throw new UnsupportedOperationException();
346 }
347
348 protected static final Object[] FINDER_ARGS_EMPTY = new Object[0];
349
350 protected static final String ORDER_BY_ASC = " ASC";
351
352 protected static final String ORDER_BY_ASC_HAS_NEXT = " ASC, ";
353
354 protected static final String ORDER_BY_CLAUSE = " ORDER BY ";
355
356 protected static final String ORDER_BY_DESC = " DESC";
357
358 protected static final String ORDER_BY_DESC_HAS_NEXT = " DESC, ";
359
360 protected static final String WHERE_AND = " AND ";
361
362 protected static final String WHERE_GREATER_THAN = " >= ? ";
363
364 protected static final String WHERE_GREATER_THAN_HAS_NEXT = " >= ? AND ";
365
366 protected static final String WHERE_LESSER_THAN = " <= ? ";
367
368 protected static final String WHERE_LESSER_THAN_HAS_NEXT = " <= ? AND ";
369
370 protected static final String WHERE_OR = " OR ";
371
372 protected ModelListener<T>[] listeners = new ModelListener[0];
373
374 private static Log _log = LogFactoryUtil.getLog(BasePersistenceImpl.class);
375
376 private DataSource _dataSource;
377 private DB _db;
378 private Dialect _dialect;
379 private SessionFactory _sessionFactory;
380
381 }